@evolu/common 6.0.1-preview.19 → 6.0.1-preview.20

package/src/Evolu/Db.ts

@@ -1,64 +1,43 @@
 import { isNonEmptyArray, NonEmptyReadonlyArray } from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
-import { CallbackId } from "../Callbacks.js";
-import { ConsoleDep } from "../Console.js";
+import { CallbackId } from "../CallbackRegistry.js";
+import { ConsoleConfig, 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 { 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 { array, 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, OwnerId, WriteKey } from "./Owner.js";
 import {
-  applyProtocolMessageAsClient,
-  Base64Url256,
-  BinaryId,
-  binaryIdToId,
-  BinaryOwnerId,
-  binaryOwnerIdToOwnerId,
-  CrdtMessage,
-  createProtocolMessageForSync,
-  createProtocolMessageFromCrdtMessages,
-  DbChange,
-  decryptAndDecodeDbChange,
-  encodeAndEncryptDbChange,
-  idToBinaryId,
-  ownerIdToBinaryOwnerId,
-  ProtocolError,
-  protocolVersion,
-  Storage,
-  StorageDep,
-} from "./Protocol.js";
+  AppOwner,
+  createAppOwner,
+  createOwnerSecret,
+  mnemonicToOwnerSecret,
+  OwnerEncryptionKey,
+  OwnerId,
+  OwnerWriteKey,
+  TransportConfig,
+} from "./Owner.js";
+import { ProtocolError, protocolVersion } from "./Protocol.js";
 import {
   createQueryRowsCache,
   deserializeQuery,
@@ -67,42 +46,145 @@ 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 {
-  binaryTimestampToTimestamp,
-  createInitialTimestamp,
-  receiveTimestamp,
-  sendTimestamp,
   Timestamp,
-  TimestampConfigDep,
-  TimestampCounterOverflowError,
-  TimestampDriftError,
+  TimestampConfig,
   TimestampError,
   TimestampString,
   timestampStringToTimestamp,
-  TimestampTimeOutOfRangeError,
-  timestampToBinaryTimestamp,
   timestampToTimestampString,
 } from "./Timestamp.js";
 
-export const DbTable = object({
-  name: Base64Url256,
-  columns: array(Base64Url256),
-});
-export type DbTable = typeof DbTable.Type;
-
-export const DbIndex = object({ name: String, sql: String });
-export type DbIndex = typeof DbIndex.Type;
+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.
+   *
+   * 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}.
+   *
+   * 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
+   * transports: [];
+   * ```
+   */
+  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 DbSchema = object({
-  tables: array(DbTable),
-  indexes: array(DbIndex),
-});
-export type DbSchema = typeof DbSchema.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>;
 
@@ -115,13 +197,16 @@ export interface CreateDbWorkerDep {
 export type DbWorkerInput =
   | {
       readonly type: "init";
-      readonly config: Config;
+      readonly config: DbConfig;
       readonly dbSchema: DbSchema;
     }
+  | {
+      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>;
     }
@@ -146,31 +231,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 appOwner: AppOwner;
-      readonly isFirst: boolean;
-    }
   | {
       readonly type: "onError";
       readonly error:
+        | ProtocolError
         | SqliteError
-        | TransferableError
+        | SymmetricCryptoDecryptError
         | TimestampError
-        | ProtocolError
-        | SymmetricCryptoDecryptError;
+        | TransferableError;
     }
   | {
-      readonly type: "onChange";
+      readonly type: "onGetAppOwner";
+      readonly appOwner: AppOwner;
+    }
+  | {
+      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;
     }
   | {
@@ -184,617 +273,196 @@ 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 &
-  OwnersDep &
-  ClockDep &
-  GetQueryRowsCacheDep &
-  ClientStorageDep;
-
-type PostMessageDep = WorkerPostMessageDep<DbWorkerOutput>;
-
-interface OwnersDep {
-  readonly owners: Owners;
-}
-
-type Owners = Map<OwnerId, AppOwner>;
-
-interface ClockDep {
-  readonly clock: Clock;
-}
-
-interface Clock {
-  readonly get: () => Timestamp;
-  readonly save: (timestamp: Timestamp) => Result<void, SqliteError>;
-}
+  AppOwnerDep;
 
 interface GetQueryRowsCacheDep {
   readonly getQueryRowsCache: (tabId: Id) => QueryRowsCache;
 }
 
-const createClock =
-  (deps: NanoIdLibDep & SqliteDep) =>
-  (initialTimestamp = createInitialTimestamp(deps)): Clock => {
-    let currentTimestamp = initialTimestamp;
-
-    return {
-      get: () => currentTimestamp,
-      save: (timestamp) => {
-        currentTimestamp = timestamp;
-
-        const timestampString = timestampToTimestampString(timestamp);
-        const saveTimestamp = deps.sqlite.exec(sql.prepared`
-          update evolu_config set "clock" = ${timestampString};
-        `);
-        if (!saveTimestamp.ok) return saveTimestamp;
+export interface PostMessageDep {
+  readonly postMessage: (message: DbWorkerOutput) => void;
+}
 
-        return ok();
-      },
-    };
-  };
+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 sqliteResult = await createSqlite(platformDeps)(
-        initMessage.config.name,
-        { memory: initMessage.config.inMemory ?? false },
-      );
-      if (!sqliteResult.ok) {
-        postMessage({ type: "onError", error: sqliteResult.error });
-        return null;
-      }
-
-      const sqlite = sqliteResult.value;
-      const platformDepsWithSqlite = { ...platformDeps, sqlite };
+    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;
+      let appOwner: AppOwner;
+      let clock: Clock;
 
-        const dbIsInitialized = currentDbSchema.value.tables.some(
-          (table) => table.name === "evolu_version",
-        );
+      const dbIsInitialized = currentDbSchema.value.tables.some(
+        (table) => table.name === "evolu_version",
+      );
 
-        if (dbIsInitialized) {
-          const versionResult = sqlite.exec<{
-            protocolVersion: number;
-          }>(sql`select protocolVersion from evolu_version limit 1;`);
-          if (!versionResult.ok) return versionResult;
-
-          // 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: EncryptionKey;
-            appOwnerWriteKey: WriteKey;
-            appOwnerMnemonic: Mnemonic | null;
-          }>(sql`
-            select
-              clock,
-              appOwnerId,
-              appOwnerEncryptionKey,
-              appOwnerWriteKey,
-              appOwnerMnemonic
-            from evolu_config
-            limit 1;
-          `);
-          if (!configResult.ok) return configResult;
-
-          const [config] = configResult.value.rows;
-
-          appOwner = {
-            type: "AppOwner",
-            id: config.appOwnerId,
-            encryptionKey: config.appOwnerEncryptionKey,
-            writeKey: config.appOwnerWriteKey,
-            mnemonic: config.appOwnerMnemonic,
-          };
-          clock = createClock(platformDepsWithSqlite)(
-            timestampStringToTimestamp(config.clock),
-          );
-        } else {
-          appOwner =
-            initMessage.config.initialAppOwner ??
-            createAppOwner(platformDeps.createMnemonic());
-          clock = createClock(platformDepsWithSqlite)();
-          const initializeDbResult = initializeDb(platformDepsWithSqlite)(
-            appOwner,
+      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,
-          );
-          if (!initializeDbResult.ok) return initializeDbResult;
-        }
-
-        const ensureDbSchemaResult = ensureDbSchema({ sqlite })(
-          initMessage.dbSchema,
-          currentDbSchema.value,
-        );
-        if (!ensureDbSchemaResult.ok) return ensureDbSchemaResult;
-
-        const owners: Owners = new Map();
-        owners.set(appOwner.id, appOwner);
-
-        const depsWithoutSyncAndStorage = {
-          ...platformDeps,
-          postMessage,
-          sqlite,
-          timestampConfig: initMessage.config,
-          symmetricCrypto: createSymmetricCrypto(platformDeps),
-          getQueryRowsCache,
-          clock,
-          owners,
-        };
+            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,
         };
 
-        postMessage({
-          type: "onInit",
-          appOwner,
-          isFirst: !dbIsInitialized,
-        });
-
-        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 date = new Date(deps.time.now()).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;
-
-            // TODO: Use owner from db change or AppOwner
-            const owner = Array.from(deps.owners.values())[0];
-
-            const protocolMessage = createProtocolMessageFromCrdtMessages(deps)(
-              owner,
-              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 appOwner = createAppOwner(message.restore.mnemonic);
-              const clock = createClock(deps)();
-
-              const initializeDbResult = initializeDb(deps)(appOwner, clock);
-              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,
-          });
-
-          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_%';
-          `,
-    );
-
-    if (!indexesRows.ok) return indexesRows;
-
-    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"),
-      }),
-    );
-
-    return ok({ tables, indexes });
-  };
 
