@evolu/common 6.0.1-preview.2 → 6.0.1-preview.21

package/src/Evolu/Db.ts

@@ -1,72 +1,44 @@
+import { isNonEmptyArray, NonEmptyReadonlyArray } from "../Array.js";
+import { CallbackId } from "../CallbackRegistry.js";
+import { ConsoleConfig, ConsoleDep } from "../Console.js";
 import {
-  isNonEmptyArray,
-  isNonEmptyReadonlyArray,
-  NonEmptyReadonlyArray,
-} from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
-import { CallbackId } from "../Callbacks.js";
-import { ConsoleDep } from "../Console.js";
-import {
-  CreateMnemonicDep,
-  CreateRandomBytesDep,
   createSymmetricCrypto,
+  EncryptionKey,
+  RandomBytesDep,
   SymmetricCryptoDecryptError,
-  SymmetricCryptoDep,
 } from "../Crypto.js";
-import { eqArrayNumber } from "../Eq.js";
 import { TransferableError } from "../Error.js";
-import { constFalse, exhaustiveCheck } from "../Function.js";
-import { NanoIdLibDep } from "../NanoId.js";
-import { objectToEntries } from "../Object.js";
 import { RandomDep } from "../Random.js";
-import { createRef, Ref } from "../Ref.js";
-import { err, ok, Result } from "../Result.js";
+import { ok, Result } from "../Result.js";
 import {
   createSqlite,
   CreateSqliteDriverDep,
   explainSqliteQueryPlan,
-  SafeSql,
   sql,
   SqliteDep,
   SqliteError,
-  SqliteQuery,
-  SqliteRow,
-  SqliteValue,
 } from "../Sqlite.js";
 import { TimeDep } from "../Time.js";
-import { Id, Mnemonic, object, SimpleName, String } from "../Type.js";
+import { Id, Mnemonic, SimpleName } from "../Type.js";
+import { CreateWebSocketDep } from "../WebSocket.js";
 import {
-  createInitializedWorker,
+  createInitializedWorkerWithHandlers,
+  MessageHandlers,
   Worker,
-  WorkerPostMessageDep,
 } from "../Worker.js";
-import { Config } from "./Config.js";
 import { makePatches, QueryPatches } from "./Diff.js";
 import {
   AppOwner,
   createAppOwner,
-  createOwnerRow,
-  OwnerRow,
-  OwnerWithWriteAccess,
+  createOwnerSecret,
+  createWebSocketTransportConfig,
+  mnemonicToOwnerSecret,
+  OwnerEncryptionKey,
+  OwnerId,
+  OwnerWriteKey,
+  TransportConfig,
 } from "./Owner.js";
-import {
-  applyProtocolMessageAsClient,
-  Base64Url256,
-  BinaryId,
-  binaryIdToId,
-  CrdtMessage,
-  createProtocolMessageForSync,
-  createProtocolMessageFromCrdtMessages,
-  DbChange,
-  decryptAndDecodeDbChange,
-  encodeAndEncryptDbChange,
-  idToBinaryId,
-  ownerIdToBinaryOwnerId,
-  ProtocolError,
-  protocolVersion,
-  Storage,
-  StorageDep,
-} from "./Protocol.js";
+import { ProtocolError, protocolVersion } from "./Protocol.js";
 import {
   createQueryRowsCache,
   deserializeQuery,
@@ -75,39 +47,167 @@ import {
   QueryRowsCache,
 } from "./Query.js";
 import {
-  createSqliteStorageBase,
-  CreateSqliteStorageBaseOptions,
-  SqliteStorageBase,
-} from "./Storage.js";
-import { CreateSyncDep, SyncConfig, SyncDep } from "./Sync.js";
+  DbSchema,
+  ensureDbSchema,
+  getDbSchema,
+  MutationChange,
+} from "./Schema.js";
+import {
+  applyLocalOnlyChange,
+  Clock,
+  createClock,
+  createSync,
+  SyncDep,
+  SyncOwner,
+} from "./Sync.js";
 import {
-  Millis,
-  receiveTimestamp,
-  sendTimestamp,
   Timestamp,
-  TimestampConfigDep,
-  TimestampCounterOverflowError,
-  TimestampDriftError,
+  TimestampConfig,
   TimestampError,
   TimestampString,
   timestampStringToTimestamp,
-  TimestampTimeOutOfRangeError,
-  timestampToBinaryTimestamp,
   timestampToTimestampString,
 } from "./Timestamp.js";
 
