@evolu/common 7.4.0 → 8.0.0-next.0

package/dist/src/local-first/Db.js

@@ -1,135 +1,281 @@
-import { firstInArray, isNonEmptyArray, } from "../Array.js";
-import { assertNonEmptyReadonlyArray } from "../Assert.js";
-import { createSymmetricCrypto, } from "../Crypto.js";
-import { ok } from "../Result.js";
-import { createSqlite, sql, } from "../Sqlite.js";
-import { SimpleName } from "../Type.js";
-import { createInitializedWorkerWithHandlers, } from "../Worker.js";
-import { createAppOwner, createOwnerSecret, mnemonicToOwnerSecret, } from "./Owner.js";
-import { protocolVersion } from "./Protocol.js";
-import { createGetQueryRowsCache, loadQueries, } from "./Query.js";
-import { ensureDbSchema, getDbSchema, } from "./Schema.js";
-import { createBaseSqliteStorageTables } from "./Storage.js";
-import { applyLocalOnlyChange, createClock, createSync, tryApplyQuarantinedMessages, } from "./Sync.js";
-import { timestampBytesToTimestamp, timestampToTimestampBytes, } from "./Timestamp.js";
-export const defaultDbConfig = {
-    name: SimpleName.orThrow("Evolu"),
-    transports: [{ type: "WebSocket", url: "wss://free.evoluhq.com" }],
-    maxDrift: 5 * 60 * 1000,
-    enableLogging: false,
-};
-export const createDbWorkerForPlatform = (platformDeps) => createInitializedWorkerWithHandlers({
-    init: async (initMessage, postMessage) => {
-        platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
-        const deps = await createDbWorkerDeps(platformDeps, initMessage, postMessage);
-        if (!deps.ok) {
-            postMessage({ type: "onError", error: deps.error });
-            return null;
-        }
-        return deps.value;
-    },
-    handlers,
-});
-const createDbWorkerDeps = async (platformDeps, initMessage, postMessage) => {
-    const sqlite = await createSqlite(platformDeps)(initMessage.config.name, {
-        memory: initMessage.config.inMemory ?? false,
-        encryptionKey: initMessage.config.encryptionKey ?? undefined,
-    });
-    if (!sqlite.ok)
-        return sqlite;
-    const deps = { ...platformDeps, sqlite: sqlite.value };
-    return deps.sqlite.transaction(() => {
-        const dbSchema = getDbSchema(deps)();
-        if (!dbSchema.ok)
-            return dbSchema;
-        const dbIsInitialized = "evolu_version" in dbSchema.value.tables;
-        let appOwner;
-        let clock;
-        if (dbIsInitialized) {
-            const currentVersion = deps.sqlite.exec(sql `select protocolVersion from evolu_version limit 1;`);
-            if (!currentVersion.ok)
-                return currentVersion;
-            const configResult = deps.sqlite.exec(sql `
-        select
-          clock,
-          appOwnerId,
-          appOwnerEncryptionKey,
-          appOwnerWriteKey,
-          appOwnerMnemonic
-        from evolu_config
-        limit 1;
-      `);
-            if (!configResult.ok)
-                return configResult;
-            assertNonEmptyReadonlyArray(configResult.value.rows);
-            const config = firstInArray(configResult.value.rows);
-            appOwner = {
-                type: "AppOwner",
-                id: config.appOwnerId,
-                encryptionKey: config.appOwnerEncryptionKey,
-                writeKey: config.appOwnerWriteKey,
-                mnemonic: config.appOwnerMnemonic,
-            };
-            clock = createClock(deps)(timestampBytesToTimestamp(config.clock));
+/**
+ * Platform-agnostic Evolu DbWorker.
+ *
+ * @module
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
         }
-        else {
-            appOwner =
-                initMessage.config.externalAppOwner ??
-                    createAppOwner(createOwnerSecret(platformDeps));
-            clock = createClock(deps)();
-            const result = initializeDb(deps)(appOwner, clock.get());
-            if (!result.ok)
-                return result;
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
         }
-        {
-            const result = ensureDbSchema(deps)(initMessage.dbSchema, dbSchema.value);
-            if (!result.ok)
-                return result;
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
         }
-        {
-            const result = ensureMessageQuarantineTable(deps);
-            if (!result.ok)
-                return result;
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
         }
-        const sync = createSync({
-            ...deps,
-            clock,
-            symmetricCrypto: createSymmetricCrypto(platformDeps),
-            timestampConfig: initMessage.config,
-            dbSchema: initMessage.dbSchema,
-        })({
-            appOwner,
-            transports: initMessage.config.transports,
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { appendToArray, firstInArray, } from "../Array.js";
+import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
+import { EncryptionKey, } from "../Crypto.js";
+import { exhaustiveCheck, lazyFalse, lazyVoid } from "../Function.js";
+import { createRecord, getProperty, objectToEntries } from "../Object.js";
+import { ok } from "../Result.js";
+import { booleanToSqliteBoolean, createSqlite, sql, SqliteBoolean, sqliteBooleanToBoolean, sqliteQueryStringToSqliteQuery, SqliteValue, } from "../Sqlite.js";
+import { callback } from "../Task.js";
+import { Millis, millisToDateIso } from "../Time.js";
+import { Id, IdBytes, idBytesToId, idToIdBytes, onePositiveInt, } from "../Type.js";
+import { ownerIdBytesToOwnerId, ownerIdToOwnerIdBytes } from "./Owner.js";
+import { applyProtocolMessageAsClient, createProtocolMessageForSync, decryptAndDecodeDbChange, encodeAndEncryptDbChange, protocolVersion, SubscriptionFlags, } from "./Protocol.js";
+import { ensureSqliteSchema, getEvoluSqliteSchema, systemColumns, } from "./Schema.js";
+import { createBaseSqliteStorage, createBaseSqliteStorageTables, DbChange, getOwnerUsage, getTimestampInsertStrategy, updateOwnerUsage, } from "./Storage.js";
+import { createInitialTimestamp, defaultTimestampMaxDrift, receiveTimestamp, sendTimestamp, TimestampBytes, timestampBytesToTimestamp, timestampToTimestampBytes, } from "./Timestamp.js";
+export const startDbWorker = (self) => async (_run) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const run = stack.use(_run.create());
+        const { deps } = run;
+        let initialized = false;
+        const initMessage = await run.orThrow(callback(({ ok }) => {
+            self.onMessage = (message) => {
+                assert(!initialized, "DbWorker must be initialized only once");
+                initialized = true;
+                ok(message);
+            };
+        }));
+        const console = deps.console.child(initMessage.name).child("DbWorker");
+        console.setLevel(initMessage.consoleLevel);
+        console.info("start DbWorker");
+        const port = stack.use(deps.createMessagePort(initMessage.port));
+        stack.defer(deps.consoleStoreOutputEntry.subscribe(() => {
+            const entry = deps.consoleStoreOutputEntry.get();
+            if (entry)
+                port.postMessage({ type: "OnConsoleEntry", entry });
+        }));
+        stack.use(await run.orThrow(deps.leaderLock.lock(initMessage.name)));
+        if (stack.disposed)
+            return ok();
+        port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
+        const sqlite = stack.use(await run.orThrow(createSqlite(initMessage.name, initMessage.memoryOnly
+            ? { mode: "memory" }
+            : { mode: "encrypted", encryptionKey: initMessage.encryptionKey })));
+        console.debug("SQLite created");
+        const baseSqliteStorage = createBaseSqliteStorage({ sqlite, ...run.deps });
+        const dbDeps = {
+            ...run.deps,
+            sqlite,
+            sqliteSchema: initMessage.sqliteSchema,
+            baseSqliteStorage,
+            timestampConfig: { maxDrift: defaultTimestampMaxDrift },
+        };
+        const currentSchema = getEvoluSqliteSchema(dbDeps)();
+        const dbIsInitialized = "evolu_version" in currentSchema.tables;
+        const clock = createClock(dbDeps)(dbIsInitialized);
+        sqlite.transaction(() => {
+            if (!dbIsInitialized)
+                initializeDb(dbDeps)(clock.get());
+            ensureSqliteSchema(dbDeps)(initMessage.sqliteSchema, currentSchema);
+            tryApplyQuarantinedMessages(dbDeps);
+        });
+        const storage = createClientStorage({ ...dbDeps, clock })({
             onError: (error) => {
-                postMessage({ type: "onError", error });
-            },
-            onReceive: () => {
-                postMessage({ type: "refreshQueries" });
+                port.postMessage({ type: "OnError", error });
             },
         });
-        if (!sync.ok)
-            return sync;
-        {
-            const result = tryApplyQuarantinedMessages({
-                ...deps,
-                dbSchema: initMessage.dbSchema,
-            })();
-            if (!result.ok)
-                return result;
-        }
-        sync.value.useOwner(true, appOwner);
-        return ok({
-            ...deps,
-            getQueryRowsCache: createGetQueryRowsCache(),
-            postMessage,
-            sync: sync.value,
-            appOwner,
-        });
-    });
+        // TODO: Call on dispose message.
+        const _moved = stack.move();
+        const runWithStorage = run.addDeps({ storage });
+        /**
+         * SharedWorker repeats sends until it gets a response, so handling here
+         * must be idempotent and ignore already processed IDs.
+         *
+         * TODO: Bound memory growth by evicting old IDs.
+         */
+        const processedRequestIds = new Set();
+        port.onMessage = ({ callbackId, request }) => {
+            if (processedRequestIds.has(callbackId))
+                return;
+            processedRequestIds.add(callbackId);
+            const postQueuedResponse = (response) => {
+                port.postMessage({ type: "OnQueuedResponse", callbackId, response }, response.type === "ForEvolu" && response.message.type === "Export"
+                    ? [response.message.file.buffer]
+                    : undefined);
+            };
+            switch (request.type) {
+                case "ForEvolu": {
+                    switch (request.message.type) {
+                        case "Mutate": {
+                            const result = handleMutation({ ...dbDeps, clock })(request.message);
+                            if (!result.ok) {
+                                port.postMessage({ type: "OnError", error: result.error });
+                            }
+                            else {
+                                postQueuedResponse({
+                                    type: "ForEvolu",
+                                    evoluPortId: request.evoluPortId,
+                                    message: result.value,
+                                });
+                            }
+                            break;
+                        }
+                        case "Query":
+                            postQueuedResponse({
+                                type: "ForEvolu",
+                                evoluPortId: request.evoluPortId,
+                                message: {
+                                    type: "Query",
+                                    rowsByQuery: loadQueries(dbDeps)(request.message.queries),
+                                },
+                            });
+                            break;
+                        case "Export":
+                            postQueuedResponse({
+                                type: "ForEvolu",
+                                evoluPortId: request.evoluPortId,
+                                message: {
+                                    type: "Export",
+                                    file: dbDeps.sqlite.export(),
+                                },
+                            });
+                            break;
+                        default:
+                            exhaustiveCheck(request.message);
+                    }
+                    break;
+                }
+                case "ForSharedWorker": {
+                    switch (request.message.type) {
+                        case "CreateSyncMessages": {
+                            const protocolMessagesByOwnerId = new Map();
+                            for (const owner of request.message.owners) {
+                                storage.setOwnerState(owner.encryptionKey);
+                                const protocolMessage = createProtocolMessageForSync({
+                                    storage,
+                                    console,
+                                })(owner.id, SubscriptionFlags.Subscribe);
+                                if (protocolMessage) {
+                                    protocolMessagesByOwnerId.set(owner.id, protocolMessage);
+                                }
+                            }
+                            postQueuedResponse({
+                                type: "ForSharedWorker",
+                                message: {
+                                    type: "CreateSyncMessages",
+                                    protocolMessagesByOwnerId,
+                                },
+                            });
+                            break;
+                        }
+                        case "ApplySyncMessage": {
+                            const { owner, inputMessage } = request.message;
+                            runWithStorage(async (run) => {
+                                storage.setOwnerState(owner.encryptionKey);
+                                const result = await run(applyProtocolMessageAsClient(inputMessage, {
+                                    writeKey: owner.writeKey,
+                                }));
+                                const didWriteMessages = storage.didWriteMessages();
+                                postQueuedResponse({
+                                    type: "ForSharedWorker",
+                                    message: {
+                                        type: "ApplySyncMessage",
+                                        ownerId: owner.id,
+                                        didWriteMessages,
+                                        result,
+                                    },
+                                });
+                                return ok();
+                            });
+                            break;
+                        }
+                        default:
+                            exhaustiveCheck(request.message);
+                    }
+                    break;
+                }
+                default:
+                    exhaustiveCheck(request);
+            }
+        };
+        return ok();
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
 };
-const initializeDb = (deps) => (initialAppOwner, initialClock) => {
+const createClock = (deps) => (dbIsInitialized) => {
+    let currentTimestamp;
+    if (dbIsInitialized) {
+        const { rows } = deps.sqlite.exec(sql `
+        select clock
+        from evolu_config
+        limit 1;
+      `);
+        assertNonEmptyReadonlyArray(rows);
+        currentTimestamp = timestampBytesToTimestamp(firstInArray(rows).clock);
+    }
+    else {
+        currentTimestamp = createInitialTimestamp(deps);
+    }
+    return {
+        get: () => currentTimestamp,
+        save: (timestamp) => {
+            currentTimestamp = timestamp;
+            deps.sqlite.exec(sql.prepared `
+          update evolu_config
+          set "clock" = ${timestampToTimestampBytes(timestamp)};
+        `);
+        },
+    };
+};
+const initializeDb = ({ sqlite }) => (initialClock) => {
     for (const query of [
-        // Never change structure to ensure all versions can read it.
         sql `
         create table evolu_version (
           "protocolVersion" integer not null
@@ -142,31 +288,13 @@ const initializeDb = (deps) => (initialAppOwner, initialClock) => {
       `,
         sql `
         create table evolu_config (
-          "clock" blob not null,
-          "appOwnerId" text not null,
-          "appOwnerEncryptionKey" blob not null,
-          "appOwnerWriteKey" blob not null,
-          "appOwnerMnemonic" text
+          "clock" blob not null
         )
         strict;
       `,
         sql `
-        insert into evolu_config
-          (
-            "clock",
-            "appOwnerId",
-            "appOwnerEncryptionKey",
-            "appOwnerWriteKey",
-            "appOwnerMnemonic"
-          )
-        values
-          (
-            ${timestampToTimestampBytes(initialClock)},
-            ${initialAppOwner.id},
-            ${initialAppOwner.encryptionKey},
-            ${initialAppOwner.writeKey},
-            ${initialAppOwner.mnemonic ?? null}
-          );
+        insert into evolu_config ("clock")
+        values (${timestampToTimestampBytes(initialClock)});
       `,
         /**
          * The History table stores all values per ownerId, timestamp, table, id,
@@ -202,167 +330,368 @@ const initializeDb = (deps) => (initialAppOwner, initialClock) => {
           "timestamp" desc
         );
       `,
+        /**
+         * Stores messages with unknown schema in a quarantine table.
+         *
+         * When a device receives sync messages containing tables or columns that
+         * don't exist in its current schema (e.g., from a newer app version),
+         * those messages are stored here instead of being discarded. This enables
+         * forward compatibility:
+         *
+         * 1. Unknown data is preserved and can be applied when the app is updated
+         * 2. Messages are still propagated to other devices that may understand them
+         * 3. Partial messages work - known columns go to app tables, unknown to
+         *    quarantine
+         *
+         * The `union all` query in `readDbChange` combines `evolu_history` and
+         * this table, ensuring all data (known and unknown) is included when
+         * syncing to other devices.
+         */
+        sql `
+        create table evolu_message_quarantine (
+          "ownerId" blob not null,
+          "timestamp" blob not null,
+          "table" text not null,
+          "id" blob not null,
+          "column" text not null,
+          "value" any,
+          primary key ("ownerId", "timestamp", "table", "id", "column")
+        )
+        strict;
+      `,
     ]) {
-        const result = deps.sqlite.exec(query);
-        if (!result.ok)
-            return result;
+        sqlite.exec(query);
     }
-    const result = createBaseSqliteStorageTables(deps);
-    if (!result.ok)
-        return result;
-    return ok();
+    createBaseSqliteStorageTables({ sqlite });
 };
-/**
- * Ensures the quarantine table exists for storing messages with unknown schema.
- *
- * When a device receives sync messages containing tables or columns that don't
- * exist in its current schema (e.g., from a newer app version), those messages
- * are stored here instead of being discarded. This enables forward
- * compatibility:
- *
- * 1. Unknown data is preserved and can be applied when the app is updated
- * 2. Messages are still propagated to other devices that may understand them
- * 3. Partial messages work - known columns go to app tables, unknown to quarantine
- *
- * The `union all` query in `readDbChange` combines `evolu_history` and this
- * table, ensuring all data (known and unknown) is included when syncing to
- * other devices.
- */
-const ensureMessageQuarantineTable = (deps) => {
-    const result = deps.sqlite.exec(sql `
-    create table if not exists evolu_message_quarantine (
-      "ownerId" blob not null,
-      "timestamp" blob not null,
-      "table" text not null,
-      "id" blob not null,
-      "column" text not null,
-      "value" any,
-      primary key ("ownerId", "timestamp", "table", "id", "column")
-    )
-    strict;
+const tryApplyQuarantinedMessages = (deps) => {
+    const rows = deps.sqlite.exec(sql `
+    select "ownerId", "timestamp", "table", "id", "column", "value"
+    from evolu_message_quarantine;
   `);
-    if (!result.ok)
-        return result;
-    return ok();
+    for (const row of rows.rows) {
+        if (!validateColumnValue(deps)(row.table, row.column, row.value))
+            continue;
+        applyColumnChange(deps)(row.ownerId, ownerIdBytesToOwnerId(row.ownerId), row.table, row.id, idBytesToId(row.id), row.column, row.value, row.timestamp);
+        deps.sqlite.exec(sql `
+      delete from evolu_message_quarantine
+      where
+        "ownerId" = ${row.ownerId}
+        and "timestamp" = ${row.timestamp}
+        and "table" = ${row.table}
+        and "id" = ${row.id}
+        and "column" = ${row.column};
+    `);
+    }
 };
-const handlers = {
-    getAppOwner: (deps) => () => {
-        deps.postMessage({
-            type: "onGetAppOwner",
-            appOwner: deps.appOwner,
-        });
-    },
-    mutate: (deps) => (message) => {
-        const mutate = deps.sqlite.transaction(() => {
-            const syncChanges = [];
-            for (const change of message.changes) {
-                const isLocalOnlyChange = change.table.startsWith("_");
-                if (isLocalOnlyChange) {
-                    const result = applyLocalOnlyChange(deps)(change);
-                    if (!result.ok)
-                        return result;
-                }
-                else {
-                    syncChanges.push(change);
+const validateColumnValue = (deps) => (table, column, _value) => {
+    const schemaColumns = getProperty(deps.sqliteSchema.tables, table);
+    return (schemaColumns != null &&
+        (systemColumnsWithoutOwnerId.has(column) || schemaColumns.has(column)));
+};
+const systemColumnsWithoutOwnerId = systemColumns.difference(new Set(["ownerId"]));
+const applyColumnChange = (deps) => (ownerIdBytes, ownerId, table, idBytes, id, column, value, timestampBytes) => {
+    deps.sqlite.exec(sql.prepared `
+      with
+        existingTimestamp as (
+          select 1
+          from evolu_history
+          where
+            "ownerId" = ${ownerIdBytes}
+            and "table" = ${table}
+            and "id" = ${idBytes}
+            and "column" = ${column}
+            and "timestamp" >= ${timestampBytes}
+          limit 1
+        )
+      insert into ${sql.identifier(table)}
+        ("ownerId", "id", ${sql.identifier(column)})
+      select ${ownerId}, ${id}, ${value}
+      where not exists (select 1 from existingTimestamp)
+      on conflict ("ownerId", "id") do update
+        set ${sql.identifier(column)} = ${value}
+        where not exists (select 1 from existingTimestamp);
+    `);
+    deps.sqlite.exec(sql.prepared `
+      insert into evolu_history
+        ("ownerId", "table", "id", "column", "value", "timestamp")
+      values
+        (
+          ${ownerIdBytes},
+          ${table},
+          ${idBytes},
+          ${column},
+          ${value},
+          ${timestampBytes}
+        )
+      on conflict do nothing;
+    `);
+};
+const createClientStorage = (deps) => ({ onError, }) => {
+    let encryptionKey = null;
+    let didWriteMessages = false;
+    const getEncryptionKey = () => {
+        assert(encryptionKey != null, "ClientStorage encryption key must be set");
+        return encryptionKey;
+    };
+    return {
+        ...deps.baseSqliteStorage,
+        // DEV: ClientStorage was designed when Storage and Sync lived in the
+        // same file.
+        // This is safe because the worker handles one message at a time. We will
+        // refactor it later, we will probably have to change Protocol API.
+        setOwnerState: (nextEncryptionKey) => {
+            encryptionKey = nextEncryptionKey;
+            didWriteMessages = false;
+        },
+        didWriteMessages: () => didWriteMessages,
+        // Not implemented yet.
+        validateWriteKey: lazyFalse,
+        setWriteKey: lazyVoid,
+        writeMessages: (ownerIdBytes, encryptedMessages) => () => {
+            // TODO: Add quota checking for collaborative scenarios.
+            // When receiving messages from other owners via relay broadcast,
+            // check if this owner is within quota before accepting the data.
+            // This prevents an owner from exceeding storage limits when receiving
+            // data shared by other collaborators.
+            const messages = [];
+            const currentEncryptionKey = getEncryptionKey();
+            for (const message of encryptedMessages) {
+                const change = decryptAndDecodeDbChange(message, currentEncryptionKey);
+                if (!change.ok) {
+                    onError(change.error);
+                    return ok();
                 }
+                messages.push({ timestamp: message.timestamp, change: change.value });
             }
-            if (isNonEmptyArray(syncChanges)) {
-                const result = deps.sync.applyChanges(syncChanges);
-                if (!result.ok)
-                    return result;
+            let clockTimestamp = deps.clock.get();
+            for (const message of messages) {
+                const nextTimestamp = receiveTimestamp(deps)(clockTimestamp, message.timestamp);
+                if (!nextTimestamp.ok) {
+                    onError(nextTimestamp.error);
+                    return ok();
+                }
+                clockTimestamp = nextTimestamp.value;
             }
-            // Read writes before commit to update UI ASAP
-            const queryPatches = loadQueries(deps)(message.tabId, message.subscribedQueries);
-            if (!queryPatches.ok)
-                return queryPatches;
-            // Update the tab that performed the mutation.
-            deps.postMessage({
-                type: "onQueryPatches",
-                tabId: message.tabId,
-                queryPatches: queryPatches.value,
-                onCompleteIds: message.onCompleteIds,
+            assertNonEmptyReadonlyArray(messages);
+            return deps.sqlite.transaction(() => {
+                applyMessages(deps)(ownerIdBytesToOwnerId(ownerIdBytes), messages);
+                deps.clock.save(clockTimestamp);
+                didWriteMessages = true;
+                return ok();
             });
-            // Notify other tabs to refresh their queries.
-            deps.postMessage({ type: "refreshQueries", tabId: message.tabId });
-            return ok();
-        });
-        if (!mutate.ok) {
-            deps.postMessage({ type: "onError", error: mutate.error });
-            return;
-        }
-    },
-    query: (deps) => (message) => {
-        const queryPatches = loadQueries(deps)(message.tabId, message.queries);
-        if (!queryPatches.ok) {
-            deps.postMessage({ type: "onError", error: queryPatches.error });
-            return;
-        }
-        deps.postMessage({
-            type: "onQueryPatches",
-            tabId: message.tabId,
-            queryPatches: queryPatches.value,
-            onCompleteIds: [],
-        });
-    },
-    reset: (deps) => (message) => {
-        const result = deps.sqlite.transaction(() => {
-            const dbSchema = getDbSchema(deps)();
-            if (!dbSchema.ok)
-                return dbSchema;
-            for (const tableName in dbSchema.value.tables) {
-                /**
-                 * The dropped table is completely removed from the database schema and
-                 * the disk file. The table can not be recovered. All indices and
-                 * triggers associated with the table are also deleted.
-                 * https://sqlite.org/lang_droptable.html
-                 */
-                const result = deps.sqlite.exec(sql `
-          drop table ${sql.identifier(tableName)};
+        },
+        readDbChange: (ownerId, timestamp) => {
+            const result = deps.sqlite.exec(sql `
+          select "table", "id", "column", "value"
+          from evolu_history
+          where "ownerId" = ${ownerId} and "timestamp" = ${timestamp}
+          union all
+          select "table", "id", "column", "value"
+          from evolu_message_quarantine
+          where "ownerId" = ${ownerId} and "timestamp" = ${timestamp};
         `);
-                if (!result.ok)
-                    return result;
-            }
-            if (message.restore) {
-                const result = ensureDbSchema(deps)(message.restore.dbSchema);
-                if (!result.ok)
-                    return result;
-                const secret = mnemonicToOwnerSecret(message.restore.mnemonic);
-                const appOwner = createAppOwner(secret);
-                const clock = createClock(deps)();
-                return initializeDb(deps)(appOwner, clock.get());
+            const { rows } = result;
+            assertNonEmptyReadonlyArray(rows, "Every timestamp must have rows");
+            const firstRow = firstInArray(rows);
+            const values = createRecord();
+            let isInsert = false;
+            let isDelete = null;
+            for (const r of rows) {
+                switch (r.column) {
+                    case "createdAt":
+                        isInsert = true;
+                        break;
+                    case "updatedAt":
+                        isInsert = false;
+                        break;
+                    case "isDeleted":
+                        if (SqliteBoolean.is(r.value)) {
+                            isDelete = sqliteBooleanToBoolean(r.value);
+                        }
+                        break;
+                    default:
+                        values[r.column] = r.value;
+                }
             }
-            return ok();
-        });
-        if (!result.ok) {
-            deps.postMessage({ type: "onError", error: result.error });
-            return;
+            const message = {
+                timestamp: timestampBytesToTimestamp(timestamp),
+                change: DbChange.orThrow({
+                    table: firstRow.table,
+                    id: idBytesToId(firstRow.id),
+                    values,
+                    isInsert,
+                    isDelete,
+                }),
+            };
+            return encodeAndEncryptDbChange(deps)(message, getEncryptionKey());
+        },
+    };
+};
+const handleMutation = (deps) => (message) => deps.sqlite.transaction(() => {
+    const messagesByOwnerId = new Map();
+    let clockTimestamp = deps.clock.get();
+    let clockChanged = false;
+    for (const change of message.changes) {
+        if (change.table.startsWith("_")) {
+            applyLocalOnlyChange(deps)(change);
+            continue;
         }
-        deps.postMessage({
-            type: "onReset",
-            onCompleteId: message.onCompleteId,
-            reload: message.reload,
-        });
-    },
-    ensureDbSchema: (deps) => (message) => {
-        const result = deps.sqlite.transaction(() => ensureDbSchema(deps)(message.dbSchema));
-        if (!result.ok) {
-            deps.postMessage({ type: "onError", error: result.error });
-            return;
+        const nextTimestamp = sendTimestamp(deps)(clockTimestamp);
+        if (!nextTimestamp.ok)
+            return nextTimestamp;
+        clockTimestamp = nextTimestamp.value;
+        clockChanged = true;
+        const { ownerId, ...dbChange } = change;
+        const message = {
+            timestamp: clockTimestamp,
+            change: dbChange,
+        };
+        const messages = messagesByOwnerId.get(ownerId);
+        if (messages)
+            messages.push(message);
+        else
+            messagesByOwnerId.set(ownerId, [message]);
+    }
+    for (const [ownerId, messages] of messagesByOwnerId) {
+        applyMessages(deps)(ownerId, messages);
+    }
+    if (clockChanged)
+        deps.clock.save(clockTimestamp);
+    return ok({
+        type: "Mutate",
+        messagesByOwnerId,
+        rowsByQuery: loadQueries(deps)(message.subscribedQueries),
+    });
+});
+const applyLocalOnlyChange = (deps) => (change) => {
+    if (change.isDelete) {
+        deps.sqlite.exec(sql `
+        delete from ${sql.identifier(change.table)}
+        where id = ${change.id};
+      `);
+    }
+    else {
+        const ownerId = change.ownerId;
+        const columns = dbChangeToColumns(change, deps.time.now());
+        for (const [column, value] of columns) {
+            deps.sqlite.exec(sql.prepared `
+          insert into ${sql.identifier(change.table)}
+            ("ownerId", "id", ${sql.identifier(column)})
+          values (${ownerId}, ${change.id}, ${value})
+          on conflict ("ownerId", "id") do update
+            set ${sql.identifier(column)} = ${value};
+        `);
         }
-    },
-    export: (deps) => (message) => {
-        const file = deps.sqlite.export();
-        if (!file.ok) {
-            deps.postMessage({ type: "onError", error: file.error });
-            return;
+    }
+};
+const applyMessages = (deps) => (ownerId, messages) => {
+    const ownerIdBytes = ownerIdToOwnerIdBytes(ownerId);
+    const usage = getOwnerUsage(deps)(ownerIdBytes, timestampToTimestampBytes(firstInArray(messages).timestamp));
+    if (!usage.ok)
+        return;
+    let { firstTimestamp, lastTimestamp } = usage.value;
+    for (const { timestamp, change } of messages) {
+        const columns = dbChangeToColumns(change, timestamp.millis);
+        const idBytes = idToIdBytes(change.id);
+        const timestampBytes = timestampToTimestampBytes(timestamp);
+        for (const [column, value] of columns) {
+            if (validateColumnValue(deps)(change.table, column, value)) {
+                applyColumnChange(deps)(ownerIdBytes, ownerId, change.table, idBytes, change.id, column, value, timestampBytes);
+            }
+            else {
+                deps.sqlite.exec(sql.prepared `
+            insert into evolu_message_quarantine
+              ("ownerId", "timestamp", "table", "id", "column", "value")
+            values
+              (
+                ${ownerIdBytes},
+                ${timestampBytes},
+                ${change.table},
+                ${idBytes},
+                ${column},
+                ${value}
+              )
+            on conflict do nothing;
+          `);
+            }
         }
-        deps.postMessage({
-            type: "onExport",
-            onCompleteId: message.onCompleteId,
-            file: file.value,
-        });
-    },
-    useOwner: (deps) => (message) => {
-        deps.sync.useOwner(message.use, message.owner);
-    },
+        let strategy;
+        [strategy, firstTimestamp, lastTimestamp] = getTimestampInsertStrategy(timestampBytes, firstTimestamp, lastTimestamp);
+        deps.baseSqliteStorage.insertTimestamp(ownerIdBytes, timestampBytes, strategy);
+    }
+    /**
+     * TODO: Implement proper storedBytes tracking for client using received and
+     * sent encrypted message sizes.
+     */
+    updateOwnerUsage(deps)(ownerIdBytes, onePositiveInt, // Placeholder until proper tracking implemented
+    firstTimestamp, lastTimestamp);
+};
+const dbChangeToColumns = (change, now) => {
+    let values = objectToEntries(change.values);
+    // SystemColumns are not encoded in change.values.
+    values = appendToArray(values, [
+        change.isInsert ? "createdAt" : "updatedAt",
+        millisToDateIso(now),
+    ]);
+    if (change.isDelete != null) {
+        values = appendToArray(values, [
+            "isDeleted",
+            booleanToSqliteBoolean(change.isDelete),
+        ]);
+    }
+    return values;
+};
+const loadQueries = (deps) => (queries) => {
+    const rowsByQuery = new Map();
+    for (const query of queries) {
+        const { rows } = deps.sqlite.exec(sqliteQueryStringToSqliteQuery(query));
+        rowsByQuery.set(query, rows);
+    }
+    return rowsByQuery;
 };
+//   reset: (deps) => (message) => {
+//     const result = deps.sqlite.transaction(() => {
+//       const sqliteSchema = getSqliteSchema(deps)();
+//       if (!sqliteSchema.ok) return sqliteSchema;
+//       for (const tableName in sqliteSchema.value.tables) {
+//         /**
+//          * The dropped table is completely removed from the database schema and
+//          * the disk file. The table can not be recovered. All indices and
+//          * triggers associated with the table are also deleted.
+//          * https://sqlite.org/lang_droptable.html
+//          */
+//         const result = deps.sqlite.exec(sql`
+//           drop table ${sql.identifier(tableName)};
+//         `);
+//         if (!result.ok) return result;
+//       }
+//       if (message.restore) {
+//         const result = ensureSqliteSchema(deps)(message.restore.sqliteSchema);
+//         if (!result.ok) return result;
+//         const secret = mnemonicToOwnerSecret(message.restore.mnemonic);
+//         const appOwner = createAppOwner(secret);
+//         const clock = createClock(deps)();
+//         return initializeDb(deps)(appOwner, clock.get());
+//       }
+//       return ok();
+//     });
+//     if (!result.ok) {
+//       deps.postMessage({ type: "onError", error: result.error });
+//       return;
+//     }
+//     deps.postMessage({
+//       type: "onReset",
+//       onCompleteId: message.onCompleteId,
+//       reload: message.reload,
+//     });
+//   },
+//   ensureSqliteSchema: (deps) => (message) => {
+//     const result = deps.sqlite.transaction(() =>
+//       ensureSqliteSchema(deps)(message.sqliteSchema),
+//     );
+//     if (!result.ok) {
+//       deps.postMessage({ type: "onError", error: result.error });
+//       return;
+//     }
+//   },