-const indexesAreEqual = (self: DbIndex, that: DbIndex): boolean =>
-  self.name === that.name && self.sql === that.sql;
-
-export interface DbSnapshot {
-  readonly schema: DbSchema;
-  readonly tables: Array<{
-    name: string;
-    rows: ReadonlyArray<SqliteRow>;
-  }>;
-}
-
-// TODO: Move to test helpers.
-export const getDbSnapshot = (deps: SqliteDep): DbSnapshot => {
-  const schema = getDbSchema(deps)({ allIndexes: true });
-  assert(schema.ok, "bug");
-
-  const tables = [];
-
-  for (const table of schema.value.tables) {
-    const result = deps.sqlite.exec(sql`
-      select * from ${sql.identifier(table.name)};
-    `);
-    assert(result.ok, "bug");
+      const deps: DbWorkerDeps = {
+        ...platformDeps,
+        getQueryRowsCache,
+        postMessage,
+        sqlite,
+        sync: sync.value,
+        appOwner,
+      };
 
-    tables.push({
-      name: table.name,
-      rows: result.value.rows,
+      return ok(deps);
     });
-  }
-
-  return { schema: schema.value, tables };
-};
 
-const ensureDbSchema =
-  (deps: SqliteDep) =>
-  (
-    newSchema: DbSchema,
-    currentSchema: DbSchema,
-    options?: { ignoreIndexes: boolean },
-  ): 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),
-            ),
-        )
-        .forEach((newIndex) => {
-          queries.push({ sql: `${newIndex.sql};` as SafeSql, parameters: [] });
-        });
+    if (!deps.ok) {
+      postMessage({ type: "onError", error: deps.error });
+      return null;
     }
 
