diff --git a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
--- a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
+++ b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
@@ -2833,7 +2833,7 @@
   std::vector<MessageWithMedias> messageWithMedias;
   for (auto &messageEntity : messages) {
     messageWithMedias.push_back(
-        {WebMessage(messageEntity.message), messageEntity.medias});
+        {Message(messageEntity.message), messageEntity.medias});
   }
 
   return messageWithMedias;
diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h b/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h
--- a/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h
@@ -82,7 +82,7 @@
 };
 
 struct MessageWithMedias {
-  WebMessage message;
+  Message message;
   std::vector<Media> medias;
 };
 
diff --git a/web/cpp/SQLiteQueryExecutorBindings.cpp b/web/cpp/SQLiteQueryExecutorBindings.cpp
--- a/web/cpp/SQLiteQueryExecutorBindings.cpp
+++ b/web/cpp/SQLiteQueryExecutorBindings.cpp
@@ -100,15 +100,15 @@
       .field("pinnedCount", &Thread::pinned_count)
       .field("timestamps", &Thread::timestamps);
 
-  value_object<WebMessage>("WebMessage")
-      .field("id", &WebMessage::id)
-      .field("localID", &WebMessage::local_id)
-      .field("thread", &WebMessage::thread)
-      .field("user", &WebMessage::user)
-      .field("type", &WebMessage::type)
-      .field("futureType", &WebMessage::future_type)
-      .field("content", &WebMessage::content)
-      .field("time", &WebMessage::time);
+  value_object<Message>("WebMessage")
+      .field("id", &Message::id)
+      .field("localID", &Message::local_id)
+      .field("thread", &Message::thread)
+      .field("user", &Message::user)
+      .field("type", &Message::type)
+      .field("futureType", &Message::future_type)
+      .field("content", &Message::content)
+      .field("time", &Message::time);
 
   value_object<Media>("Media")
       .field("id", &Media::id)
@@ -118,9 +118,9 @@
       .field("type", &Media::type)
       .field("extras", &Media::extras);
 
-  value_object<MessageWithMedias>("MessageWithMedias")
-      .field("message", &MessageWithMedias::message)
-      .field("medias", &MessageWithMedias::medias);
+  value_object<MessageEntity>("MessageEntity")
+      .field("message", &MessageEntity::message)
+      .field("medias", &MessageEntity::medias);
 
   value_object<OlmPersistSession>("OlmPersistSession")
       .field("targetDeviceID", &OlmPersistSession::target_device_id)
@@ -151,14 +151,13 @@
       .function("getAllDrafts", &SQLiteQueryExecutor::getAllDrafts)
       .function("removeAllDrafts", &SQLiteQueryExecutor::removeAllDrafts)
       .function("removeDrafts", &SQLiteQueryExecutor::removeDrafts)
-      .function(
-          "getInitialMessagesWeb", &SQLiteQueryExecutor::getInitialMessagesWeb)
+      .function("getInitialMessages", &SQLiteQueryExecutor::getInitialMessages)
       .function("removeAllMessages", &SQLiteQueryExecutor::removeAllMessages)
       .function("removeMessages", &SQLiteQueryExecutor::removeMessages)
       .function(
           "removeMessagesForThreads",
           &SQLiteQueryExecutor::removeMessagesForThreads)
-      .function("replaceMessageWeb", &SQLiteQueryExecutor::replaceMessageWeb)
+      .function("replaceMessage", &SQLiteQueryExecutor::replaceMessage)
       .function("rekeyMessage", &SQLiteQueryExecutor::rekeyMessage)
       .function("removeAllMedia", &SQLiteQueryExecutor::removeAllMedia)
       .function(
@@ -336,16 +335,15 @@
       .function(
           "getInboundP2PMessagesByID",
           &SQLiteQueryExecutor::getInboundP2PMessagesByID)
-      .function(
-          "getRelatedMessagesWeb", &SQLiteQueryExecutor::getRelatedMessagesWeb)
+      .function("getRelatedMessages", &SQLiteQueryExecutor::getRelatedMessages)
       .function(
           "updateMessageSearchIndex",
           &SQLiteQueryExecutor::updateMessageSearchIndex)
       .function(
           "deleteMessageFromSearchIndex",
           &SQLiteQueryExecutor::deleteMessageFromSearchIndex)
-      .function("searchMessages", &SQLiteQueryExecutor::searchMessagesWeb)
-      .function("fetchMessagesWeb", &SQLiteQueryExecutor::fetchMessagesWeb);
+      .function("searchMessages", &SQLiteQueryExecutor::searchMessages)
+      .function("fetchMessages", &SQLiteQueryExecutor::fetchMessages);
 }
 
 } // namespace comm