-export interface DbSchema {
-  readonly tables: ReadonlyArray<DbTable>;
-  readonly indexes: ReadonlyArray<DbIndex>;
-}
-
-export interface DbTable {
-  readonly name: Base64Url256;
-  readonly columns: ReadonlyArray<Base64Url256>;
+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 createWebSocketTransportConfig} 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 createWebSocketTransportConfig helper for relay authentication
+   * transports: [
+   *   createWebSocketTransportConfig({
+   *     relayUrl: "ws://localhost:4000",
+   *     ownerId,
+   *   }),
+   * ];
+   * ```
+   */
+  readonly transports: ReadonlyArray<TransportConfig>;
+
+  /**
+   * 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.
+   *
+   * @experimental
+   */
+  readonly encryptionKey?: EncryptionKey;
 }
 
-export const DbIndex = object({ name: String, sql: String });
-export type DbIndex = typeof DbIndex.Type;
+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<DbWorkerInput, DbWorkerOutput>;
 
@@ -120,14 +220,16 @@ export interface CreateDbWorkerDep {
 export type DbWorkerInput =
   | {
       readonly type: "init";
-      readonly config: Config;
+      readonly config: DbConfig;
       readonly dbSchema: DbSchema;
-      readonly initialData: ReadonlyArray<DbChange>;
+    }
+  | {
+      readonly type: "getAppOwner";
     }
   | {
       readonly type: "mutate";
       readonly tabId: Id;
-      readonly changes: NonEmptyReadonlyArray<DbChange>;
+      readonly changes: NonEmptyReadonlyArray<MutationChange>;
       readonly onCompleteIds: ReadonlyArray<CallbackId>;
       readonly subscribedQueries: ReadonlyArray<Query>;
     }
@@ -152,30 +254,35 @@ export type DbWorkerInput =
   | {
       readonly type: "export";
       readonly onCompleteId: CallbackId;
+    }
+  | {
+      readonly type: "useOwner";
+      readonly use: boolean;
+      readonly owner: SyncOwner;
     };
 
 export type DbWorkerOutput =
-  | {
-      readonly type: "onInit";
-      readonly owner: AppOwner;
-    }
   | {
       readonly type: "onError";
       readonly error:
+        | ProtocolError
         | SqliteError
-        | TransferableError
+        | SymmetricCryptoDecryptError
         | TimestampError
-        | ProtocolError
-        | SymmetricCryptoDecryptError;
+        | TransferableError;
+    }
+  | {
+      readonly type: "onGetAppOwner";
+      readonly appOwner: AppOwner;
     }
   | {
-      readonly type: "onChange";
+      readonly type: "onQueryPatches";
       readonly tabId: Id;
-      readonly patches: ReadonlyArray<QueryPatches>;
+      readonly queryPatches: ReadonlyArray<QueryPatches>;
       readonly onCompleteIds: ReadonlyArray<CallbackId>;
     }
   | {
-      readonly type: "onReceive";
+      readonly type: "refreshQueries";
       readonly tabId?: Id;
     }
   | {
@@ -189,812 +296,446 @@ export type DbWorkerOutput =
       readonly file: Uint8Array;
     };
 
-export type DbWorkerPlatformDeps = CreateSqliteDriverDep &
-  CreateSyncDep &
-  ConsoleDep &
-  TimeDep &
+export type DbWorkerPlatformDeps = ConsoleDep &
+  CreateSqliteDriverDep &
+  CreateWebSocketDep &
+  RandomBytesDep &
   RandomDep &
-  NanoIdLibDep &
-  CreateMnemonicDep &
-  CreateRandomBytesDep;
+  TimeDep;
 
 type DbWorkerDeps = Omit<
   DbWorkerPlatformDeps,
-  keyof CreateSqliteDriverDep | keyof CreateSyncDep
+  keyof CreateSqliteDriverDep | keyof CreateWebSocketDep
 > &
+  GetQueryRowsCacheDep &
+  PostMessageDep &
   SqliteDep &
   SyncDep &
-  TimestampConfigDep &
-  SymmetricCryptoDep &
-  PostMessageDep &
-  OwnerRowRefDep &
-  GetQueryRowsCacheDep &
-  ClientStorageDep;
+  AppOwnerDep;
 
-type PostMessageDep = WorkerPostMessageDep<DbWorkerOutput>;
+interface GetQueryRowsCacheDep {
+  readonly getQueryRowsCache: (tabId: Id) => QueryRowsCache;
+}
 
-// TODO: More owners (the whole table with ad-hoc added)
-export interface OwnerRowRefDep {
-  readonly ownerRowRef: Ref<OwnerRow>;
+export interface PostMessageDep {
+  readonly postMessage: (message: DbWorkerOutput) => void;
 }
 
-interface GetQueryRowsCacheDep {
-  readonly getQueryRowsCache: (tabId: Id) => QueryRowsCache;
+export interface AppOwnerDep {
+  readonly appOwner: AppOwner;
 }
 
 export const createDbWorkerForPlatform = (
   platformDeps: DbWorkerPlatformDeps,
-): DbWorker => {
-  const tabQueryRowsCacheMap = new Map<Id, QueryRowsCache>();
-  const getQueryRowsCache = (tabId: Id) => {
-    let cache = tabQueryRowsCacheMap.get(tabId);
-    if (!cache) {
-      cache = createQueryRowsCache();
-      tabQueryRowsCacheMap.set(tabId, cache);
+): DbWorker =>
+  createInitializedWorkerWithHandlers<
+    DbWorkerInput,
+    DbWorkerOutput,
+    DbWorkerDeps
+  >({ init: createDbWorkerDeps(platformDeps), handlers });
+
+const createDbWorkerDeps =
+  (platformDeps: DbWorkerPlatformDeps) =>
+  async (
+    initMessage: Extract<DbWorkerInput, { type: "init" }>,
+    postMessage: (msg: DbWorkerOutput) => void,
+  ): Promise<DbWorkerDeps | null> => {
+    platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
+
+    const sqliteResult = await createSqlite(platformDeps)(
+      initMessage.config.name,
+      {
+        memory: initMessage.config.inMemory ?? false,
+        encryptionKey: initMessage.config.encryptionKey ?? undefined,
+      },
+    );
+    if (!sqliteResult.ok) {
+      postMessage({ type: "onError", error: sqliteResult.error });
+      return null;
     }
-    return cache;
-  };
-
-  return createInitializedWorker<DbWorkerInput, DbWorkerOutput, DbWorkerDeps>({
-    init: async (initMessage, postMessage, safeHandler) => {
-      platformDeps.console.enabled = initMessage.config.enableLogging ?? false;
+    const sqlite = sqliteResult.value;
 
-      const sqliteResult = await createSqlite(platformDeps)(
-        initMessage.config.name,
-      );
-
-      if (!sqliteResult.ok) {
-        postMessage({ type: "onError", error: sqliteResult.error });
-        return null;
-      }
-      const sqlite = sqliteResult.value;
+    const deps = sqlite.transaction(() => {
+      const currentDbSchema = getDbSchema({ sqlite })();
+      if (!currentDbSchema.ok) return currentDbSchema;
 
-      const deps = sqlite.transaction(() => {
-        const currentDbSchema = getDbSchema({ sqlite })();
-        if (!currentDbSchema.ok) return currentDbSchema;
+      let appOwner: AppOwner;
+      let clock: Clock;
 
-        const ensureDbSchemaResult = ensureDbSchema({ sqlite })(
-          initMessage.dbSchema,
-          currentDbSchema.value,
-        );
-        if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
-
-        const maybeMigrateToVersion0Result = maybeMigrateToVersion0({ sqlite })(
-          currentDbSchema.value,
-        );
-        if (!maybeMigrateToVersion0Result.ok)
-          return maybeMigrateToVersion0Result;
-
-        const ownerExists = currentDbSchema.value.tables.some(
-          (table) => table.name === "evolu_owner",
-        );
+      const dbIsInitialized = currentDbSchema.value.tables.some(
+        (table) => table.name === "evolu_version",
+      );
 
-        const appOwnerAndOwnerRow = ownerExists
-          ? selectAppOwner({ sqlite })
-          : initializeDb({ ...platformDeps, sqlite })(
-              maybeMigrateToVersion0Result.value?.mnemonic ??
-                initMessage.config.mnemonic,
-            );
-        if (!appOwnerAndOwnerRow.ok) return appOwnerAndOwnerRow;
-
-        const [appOwner, ownerRow] = appOwnerAndOwnerRow.value;
-
-        const depsWithoutSyncAndStorage = {
-          ...platformDeps,
-          postMessage,
-          sqlite,
-          timestampConfig: initMessage.config,
-          symmetricCrypto: createSymmetricCrypto(platformDeps),
-          getQueryRowsCache,
-          ownerRowRef: createRef(ownerRow),
-        };
+      if (dbIsInitialized) {
+        const currentVersion = sqlite.exec<{
+          protocolVersion: number;
+        }>(sql`select protocolVersion from evolu_version limit 1;`);
+        if (!currentVersion.ok) return currentVersion;
+
+        // TODO: Handle version migrations here if needed
+        // const [{ protocolVersion }] = protocolVersionResult.value.rows;
+        // if (protocolVersion < currentProtocolVersion) {
+        //   const migrateResult = migrateDatabase({ sqlite })(
+        //     protocolVersion,
+        //     currentProtocolVersion
+        //   );
+        //   if (!migrateResult.ok) return migrateResult;
+        // }
+
+        const configResult = sqlite.exec<{
+          clock: TimestampString;
+          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;
 
-        const storage = createClientStorage(depsWithoutSyncAndStorage)({
-          onStorageError: (error) => {
-            postMessage({ type: "onError", error });
-          },
-        });
-        if (!storage.ok) return storage;
+        const [config] = configResult.value.rows;
 
-        const depsWithoutSync = {
-          ...depsWithoutSyncAndStorage,
-          storage: storage.value,
+        appOwner = {
+          type: "AppOwner",
+          id: config.appOwnerId,
+          encryptionKey: config.appOwnerEncryptionKey,
+          writeKey: config.appOwnerWriteKey,
+          mnemonic: config.appOwnerMnemonic,
         };
 
-        if (maybeMigrateToVersion0Result.value) {
-          const result = applyMessages(depsWithoutSync)(
-            maybeMigrateToVersion0Result.value.messages,
-            maybeMigrateToVersion0Result.value.lastTimestamp,
-          );
-          if (!result.ok) return result;
-        }
-
-        if (!ownerExists && isNonEmptyReadonlyArray(initMessage.initialData)) {
-          const result = applyChanges(depsWithoutSync)(initMessage.initialData);
-          if (!result.ok) return result;
-        }
-
-        postMessage({ type: "onInit", owner: appOwner });
-
-        const sync = platformDeps.createSync(platformDeps)({
-          ...initMessage.config,
-          onOpen: safeHandler(handleSyncOpen(depsWithoutSync)),
-          onMessage: safeHandler(createHandleSyncMessage(depsWithoutSync)),
-        });
+        clock = createClock({ ...platformDeps, sqlite })(
+          timestampStringToTimestamp(config.clock),
+        );
+      } else {
+        appOwner =
+          initMessage.config.externalAppOwner ??
+          createAppOwner(createOwnerSecret(platformDeps));
 
-        return ok({ ...depsWithoutSync, sync });
-      });
+        clock = createClock({ ...platformDeps, sqlite })();
 
-      if (!deps.ok) {
-        postMessage({ type: "onError", error: deps.error });
-        return null;
+        const result = initializeDb({ sqlite })(appOwner, clock.get());
+        if (!result.ok) return result;
       }
 
-      return deps.value;
-    },
-
-    onMessage: (deps) => (message) => {
-      switch (message.type) {
-        case "mutate": {
-          const mutate = deps.sqlite.transaction(() => {
-            const toSyncChanges = [];
-            const localOnlyChanges = [];
-
-            for (const change of message.changes) {
-              // Table name starting with '_' is local-only (not synced).
-              if (change.table.startsWith("_")) localOnlyChanges.push(change);
-              else toSyncChanges.push(change);
-            }
-
-            for (const change of localOnlyChanges) {
-              if (
-                "isDeleted" in change.values &&
-                change.values.isDeleted === 1
-              ) {
-                const result = deps.sqlite.exec(sql`
-                  delete from ${sql.identifier(change.table)}
-                  where id = ${change.id};
-                `);
-                if (!result.ok) return result;
-              } else {
-                const millis = Millis.from(deps.time.now());
-                if (!millis.ok) {
-                  return err<TimestampTimeOutOfRangeError>({
-                    type: "TimestampTimeOutOfRangeError",
-                  });
-                }
-                const date = new Date(millis.value).toISOString();
-                for (const [column, value] of objectToEntries(change.values)) {
-                  const result = deps.sqlite.exec(sql.prepared`
-                    insert into ${sql.identifier(change.table)}
-                      ("id", ${sql.identifier(column)}, createdAt, updatedAt)
-                    values (${change.id}, ${value}, ${date}, ${date})
-                    on conflict ("id") do update
-                      set
-                        ${sql.identifier(column)} = ${value},
-                        updatedAt = ${date};
-                  `);
-                  if (!result.ok) return result;
-                }
-              }
-            }
-
-            /**
-             * We don't have to wait for the transaction to end because changes
-             * are idempotent, so there is no reason why they should fail. We
-             * want to call onChange ASAP.
-             */
-            const onChange = () => {
-              deps.console.log("[db]", "onChange", {
-                subscribedQueries: message.subscribedQueries,
-              });
-              const patches = loadQueries(deps)(
-                message.tabId,
-                message.subscribedQueries,
-              );
-              if (!patches.ok) {
-                deps.postMessage({ type: "onError", error: patches.error });
-                return;
-              }
-              // Notify the tab that performed the mutation.
-              deps.postMessage({
-                type: "onChange",
-                tabId: message.tabId,
-                patches: patches.value,
-                onCompleteIds: message.onCompleteIds,
-              });
-              // Notify other tabs to refresh their queries.
-              deps.postMessage({ type: "onReceive", tabId: message.tabId });
-            };
-
-            if (!isNonEmptyArray(toSyncChanges)) {
-              onChange();
-              return ok();
-            }
-
-            const messages = applyChanges(deps)(toSyncChanges, onChange);
-            if (!messages.ok) return messages;
-
-            const owner = deps.ownerRowRef.get();
-            // TODO: Check owner whether it's allowed to write, return an
-            // error if not.
-            if (owner.writeKey == null) {
-              return ok();
-            }
-
-            const protocolMessage = createProtocolMessageFromCrdtMessages(deps)(
-              owner as OwnerWithWriteAccess,
-              messages.value,
-            );
-
-            deps.console.log(
-              "[db]",
-              "send data message",
-              messages.value,
-              protocolMessage,
-            );
-            deps.sync.send(protocolMessage);
-
-            return ok();
-          });
-
-          if (!mutate.ok) {
-            deps.postMessage({ type: "onError", error: mutate.error });
-            return;
-          }
-
-          break;
-        }
-
-        case "query": {
-          const patches = loadQueries(deps)(message.tabId, message.queries);
-
-          if (!patches.ok) {
-            deps.postMessage({ type: "onError", error: patches.error });
-            return;
-          }
-
-          deps.postMessage({
-            type: "onChange",
-            tabId: message.tabId,
-            patches: patches.value,
-            onCompleteIds: [],
-          });
-          break;
-        }
-
-        case "reset": {
-          const resetResult = deps.sqlite.transaction(() => {
-            const dropAllTablesResult = dropAllTables(deps);
-            if (!dropAllTablesResult.ok) return dropAllTablesResult;
-
-            if (message.restore) {
-              const dbSchema = getDbSchema(deps)();
-              if (!dbSchema.ok) return dbSchema;
-
-              const ensureDbSchemaResult = ensureDbSchema(deps)(
-                message.restore.dbSchema,
-                dbSchema.value,
-              );
-              if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
-
-              const initializeDbResult = initializeDb(deps)(
-                message.restore.mnemonic,
-              );
-              if (!initializeDbResult.ok) return initializeDbResult;
-            }
-            return ok();
-          });
-
-          if (!resetResult.ok) {
-            deps.postMessage({ type: "onError", error: resetResult.error });
-            return;
-          }
-
-          deps.postMessage({
-            type: "onReset",
-            onCompleteId: message.onCompleteId,
-            reload: message.reload,
-          });
-          deps.sqlite[Symbol.dispose]();
-
-          break;
-        }
-
-        case "ensureDbSchema": {
-          const ensureSchema = deps.sqlite.transaction(() => {
-            const dbSchema = getDbSchema(deps)();
-            if (!dbSchema.ok) return dbSchema;
-
-            const ensureDbSchemaResult = ensureDbSchema(deps)(
-              message.dbSchema,
-              dbSchema.value,
-            );
-            if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
-
-            return ok();
-          });
-
-          if (!ensureSchema.ok) {
-            deps.postMessage({ type: "onError", error: ensureSchema.error });
-            return;
-          }
-          break;
-        }
+      const result = ensureDbSchema({ sqlite })(
+        initMessage.dbSchema,
+        currentDbSchema.value,
+      );
+      if (!result.ok) return result;
 
-        case "export": {
-          const file = deps.sqlite.export();
+      const sync = createSync({
+        ...platformDeps,
+        clock,
+        sqlite,
+        symmetricCrypto: createSymmetricCrypto(platformDeps),
+        timestampConfig: initMessage.config,
+        postMessage,
+      })({
+        appOwner,
+        transports: initMessage.config.transports,
+        onError: (error) => {
+          postMessage({ type: "onError", error });
+        },
+        onReceive: () => {
+          postMessage({ type: "refreshQueries" });
+        },
+      });
+      if (!sync.ok) return sync;
 
-          if (!file.ok) {
-            deps.postMessage({ type: "onError", error: file.error });
-            return;
-          }
+      sync.value.useOwner(true, appOwner);
 
-          deps.postMessage({
-            type: "onExport",
-            onCompleteId: message.onCompleteId,
-            file: file.value,
-          });
-          break;
+      const tabQueryRowsCacheMap = new Map<Id, QueryRowsCache>();
+      const getQueryRowsCache = (tabId: Id) => {
+        let cache = tabQueryRowsCacheMap.get(tabId);
+        if (!cache) {
+          cache = createQueryRowsCache();
+          tabQueryRowsCacheMap.set(tabId, cache);
         }
-
-        default:
-          exhaustiveCheck(message);
-      }
-    },
-  });
-};
-
-/**
- * Get the current database schema by reading SQLite metadata.
- *
- * TODO: Refactor out Evolu stuff and move it to Sqlite.
- */
-export const getDbSchema =
-  (deps: SqliteDep) =>
-  ({ allIndexes = false }: { allIndexes?: boolean } = {}): Result<
-    DbSchema,
-    SqliteError
-  > => {
-    const map = new Map<Base64Url256, Array<Base64Url256>>();
-
-    const tableAndColumnInfoRows = deps.sqlite.exec(sql`
-      select
-        sqlite_master.name as tableName,
-        table_info.name as columnName
-      from
-        sqlite_master
-        join pragma_table_info(sqlite_master.name) as table_info;
-    `);
-
-    if (!tableAndColumnInfoRows.ok) return tableAndColumnInfoRows;
-
-    tableAndColumnInfoRows.value.rows.forEach((row) => {
-      const { tableName, columnName } = row as unknown as {
-        tableName: Base64Url256;
-        columnName: Base64Url256;
+        return cache;
       };
-      if (!map.has(tableName)) map.set(tableName, []);
-      map.get(tableName)?.push(columnName);
-    });
 
-    const tables = Array.from(map, ([name, columns]) => ({ name, columns }));
-
-    const indexesRows = deps.sqlite.exec(
-      allIndexes
-        ? sql`
-            select name, sql
-            from sqlite_master
-            where type = 'index' and name not like 'sqlite_%';
-          `
-        : sql`
-            select name, sql
-            from sqlite_master
-            where
-              type = 'index'
-              and name not like 'sqlite_%'
-              and name not like 'evolu_%';
-          `,
-    );
+      const deps: DbWorkerDeps = {
+        ...platformDeps,
+        getQueryRowsCache,
+        postMessage,
+        sqlite,
+        sync: sync.value,
+        appOwner,
+      };
 
-    if (!indexesRows.ok) return indexesRows;
+      return ok(deps);
+    });
 
-    const indexes = indexesRows.value.rows.map(
-      (row): DbIndex => ({
-        name: row.name as string,
-        /**
-         * SQLite returns "CREATE INDEX" for "create index" for some reason.
-         * Other keywords remain unchanged. We have to normalize the casing for
-         * {@link indexesAreEqual} manually.
-         */
-        sql: (row.sql as string)
-          .replace("CREATE INDEX", "create index")
-          .replace("CREATE UNIQUE INDEX", "create unique index"),
-      }),
-    );
+    if (!deps.ok) {
+      postMessage({ type: "onError", error: deps.error });
+      return null;
+    }
 
-    return ok({ tables, indexes });
+    return deps.value;
   };
 
-const indexesAreEqual = (self: DbIndex, that: DbIndex): boolean =>
-  self.name === that.name && self.sql === that.sql;
-
-export interface DbSnapshot {
-  readonly schema: DbSchema;
-  readonly rows: Array<{
-    rows: ReadonlyArray<SqliteRow>;
-    name: string;
-  }>;
-}
-
-// TODO: Move it to Sqlite.
-export const getDbSnapshot = (
-  deps: SqliteDep,
-): Result<DbSnapshot, SqliteError> => {
-  const schema = getDbSchema(deps)({ allIndexes: true });
-  if (!schema.ok) return schema;
-
-  const rows = [];
-
-  for (const table of schema.value.tables) {
-    const result = deps.sqlite.exec(sql`
-      select * from ${sql.identifier(table.name)};
-    `);
-    if (!result.ok) return result;
-
-    rows.push({
-      rows: result.value.rows,
-      name: table.name,
-    });
-  }
-
-  return ok({ schema: schema.value, rows });
-};
-
-const ensureDbSchema =
+const initializeDb =
   (deps: SqliteDep) =>
   (
-    newSchema: DbSchema,
-    currentSchema: DbSchema,
-    options?: { ignoreIndexes: boolean },
+    initialAppOwner: AppOwner,
+    initialClock: Timestamp,
   ): Result<void, SqliteError> => {
-    const queries: Array<SqliteQuery> = [];
-
-    newSchema.tables.forEach((newTable) => {
-      const currentTable = currentSchema.tables.find(
-        (t) => t.name === newTable.name,
-      );
-      if (!currentTable) {
-        queries.push({
-          sql: createAppTable(newTable.name, newTable.columns),
-          parameters: [],
-        });
-      } else {
-        newTable.columns
-          .filter((newColumn) => !currentTable.columns.includes(newColumn))
-          .forEach((newColumn) => {
-            queries.push(sql`
-              alter table ${sql.identifier(newTable.name)}
-              add column ${sql.identifier(newColumn)} blob;
-            `);
-          });
-      }
-    });
-
-    if (options?.ignoreIndexes !== true) {
-      // Remove current indexes that are not in the newSchema.
-      currentSchema.indexes
-        .filter(
-          (currentIndex) =>
-            !newSchema.indexes.some((newIndex) =>
-              indexesAreEqual(newIndex, currentIndex),
-            ),
-        )
-        .forEach((index) => {
-          queries.push(sql`drop index ${sql.identifier(index.name)};`);
-        });
-
-      // Add new indexes that are not in the currentSchema.
-      newSchema.indexes
-        .filter(
-          (newIndex) =>
-            !currentSchema.indexes.some((currentIndex) =>
-              indexesAreEqual(newIndex, currentIndex),
-            ),
+    for (const query of [
+      // Never change structure to ensure all versions can read it.
+      sql`
+        create table evolu_version (
+          "protocolVersion" integer not null
         )