-    for (const query of queries) {
-      const result = deps.sqlite.exec(query);
-      if (!result.ok) return result;
-    }
-    return ok();
+    return deps.value;
   };
 
-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 initializeDb =
-  (deps: SqliteDep & CreateMnemonicDep & TimeDep & CreateRandomBytesDep) =>
+  (deps: SqliteDep) =>
   (
     initialAppOwner: AppOwner,
-    initialClock: Clock,
+    initialClock: Timestamp,
   ): Result<void, SqliteError> => {
     for (const query of [
       // Never change structure to ensure all versions can read it.
@@ -832,7 +500,7 @@ const initializeDb =
           )
         values
           (
-            ${timestampToTimestampString(initialClock.get())},
+            ${timestampToTimestampString(initialClock)},
             ${initialAppOwner.id},
             ${initialAppOwner.encryptionKey},
             ${initialAppOwner.writeKey},
@@ -885,140 +553,166 @@ const initializeDb =
     return ok();
   };
 
-const applyChanges =
-  (
-    deps: SqliteDep &
-      TimeDep &
-      TimestampConfigDep &
-      RandomDep &
-      ClientStorageDep &
-      OwnersDep &
-      ClockDep,
-  ) =>
-  (
-    changes: NonEmptyReadonlyArray<DbChange>,
-    onChange?: () => void,
-  ): Result<
-    NonEmptyReadonlyArray<CrdtMessage>,
-    | TimestampTimeOutOfRangeError
-    | TimestampDriftError
-    | TimestampCounterOverflowError
-    | SqliteError
-  > => {
-    let clockTimestamp = deps.clock.get();
-
-    const messages: Array<CrdtMessage> = [];
-
-    for (const change of changes) {
-      const nextTimestamp = sendTimestamp(deps)(clockTimestamp);
-      if (!nextTimestamp.ok) return nextTimestamp;
-      clockTimestamp = nextTimestamp.value;
-      messages.push({ timestamp: clockTimestamp, change });
-    }
+const handlers: Omit<MessageHandlers<DbWorkerInput, DbWorkerDeps>, "init"> = {
+  getAppOwner: (deps) => () => {
+    deps.postMessage({
+      type: "onGetAppOwner",
+      appOwner: deps.appOwner,
+    });
+  },
 
-    const apply = applyMessages(deps)(messages, clockTimestamp);
-    if (!apply.ok) return apply;
+  mutate: (deps) => (message) => {
+    const mutate = deps.sqlite.transaction(() => {
+      const syncChanges: Array<MutationChange> = [];
 
-    if (onChange) onChange();
+      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);
+        }
+      }
 
-    assertNonEmptyReadonlyArray(messages);
-    return ok(messages);
-  };
+      if (isNonEmptyArray(syncChanges)) {
+        const result = deps.sync.applyChanges(syncChanges);
+        if (!result.ok) return result;
+      }
 
-const applyMessages =
-  (deps: SqliteDep & RandomDep & ClientStorageDep & ClockDep & OwnersDep) =>
-  (
-    messages: ReadonlyArray<CrdtMessage>,
-    clockTimestamp: Timestamp,
-  ): Result<void, SqliteError> => {
-    const ownerId = ownerIdToBinaryOwnerId(
-      Array.from(deps.owners.values())[0].id,
-    );
+      // 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,
+      });
 
-    for (const message of messages) {
-      const result1 = applyMessageToAppTable(deps)(ownerId, message);
-      if (!result1.ok) return result1;
+      // Notify other tabs to refresh their queries.
+      deps.postMessage({ type: "refreshQueries", tabId: message.tabId });
 
-      const result2 = applyMessageToTimestampAndHistoryTables(deps)(
-        ownerId,
-        message,
-      );
-      if (!result2.ok) return result2;
+      return ok();
+    });
+
+    if (!mutate.ok) {
+      deps.postMessage({ type: "onError", error: mutate.error });
+      return;
     }
+  },
 
