@evolu/common 7.4.1 → 8.0.0-next.1

package/src/local-first/Db.ts

@@ -1,483 +1,406 @@
+/**
+ * Platform-agnostic Evolu DbWorker.
+ *
+ * @module
+ */
+
 import {
+  appendToArray,
   firstInArray,
-  isNonEmptyArray,
-  NonEmptyReadonlyArray,
+  type NonEmptyArray,
+  type NonEmptyReadonlyArray,
 } from "../Array.js";
-import { assertNonEmptyReadonlyArray } from "../Assert.js";
-import { CallbackId } from "../Callbacks.js";
-import { ConsoleConfig, ConsoleDep } from "../Console.js";
+import { assert, assertNonEmptyReadonlyArray, assertType } from "../Assert.js";
+import type { ConsoleLevel } from "../Console.js";
 import {
-  createSymmetricCrypto,
   EncryptionKey,
-  RandomBytesDep,
-  SymmetricCryptoDecryptError,
+  type DecryptWithXChaCha20Poly1305Error,
+  type RandomBytesDep,
 } from "../Crypto.js";
-import { TransferableError } from "../Error.js";
-import { RandomDep } from "../Random.js";
-import { ok, Result } from "../Result.js";
+import { exhaustiveCheck, lazyFalse, lazyVoid } from "../Function.js";
+import { createRecord, getProperty, objectToEntries } from "../Object.js";
+import { ok, type Result } from "../Result.js";
+import type {
+  CreateSqliteDriverDep,
+  SqliteDep,
+  SqliteRow,
+  SqliteSchema,
+} from "../Sqlite.js";
 import {
+  booleanToSqliteBoolean,
   createSqlite,
-  CreateSqliteDriverDep,
   sql,
-  SqliteDep,
-  SqliteError,
+  SqliteBoolean,
+  sqliteBooleanToBoolean,
+  sqliteQueryStringToSqliteQuery,
+  SqliteValue,
 } from "../Sqlite.js";
-import { TimeDep } from "../Time.js";
-import { Id, Mnemonic, SimpleName } from "../Type.js";
-import { CreateWebSocketDep } from "../WebSocket.js";
+import { callback, type LeaderLockDep, type Task } from "../Task.js";
+import { Millis, millisToDateIso, type TimeDep } from "../Time.js";
+import type { Name } from "../Type.js";
 import {
-  createInitializedWorkerWithHandlers,
-  MessageHandlers,
+  Id,
+  IdBytes,
+  idBytesToId,
+  idToIdBytes,
+  onePositiveInt,
+} from "../Type.js";
+import type { ExtractType } from "../Types.js";
+import type {
+  NativeMessagePort,
   Worker,
+  WorkerDeps,
+  WorkerSelf,
 } from "../Worker.js";
+import type { OwnerId, OwnerIdBytes } from "./Owner.js";
+import { ownerIdBytesToOwnerId, ownerIdToOwnerIdBytes } from "./Owner.js";
 import {
-  AppOwner,
-  AppOwnerDep,
-  createAppOwner,
-  createOwnerSecret,
-  createOwnerWebSocketTransport,
-  mnemonicToOwnerSecret,
-  OwnerEncryptionKey,
-  OwnerId,
-  OwnerTransport,
-  OwnerWriteKey,
-} from "./Owner.js";
-import { ProtocolError, protocolVersion } from "./Protocol.js";
+  applyProtocolMessageAsClient,
+  createProtocolMessageForSync,
+  decryptAndDecodeDbChange,
+  encodeAndEncryptDbChange,
+  protocolVersion,
+  SubscriptionFlags,
+  type ProtocolInvalidDataError,
+  type ProtocolMessage,
+  type ProtocolTimestampMismatchError,
+} from "./Protocol.js";
+import type { Query, RowsByQueryMap } from "./Query.js";
+import type { MutationChange, SqliteSchemaDep } from "./Schema.js";
 import {
-  createGetQueryRowsCache,
-  GetQueryRowsCacheDep,
-  loadQueries,
-  Query,
-  QueryPatches,
-} from "./Query.js";
-import {
-  DbSchema,
-  ensureDbSchema,
-  getDbSchema,
-  MutationChange,
+  ensureSqliteSchema,
+  getEvoluSqliteSchema,
+  systemColumns,
 } from "./Schema.js";