-        .forEach((newIndex) => {
-          queries.push({ sql: `${newIndex.sql};` as SafeSql, parameters: [] });
-        });
-    }
-
-    for (const query of queries) {
-      const result = deps.sqlite.exec(query);
-      if (!result.ok) return result;
-    }
-    return ok();
-  };
-
-export const createAppTable = (
-  tableName: string,
-  columns: ReadonlyArray<string>,
-): SafeSql =>
-  `
-    create table ${sql.identifier(tableName).sql} (
-      "id" text primary key,
-      ${columns
-        // Add default columns.
-        .concat(["createdAt", "updatedAt", "isDeleted"])
-        .filter((c) => c !== "id")
-        // "A column with affinity BLOB does not prefer one storage class over another
-        // and no attempt is made to coerce data from one storage class into another."
-        // https://www.sqlite.org/datatype3.html
-        .map((name) => `${sql.identifier(name).sql} blob`)
-        .join(", ")}
-    );
-  ` as SafeSql;
-
-const selectAppOwner = (
-  deps: SqliteDep,
-): Result<[AppOwner, OwnerRow], SqliteError> => {
-  const result = deps.sqlite.exec<OwnerRow>(sql`
-    select mnemonic, id, createdAt, encryptionKey, writeKey, timestamp
-    from evolu_owner
-    order by createdAt asc
-    limit 1;
-  `);
-
-  if (!result.ok) return result;
-
-  const {
-    rows: [ownerRow],
-  } = result.value;
-
-  assert(ownerRow.writeKey != null, "The writeKey is null");
-
-  const appOwner: AppOwner = {
-    type: "AppOwner",
-    mnemonic: ownerRow.mnemonic,
-    createdAt: ownerRow.createdAt,
-    id: ownerRow.id,
-    encryptionKey: ownerRow.encryptionKey,
-    writeKey: ownerRow.writeKey,
-  };
+        strict;
+      `,
 
-  return ok([appOwner, ownerRow]);
-};
+      sql`
+        insert into evolu_version ("protocolVersion")
+        values (${protocolVersion});
+      `,
 
-const initializeDb =
-  (
-    deps: SqliteDep &
-      NanoIdLibDep &
-      CreateMnemonicDep &
-      TimeDep &
-      CreateRandomBytesDep,
-  ) =>
-  (mnemonic?: Mnemonic): Result<[AppOwner, OwnerRow], SqliteError> => {
-    for (const query of [
       sql`
         create table evolu_config (
-          "key" text not null primary key,
-          "value" any not null
+          "clock" text not null,
+          "appOwnerId" text not null,
+          "appOwnerEncryptionKey" blob not null,
+          "appOwnerWriteKey" blob not null,
+          "appOwnerMnemonic" text
         )
         strict;
       `,
 
       sql`
-        insert into evolu_config ("key", "value")
-        values ('protocolVersion', ${protocolVersion});
+        insert into evolu_config
+          (
+            "clock",
+            "appOwnerId",
+            "appOwnerEncryptionKey",
+            "appOwnerWriteKey",
+            "appOwnerMnemonic"
+          )
+        values
+          (
+            ${timestampToTimestampString(initialClock)},
+            ${initialAppOwner.id},
+            ${initialAppOwner.encryptionKey},
+            ${initialAppOwner.writeKey},
+            ${initialAppOwner.mnemonic ?? null}
+          );
       `,
 
       /**
-       * The History table stores all values per timestamp, table, row, and
-       * column. It's required for merging without conflicts. Evolu uses
-       * last-write-win CRDT. In case of last-write-win value isn't what we
-       * want, we can use time travel. The current implementation prefers
-       * performance over storage size. The History table denormalizes Timestamp
-       * and DbChange to leverage a covering index. Hence, every value change
-       * has its timestamp, table, row, and column. In the future, we will
-       * rethink that and store history more efficiently.
-       *
-       * There is no need to use `OwnerId` on the client, because timestamps
-       * (which include a `NodeId`) are globally unique. The relay needs
-       * `OwnerId` because it hosts multiple apps/owners, but client storage
-       * represents one DB, and even when it hosts multiple owners, their
-       * timestamps remain unique.
+       * The History table stores all values per ownerId, timestamp, table, id,
+       * and column for conflict-free merging using last-write-win CRDT.
+       * Denormalizes Timestamp and DbChange for covering index performance.
+       * Time travel is available when last-write-win isn't desired. Future
+       * optimization will store history more efficiently.
        */
       sql`
         create table evolu_history (
-          "timestamp" blob not null,
+          "ownerId" blob not null,
           "table" text not null,
-          "row" blob not null,
+          "id" blob not null,
           "column" text not null,
+          "timestamp" blob not null,
           "value" any
         )
         strict;
       `,
 
+      // Index for reading database changes by owner and timestamp.
+      // Timestamp always corresponds to a DbChange.
       sql`
-        create index evolu_history_timestamp on evolu_history ("timestamp");
+        create index evolu_history_ownerId_timestamp on evolu_history (
+          "ownerId",
+          "timestamp"
+        );
       `,
 
       sql`
-        create unique index evolu_history_row_column_table_timestampDesc on evolu_history (
-          "row",
-          "column",
+        create unique index evolu_history_ownerId_table_id_column_timestampDesc on evolu_history (
+          "ownerId",
           "table",
+          "id",
+          "column",
           "timestamp" desc
         );
       `,
-
-      sql`
-        create table evolu_owner (
-          "mnemonic" text not null primary key,
-          "id" text not null,
-          "encryptionKey" blob not null,
-          "createdAt" text not null,
-          "writeKey" blob,
-          "timestamp" text not null
-        )
-        strict;
-      `,
     ]) {
       const result = deps.sqlite.exec(query);
       if (!result.ok) return result;
     }
 
-    const appOwner = createAppOwner(deps)(mnemonic);
-    const ownerRow = createOwnerRow(deps)(appOwner);
-
-    const result = deps.sqlite.exec(sql`
-      insert into evolu_owner
-        (mnemonic, id, encryptionKey, createdAt, writeKey, timestamp)
-      values
-        (
-          ${ownerRow.mnemonic},
-          ${ownerRow.id},
-          ${ownerRow.encryptionKey},
-          ${ownerRow.createdAt},
-          ${ownerRow.writeKey},
-          ${ownerRow.timestamp}
-        );
-    `);
+    return ok();
+  };
 
-    if (!result.ok) return result;
+const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
+  getAppOwner: (deps) => () => {
+    deps.postMessage({
+      type: "onGetAppOwner",
+      appOwner: deps.appOwner,
+    });
+  },
 
-    return ok([appOwner, ownerRow]);
-  };
+  mutate: (deps) => (message) => {
+    const mutate = deps.sqlite.transaction(() => {
+      const syncChanges: Array<MutationChange> = [];
 
-const applyChanges =
-  (
-    deps: SqliteDep &
-      TimeDep &
-      TimestampConfigDep &
-      RandomDep &
-      OwnerRowRefDep &
-      ClientStorageDep,
-  ) =>
-  (
-    changes: NonEmptyReadonlyArray<DbChange>,
-    onChange?: () => void,
-  ): Result<
-    NonEmptyReadonlyArray<CrdtMessage>,
-    | TimestampTimeOutOfRangeError
-    | TimestampDriftError
-    | TimestampCounterOverflowError
-    | SqliteError
-  > => {
-    let lastTimestamp = timestampStringToTimestamp(
-      deps.ownerRowRef.get().timestamp,
-    );
+      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);
+        }
+      }
+
+      if (isNonEmptyArray(syncChanges)) {
+        const result = deps.sync.applyChanges(syncChanges);
+        if (!result.ok) return result;
+      }
+
+      // 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,
+      });
 
-    const messages: Array<CrdtMessage> = [];
+      // Notify other tabs to refresh their queries.
+      deps.postMessage({ type: "refreshQueries", tabId: message.tabId });
+
+      return ok();
+    });
 
-    for (const change of changes) {
-      const nextTimestamp = sendTimestamp(deps)(lastTimestamp);
-      if (!nextTimestamp.ok) return nextTimestamp;
-      lastTimestamp = nextTimestamp.value;
-      messages.push({ timestamp: lastTimestamp, change });
+    if (!mutate.ok) {
+      deps.postMessage({ type: "onError", error: mutate.error });
+      return;
     }
+  },
 
-    const apply = applyMessages(deps)(messages, lastTimestamp);
-    if (!apply.ok) return apply;
+  query: (deps) => (message) => {
+    const queryPatches = loadQueries(deps)(message.tabId, message.queries);
 
-    if (onChange) onChange();
+    if (!queryPatches.ok) {
+      deps.postMessage({ type: "onError", error: queryPatches.error });
+      return;
+    }
 
-    assertNonEmptyReadonlyArray(messages);
-    return ok(messages);
-  };
+    deps.postMessage({
+      type: "onQueryPatches",
+      tabId: message.tabId,
+      queryPatches: queryPatches.value,
+      onCompleteIds: [],
+    });
+  },
 
-const applyMessages =
-  (deps: SqliteDep & RandomDep & OwnerRowRefDep & ClientStorageDep) =>
-  (
-    messages: ReadonlyArray<CrdtMessage>,
-    lastTimestamp: Timestamp,
-    options: { isMigrationFromVersion0?: boolean } = {},
-  ): Result<void, SqliteError> => {
-    for (const message of messages) {
-      if (!options.isMigrationFromVersion0) {
-        const apply1 = applyMessageToAppTable(deps)(message);
-        if (!apply1.ok) return apply1;
+  reset: (deps) => (message) => {
+    const resetResult = deps.sqlite.transaction(() => {
+      const dbSchema = getDbSchema(deps)();
+      if (!dbSchema.ok) return dbSchema;
+
+      for (const table of 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(table.name)};
+        `);
+        if (!result.ok) return result;
       }
 