diff --git a/web/shared-worker/_generated/comm_query_executor.wasm b/web/shared-worker/_generated/comm_query_executor.wasm
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
GIT binary patch
literal 0
Hc$@<O00001

literal 0
Hc$@<O00001

diff --git a/web/shared-worker/queries/fetch-messages-queries.test.js b/web/shared-worker/queries/fetch-messages-queries.test.js
--- a/web/shared-worker/queries/fetch-messages-queries.test.js
+++ b/web/shared-worker/queries/fetch-messages-queries.test.js
@@ -3,7 +3,6 @@
 import { messageTypes } from 'lib/types/message-types-enum.js';
 
 import { getDatabaseModule } from '../db-module.js';
-import { createNullableInt, createNullableString } from '../types/entities.js';
 import type {
   MessageEntity,
   WebMessage,
@@ -32,15 +31,15 @@
     for (let i = 0; i < 50; i++) {
       const message: WebMessage = {
         id: i.toString(),
-        localID: createNullableString(),
+        localID: null,
         thread: threadID,
         user: userID,
         type: messageTypes.TEXT,
-        futureType: createNullableInt(),
-        content: createNullableString(`text-${i}`),
-        time: i.toString(),
+        futureType: null,
+        content: `text-${i}`,
+        time: BigInt(i),
       };
-      queryExecutor.replaceMessageWeb(message);
+      queryExecutor.replaceMessage(message);
     }
   });
 