-import { createBaseSqliteStorageTables } from "./Storage.js";
-import {
-  applyLocalOnlyChange,
-  Clock,
-  createClock,
-  createSync,
-  SyncDep,
-  SyncOwner,
-  tryApplyQuarantinedMessages,
-} from "./Sync.js";
+import type { DbWorkerInput, DbWorkerOutput } from "./Shared.js";
 import {
+  createBaseSqliteStorage,
+  createBaseSqliteStorageTables,
+  DbChange,
+  getTimestampInsertStrategy,
+  readOwnerUsageOrDefault,
+  updateOwnerUsage,
+  type BaseSqliteStorage,
+  type BaseSqliteStorageDep,
+  type CrdtMessage,
+  type Storage,
+} from "./Storage.js";
+import type {
   Timestamp,
+  TimestampCounterOverflowError,
+  TimestampDriftError,
+  TimestampTimeOutOfRangeError,
+} from "./Timestamp.js";
+import {
+  createInitialTimestamp,
+  defaultTimestampMaxDrift,
+  receiveTimestamp,
+  sendTimestamp,
   TimestampBytes,
   timestampBytesToTimestamp,
-  TimestampConfig,
-  TimestampError,
   timestampToTimestampBytes,
+  type TimestampConfigDep,
 } from "./Timestamp.js";
 
-export interface DbConfig extends ConsoleConfig, TimestampConfig {
-  /**
-   * The name of the Evolu instance. Evolu is multitenant - it can run multiple
-   * instances concurrently. Each instance must have a unique name.
-   *
-   * The instance name is used as the SQLite database filename for persistent
-   * storage, ensuring that database files are separated and invisible to each
-   * other.
-   *
-   * The default value is: `Evolu`.
-   *
-   * ### Example
-   *
-   * ```ts
-   * // name: SimpleName.orThrow("MyApp")
-   * ```
-   */
-  readonly name: SimpleName;
-
-  /**
-   * Transport configuration for data sync and backup. Supports single transport
-   * or multiple transports simultaneously for redundancy.
-   *
-   * **Redundancy:** The ideal setup uses at least two completely independent
-   * relays - for example, a home relay and a geographically separate relay.
-   * Data is sent to both relays simultaneously, providing true redundancy
-   * similar to using two independent clouds. This eliminates vendor lock-in and
-   * ensures your app continues working regardless of circumstances - whether
-   * home relay hardware is stolen or a remote relay provider shuts down.
-   *
-   * Currently supports:
-   *
-   * - WebSocket: Real-time bidirectional communication with relay servers
-   *
-   * Empty transports create local-only instances. Transports can be dynamically
-   * added and removed for any owner (including {@link AppOwner}) via
-   * {@link Evolu#useOwner}.
-   *
-   * Use {@link createOwnerWebSocketTransport} to create WebSocket transport
-   * configurations with proper URL formatting and {@link OwnerId} inclusion. The
-   * {@link OwnerId} in the URL enables relay authentication, allowing relay
-   * servers to control access (e.g., for paid tiers or private instances).
-   *
-   * The default value is:
-   *
-   * `{ type: "WebSocket", url: "wss://free.evoluhq.com" }`.
-   *
-   * ### Example
-   *
-   * ```ts
-   * // Single WebSocket relay
-   * transports: [{ type: "WebSocket", url: "wss://relay1.example.com" }];
-   *
-   * // Multiple WebSocket relays for redundancy
-   * transports: [
-   *   { type: "WebSocket", url: "wss://relay1.example.com" },
-   *   { type: "WebSocket", url: "wss://relay2.example.com" },
-   *   { type: "WebSocket", url: "wss://relay3.example.com" },
-   * ];
-   *
-   * // Local-only instance (no sync) - useful for device settings or when relay
-   * // URL will be provided later (e.g., after authentication), allowing users
-   * // to work offline before the app connects
-   * transports: [];
-   *
-   * // Using createOwnerWebSocketTransport helper for relay authentication
-   * transports: [
-   *   createOwnerWebSocketTransport({
-   *     url: "ws://localhost:4000",
-   *     ownerId,
-   *   }),
-   * ];
-   * ```
-   */
-  readonly transports: ReadonlyArray<OwnerTransport>;
-
-  /**
-   * External AppOwner to use when creating Evolu instance. Use this when you
-   * want to manage AppOwner creation and persistence externally (e.g., with
-   * your own authentication system). If omitted, Evolu will automatically
-   * create and persist an AppOwner locally.
-   *
-   * For device-specific settings and account management state, we can use a
-   * separate local-only Evolu instance via `transports: []`.
-   *
-   * ### Example
-   *
-   * ```ts
-   * const ConfigId = id("Config");
-   * type ConfigId = typeof ConfigId.Type;
-   *
-   * const DeviceSchema = {
-   *   config: {
-   *     id: ConfigId,
-   *     key: NonEmptyString50,
-   *     value: NonEmptyString50,
-   *   },
-   * };
-   *
-   * // Local-only instance for device settings (no sync)
-   * const deviceEvolu = createEvolu(evoluReactWebDeps)(DeviceSchema, {
-   *   name: SimpleName.orThrow("MyApp-Device"),
-   *   transports: [], // No sync - stays local to device
-   * });
-   *
-   * // Main synced instance for user data
-   * const evolu = createEvolu(evoluReactWebDeps)(MainSchema, {
-   *   name: SimpleName.orThrow("MyApp"),
-   *   // Default transports for sync
-   * });
-   * ```
-   */
-  readonly externalAppOwner?: AppOwner;
-
-  /**
-   * Use in-memory SQLite database instead of persistent storage. Useful for
-   * testing or temporary data that doesn't need persistence.
-   *
-   * In-memory databases exist only in RAM and are completely destroyed when the
-   * process ends, making them forensically safe for sensitive data.
-   *
-   * The default value is: `false`.
-   */
-  readonly inMemory?: boolean;
-
-  /**
-   * Encryption key for the SQLite database.
-   *
-   * Note: If an unencrypted SQLite database already exists and you provide an
-   * encryptionKey, SQLite will throw an error.
-   *
-   * @experimental
-   */
-  readonly encryptionKey?: EncryptionKey;
-}
-
-export const defaultDbConfig: DbConfig = {
-  name: SimpleName.orThrow("Evolu"),
-  transports: [{ type: "WebSocket", url: "wss://free.evoluhq.com" }],
-  maxDrift: 5 * 60 * 1000,
-  enableLogging: false,
-};
+export type DbWorker = Worker<DbWorkerInit>;
 