-      const apply2 = applyMessageToTimestampAndHistoryTables(deps)(message);
-      if (!apply2.ok) return apply2;
-    }
+      if (message.restore) {
+        const dbSchema = getDbSchema(deps)();
+        if (!dbSchema.ok) return dbSchema;
 
-    const timestamp = timestampToTimestampString(lastTimestamp);
-    deps.ownerRowRef.modify((owner) => ({ ...owner, timestamp }));
-    const saveTimestamp = deps.sqlite.exec(sql.prepared`
-      update evolu_owner set "timestamp" = ${timestamp};
-    `);
-    if (!saveTimestamp.ok) return saveTimestamp;
+        const ensureDbSchemaResult = ensureDbSchema(deps)(
+          message.restore.dbSchema,
+          dbSchema.value,
+        );
+        if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
 
-    return ok();
-  };
+        const secret = mnemonicToOwnerSecret(message.restore.mnemonic);
+        const appOwner = createAppOwner(secret);
+        const clock = createClock(deps)();
 
-const applyMessageToAppTable =
-  (deps: SqliteDep) =>
-  (message: CrdtMessage): Result<void, SqliteError> => {
-    const date = new Date(message.timestamp.millis).toISOString();
-    const timestamp = timestampToBinaryTimestamp(message.timestamp);
-
-    for (const [column, value] of objectToEntries(message.change.values)) {
-      const result = deps.sqlite.exec(sql.prepared`
-        with
-          lastTimestamp as (
-            select timestamp
-            from evolu_history
-            where
-              "row" = ${message.change.id}
-              and "column" = ${column}
-              and "table" = ${message.change.table}
-            order by timestamp desc
-            limit 1
-          )
-        insert into ${sql.identifier(message.change.table)}
-          ("id", ${sql.identifier(column)}, createdAt, updatedAt)
-        select ${message.change.id}, ${value}, ${date}, ${date}
-        where
-          (select timestamp from lastTimestamp) is null
-          or (select timestamp from lastTimestamp) < ${timestamp}
-        on conflict ("id") do update
-          set
-            ${sql.identifier(column)} = ${value},
-            updatedAt = ${date}
-          where
-            (select timestamp from lastTimestamp) is null
-            or (select timestamp from lastTimestamp) < ${timestamp};
-      `);
+        const initializeDbResult = initializeDb(deps)(appOwner, clock.get());
+        if (!initializeDbResult.ok) return initializeDbResult;
+      }
 
-      if (!result.ok) return result;
+      return ok();
+    });
+
+    if (!resetResult.ok) {
+      deps.postMessage({ type: "onError", error: resetResult.error });
+      return;
     }
 