@@ -51,19 +50,19 @@
   function assertMessageEqual(message: MessageEntity, id: number) {
     const expected: WebMessage = {
       id: id.toString(),
-      localID: createNullableString(),
+      localID: null,
       thread: threadID,
       user: userID,
       type: messageTypes.TEXT,
-      futureType: createNullableInt(),
-      content: createNullableString(`text-${id}`),
-      time: id.toString(),
+      futureType: null,
+      content: `text-${id}`,
+      time: BigInt(id),
     };
     expect(message.message).toEqual(expected);
   }
 
   it('should fetch the first messages', () => {
-    const result = queryExecutor.fetchMessagesWeb(threadID, 5, 0);
+    const result = queryExecutor.fetchMessages(threadID, 5, 0);
     expect(result.length).toBe(5);
     for (let i = 0; i < 5; i++) {
       assertMessageEqual(result[i], 49 - i);
@@ -71,7 +70,7 @@
   });
 
   it('should fetch the following messages', () => {
-    const result = queryExecutor.fetchMessagesWeb(threadID, 5, 5);
+    const result = queryExecutor.fetchMessages(threadID, 5, 5);
     expect(result.length).toBe(5);
     for (let i = 0; i < 5; i++) {
       assertMessageEqual(result[i], 44 - i);
@@ -79,7 +78,7 @@
   });
 
   it('should fetch the last messages', () => {
-    const result = queryExecutor.fetchMessagesWeb(threadID, 5, 45);
+    const result = queryExecutor.fetchMessages(threadID, 5, 45);
     expect(result.length).toBe(5);
     for (let i = 0; i < 5; i++) {
       assertMessageEqual(result[i], 4 - i);
@@ -87,12 +86,12 @@
   });
 
   it('should check if thread ID matches', () => {
-    const result = queryExecutor.fetchMessagesWeb('000', 5, 45);
+    const result = queryExecutor.fetchMessages('000', 5, 45);
     expect(result.length).toBe(0);
   });
 
   it('should fetch the remaining messages when limit exceeds the bounds', () => {
-    const result = queryExecutor.fetchMessagesWeb(threadID, 100, 40);
+    const result = queryExecutor.fetchMessages(threadID, 100, 40);
     expect(result.length).toBe(10);
     for (let i = 0; i < 10; i++) {
       assertMessageEqual(result[i], 9 - i);
@@ -100,7 +99,7 @@
   });
 
   it('should return all the messages when limit is high enough', () => {
-    const result = queryExecutor.fetchMessagesWeb(threadID, 500, 0);
+    const result = queryExecutor.fetchMessages(threadID, 500, 0);
     expect(result.length).toBe(50);
     for (let i = 0; i < 50; i++) {
       assertMessageEqual(result[i], 49 - i);
diff --git a/web/shared-worker/queries/message-search.test.js b/web/shared-worker/queries/message-search.test.js
--- a/web/shared-worker/queries/message-search.test.js
+++ b/web/shared-worker/queries/message-search.test.js
@@ -3,7 +3,7 @@
 import { messageTypes } from 'lib/types/message-types-enum.js';
 
 import { getDatabaseModule } from '../db-module.js';
-import { type WebMessage } from '../types/sqlite-query-executor.js';
+import type { WebMessage } from '../types/sqlite-query-executor.js';
 import { clearSensitiveData } from '../utils/db-utils.js';
 
 const FILE_PATH = 'test.sqlite';
@@ -13,8 +13,8 @@
   let dbModule;
   const threadID = '100';
   const userID = '111';
-  const futureType = { value: 0, isNull: true };
-  const localID = { value: '', isNull: true };
+  const futureType = null;
+  const localID = null;
 
   beforeAll(async () => {
     dbModule = getDatabaseModule();
@@ -44,10 +44,10 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
-      time: '123',
+      content: text,
+      time: BigInt(123),
     };
-    queryExecutor.replaceMessageWeb(message);
+    queryExecutor.replaceMessage(message);
     queryExecutor.updateMessageSearchIndex(id, id, text);
     const result = queryExecutor.searchMessages('test', threadID, null, null);
     expect(result.length).toBe(1);
@@ -57,29 +57,29 @@
   it('should find all messages matching provided query', () => {
     const text1 = 'test text';
     const id1 = '1';
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: id1,
       localID,
       thread: threadID,
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text1, isNull: false },
-      time: '1',
+      content: text1,
+      time: BigInt(1),
     });
     queryExecutor.updateMessageSearchIndex(id1, id1, text1);
 
     const text2 = 'I am test';
     const id2 = '2';
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: id2,
       localID,
       thread: threadID,
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text2, isNull: false },
-      time: '1',
+      content: text2,
+      time: BigInt(1),
     });
     queryExecutor.updateMessageSearchIndex(id2, id2, text2);
     const result = queryExecutor.searchMessages('test', threadID, null, null);
@@ -96,23 +96,23 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text1, isNull: false },
-      time: '123',
+      content: text1,
+      time: BigInt(123),
     };
-    queryExecutor.replaceMessageWeb(matchingMessage);
+    queryExecutor.replaceMessage(matchingMessage);
     queryExecutor.updateMessageSearchIndex(id1, id1, text1);
 
     const text2 = 'I am text';
     const id2 = '2';
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: id2,
       localID,
       thread: threadID,
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text2, isNull: false },
-      time: '1',
+      content: text2,
+      time: BigInt(1),
     });
     queryExecutor.updateMessageSearchIndex(id2, id2, text2);
     const result = queryExecutor.searchMessages('test', threadID, null, null);
@@ -130,26 +130,23 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text1, isNull: false },
-      time: '1',
+      content: text1,
+      time: BigInt(1),
     };
-    queryExecutor.replaceMessageWeb(matchingMessage);
+    queryExecutor.replaceMessage(matchingMessage);
     queryExecutor.updateMessageSearchIndex(id1, id1, text1);
 
     const text2 = 'I am test';
     const id2 = '2';
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: id2,
       localID,
       thread: threadID,
       user: userID,
       type: messageTypes.EDIT_MESSAGE,
       futureType,