-export type DbWorker = Worker<DbWorkerInput, DbWorkerOutput>;
+export interface DbWorkerInit {
+  readonly type: "Init";
+  readonly name: Name;
+  readonly consoleLevel: ConsoleLevel;
+  readonly sqliteSchema: SqliteSchema;
+  readonly encryptionKey: EncryptionKey;
+  readonly memoryOnly: boolean;
+  readonly port: NativeMessagePort<DbWorkerOutput, DbWorkerInput>;
+}
 
-export type CreateDbWorker = (name: SimpleName) => DbWorker;
+export type CreateDbWorker = () => DbWorker;
 
 export interface CreateDbWorkerDep {
   readonly createDbWorker: CreateDbWorker;
 }
 
-export type DbWorkerInput =
-  | {
-      readonly type: "init";
-      readonly config: DbConfig;
-      readonly dbSchema: DbSchema;
-    }
-  | {
-      readonly type: "getAppOwner";
-    }
-  | {
-      readonly type: "mutate";
-      readonly tabId: Id;
-      readonly changes: NonEmptyReadonlyArray<MutationChange>;
-      readonly onCompleteIds: ReadonlyArray<CallbackId>;
-      readonly subscribedQueries: ReadonlyArray<Query>;
-    }
-  | {
-      readonly type: "query";
-      readonly tabId: Id;
-      readonly queries: NonEmptyReadonlyArray<Query>;
-    }
-  | {
-      readonly type: "reset";
-      readonly onCompleteId: CallbackId;
-      readonly reload: boolean;
-      readonly restore?: {
-        readonly dbSchema: DbSchema;
-        readonly mnemonic: Mnemonic;
-      };
-    }
-  | {
-      readonly type: "ensureDbSchema";
-      readonly dbSchema: DbSchema;
-    }
-  | {
-      readonly type: "export";
-      readonly onCompleteId: CallbackId;
-    }
-  | {
-      readonly type: "useOwner";
-      readonly use: boolean;
-      readonly owner: SyncOwner;
-    };
-
-export type DbWorkerOutput =
-  | {
-      readonly type: "onError";
-      readonly error:
-        | ProtocolError
-        | SqliteError
-        | SymmetricCryptoDecryptError
-        | TimestampError
-        | TransferableError;
-    }
-  | {
-      readonly type: "onGetAppOwner";
-      readonly appOwner: AppOwner;
-    }
-  | {
-      readonly type: "onQueryPatches";
-      readonly tabId: Id;
-      readonly queryPatches: ReadonlyArray<QueryPatches>;
-      readonly onCompleteIds: ReadonlyArray<CallbackId>;
-    }
-  | {
-      readonly type: "refreshQueries";
-      readonly tabId?: Id;
-    }
-  | {
-      readonly type: "onReset";
-      readonly onCompleteId: CallbackId;
-      readonly reload: boolean;
-    }
-  | {
-      readonly type: "onExport";
-      readonly onCompleteId: CallbackId;
-      readonly file: Uint8Array;
-    };
+export type DbWorkerDeps = WorkerDeps & LeaderLockDep & CreateSqliteDriverDep;
+
+export const startDbWorker =
+  (self: WorkerSelf<DbWorkerInit>): Task<void, never, DbWorkerDeps> =>
+  async (_run) => {
+    await using stack = new AsyncDisposableStack();
+    const run = stack.use(_run.create());
+    const { deps } = run;
+
+    let initialized = false;
+
+    const initMessage = await run.orThrow(
+      callback<DbWorkerInit>(({ ok }) => {
+        self.onMessage = (message) => {
+          assert(!initialized, "DbWorker must be initialized only once");
+          initialized = true;
+          ok(message);
+        };
+      }),
+    );
 
-export type DbWorkerPlatformDeps = ConsoleDep &
-  CreateSqliteDriverDep &
-  CreateWebSocketDep &
-  RandomBytesDep &
-  RandomDep &
-  TimeDep;
-
-type DbWorkerDeps = Omit<
-  DbWorkerPlatformDeps,
-  keyof CreateSqliteDriverDep | keyof CreateWebSocketDep
-> &
-  AppOwnerDep &
-  GetQueryRowsCacheDep &
-  PostMessageDep &
-  SqliteDep &
-  SyncDep;
-
-export interface PostMessageDep {
-  readonly postMessage: (message: DbWorkerOutput) => void;
-}
+    const console = deps.console.child(initMessage.name).child("DbWorker");
+    console.setLevel(initMessage.consoleLevel);
+    console.info("start DbWorker");
 
-export const createDbWorkerForPlatform = (
-  platformDeps: DbWorkerPlatformDeps,
-): DbWorker =>
-  createInitializedWorkerWithHandlers<
-    DbWorkerInput,
-    DbWorkerOutput,
-    DbWorkerDeps
-  >({
-    init: async (initMessage, postMessage) => {
-      platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
-
-      const deps = await createDbWorkerDeps(
-        platformDeps,
-        initMessage,
-        postMessage,
-      );
+    const port = stack.use(
+      deps.createMessagePort<DbWorkerOutput, DbWorkerInput>(initMessage.port),
+    );
 
-      if (!deps.ok) {
-        postMessage({ type: "onError", error: deps.error });
-        return null;
-      }
+    stack.defer(
+      deps.consoleStoreOutputEntry.subscribe(() => {
+        const entry = deps.consoleStoreOutputEntry.get();
+        if (entry) port.postMessage({ type: "OnConsoleEntry", entry });
+      }),
+    );
 
-      return deps.value;
-    },
-    handlers,
-  });
+    stack.use(await run.orThrow(deps.leaderLock.lock(initMessage.name)));
+    if (stack.disposed) return ok();
 
-const createDbWorkerDeps = async (
-  platformDeps: DbWorkerPlatformDeps,
-  initMessage: Extract<DbWorkerInput, { type: "init" }>,
-  postMessage: (msg: DbWorkerOutput) => void,
-) => {
-  const sqlite = await createSqlite(platformDeps)(initMessage.config.name, {
-    memory: initMessage.config.inMemory ?? false,
-    encryptionKey: initMessage.config.encryptionKey ?? undefined,
-  });
-  if (!sqlite.ok) return sqlite;
+    port.postMessage({ type: "LeaderAcquired", name: initMessage.name });
 
-  const deps = { ...platformDeps, sqlite: sqlite.value };
+    const sqlite = stack.use(
+      await run.orThrow(
+        createSqlite(
+          initMessage.name,
+          initMessage.memoryOnly
+            ? { mode: "memory" }
+            : { mode: "encrypted", encryptionKey: initMessage.encryptionKey },
+        ),
+      ),
+    );
+    console.debug("SQLite created");
 
-  return deps.sqlite.transaction(() => {
-    const dbSchema = getDbSchema(deps)();
-    if (!dbSchema.ok) return dbSchema;
+    const baseSqliteStorage = createBaseSqliteStorage({ sqlite, ...run.deps });
 
-    const dbIsInitialized = "evolu_version" in dbSchema.value.tables;
+    const dbDeps = {
+      ...run.deps,
+      sqlite,
+      sqliteSchema: initMessage.sqliteSchema,
+      baseSqliteStorage,
+      timestampConfig: { maxDrift: defaultTimestampMaxDrift },
+    };
 
-    let appOwner: AppOwner;
-    let clock: Clock;
+    const currentSchema = getEvoluSqliteSchema(dbDeps)();
+    const dbIsInitialized = "evolu_version" in currentSchema.tables;
+    const clock = createClock(dbDeps)(dbIsInitialized);
 
-    if (dbIsInitialized) {
-      const currentVersion = deps.sqlite.exec<{
-        protocolVersion: number;
-      }>(sql`select protocolVersion from evolu_version limit 1;`);
-      if (!currentVersion.ok) return currentVersion;
-
-      const configResult = deps.sqlite.exec<{
-        clock: TimestampBytes;
-        appOwnerId: OwnerId;
-        appOwnerEncryptionKey: OwnerEncryptionKey;
-        appOwnerWriteKey: OwnerWriteKey;
-        appOwnerMnemonic: Mnemonic | null;
-      }>(sql`
-        select
-          clock,
-          appOwnerId,
-          appOwnerEncryptionKey,
-          appOwnerWriteKey,
-          appOwnerMnemonic
-        from evolu_config
-        limit 1;
-      `);
-      if (!configResult.ok) return configResult;
+    sqlite.transaction(() => {
+      if (!dbIsInitialized) initializeDb(dbDeps)(clock.get());
+      ensureSqliteSchema(dbDeps)(initMessage.sqliteSchema, currentSchema);
+      tryApplyQuarantinedMessages(dbDeps);
+    });
 
-      assertNonEmptyReadonlyArray(configResult.value.rows);
-      const config = firstInArray(configResult.value.rows);
+    const storage = createClientStorage({ ...dbDeps, clock })({
+      onError: (error) => {
+        port.postMessage({ type: "OnError", error });
+      },
+    });
 
-      appOwner = {
-        type: "AppOwner",
-        id: config.appOwnerId,
-        encryptionKey: config.appOwnerEncryptionKey,
-        writeKey: config.appOwnerWriteKey,
-        mnemonic: config.appOwnerMnemonic,
+    // TODO: Call on dispose message.
+    const _moved = stack.move();
+    const runWithStorage = run.addDeps({ storage });
+
+    /**
+     * SharedWorker retries until some leader replies, so this worker must
+     * ignore callback IDs it already completed.
+     *
+     * The Set intentionally lives for one leader's lifetime. If that leader tab
+     * closes, retries go to a new leader with a fresh Set. Revisit this only if
+     * memory pressure shows up; even millions of short callback IDs are
+     * acceptable here, and naive eviction could let a still-retried request run
+     * again.
+     */
+    const processedRequestIds = new Set<Id>();
+
+    port.onMessage = ({ callbackId, request }) => {
+      if (processedRequestIds.has(callbackId)) return;
+      processedRequestIds.add(callbackId);
+
+      const postQueuedResponse = (
+        response: ExtractType<DbWorkerOutput, "OnQueuedResponse">["response"],
+      ): void => {
+        port.postMessage(
+          { type: "OnQueuedResponse", callbackId, response },
+          response.type === "ForEvolu" && response.message.type === "Export"
+            ? [response.message.file.buffer]
+            : undefined,
+        );
       };
 
-      clock = createClock(deps)(timestampBytesToTimestamp(config.clock));
-    } else {
-      appOwner =
-        initMessage.config.externalAppOwner ??
-        createAppOwner(createOwnerSecret(platformDeps));
+      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;
+        }
 
-      clock = createClock(deps)();
+        case "ForSharedWorker": {
+          switch (request.message.type) {
+            case "CreateSyncMessages": {
+              const protocolMessagesByOwnerId = new Map<
+                OwnerId,
+                ProtocolMessage
+              >();
+
+              for (const owner of request.message.owners) {
+                storage.setRequestContext(owner.encryptionKey);
+                const protocolMessage = createProtocolMessageForSync({
+                  storage,
+                  console,
+                })(owner.id, SubscriptionFlags.Subscribe);
+                protocolMessagesByOwnerId.set(owner.id, protocolMessage);
+              }
+
+              postQueuedResponse({
+                type: "ForSharedWorker",
+                message: {
+                  type: "CreateSyncMessages",
+                  protocolMessagesByOwnerId,
+                },
+              });
+              break;
+            }
+
+            case "ApplySyncMessage": {
+              const { owner, inputMessage } = request.message;
+
+              runWithStorage<void, never>(async (run) => {
+                storage.setRequestContext(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;
+        }
 
-      const result = initializeDb(deps)(appOwner, clock.get());
-      if (!result.ok) return result;
-    }
+        default:
+          exhaustiveCheck(request);
+      }
+    };
 
-    {
-      const result = ensureDbSchema(deps)(initMessage.dbSchema, dbSchema.value);
-      if (!result.ok) return result;
-    }
+    return ok();
 
-    {
-      const result = ensureMessageQuarantineTable(deps);
-      if (!result.ok) return result;
-    }
+    // TODO: Add parallel stale-leader detection.
+    // Heartbeat is emitted by the active DB worker and sent to
+    // SharedWorker. SharedWorker tracks last-seen heartbeat per Evolu
+    // name and if silent for 10 seconds, it waits for another DB worker
+    // to announce itself alive and then routes requests to that worker.
+  };
 
-    const sync = createSync({
-      ...deps,
-      clock,
-      symmetricCrypto: createSymmetricCrypto(platformDeps),
-      timestampConfig: initMessage.config,
-      dbSchema: initMessage.dbSchema,
-    })({
-      appOwner,
-      transports: initMessage.config.transports,
-      onError: (error) => {
-        postMessage({ type: "onError", error });
-      },
-      onReceive: () => {
-        postMessage({ type: "refreshQueries" });
-      },
-    });
-    if (!sync.ok) return sync;
+/**
+ * Hybrid Logical Clock. Keeps the current timestamp in memory to avoid frequent
+ * SQLite reads.
+ */
+interface Clock {
+  readonly get: () => Timestamp;
+  readonly save: (timestamp: Timestamp) => void;
+}
 
-    {
-      const result = tryApplyQuarantinedMessages({
-        ...deps,
-        dbSchema: initMessage.dbSchema,
-      })();
-      if (!result.ok) return result;
+interface ClockDep {
+  readonly clock: Clock;
+}
+
+const createClock =
+  (deps: RandomBytesDep & SqliteDep) =>
+  (dbIsInitialized: boolean): Clock => {
+    let currentTimestamp: Timestamp;
+
+    if (dbIsInitialized) {
+      const { rows } = deps.sqlite.exec<{ clock: TimestampBytes }>(sql`
+        select clock
+        from evolu_config
+        limit 1;
+      `);
+      assertNonEmptyReadonlyArray(rows);
+      currentTimestamp = timestampBytesToTimestamp(firstInArray(rows).clock);
+    } else {
+      currentTimestamp = createInitialTimestamp(deps);
     }
 
-    sync.value.useOwner(true, appOwner);
+    return {
+      get: () => currentTimestamp,
 
-    return ok({
-      ...deps,
-      getQueryRowsCache: createGetQueryRowsCache(),
-      postMessage,
-      sync: sync.value,
-      appOwner,
-    });
-  });
-};
+      save: (timestamp) => {
+        currentTimestamp = timestamp;
+
+        deps.sqlite.exec(sql.prepared`
+          update evolu_config
+          set "clock" = ${timestampToTimestampBytes(timestamp)};
+        `);
+      },
+    };
+  };
 
 const initializeDb =
-  (deps: SqliteDep) =>
-  (
-    initialAppOwner: AppOwner,
-    initialClock: Timestamp,
-  ): Result<void, SqliteError> => {
+  ({ sqlite }: SqliteDep) =>
+  (initialClock: Timestamp): void => {
     for (const query of [
-      // Never change structure to ensure all versions can read it.
       sql`
         create table evolu_version (
           "protocolVersion" integer not null
@@ -492,32 +415,14 @@ const initializeDb =
 
       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)});
       `,
 
       /**
@@ -556,193 +461,558 @@ const initializeDb =
           "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;
+    createBaseSqliteStorageTables({ sqlite });
+  };
 
-    return ok();
+const tryApplyQuarantinedMessages = (
+  deps: SqliteDep & SqliteSchemaDep,
+): void => {
+  const rows = deps.sqlite.exec<{
+    readonly ownerId: OwnerIdBytes;
+    readonly timestamp: TimestampBytes;
+    readonly table: string;
+    readonly id: IdBytes;
+    readonly column: string;
+    readonly value: SqliteValue;
+  }>(sql`
+    select "ownerId", "timestamp", "table", "id", "column", "value"
+    from evolu_message_quarantine;
+  `);
+
+  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 validateColumnValue =
+  (deps: SqliteSchemaDep) =>
+  (table: string, column: string, _value: SqliteValue): boolean => {
+    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: SqliteDep) =>
+  (
+    ownerIdBytes: OwnerIdBytes,
+    ownerId: OwnerId,
+    table: string,
+    idBytes: IdBytes,
+    id: Id,
+    column: string,
+    value: SqliteValue,
+    timestampBytes: TimestampBytes,
+  ): void => {
+    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;
+    `);
   };
 
 /**
- * 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.
+ * The Db worker needs one object that can both satisfy sync code expecting
+ * {@link Storage}, expose {@link BaseSqliteStorage} helpers to the local
+ * implementation, and switch owner encryption keys between requests.
  */
-const ensureMessageQuarantineTable = (
-  deps: SqliteDep,
-): Result<void, SqliteError> => {
-  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;
-  `);
-  if (!result.ok) return result;
-  return ok();
-};
+interface ClientStorage extends Storage, BaseSqliteStorage {
+  readonly setRequestContext: (encryptionKey: EncryptionKey) => void;
+  readonly didWriteMessages: () => boolean;
+}
 
-const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
-  getAppOwner: (deps) => () => {
-    deps.postMessage({
-      type: "onGetAppOwner",
-      appOwner: deps.appOwner,
-    });
-  },
+const createClientStorage =
+  (
+    deps: BaseSqliteStorageDep &
+      ClockDep &
+      SqliteSchemaDep &
+      RandomBytesDep &
+      SqliteDep &
+      TimeDep &
+      TimestampConfigDep,
+  ) =>
+  ({
+    onError,
+  }: {
+    onError: (
+      error:
+        | ProtocolInvalidDataError
+        | ProtocolTimestampMismatchError
+        | DecryptWithXChaCha20Poly1305Error
+        | TimestampCounterOverflowError
+        | TimestampDriftError
+        | TimestampTimeOutOfRangeError,
+    ) => void;
+  }): ClientStorage => {
+    let encryptionKey: EncryptionKey | null = null;
+    let didWriteMessages = false;
+
+    const getEncryptionKey = (): EncryptionKey => {
+      assert(encryptionKey != null, "ClientStorage encryption key must be set");
+      return encryptionKey;
+    };
 
-  mutate: (deps) => (message) => {
-    const mutate = deps.sqlite.transaction(() => {
-      const syncChanges: Array<MutationChange> = [];
+    return {
+      ...deps.baseSqliteStorage,
 
-      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);
-        }
-      }
+      // 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.
+      setRequestContext: (nextEncryptionKey) => {
+        encryptionKey = nextEncryptionKey;
+        didWriteMessages = false;
+      },
 
-      if (isNonEmptyArray(syncChanges)) {
-        const result = deps.sync.applyChanges(syncChanges);
-        if (!result.ok) return result;
-      }
+      didWriteMessages: () => didWriteMessages,
 
-      // 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,
-      });
+      // Not implemented yet.
+      validateWriteKey: lazyFalse,
+      setWriteKey: lazyVoid,
 
-      // Notify other tabs to refresh their queries.
-      deps.postMessage({ type: "refreshQueries", tabId: message.tabId });
+      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.
 
-      return ok();
-    });
+        const messages: Array<CrdtMessage> = [];
+        const currentEncryptionKey = getEncryptionKey();
 
-    if (!mutate.ok) {
-      deps.postMessage({ type: "onError", error: mutate.error });
-      return;
-    }
-  },
+        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 });
+        }
 
-  query: (deps) => (message) => {
-    const queryPatches = loadQueries(deps)(message.tabId, message.queries);
+        let clockTimestamp = deps.clock.get();
 
-    if (!queryPatches.ok) {
-      deps.postMessage({ type: "onError", error: queryPatches.error });
-      return;
-    }
+        for (const message of messages) {
+          const nextTimestamp = receiveTimestamp(deps)(
+            clockTimestamp,
+            message.timestamp,
+          );
+          if (!nextTimestamp.ok) {
+            onError(nextTimestamp.error);
+            return ok();
+          }
+          clockTimestamp = nextTimestamp.value;
+        }
 
-    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)};
+        assertNonEmptyReadonlyArray(messages);
+
+        return deps.sqlite.transaction(() => {
+          applyMessages(deps)(ownerIdBytesToOwnerId(ownerIdBytes), messages);
+          deps.clock.save(clockTimestamp);
+          didWriteMessages = true;
+          return ok();
+        });
+      },
+
+      readDbChange: (ownerId, timestamp) => {
+        const result = deps.sqlite.exec<{
+          readonly table: string;
+          readonly id: IdBytes;
+          readonly column: string;
+          readonly value: SqliteValue;
+        }>(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 { rows } = result;
+        assertNonEmptyReadonlyArray(rows, "Every timestamp must have rows");
+        const firstRow = firstInArray(rows);
+
+        const values = createRecord<string, SqliteValue>();
+        let isInsert: DbChange["isInsert"] = false;
+        let isDelete: DbChange["isDelete"] = null;
+
+        for (const r of rows) {
+          switch (r.column) {
+            case "createdAt":
+              isInsert = true;
+              break;
+            case "updatedAt":
+              isInsert = false;
+              break;
+            case "isDeleted":
+              assertType(SqliteBoolean, r.value);
+              isDelete = sqliteBooleanToBoolean(r.value);
+              break;
+            default:
+              values[r.column] = r.value;
+          }
+        }
+
+        const message: CrdtMessage = {
+          timestamp: timestampBytesToTimestamp(timestamp),
+          change: DbChange.orThrow({
+            table: firstRow.table,
+            id: idBytesToId(firstRow.id),
+            values,
+            isInsert,
+            isDelete,
+          }),
+        };
+
+        return encodeAndEncryptDbChange(deps)(message, getEncryptionKey());
+      },
+    };
+  };
+
+const handleMutation =
+  (
+    deps: BaseSqliteStorageDep &
+      ClockDep &
+      SqliteSchemaDep &
+      RandomBytesDep &
+      SqliteDep &
+      TimeDep &
+      TimestampConfigDep,
+  ) =>
+  (
+    message: ExtractType<
+      ExtractType<DbWorkerInput["request"], "ForEvolu">["message"],
+      "Mutate"
+    >,
+  ): Result<
+    {
+      readonly type: "Mutate";
+      readonly messagesByOwnerId: ReadonlyMap<
+        OwnerId,
+        NonEmptyReadonlyArray<CrdtMessage>
+      >;
+      readonly rowsByQuery: RowsByQueryMap;
+    },
+    | TimestampDriftError
+    | TimestampCounterOverflowError
+    | TimestampTimeOutOfRangeError
+  > =>
+    deps.sqlite.transaction(() => {
+      const messagesByOwnerId = new Map<OwnerId, NonEmptyArray<CrdtMessage>>();
+      let clockTimestamp = deps.clock.get();
+      let clockChanged = false;
+
+      for (const change of message.changes) {
+        if (change.table.startsWith("_")) {
+          applyLocalOnlyChange(deps)(change);
+          continue;
+        }
+
+        const nextTimestamp = sendTimestamp(deps)(clockTimestamp);
+        if (!nextTimestamp.ok) return nextTimestamp;
+
+        clockTimestamp = nextTimestamp.value;
+        clockChanged = true;
+
+        const { ownerId, ...dbChange } = change;
+        const message: CrdtMessage = {
+          timestamp: clockTimestamp,
+          change: dbChange,
+        };
 
-        const secret = mnemonicToOwnerSecret(message.restore.mnemonic);
-        const appOwner = createAppOwner(secret);
-        const clock = createClock(deps)();
+        const messages = messagesByOwnerId.get(ownerId);
+        if (messages) messages.push(message);
+        else messagesByOwnerId.set(ownerId, [message]);
+      }
 
-        return initializeDb(deps)(appOwner, clock.get());
+      for (const [ownerId, messages] of messagesByOwnerId) {
+        applyMessages(deps)(ownerId, messages);
       }
 
-      return ok();
+      if (clockChanged) deps.clock.save(clockTimestamp);
+
+      return ok({
+        type: "Mutate",
+        messagesByOwnerId,
+        rowsByQuery: loadQueries(deps)(message.subscribedQueries),
+      });
     });
 
-    if (!result.ok) {
-      deps.postMessage({ type: "onError", error: result.error });
-      return;
+const applyLocalOnlyChange =
+  (deps: SqliteDep & TimeDep) =>
+  (change: MutationChange): void => {
+    if (change.isDelete) {
+      deps.sqlite.exec(sql`
+        delete from ${sql.identifier(change.table)}
+        where "ownerId" = ${change.ownerId} and "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};
+        `);
+      }
     }
+  };
 
-    deps.postMessage({
-      type: "onReset",
-      onCompleteId: message.onCompleteId,
-      reload: message.reload,
-    });
-  },
+const applyMessages =
+  (deps: BaseSqliteStorageDep & ClockDep & SqliteSchemaDep & SqliteDep) =>
+  (ownerId: OwnerId, messages: NonEmptyReadonlyArray<CrdtMessage>): void => {
+    const ownerIdBytes = ownerIdToOwnerIdBytes(ownerId);
 
-  ensureDbSchema: (deps) => (message) => {
-    const result = deps.sqlite.transaction(() =>
-      ensureDbSchema(deps)(message.dbSchema),
+    const usage = readOwnerUsageOrDefault(deps)(
+      ownerIdBytes,
+      timestampToTimestampBytes(firstInArray(messages).timestamp),
     );
 
-    if (!result.ok) {
-      deps.postMessage({ type: "onError", error: result.error });
-      return;
-    }
-  },
+    let { firstTimestamp, lastTimestamp } = usage;
+
+    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;
+          `);
+        }
+      }
 
-  export: (deps) => (message) => {
-    const file = deps.sqlite.export();
+      let strategy;
+      [strategy, firstTimestamp, lastTimestamp] = getTimestampInsertStrategy(
+        timestampBytes,
+        firstTimestamp,
+        lastTimestamp,
+      );
 
-    if (!file.ok) {
-      deps.postMessage({ type: "onError", error: file.error });
-      return;
+      deps.baseSqliteStorage.insertTimestamp(
+        ownerIdBytes,
+        timestampBytes,
+        strategy,
+      );
     }
 
-    deps.postMessage({
-      type: "onExport",
-      onCompleteId: message.onCompleteId,
-      file: file.value,
-    });
-  },
+    /**
+     * 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,
+    );
+  };
 
-  useOwner: (deps) => (message) => {
-    deps.sync.useOwner(message.use, message.owner);
-  },
+const dbChangeToColumns = (change: DbChange, now: Millis) => {
+  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: SqliteDep) =>
+  (queries: Iterable<Query>): Map<Query, ReadonlyArray<SqliteRow>> => {
+    const rowsByQuery = new Map<Query, ReadonlyArray<SqliteRow>>();
+
+    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;
+//     }
+//   },