-    return ok();
-  };
+    deps.postMessage({
+      type: "onReset",
+      onCompleteId: message.onCompleteId,
+      reload: message.reload,
+    });
+  },
 
-export const applyMessageToTimestampAndHistoryTables =
-  (deps: SqliteDep & RandomDep & OwnerRowRefDep & ClientStorageDep) =>
-  (message: CrdtMessage): Result<void, SqliteError> => {
-    const timestamp = timestampToBinaryTimestamp(message.timestamp);
-    const ownerId = ownerIdToBinaryOwnerId(deps.ownerRowRef.get().id);
-    const id = idToBinaryId(message.change.id);
+  ensureDbSchema: (deps) => (message) => {
+    const ensureSchema = deps.sqlite.transaction(() => {
+      const dbSchema = getDbSchema(deps)();
+      if (!dbSchema.ok) return dbSchema;
 
-    const result = deps.storage.insertTimestamp(ownerId, timestamp);
-    if (!result.ok) return result;
+      const ensureDbSchemaResult = ensureDbSchema(deps)(
+        message.dbSchema,
+        dbSchema.value,
+      );
+      if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
 
-    for (const [column, value] of Object.entries(message.change.values)) {
-      const result = deps.sqlite.exec(sql.prepared`
-        insert into evolu_history
-          ("timestamp", "table", "row", "column", "value")
-        values
-          (${timestamp}, ${message.change.table}, ${id}, ${column}, ${value})
-        on conflict do nothing;
-      `);
-      if (!result.ok) return result;
+      return ok();
+    });
+
+    if (!ensureSchema.ok) {
+      deps.postMessage({ type: "onError", error: ensureSchema.error });
+      return;
     }
+  },
 
-    return ok();
-  };
+  export: (deps) => (message) => {
+    const file = deps.sqlite.export();
+
+    if (!file.ok) {
+      deps.postMessage({ type: "onError", error: file.error });
+      return;
+    }
+
+    deps.postMessage({
+      type: "onExport",
+      onCompleteId: message.onCompleteId,
+      file: file.value,
+    });
+  },
+
+  useOwner: (deps) => (message) => {
+    deps.sync.useOwner(message.use, message.owner);
+  },
+};
 
 const loadQueries =
   (deps: GetQueryRowsCacheDep & SqliteDep) =>