-      content: {
-        value: JSON.stringify({ targetMessageID: id1 }),
-        isNull: false,
-      },
-      time: '5',
+      content: JSON.stringify({ targetMessageID: id1 }),
+      time: BigInt(5),
     });
     queryExecutor.updateMessageSearchIndex(id1, id2, text2);
     const result = queryExecutor.searchMessages('test', threadID, null, null);
@@ -159,9 +156,9 @@
   });
 
   it('should return only messages with time equal or smaller than timestampCursor', () => {
-    const timeOlderThanSearchedFor = '1';
+    const timeOlderThanSearchedFor = BigInt(1);
     const timeSearchedFor = '1000';
-    const timeNewerThanSearchedFor = '2000';
+    const timeNewerThanSearchedFor = BigInt(2000);
 
     const text = 'test';
 
@@ -173,21 +170,21 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
+      content: text,
       time: timeOlderThanSearchedFor,
     };
-    queryExecutor.replaceMessageWeb(matchingMessage);
+    queryExecutor.replaceMessage(matchingMessage);
     queryExecutor.updateMessageSearchIndex(id1, id1, text);
 
     const id2 = '2';
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: id2,
       localID,
       thread: threadID,
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
+      content: text,
       time: timeNewerThanSearchedFor,
     });
     queryExecutor.updateMessageSearchIndex(id2, id2, text);
@@ -203,7 +200,7 @@
 
   it('should correctly return messages with regards to messageIDCursor', () => {
     const text = 'test';
-    const time = '1';
+    const time = BigInt(1);
 
     const id1 = '1';
     const matchingMessage: WebMessage = {
@@ -213,26 +210,31 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
+      content: text,
       time,
     };
-    queryExecutor.replaceMessageWeb(matchingMessage);
+    queryExecutor.replaceMessage(matchingMessage);
     queryExecutor.updateMessageSearchIndex(id1, id1, text);
 
     const id2 = '2';
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: id2,
       localID,
       thread: threadID,
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
+      content: text,
       time,
     });
     queryExecutor.updateMessageSearchIndex(id2, id2, text);
 
-    const result = queryExecutor.searchMessages(text, threadID, time, id2);
+    const result = queryExecutor.searchMessages(
+      text,
+      threadID,
+      time.toString(),
+      id2,
+    );
     expect(result.length).toBe(1);
     expect(result[0].message).toStrictEqual(matchingMessage);
   });
@@ -244,8 +246,8 @@
     const smallerID = '2';
     const intBetweenIDs = '100';
 
-    const olderTimestamp = '1';
-    const youngerTimestamp = '1000';
+    const olderTimestamp = BigInt(1);
+    const youngerTimestamp = BigInt(1000);
     const timeBetweenTimestamps = '500';
 
     const matchingMessage: WebMessage = {
@@ -255,20 +257,20 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
+      content: text,
       time: olderTimestamp,
     };
-    queryExecutor.replaceMessageWeb(matchingMessage);
+    queryExecutor.replaceMessage(matchingMessage);
     queryExecutor.updateMessageSearchIndex(greaterID, greaterID, text);
 
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: smallerID,
       localID,
       thread: threadID,
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
+      content: text,
       time: youngerTimestamp,
     });
     queryExecutor.updateMessageSearchIndex(smallerID, smallerID, text);
@@ -295,10 +297,10 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
-      time: '1',
+      content: text,
+      time: BigInt(1),
     };
-    queryExecutor.replaceMessageWeb(secondMessage);
+    queryExecutor.replaceMessage(secondMessage);
     queryExecutor.updateMessageSearchIndex(id1, id1, text);
 
     const id2 = '2';
@@ -309,10 +311,10 @@
       user: userID,
       type: messageTypes.TEXT,
       futureType,
-      content: { value: text, isNull: false },
-      time: '2',
+      content: text,
+      time: BigInt(2),
     };