-    return deps.clock.save(clockTimestamp);
-  };
+  query: (deps) => (message) => {
+    const queryPatches = loadQueries(deps)(message.tabId, message.queries);
 
-const applyMessageToAppTable =
-  (deps: SqliteDep) =>
-  (ownerId: BinaryOwnerId, message: CrdtMessage): Result<void, SqliteError> => {
-    const timestamp = timestampToBinaryTimestamp(message.timestamp);
-    const updatedAt = new Date(message.timestamp.millis).toISOString();
-
-    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
-              "ownerId" = ${ownerId}
-              and "table" = ${message.change.table}
-              and "id" = ${message.change.id}
-              and "column" = ${column}
-            order by "timestamp" desc
-            limit 1
-          )
-        insert into ${sql.identifier(message.change.table)}
-          ("id", ${sql.identifier(column)}, updatedAt)
-        select ${message.change.id}, ${value}, ${updatedAt}
-        where
-          (select "timestamp" from lastTimestamp) is null
-          or (select "timestamp" from lastTimestamp) < ${timestamp}
-        on conflict ("id") do update
-          set
-            ${sql.identifier(column)} = ${value},
-            updatedAt = ${updatedAt}
-          where
-            (select "timestamp" from lastTimestamp) is null
-            or (select "timestamp" from lastTimestamp) < ${timestamp};
-      `);
+    if (!queryPatches.ok) {
+      deps.postMessage({ type: "onError", error: queryPatches.error });
+      return;
+    }
 
-      if (!result.ok) return result;
+    deps.postMessage({
+      type: "onQueryPatches",
+      tabId: message.tabId,
+      queryPatches: queryPatches.value,
+      onCompleteIds: [],
+    });
+  },
+
+  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;
+      }
+
+      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 secret = mnemonicToOwnerSecret(message.restore.mnemonic);
+        const appOwner = createAppOwner(secret);
+        const clock = createClock(deps)();
+
+        const initializeDbResult = initializeDb(deps)(appOwner, clock.get());
+        if (!initializeDbResult.ok) return initializeDbResult;
+      }
+
+      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 & ClientStorageDep) =>
-  (ownerId: BinaryOwnerId, message: CrdtMessage): Result<void, SqliteError> => {
-    const timestamp = timestampToBinaryTimestamp(message.timestamp);
-    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
-          ("ownerId", "table", "id", "column", "value", "timestamp")
-        values
-          (
-            ${ownerId},
-            ${message.change.table},
-            ${id},
-            ${column},
-            ${value},
-            ${timestamp}
-          )
-        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) =>
@@ -1057,189 +751,3 @@ const loadQueries =
     );
     return ok(queryPatchesArray);
   };
-
-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: StorageDep & ConsoleDep & OwnersDep): SyncConfig["onOpen"] =>
-  (send) => {
-    for (const [id] of deps.owners) {
-      const message = createProtocolMessageForSync(deps)(id);
-      if (!message) return;
-      deps.console.log("[db]", "send initial sync message", message);
-      send(message);
-    }
-  };
-
-const createHandleSyncMessage =
-  (
-    deps: PostMessageDep & StorageDep & SqliteDep & ConsoleDep & OwnersDep,
-  ): SyncConfig["onMessage"] =>
-  (input, send) => {
-    deps.console.log("[db]", "receive sync message", input);
-
-    const output = deps.sqlite.transaction(() =>
-      applyProtocolMessageAsClient(deps)(input, {
-        getWriteKey: (ownerId) => deps.owners.get(ownerId)?.writeKey ?? null,
-      }),
-    );
-    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 ClientStorageDep {
-  readonly storage: ClientStorage;
-}
-
-export interface ClientStorage extends SqliteStorageBase, Storage {}
-
-const createClientStorage =
-  (
-    deps: SqliteDep &
-      PostMessageDep &
-      SymmetricCryptoDep &
-      RandomDep &
-      TimeDep &
-      OwnersDep &
-      ClockDep &
-      TimestampConfigDep,
-  ) =>
-  (
-    options: CreateSqliteStorageBaseOptions,
-  ): Result<ClientStorage, SqliteError> => {
-    const sqliteStorageBase = createSqliteStorageBase(deps)(options);
-    if (!sqliteStorageBase.ok) return sqliteStorageBase;
-
-    const storage: ClientStorage = {
-      ...sqliteStorageBase.value,
-
-      validateWriteKey: constFalse,
-      setWriteKey: constFalse,
-
-      writeMessages: (ownerId, messages) => {
-        const owner = deps.owners.get(binaryOwnerIdToOwnerId(ownerId));
-        assert(owner, "Missing owner");
-
-        const decodedAndDecryptedMessages: Array<CrdtMessage> = [];
-
-        for (const message of messages) {
-          const dbChange = decryptAndDecodeDbChange(deps)(
-            message,
-            owner.encryptionKey,
-          );
-
-          if (!dbChange.ok) {
-            deps.postMessage({
-              type: "onError",
-              error: dbChange.error,
-            });
-            return false;
-          }
-
-          decodedAndDecryptedMessages.push({
-            timestamp: message.timestamp,
-            change: dbChange.value,
-          });
-        }
-
-        let clockTimestamp = deps.clock.get();
-
-        for (const message of messages) {
-          const receive = receiveTimestamp(deps)(
-            clockTimestamp,
-            message.timestamp,
-          );
-          if (!receive.ok) {
-            deps.postMessage({ type: "onError", error: receive.error });
-            return false;
-          }
-          clockTimestamp = receive.value;
-        }
-
-        const applyMessagesResult = applyMessages({ ...deps, storage })(
-          decodedAndDecryptedMessages,
-          clockTimestamp,
-        );
-
-        if (!applyMessagesResult.ok) {
-          deps.postMessage({
-            type: "onError",
-            error: applyMessagesResult.error,
-          });
-          return false;
-        }
-
-        deps.postMessage({ type: "onReceive" });
-
-        return true;
-      },
-
-      readDbChange: (ownerId, timestamp) => {
-        const owner = deps.owners.get(binaryOwnerIdToOwnerId(ownerId));
-        assert(owner, "Missing owner");
-
-        const result = deps.sqlite.exec<{
-          table: Base64Url256;
-          id: BinaryId;
-          column: Base64Url256;
-          value: SqliteValue;
-        }>(sql`
-          select "table", "id", "column", "value"
-          from evolu_history
-          where "ownerId" = ${ownerId} and "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, id } = 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.id, id), "All rows must have the same Id");
-          values[r.column] = r.value;
-        }
-
-        const message: CrdtMessage = {
-          timestamp: binaryTimestampToTimestamp(timestamp),
-          change: {
-            table: rows[0].table,
-            id: binaryIdToId(rows[0].id),
-            values,
-          },
-        };
-
-        return encodeAndEncryptDbChange(deps)(message, owner.encryptionKey);
-      },
-    };
-
-    return ok(storage);
-  };