@@ -1033,243 +774,3 @@ const loadQueries =
     );
     return ok(queryPatchesArray);
   };
-
-export const maybeMigrateToVersion0 =
-  (deps: SqliteDep) =>
-  (
-    schema: DbSchema,
-  ): Result<
-    {
-      readonly messages: ReadonlyArray<CrdtMessage>;
-      readonly mnemonic: Mnemonic;
-      readonly lastTimestamp: Timestamp;
-    } | null,
-    SqliteError
-  > => {
-    // evolu_history is a new table
-    const hasOwnerButNoHistory =
-      schema.tables.some((t) => t.name === "evolu_owner") &&
-      !schema.tables.some((t) => t.name === "evolu_history");
-    if (!hasOwnerButNoHistory) {
-      return ok(null);
-    }
-
-    const mnemonicAndLastTimestamp = deps.sqlite.exec<{
-      mnemonic: Mnemonic;
-      timestamp: TimestampString;
-    }>(sql` select mnemonic, timestamp from evolu_owner limit 1; `);
-    if (!mnemonicAndLastTimestamp.ok) return mnemonicAndLastTimestamp;
-
-    const messagesRows = deps.sqlite.exec<{
-      timestamp: TimestampString;
-      table: Base64Url256;
-      row: Id;
-      column: Base64Url256;
-      value: SqliteValue;
-    }>(sql`
-      select "timestamp", "table", "row", "column", "value" from evolu_message;
-    `);
-
-    if (!messagesRows.ok) return messagesRows;
-
-    for (const query of [
-      sql`drop table evolu_owner;`,
-      sql`drop table evolu_message;`,
-    ]) {
-      const result = deps.sqlite.exec(query);
-      if (!result.ok) return result;
-    }
-
-    const messages = messagesRows.value.rows.map((message) => ({
-      timestamp: timestampStringToTimestamp(message.timestamp),
-      change: {
-        id: message.row,
-        table: message.table,
-        values: { [message.column]: message.value },
-      },
-    }));
-
-    const {
-      rows: [{ mnemonic, timestamp }],
-    } = mnemonicAndLastTimestamp.value;
-    const lastTimestamp = timestampStringToTimestamp(timestamp);
-
-    return ok({ messages, mnemonic, lastTimestamp });
-  };
-
-const dropAllTables = (deps: SqliteDep): Result<void, SqliteError> => {
-  const schema = getDbSchema(deps)();
-  if (!schema.ok) return schema;
-  for (const table of schema.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(table.name)};
-    `);
-    if (!result.ok) return result;
-  }
-  return ok();
-};
-
-const handleSyncOpen =
-  (deps: OwnerRowRefDep & StorageDep & ConsoleDep): SyncConfig["onOpen"] =>
-  (send) => {
-    const ownerId = deps.ownerRowRef.get().id;
-    const message = createProtocolMessageForSync(deps)(ownerId);
-    if (message) {
-      deps.console.log("[db]", "send initial sync message", message);
-      send(message);
-    }
-  };
-
-const createHandleSyncMessage =
-  (
-    deps: PostMessageDep & StorageDep & SqliteDep & ConsoleDep & OwnerRowRefDep,
-  ): SyncConfig["onMessage"] =>
-  (input, send) => {
-    deps.console.log("[db]", "receive sync message", input);
-    const { writeKey } = deps.ownerRowRef.get();
-
-    const output = deps.sqlite.transaction(() =>
-      applyProtocolMessageAsClient(deps)(input, {
-        getWriteKey: (_ownerId) => writeKey,
-      }),
-    );
-    if (!output.ok) {
-      deps.postMessage({ type: "onError", error: output.error });
-      return;
-    }
-
-    if (output.value) {
-      deps.console.log("[db]", "respond sync message", output.value);
-      send(output.value);
-    }
-  };
-
-export interface ClientStorage extends SqliteStorageBase, Storage {}
-
-export interface ClientStorageDep {
-  readonly storage: ClientStorage;
-}
-
-const createClientStorage =
-  (
-    deps: SqliteDep &
-      PostMessageDep &
-      SymmetricCryptoDep &
-      OwnerRowRefDep &
-      RandomDep &
-      TimeDep &
-      TimestampConfigDep,
-  ) =>
-  (
-    options: CreateSqliteStorageBaseOptions,
-  ): Result<ClientStorage, SqliteError> => {
-    const sqliteStorageBase = createSqliteStorageBase(deps)(options);
-    if (!sqliteStorageBase.ok) return sqliteStorageBase;
-
-    const storage: ClientStorage = {
-      ...sqliteStorageBase.value,
-
-      validateWriteKey: constFalse,
-
-      writeMessages: (_ownerId, messages) => {
-        // TODO: Get owner by _ownerId when we support more.
-        const owner = deps.ownerRowRef.get();
-        const decodedAndDecryptedMessages: Array<CrdtMessage> = [];
-
-        for (const message of messages) {
-          const dbChange = decryptAndDecodeDbChange(deps)(
-            message.change,
-            owner.encryptionKey,
-          );
-
-          if (!dbChange.ok) {
-            deps.postMessage({
-              type: "onError",
-              error: dbChange.error,
-            });
-            return false;
-          }
-
-          decodedAndDecryptedMessages.push({
-            timestamp: message.timestamp,
-            change: dbChange.value,
-          });
-        }
-
-        let timestamp = timestampStringToTimestamp(owner.timestamp);
-
-        for (const message of messages) {
-          const receive = receiveTimestamp(deps)(timestamp, message.timestamp);
-          if (!receive.ok) {
-            deps.postMessage({ type: "onError", error: receive.error });
-            return false;
-          }
-          timestamp = receive.value;
-        }
-
-        const applyMessagesResult = applyMessages({ ...deps, storage })(
-          decodedAndDecryptedMessages,
-          timestamp,
-        );
-
-        if (!applyMessagesResult.ok) {
-          deps.postMessage({
-            type: "onError",
-            error: applyMessagesResult.error,
-          });
-          return false;
-        }
-
-        deps.postMessage({ type: "onReceive" });
-
-        return true;
-      },
-
-      readDbChange: (_ownerId, timestamp) => {
-        const result = deps.sqlite.exec<{
-          table: Base64Url256;
-          row: BinaryId;
-          column: Base64Url256;
-          value: SqliteValue;
-        }>(sql`
-          select "table", "row", "column", "value"
-          from evolu_history
-          where "timestamp" = ${timestamp};
-        `);
-        if (!result.ok) {
-          deps.postMessage({ type: "onError", error: result.error });
-          return null;
-        }
-
-        const { rows } = result.value;
-        assert(rows.length > 0, "Rows must not be empty");
-
-        const { table, row } = rows[0];
-        const values: Record<string, SqliteValue> = {};
-
-        for (const r of rows) {
-          assert(r.table === table, "All rows must have the same table");
-          assert(eqArrayNumber(r.row, row), "All rows must have the same Id");
-          values[r.column] = r.value;
-        }
-
-        const change: DbChange = {
-          table: rows[0].table,
-          id: binaryIdToId(rows[0].row),
-          values,
-        };
-
-        const { encryptionKey } = deps.ownerRowRef.get();
-
-        return encodeAndEncryptDbChange(deps)(change, encryptionKey);
-      },
-    };
-
-    return ok(storage);
-  };