-    queryExecutor.replaceMessageWeb(firstMessage);
+    queryExecutor.replaceMessage(firstMessage);
     queryExecutor.updateMessageSearchIndex(id2, id2, text);
 
     const result = queryExecutor.searchMessages(text, threadID, null, null);
diff --git a/web/shared-worker/queries/messages-and-media-queries.test.js b/web/shared-worker/queries/messages-and-media-queries.test.js
--- a/web/shared-worker/queries/messages-and-media-queries.test.js
+++ b/web/shared-worker/queries/messages-and-media-queries.test.js
@@ -23,35 +23,35 @@
     if (!queryExecutor) {
       throw new Error('SQLiteQueryExecutor is missing');
     }
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: '1',
-      localID: { value: '', isNull: true },
+      localID: null,
       thread: '1',
       user: '1',
       type: 0,
-      futureType: { value: 0, isNull: true },
-      content: { value: '', isNull: true },
-      time: '0',
+      futureType: null,
+      content: null,
+      time: BigInt(0),
     });
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: '2',
-      localID: { value: '', isNull: true },
+      localID: null,
       thread: '1',
       user: '1',
       type: 0,
-      futureType: { value: 0, isNull: true },
-      content: { value: '', isNull: true },
-      time: '0',
+      futureType: null,
+      content: null,
+      time: BigInt(0),
     });
-    queryExecutor.replaceMessageWeb({
+    queryExecutor.replaceMessage({
       id: '3',
-      localID: { value: '', isNull: true },
+      localID: null,
       thread: '2',
       user: '1',
       type: 0,
-      futureType: { value: 5, isNull: false },
-      content: { value: '', isNull: true },
-      time: '0',
+      futureType: 5,
+      content: null,
+      time: BigInt(0),
     });
     queryExecutor.replaceMedia({
       id: '1',
@@ -130,7 +130,7 @@
   });
 
   it('should return all messages with media', () => {
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages.length).toBe(3);
     expect(allMessages[0].medias.length).toBe(2);
     expect(allMessages[1].medias.length).toBe(0);
@@ -139,13 +139,13 @@
 
   it('should remove all messages', () => {
     queryExecutor.removeAllMessages();
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages.length).toBe(0);
   });
 
   it('should remove all media', () => {
     queryExecutor.removeAllMedia();
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages[0].medias.length).toBe(0);
     expect(allMessages[1].medias.length).toBe(0);
     expect(allMessages[2].medias.length).toBe(0);
@@ -153,19 +153,19 @@
 
   it('should remove all messages for threads', () => {
     queryExecutor.removeMessagesForThreads(['1']);
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages.length).toBe(1);
   });
 
   it('should remove all messages with ids', () => {
     queryExecutor.removeMessages(['1']);
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages.length).toBe(2);
   });
 
   it('should remove all media for message', () => {
     queryExecutor.removeMediaForMessage('1');
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages[0].medias.length).toBe(0);
     expect(allMessages[1].medias.length).toBe(0);
     expect(allMessages[2].medias.length).toBe(2);
@@ -173,7 +173,7 @@
 
   it('should remove all media for messages', () => {
     queryExecutor.removeMediaForMessages(['3']);
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages[0].medias.length).toBe(2);
     expect(allMessages[1].medias.length).toBe(0);
     expect(allMessages[2].medias.length).toBe(0);
@@ -181,7 +181,7 @@
 
   it('should remove all media for threads', () => {
     queryExecutor.removeMediaForThreads(['2']);
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages[0].medias.length).toBe(2);
     expect(allMessages[1].medias.length).toBe(0);
     expect(allMessages[2].medias.length).toBe(0);
@@ -189,7 +189,7 @@
 
   it('should rekey media containers', () => {
     queryExecutor.rekeyMediaContainers('1', '3');
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages[0].medias.length).toBe(0);
     expect(allMessages[1].medias.length).toBe(0);
     expect(allMessages[2].medias.length).toBe(4);
@@ -197,7 +197,7 @@
 
   it('should rekey message', () => {
     queryExecutor.rekeyMessage('3', '2');
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     expect(allMessages.length).toBe(2);
     const rekeyedMessage = allMessages.find(
       messageWithMedia => messageWithMedia.message.id === '2',
@@ -206,17 +206,14 @@
   });
 
   it('should correctly handle nullable integer', () => {
-    const allMessages = queryExecutor.getInitialMessagesWeb();
+    const allMessages = queryExecutor.getInitialMessages();
     const messageWithNullFutureType = allMessages.find(
       messageWithMedia => messageWithMedia.message.id === '1',
     );
     const messageWithNonNullIFutureType = allMessages.find(
       messageWithMedia => messageWithMedia.message.id === '3',
     );
-    expect(messageWithNullFutureType?.message.futureType.isNull).toBe(true);
-    expect(messageWithNonNullIFutureType?.message.futureType.isNull).toBe(
-      false,
-    );
-    expect(messageWithNonNullIFutureType?.message.futureType.value).toBe(5);
+    expect(messageWithNullFutureType?.message.futureType).toBeDefined();
+    expect(messageWithNonNullIFutureType?.message.futureType).toBe(5);
   });
 });
diff --git a/web/shared-worker/types/entities.js b/web/shared-worker/types/entities.js
--- a/web/shared-worker/types/entities.js
+++ b/web/shared-worker/types/entities.js
@@ -121,13 +121,15 @@
   return {
     message: {
       id: messageInfo.id,
-      localID: createNullableString(messageInfo.local_id),
+      localID: messageInfo.local_id,
       thread: messageInfo.thread,
       user: messageInfo.user,
       type: Number(messageInfo.type),
-      futureType: createNullableInt(messageInfo.future_type),
-      content: createNullableString(messageInfo.content),
-      time: messageInfo.time,
+      futureType: messageInfo.future_type
+        ? Number(messageInfo.future_type)
+        : null,
+      content: messageInfo.content,
+      time: BigInt(Number(messageInfo.time)),
     },
     medias:
       messageInfo.media_infos?.map(({ id, uri, type, extras }) => ({
@@ -160,15 +162,13 @@
 
   return {
     id: message.id,
-    local_id: message.localID.isNull ? null : message.localID.value,
+    local_id: message.localID,
     thread: message.thread,
     user: message.user,
     type: message.type.toString(),
-    future_type: message.futureType.isNull
-      ? null
-      : message.futureType.value.toString(),
-    content: message.content.isNull ? null : message.content.value,
-    time: message.time,
+    future_type: message.futureType ? message.futureType.toString() : null,
+    content: message.content,
+    time: message.time.toString(),
     media_infos,
   };
 }
diff --git a/web/shared-worker/types/sqlite-query-executor.js b/web/shared-worker/types/sqlite-query-executor.js
--- a/web/shared-worker/types/sqlite-query-executor.js
+++ b/web/shared-worker/types/sqlite-query-executor.js
@@ -17,21 +17,17 @@
   InboundP2PMessage,
 } from 'lib/types/sqlite-types.js';
 
-import {
-  type NullableInt,
-  type NullableString,
-  type WebClientDBThreadInfo,
-} from './entities.js';
+import { type NullableString, type WebClientDBThreadInfo } from './entities.js';
 
 export type WebMessage = {
   +id: string,
-  +localID: NullableString,
+  +localID: ?string,
   +thread: string,
   +user: string,
   +type: number,
-  +futureType: NullableInt,
-  +content: NullableString,
-  +time: string,
+  +futureType: ?number,
+  +content: ?string,
+  +time: bigint,
 };
 
 export type Media = {
@@ -63,8 +59,8 @@
   removeAllDrafts(): void;
   removeDrafts(ids: $ReadOnlyArray<string>): void;
 
-  getInitialMessagesWeb(): $ReadOnlyArray<MessageEntity>;
-  fetchMessagesWeb(
+  getInitialMessages(): $ReadOnlyArray<MessageEntity>;
+  fetchMessages(
     threadID: string,
     limit: number,
     offset: number,
@@ -72,7 +68,7 @@
   removeAllMessages(): void;
   removeMessages(ids: $ReadOnlyArray<string>): void;
   removeMessagesForThreads(threadIDs: $ReadOnlyArray<string>): void;
-  replaceMessageWeb(message: WebMessage): void;
+  replaceMessage(message: WebMessage): void;
   rekeyMessage(from: string, to: string): void;
   removeAllMedia(): void;
   removeMediaForThreads(threadIDs: $ReadOnlyArray<string>): void;
@@ -208,7 +204,7 @@
     ids: $ReadOnlyArray<string>,
   ): $ReadOnlyArray<InboundP2PMessage>;
 
-  getRelatedMessagesWeb(id: string): $ReadOnlyArray<MessageEntity>;
+  getRelatedMessages(id: string): $ReadOnlyArray<MessageEntity>;
 
   updateMessageSearchIndex(
     originalMessageID: string,
diff --git a/web/shared-worker/worker/process-operations.js b/web/shared-worker/worker/process-operations.js
--- a/web/shared-worker/worker/process-operations.js
+++ b/web/shared-worker/worker/process-operations.js
@@ -280,7 +280,7 @@
         const { message, medias } = clientDBMessageInfoToWebMessage(
           operation.payload,
         );
-        sqliteQueryExecutor.replaceMessageWeb(message);
+        sqliteQueryExecutor.replaceMessage(message);
         for (const media of medias) {
           sqliteQueryExecutor.replaceMedia(media);
         }
@@ -670,7 +670,7 @@
   return {
     drafts: sqliteQueryExecutor.getAllDrafts(),
     messages: sqliteQueryExecutor
-      .getInitialMessagesWeb()
+      .getInitialMessages()
       .map(webMessageToClientDBMessageInfo),
     threads: sqliteQueryExecutor
       .getAllThreads()
diff --git a/web/shared-worker/worker/shared-worker.js b/web/shared-worker/worker/shared-worker.js
--- a/web/shared-worker/worker/shared-worker.js
+++ b/web/shared-worker/worker/shared-worker.js
@@ -254,12 +254,12 @@
       outboundP2PMessages: sqliteQueryExecutor.getUnsentOutboundP2PMessages(),
     };
   } else if (message.type === workerRequestMessageTypes.GET_RELATED_MESSAGES) {
-    const webMessageEntities = sqliteQueryExecutor.getRelatedMessagesWeb(
+    const messageEntities = sqliteQueryExecutor.getRelatedMessages(
       message.messageID,
     );
     return {
       type: workerResponseMessageTypes.GET_MESSAGES,
-      messages: webMessageEntities.map(webMessageToClientDBMessageInfo),
+      messages: messageEntities.map(webMessageToClientDBMessageInfo),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_OUTBOUND_P2P_MESSAGES_BY_ID
@@ -271,7 +271,7 @@
       ),
     };
   } else if (message.type === workerRequestMessageTypes.SEARCH_MESSAGES) {
-    const webMessageEntities = sqliteQueryExecutor.searchMessages(
+    const messageEntities = sqliteQueryExecutor.searchMessages(
       message.query,
       message.threadID,
       message.timestampCursor,
@@ -279,17 +279,17 @@
     );
     return {
       type: workerResponseMessageTypes.GET_MESSAGES,
-      messages: webMessageEntities.map(webMessageToClientDBMessageInfo),
+      messages: messageEntities.map(webMessageToClientDBMessageInfo),
     };
   } else if (message.type === workerRequestMessageTypes.FETCH_MESSAGES) {
-    const webMessageEntities = sqliteQueryExecutor.fetchMessagesWeb(
+    const messageEntities = sqliteQueryExecutor.fetchMessages(
       message.threadID,
       message.limit,
       message.offset,
     );
     return {
       type: workerResponseMessageTypes.GET_MESSAGES,
-      messages: webMessageEntities.map(webMessageToClientDBMessageInfo),
+      messages: messageEntities.map(webMessageToClientDBMessageInfo),
     };
   } else if (
     message.type === workerRequestMessageTypes.GET_INBOUND_P2P_MESSAGES_BY_ID