@evolu/common 7.4.0 → 8.0.0-next.0

package/src/local-first/Evolu.ts

@@ -1,80 +1,199 @@
-import { pack } from "msgpackr";
+/**
+ * Local-first platform.
+ *
+ * @module
+ */
+
 import {
-  dedupeArray,
+  emptyArray,
   isNonEmptyArray,
-  isNonEmptyReadonlyArray,
+  mapArray,
+  type NonEmptyReadonlyArray,
 } from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
-import { createCallbacks } from "../Callbacks.js";
-import { ConsoleDep } from "../Console.js";
-import { RandomBytesDep, SymmetricCryptoDecryptError } from "../Crypto.js";
-import { eqArrayNumber } from "../Eq.js";
-import { TransferableError } from "../Error.js";
-import { exhaustiveCheck } from "../Function.js";
-import { createInstances, Instances } from "../Instances.js";
-import { err, ok, Result } from "../Result.js";
 import {
-  isSqlMutation,
-  SafeSql,
-  SqliteBoolean,
-  sqliteBooleanToBoolean,
-  SqliteError,
-  SqliteQuery,
-} from "../Sqlite.js";
-import { createStore, StoreSubscribe } from "../Store.js";
-import { TimeDep } from "../Time.js";
+  assert,
+  assertNonEmptyReadonlyArray,
+  assertNotDisposed,
+} from "../Assert.js";
+import { createCallbacks } from "../Callbacks.js";
+import type { ConsoleDep } from "../Console.js";
+import { createConsole } from "../Console.js";
+import { createUnknownError } from "../Error.js";
+import { exhaustiveCheck, todo } from "../Function.js";
+import { createMicrotaskBatch } from "../Microtask.js";
+import type { FlushSyncDep, ReloadAppDep } from "../Platform.js";
+import { createRefCountByKey } from "../RefCount.js";
+import { err, ok } from "../Result.js";
+import { isNonEmptySet } from "../Set.js";
+import { SqliteBoolean, sqliteBooleanToBoolean } from "../Sqlite.js";
+import type { Listener, ReadonlyStore, Unsubscribe } from "../Store.js";
+import { createStore } from "../Store.js";
+import { type createRun, type Task } from "../Task.js";
+import type { Id, TypeError } from "../Type.js";
 import {
+  brand,
   createId,
-  Id,
-  InferErrors,
-  InferInput,
-  InferType,
-  Mnemonic,
-  ObjectType,
-  SimpleName,
-  ValidMutationSize,
-  ValidMutationSizeError,
+  createIdFromString,
+  Name,
+  UrlSafeString,
 } from "../Type.js";
-import { IntentionalNever } from "../Types.js";
-import { CreateDbWorkerDep, DbConfig, defaultDbConfig } from "./Db.js";
-import { AppOwner } from "./Owner.js";
-import { FlushSyncDep, ReloadAppDep } from "./Platform.js";
-import { ProtocolError } from "./Protocol.js";
-import {
-  applyPatches,
-  createSubscribedQueries,
-  emptyRows,
+import type { ExtractType } from "../Types.js";
+import type { CreateMessageChannelDep } from "../Worker.js";
+import type { CreateDbWorkerDep } from "./Db.js";
+import type { EvoluError } from "./Error.js";
+import type {
+  AppOwner,
+  Owner,
+  OwnerId,
+  OwnerTransport,
+  ReadonlyOwner,
+  SyncOwner,
+} from "./Owner.js";
+import { createOwnerWebSocketTransport } from "./Owner.js";
+import type {
   Queries,
   QueriesToQueryRowsPromises,
   Query,
   QueryRows,
-  QueryRowsMap,
   Row,
-  serializeQuery,
-  SubscribedQueries,
+  RowsByQueryMap,
 } from "./Query.js";
-import {
-  CreateQuery,
+import { applyPatches } from "./Query.js";
+import type {
   EvoluSchema,
-  evoluSchemaToDbSchema,
   IndexesConfig,
-  insertable,
-  kysely,
   Mutation,
   MutationChange,
-  MutationKind,
-  MutationMapping,
-  MutationOptions,
-  SystemColumns,
-  updateable,
-  upsertable,
   ValidateSchema,
 } from "./Schema.js";
+import { evoluSchemaToSqliteSchema } from "./Schema.js";
+import type {
+  DbWorkerInput,
+  DbWorkerOutput,
+  EvoluInput,
+  EvoluOutput,
+  EvoluTabOutput,
+  SharedWorkerDep,
+} from "./Shared.js";
 import { DbChange } from "./Storage.js";
-import { initialSyncState, SyncOwner, SyncState } from "./Sync.js";
-import { TimestampError } from "./Timestamp.js";
+import type { Timestamp } from "./Timestamp.js";
+
+export interface EvoluConfig {
+  /**
+   * The app name. Evolu is multitenant - it can run multiple instances
+   * concurrently. The same app can have multiple instances for different
+   * accounts.
+   *
+   * Evolu derives the final instance name from `appName` and `appOwner` in
+   * {@link EvoluConfig}. The derived instance name is used as the SQLite
+   * database filename and as the log prefix. This ensures that each
+   * {@link Owner} gets a separate local database while preserving a readable app
+   * prefix.
+   *
+   * ### Example
+   *
+   * ```ts
+   * // appName: AppName.orThrow("MyApp")
+   * ```
+   */
+  readonly appName: AppName;
+
+  /**
+   * {@link AppOwner} used to create this {@link Evolu} instance.
+   *
+   * Exposed as {@link Evolu.appOwner}. If `appOwner` is not passed, Evolu
+   * creates one.
+   *
+   * AppOwner controls access to the encrypted local SQLite database. If its
+   * secret material (Owner secret / Mnemonic) is not stored safely, data
+   * written by that instance is permanently inaccessible.
+   *
+   * Best onboarding UX is accountless first use: let users try a ready-to-use
+   * app, then prompt backup of `evolu.appOwner`.
+   *
+   * Recommended usage:
+   *
+   * - Omit `appOwner` for first run, then persist `evolu.appOwner` after user
+   *   activity and guide the user to back it up.
+   * - Pass `appOwner` restored from secure storage (for example, Expo
+   *   SecureStore, WebAuthn-backed storage, or app-managed account recovery
+   *   flow).
+   */
+  readonly appOwner: AppOwner;
+
+  /**
+   * Transport configuration for sync and backup.
+   *
+   * If not specified, Evolu uses the default Evolu relay. Pass one or more
+   * transports to override it with your own relays. Pass an empty array to
+   * disable sync, which is useful when sync should be configured later.
+   *
+   * Empty transports start the instance without sync. In that case,
+   * {@link Evolu.useOwner} must be called with explicit non-empty transports to
+   * enable sync for any Owner, including the AppOwner.
+   *
+   * **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 fails or disappears, or a remote relay provider shuts
+   * down.
+   *
+   * Currently supports:
+   *
+   * - WebSocket: Real-time bidirectional communication with relay servers
+   *
+   * Use {@link createOwnerWebSocketTransport} to create WebSocket transport
+   * configurations with proper URL formatting and {@link OwnerId} inclusion. The
+   * {@link OwnerId} in the URL enables relay authentication, allowing relay
+   * servers to control access (e.g., for paid tiers or private instances).
+   *
+   * The default value is:
+   *
+   * `{ type: "WebSocket", url: "wss://free.evoluhq.com" }`.
+   *
+   * ### Example
+   *
+   * ```ts
+   * // Single WebSocket relay
+   * transports: [{ type: "WebSocket", url: "wss://relay1.example.com" }];
+   *
+   * // Multiple WebSocket relays for redundancy
+   * transports: [
+   *   { type: "WebSocket", url: "wss://relay1.example.com" },
+   *   { type: "WebSocket", url: "wss://relay2.example.com" },
+   *   { type: "WebSocket", url: "wss://relay3.example.com" },
+   * ];
+   *
+   * // Local-only instance (no sync) - useful for device settings or when relay
+   * // URL will be provided later (e.g., after authentication), allowing users
+   * // to work offline before the app connects
+   * transports: [];
+   *
+   * // Using createOwnerWebSocketTransport helper for relay authentication
+   * transports: [
+   *   createOwnerWebSocketTransport({
+   *     url: "ws://localhost:4000",
+   *     ownerId,
+   *   }),
+   * ];
+   * ```
+   */
+  readonly transports?: ReadonlyArray<OwnerTransport>;
+
+  /**
+   * Keep local data only in memory instead of persisting it on this device.
+   * Useful for testing, temporary data, or sensitive data that should not be
+   * recoverable from local storage after the process ends.
+   *
+   * Local data stored in memory is completely destroyed when the process ends.
+   * Sync can still persist data remotely when transports are enabled.
+   *
+   * The default value is: `false`.
+   */
+  readonly memoryOnly?: boolean;
 
-export interface EvoluConfig extends Partial<DbConfig> {
   /**
    * Use the `indexes` option to define SQLite indexes.
    *
@@ -98,79 +217,153 @@ export interface EvoluConfig extends Partial<DbConfig> {
   readonly indexes?: IndexesConfig;
 
   /**
-   * URL to reload browser tabs after reset or restore.
+   * Called when this instance's local database is deleted.
    *
-   * The default value is `/`.
+   * Apps can use this to update UI immediately because the corresponding
+   * {@link Evolu} instance becomes unusable after local database deletion.
+   */
+  readonly onDatabaseDeleted?: () => void;
+
+  /**
+   * Called when local data for an {@link Owner} is deleted.
    *
-   * Note: This option will be moved to web platform deps in the next major
-   * version.
+   * Apps can use this to update UI immediately because that owner stops being
+   * used across tabs and instances.
    */
-  readonly reloadUrl?: string;
+  readonly onOwnerDeleted?: (owner: Owner) => void;
 }
 
-export interface Evolu<S extends EvoluSchema = EvoluSchema> extends Disposable {
+/**
+ * Application name.
+ *
+ * Evolu uses AppName as the base prefix for {@link Evolu.name}. The final
+ * instance name is derived per {@link AppOwner} as
+ * `${appName}-${createIdFromString(appOwner.id)}`.
+ *
+ * Uses the same safe alphabet as {@link UrlSafeString} (letters, digits, `-`,
+ * `_`) and must be between 1 and 41 characters.
+ */
+export const AppName = /*#__PURE__*/ brand("AppName", UrlSafeString, (value) =>
+  value.length >= 1 && value.length <= 41
+    ? ok(value)
+    : err<AppNameError>({ type: "AppName", value }),
+);
+export type AppName = typeof AppName.Type;
+export interface AppNameError extends TypeError<"AppName"> {}
+
+export const testAppName = /*#__PURE__*/ AppName.orThrow("AppName");
+
+/**
+ * Local-first SQL database with typed queries, mutations, and sync.
+ *
+ * TODO: Better docs.
+ */
+export interface Evolu<
+  S extends EvoluSchema = EvoluSchema,
+> extends AsyncDisposable {
+  /**
+   * Evolu instance name is derived from {@link EvoluConfig.appName} and
+   * {@link AppOwner}'s hash.
+   */
+  readonly name: Name;
+
+  /** {@link AppOwner}. */
+  readonly appOwner: AppOwner;
+
   /**
-   * Subscribe to {@link EvoluError} changes.
+   * Inserts a row and returns the generated {@link Id}.
+   *
+   * All non-nullable columns are required, nullable columns are optional, and
+   * `id` is omitted because Evolu generates it automatically. This ensures
+   * every row has a globally unique, conflict-free identifier without
+   * coordination.
    *
    * ### Example
    *
    * ```ts
-   * const unsubscribe = evolu.subscribeError(() => {
-   *   const error = evolu.getError();
-   *   console.log(error);
+   * const { id } = evolu.insert("todo", {
+   *   title: NonEmptyString100.orThrow("Learn Evolu"),
    * });
+   *
+   * // With onComplete callback
+   * evolu.insert(
+   *   "todo",
+   *   { title: NonEmptyString100.orThrow("Another todo") },
+   *   { onComplete: () => console.log("Insert completed") },
+   * );
    * ```
+   *
+   * @see {@link Mutation}
    */
-  readonly subscribeError: StoreSubscribe;
-
-  /** Get {@link EvoluError}. */
-  readonly getError: () => EvoluError | null;
+  readonly insert: Mutation<S, "insert">;
 
   /**
-   * Create type-safe SQL {@link Query}.
+   * Updates a row and returns the {@link Id}.
+   *
+   * Only `id` is required, all other columns are optional.
    *
-   * Evolu uses Kysely - the type-safe SQL query builder for TypeScript. See
-   * https://kysely.dev.
+   * ### Example
+   *
+   * ```ts
+   * const { id } = evolu.update("todo", {
+   *   id: todoId,
+   *   title: NonEmptyString100.orThrow("Updated title"),
+   * });
    *
-   * All this function does is compile the Kysely query and serialize it into a
-   * unique string. Both operations are fast and cheap.
+   * // Soft delete
+   * evolu.update("todo", { id: todoId, isDeleted: sqliteTrue });
+   * ```
    *
-   * For mutations, use {@link Evolu#insert}, {@link Evolu#update}, or
-   * {@link Evolu#upsert}.
+   * @see {@link Mutation}
+   */
+  readonly update: Mutation<S, "update">;
+
+  /**
+   * Upserts a row and returns the {@link Id}.
+   *
+   * Like insert, but requires an `id`. Useful for rows with external ID via
+   * {@link createIdFromString}. All other non-nullable columns are required,
+   * nullable columns are optional.
+   *
+   * `createdAt` and `updatedAt` cannot be set manually. Evolu derives both from
+   * the CRDT {@link Timestamp} — they share the same value, encoded once to
+   * avoid redundancy. Timestamps are always generated by Evolu to preserve CRDT
+   * consistency guarantees.
    *
    * ### Example
    *
    * ```ts
-   * const allTodos = evolu.createQuery((db) =>
-   *   db.selectFrom("todo").selectAll(),
-   * );
-   *
-   * const todoById = (id: TodoId) =>
-   *   evolu.createQuery((db) =>
-   *     db.selectFrom("todo").selectAll().where("id", "=", id),
-   *   );
+   * const stableId = createIdFromString("my-todo-1");
+   * const { id } = evolu.upsert("todo", {
+   *   id: stableId,
+   *   title: NonEmptyString100.orThrow("Learn Evolu"),
+   * });
    * ```
+   *
+   * @see {@link Mutation}
    */
-  readonly createQuery: CreateQuery<S>;
+  readonly upsert: Mutation<S, "upsert">;
 
   /**
    * Load {@link Query} and return a promise with {@link QueryRows}.
    *
    * The returned promise always resolves successfully because there is no
-   * reason why loading should fail. All data are local, and the query is typed.
-   * Unexpected errors are handled with {@link Evolu#subscribeError}.
+   * reason why loading should fail. All data are local, and the query is
+   * typed.
    *
-   * Loading is batched, and returned promises are cached until resolved to
-   * prevent redundant database queries and to support React Suspense (which
-   * requires stable promise references while pending).
+   * Loading is batched. Returned promises are cached while pending and can be
+   * reused after fulfillment until mutation-driven invalidation, which prevents
+   * redundant database queries and supports React Suspense (stable references
+   * while pending).
    *
    * To subscribe a query for automatic updates, use
-   * {@link Evolu#subscribeQuery}.
+   * {@link Evolu.subscribeQuery}.
    *
    * ### Example
    *
    * ```ts
-   * const allTodos = evolu.createQuery((db) =>
+   * const createQuery = createQueryBuilder(Schema);
+   * const allTodos = createQuery((db) =>
    *   db.selectFrom("todo").selectAll(),
    * );
    * evolu.loadQuery(allTodos).then((rows) => {
@@ -178,7 +371,9 @@ export interface Evolu<S extends EvoluSchema = EvoluSchema> extends Disposable {
    * });
    * ```
    */
-  readonly loadQuery: <R extends Row>(query: Query<R>) => Promise<QueryRows<R>>;
+  readonly loadQuery: <R extends Row>(
+    query: Query<S, R>,
+  ) => Promise<QueryRows<R>>;
 
   /**
    * Load an array of {@link Query} queries and return an array of
@@ -191,7 +386,7 @@ export interface Evolu<S extends EvoluSchema = EvoluSchema> extends Disposable {
    * evolu.loadQueries([allTodos, todoById(1)]);
    * ```
    */
-  readonly loadQueries: <R extends Row, Q extends Queries<R>>(
+  readonly loadQueries: <Q extends Queries<S>>(
     queries: [...Q],
   ) => [...QueriesToQueryRowsPromises<Q>];
 
@@ -206,7 +401,9 @@ export interface Evolu<S extends EvoluSchema = EvoluSchema> extends Disposable {
    * });
    * ```
    */
-  readonly subscribeQuery: (query: Query) => StoreSubscribe;
+  readonly subscribeQuery: (
+    query: Query<S>,
+  ) => (listener: Listener) => Unsubscribe;
 
   /**
    * Get {@link QueryRows}.
@@ -219,863 +416,727 @@ export interface Evolu<S extends EvoluSchema = EvoluSchema> extends Disposable {
    * });
    * ```
    */
-  readonly getQueryRows: <R extends Row>(query: Query<R>) => QueryRows<R>;
+  readonly getQueryRows: <R extends Row>(query: Query<S, R>) => QueryRows<R>;
 
   /**
-   * Promise that resolves to {@link AppOwner} when available.
+   * Exports the SQLite database file.
    *
-   * Note: With web-only deps, this promise will not resolve during SSR because
-   * there is no AppOwner on the server.
-   *
-   * ### Example
+   * Exports are sequential: concurrent calls share one pending export instead
+   * of starting parallel exports.
    *
-   * ```ts
-   * const owner = await evolu.appOwner;
-   * ```
+   * The pending promise rejects if this {@link Evolu} instance is disposed
+   * before export completion.
    */
-  readonly appOwner: Promise<AppOwner>;
+  readonly exportDatabase: () => Promise<Uint8Array<ArrayBuffer>>;
+
+  // TODO: Add exportHistory.
 
   /**
-   * Inserts a row into the database and returns a {@link Result} with the new
-   * {@link Id}.
-   *
-   * The first argument is the table name, and the second is an object
-   * containing the row data. An optional third argument provides mutation
-   * options including an `onComplete` callback and `onlyValidate` flag.
-   *
-   * Returns a Result type - use `.ok` to check if the insertion succeeded, and
-   * `.value.id` to access the generated ID on success, or `.error` to handle
-   * validation errors.
+   * Delete the local SQLite database for this {@link Evolu} instance on the
+   * current device.
    *
-   * Evolu does not use SQL for mutations to ensure data can be safely and
-   * predictably merged without conflicts. Explicit mutations also allow Evolu
-   * to automatically update {@link SystemColumns}.
+   * **Warning**: This first drops all 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
    *
-   * ### Example
-   *
-   * ```ts
-   * const result = evolu.insert("todo", {
-   *   title: "Learn Evolu",
-   *   isCompleted: false,
-   * });
-   *
-   * if (result.ok) {
-   *   console.log("Todo created with ID:", result.value.id);
-   * } else {
-   *   console.error("Validation error:", result.error);
-   * }
+   * After that, it deletes the SQLite file identified by {@link Evolu.name},
+   * permanently forgetting all local data for that instance on this device.
    *
-   * // With onComplete callback
-   * evolu.insert(
-   *   "todo",
-   *   { title: "Another todo" },
-   *   {
-   *     onComplete: () => {
-   *       console.log("Insert completed");
-   *     },
-   *   },
-   * );
-   * ```
+   * All instances identified by {@link Evolu.name} will be self-disposed. Use
+   * {@link EvoluConfig.onDatabaseDeleted} to update app UI when that happens.
    */
-  insert: Mutation<S, "insert">;
+  readonly deleteDatabase: () => void;
 
   /**
-   * Updates a row in the database and returns a {@link Result} with the existing
-   * {@link Id}.
-   *
-   * The first argument is the table name, and the second is an object
-   * containing the row data including the required `id` field. An optional
-   * third argument provides mutation options including an `onComplete` callback
-   * and `onlyValidate` flag.
-   *
-   * Returns a Result type - use `.ok` to check if the update succeeded, and
-   * `.value.id` to access the ID on success, or `.error` to handle validation
-   * errors.
+   * Delete all local data for a specific {@link Owner}.
    *
-   * Evolu does not use SQL for mutations to ensure data can be safely and
-   * predictably merged without conflicts. Explicit mutations also allow Evolu
-   * to automatically update {@link SystemColumns}.
-   *
-   * ### Example
-   *
-   * ```ts
-   * const result = evolu.update("todo", {
-   *   id: todoId,
-   *   title: "Updated title",
-   *   isCompleted: true,
-   * });
+   * This deletes all rows whose `ownerId` matches the provided owner and
+   * deletes that owner's local history as well.
    *
-   * if (result.ok) {
-   *   console.log("Todo updated with ID:", result.value.id);
-   * } else {
-   *   console.error("Validation error:", result.error);
-   * }
-   *
-   * // To delete a row, set isDeleted to true
-   * evolu.update("todo", { id: todoId, isDeleted: true });
-   *
-   * // With onComplete callback
-   * evolu.update(
-   *   "todo",
-   *   { id: todoId, title: "New title" },
-   *   {
-   *     onComplete: () => {
-   *       console.log("Update completed");
-   *     },
-   *   },
-   * );
-   * ```
+   * It also stops using that owner across all tabs and instances. Use
+   * {@link EvoluConfig.onOwnerDeleted} to update app UI when that happens.
    */
-  update: Mutation<S, "update">;
+  readonly deleteOwner: (owner: Owner) => void;
 
   /**
-   * Upserts a row in the database and returns a {@link Result} with the existing
-   * {@link Id}.
+   * Use an Owner for sync. Returns a {@link UnuseOwner}.
    *
-   * The first argument is the table name, and the second is an object
-   * containing the row data including the required `id` field. An optional
-   * third argument provides mutation options including an `onComplete` callback
-   * and `onlyValidate` flag.
+   * Using an Owner means syncing it with the provided transports, or with the
+   * default transports defined in {@link EvoluConfig} when transports are
+   * omitted.
    *
-   * This function allows you to use custom IDs and optionally set `createdAt`,
-   * which is useful for external systems, data migrations, or when the same row
-   * may already be created on a different device.
+   * If {@link EvoluConfig.transports} is an empty array, this method must be
+   * called with explicit non-empty transports.
    *
-   * Returns a Result type - use `.ok` to check if the upsert succeeded, and
-   * `.value.id` to access the ID on success, or `.error` to handle validation
-   * errors.
-   *
-   * Evolu does not use SQL for mutations to ensure data can be safely and
-   * predictably merged without conflicts. Explicit mutations also allow Evolu
-   * to automatically update {@link SystemColumns}.
+   * Transports are automatically deduplicated and reference-counted, so
+   * multiple Owners using the same transport will share a single connection.
    *
    * ### Example
    *
    * ```ts
-   * // Use deterministic ID for stable upserts across devices
-   * const stableId = createIdFromString("my-todo-1");
-   *
-   * const result = evolu.upsert("todo", {
-   *   id: stableId,
-   *   title: "Learn Evolu",
-   *   isCompleted: false,
-   * });
+   * // Use an Owner (starts syncing).
+   * const unuseOwner = evolu.useOwner(shardOwner, [
+   *   createOwnerWebSocketTransport({
+   *     url: "ws://localhost:4000",
+   *     ownerId: shardOwner.id,
+   *   }),
+   * ]);
    *
-   * if (result.ok) {
-   *   console.log("Todo upserted with ID:", result.value.id);
-   * } else {
-   *   console.error("Validation error:", result.error);
-   * }
-   *
-   * // Data migration with custom createdAt
-   * evolu.upsert("todo", {
-   *   id: externalId,
-   *   title: "Migrated todo",
-   *   createdAt: new Date("2023-01-01"), // Preserve original timestamp
-   * });
+   * // Later, stop using the Owner.
+   * unuseOwner();
    *
-   * // With onComplete callback
-   * evolu.upsert(
-   *   "todo",
-   *   { id: stableId, title: "Updated title" },
-   *   {
-   *     onComplete: () => {
-   *       console.log("Upsert completed");
-   *     },
-   *   },
-   * );
+   * // Bulk operations.
+   * const unuseOwners = owners.map(evolu.useOwner);
+   * // Later: for (const unuse of unuseOwners) unuse();
    * ```
    */
-  upsert: Mutation<S, "upsert">;
-
-  /**
-   * Delete {@link AppOwner} and all their data from the current device. After
-   * the deletion, Evolu will purge the application state. For browsers, this
-   * will reload all tabs using Evolu. For native apps, it will restart the
-   * app.
-   *
-   * Reloading can be turned off via options if you want to provide a different
-   * UX.
-   */
-  readonly resetAppOwner: (options?: {
-    readonly reload?: boolean;
-  }) => Promise<void>;
-
-  /**
-   * Restore {@link AppOwner} with all their synced data. It uses
-   * {@link Evolu#resetAppOwner}, so be careful.
-   */
-  readonly restoreAppOwner: (
-    mnemonic: Mnemonic,
-    options?: {
-      readonly reload?: boolean;
-    },
-  ) => Promise<void>;
-
-  /**
-   * Reload the app in a platform-specific way. For browsers, this will reload
-   * all tabs using Evolu. For native apps, it will restart the app.
-   */
-  readonly reloadApp: () => void;
+  readonly useOwner: (
+    owner: ReadonlyOwner | Owner,
+    transports?: NonEmptyReadonlyArray<OwnerTransport>,
+  ) => UnuseOwner;
+}
 
-  /**
-   * Export SQLite database file as Uint8Array.
-   *
-   * In the future, it will be possible to import a database and export/import
-   * history for 1:1 migrations across owners.
-   */
-  readonly exportDatabase: () => Promise<Uint8Array<ArrayBuffer>>;
+/** Function returned by {@link Evolu.useOwner} to stop using an Owner for sync. */
+export type UnuseOwner = () => void;
 
+export interface EvoluErrorDep {
   /**
-   * Use a {@link SyncOwner}. Returns a {@link UnuseOwner}.
+   * {@link ReadonlyStore} of {@link EvoluError} shared by all {@link Evolu}
+   * instances created from the same {@link createEvoluDeps} result.
    *
-   * Using an owner means syncing it with its transports, or the transports
-   * defined in Evolu config if the owner has no transports defined.
-   *
-   * Transport are automatically deduplicated and reference-counted, so multiple
-   * owners using the same transport will share a single connection.
+   * Subscribe once to show user-facing messages across all instances. Logging
+   * is handled by platform {@link createRun} global error handlers.
    *
    * ### Example
    *
    * ```ts
-   * // Use an owner (starts syncing).
-   * const unuseOwner = evolu.useOwner(shardOwner);
-   *
-   * // Later, stop using the owner.
-   * unuseOwner();
+   * deps.evoluError.subscribe(() => {
+   *   const error = deps.evoluError.get();
+   *   if (!error) return;
    *
-   * // Bulk operations.
-   * const unuseOwners = owners.map((owner) => evolu.useOwner(owner));
-   * // Later: for (const unuse of unuseOwners) unuse();
+   *   switch (error.type) {
+   *     case "InvalidComputerClock":
+   *       // Show guidance specific to the detected error.
+   *       showMessage(
+   *         "Your system clock appears incorrect. Please fix it.",
+   *       );
+   *       break;
+   *     default:
+   *       // Show a generic user message for other operational errors.
+   *       showMessage("Something went wrong. Please try again.");
+   *   }
+   * });
    * ```
-   *
-   * @experimental
-   */
-  readonly useOwner: (owner: SyncOwner) => UnuseOwner;
-}
-
-/** Function returned by {@link Evolu#useOwner} to stop using an {@link SyncOwner}. */
-export type UnuseOwner = () => void;
-
-/** Represents errors that can occur in Evolu. */
-export type EvoluError =
-  | ProtocolError
-  | SqliteError
-  | SymmetricCryptoDecryptError
-  | TimestampError
-  | TransferableError;
-
-interface InternalEvoluInstance<S extends EvoluSchema = EvoluSchema>
-  extends Evolu<S> {
-  /**
-   * Ensure tables and columns defined in {@link EvoluSchema} exist in the
-   * database. This function is for hot reloading.
    */
-  readonly ensureSchema: (schema: EvoluSchema) => void;
+  readonly evoluError: ReadonlyStore<EvoluError | null>;
 }
 
-export type EvoluDeps = ConsoleDep &
-  CreateDbWorkerDep &
-  Partial<FlushSyncDep> &
-  RandomBytesDep &
-  ReloadAppDep &
-  TimeDep;
-
-const evoluInstances = createInstances<SimpleName, InternalEvoluInstance>();
-
 /**
- * Unique identifier for the current browser tab or app instance, lazily
- * initialized on first use to distinguish between multiple tabs.
+ * Shared platform dependencies for creating {@link Evolu} instances.
+ *
+ * Includes platform adapters, the shared {@link EvoluErrorDep.evoluError} store,
+ * and disposal for owned resources.
  */
-let tabId: Id | null = null;
+export type EvoluDeps = EvoluPlatformDeps & EvoluErrorDep & Disposable;
 
 /**
- * Creates an {@link Evolu} instance for a platform configured with the specified
- * {@link EvoluSchema} and optional {@link EvoluConfig} providing a typed
- * interface for querying, mutating, and syncing your application's data.
- *
- * ### Example
- *
- * ```ts
- * const TodoId = id("Todo");
- * type TodoId = InferType<typeof TodoId>;
- *
- * const TodoCategoryId = id("TodoCategory");
- * type TodoCategoryId = InferType<typeof TodoCategoryId>;
- *
- * const NonEmptyString50 = maxLength(50, NonEmptyString);
- * type NonEmptyString50 = InferType<typeof NonEmptyString50>;
- *
- * const Schema = {
- *   todo: {
- *     id: TodoId,
- *     title: NonEmptyString1000,
- *     isCompleted: nullOr(SqliteBoolean),
- *     categoryId: nullOr(TodoCategoryId),
- *   },
- *   todoCategory: {
- *     id: TodoCategoryId,
- *     name: NonEmptyString50,
- *   },
- * };
+ * Platform-specific dependencies required to create {@link EvoluDeps}.
  *
- * const evolu = createEvolu(evoluReactDeps)(Schema);
- * ```
+ * Provides worker and channel adapters plus optional platform integrations for
+ * logging and synchronous UI flush.
+ */
+export type EvoluPlatformDeps = CreateDbWorkerDep &
+  CreateMessageChannelDep &
+  ReloadAppDep &
+  SharedWorkerDep &
+  Partial<ConsoleDep> &
+  Partial<FlushSyncDep>;
+
+/**
+ * Creates shared dependencies used by all {@link createEvolu} instances on a
+ * platform.
  *
- * ### Instance Caching
+ * Call this once per platform and reuse the returned deps when creating
+ * multiple Evolu instances. The returned deps object owns long-lived resources
+ * such as worker channels and the shared {@link EvoluErrorDep.evoluError}
+ * store.
  *
- * `createEvolu` caches instances using {@link Instances} by {@link EvoluConfig}
- * name to enable hot reloading and prevent database corruption from multiple
- * connections. For testing, use unique instance names to ensure proper
- * isolation.
+ * Dispose it only during app shutdown.
  */
-export const createEvolu =
-  (deps: EvoluDeps) =>
-  <S extends EvoluSchema>(
-    schema: ValidateSchema<S> extends never ? S : ValidateSchema<S>,
-    config?: EvoluConfig,
-  ): Evolu<S> =>
-    evoluInstances.ensure(
-      config?.name ?? defaultDbConfig.name,
-      () => createEvoluInstance(deps)(schema as EvoluSchema, config),
-      (evolu) => {
-        // Hot reloading. Note that indexes are intentionally omitted.
-        evolu.ensureSchema(schema as EvoluSchema);
-      },
-    ) as Evolu<S>;
-
-const createEvoluInstance =
-  (deps: EvoluDeps) =>
-  (schema: EvoluSchema, config?: EvoluConfig): InternalEvoluInstance => {
-    deps.console.enabled = config?.enableLogging ?? false;
-
-    const { indexes, reloadUrl = "/", ...partialDbConfig } = config ?? {};
-
-    const dbConfig: DbConfig = { ...defaultDbConfig, ...partialDbConfig };
-
-    deps.console.log("[evolu]", "createEvoluInstance", {
-      name: dbConfig.name,
-    });
-
-    const errorStore = createStore<EvoluError | null>(null);
-    const rowsStore = createStore<QueryRowsMap>(new Map());
+export const createEvoluDeps = (deps: EvoluPlatformDeps): EvoluDeps => {
+  const { createMessageChannel, sharedWorker } = deps;
+  const console = deps.console ?? createConsole();
+
+  const stack = new DisposableStack();
+  stack.use(sharedWorker);
+  const evoluError = stack.use(createStore<EvoluError | null>(null));
+
+  const tabChannel = stack.use(createMessageChannel<EvoluTabOutput>());
+  tabChannel.port2.onMessage = (message) => {
+    switch (message.type) {
+      case "OnConsoleEntry":
+        console.write(message.entry);
+        // Fallback channel for unexpected errors without EvoluError typing.
+        if (message.entry.method === "error") {
+          evoluError.set(createUnknownError(message.entry.args));
+        }
+        break;
 
-    const { promise: appOwner, resolve: resolveAppOwner } =
-      Promise.withResolvers<AppOwner>();
+      case "OnError":
+        evoluError.set(message.error);
+        // Keep typed errors visible in logs as operational failures.
+        console.error(message.error);
+        break;
 
-    if (config?.externalAppOwner) {
-      resolveAppOwner(config.externalAppOwner);
+      default:
+        exhaustiveCheck(message);
     }
+  };
 
-    // TODO: Update it for the owner-api
-    const _syncStore = createStore<SyncState>(initialSyncState);
+  sharedWorker.port.postMessage(
+    {
+      type: "InitTab",
+      consoleLevel: console.getLevel(),
+      port: tabChannel.port1.native,
+    },
+    [tabChannel.port1.native],
+  );
 
-    const subscribedQueries = createSubscribedQueries(rowsStore);
-    const loadingPromises = createLoadingPromises(subscribedQueries);
-    const onCompleteCallbacks = createCallbacks(deps);
-    const exportCallbacks = createCallbacks<Uint8Array<ArrayBuffer>>(deps);
+  const moved = stack.move();
 
-    const dbWorker = deps.createDbWorker(dbConfig.name);
+  return {
+    ...deps,
+    evoluError,
+    [Symbol.dispose]: () => moved.dispose(),
+  };
+};
 
-    const getTabId = () => {
-      tabId ??= createId(deps);
-      return tabId;
-    };
+/**
+ * Creates an {@link Evolu} instance from {@link EvoluSchema} and
+ * {@link EvoluConfig}.
+ */
+export const createEvolu =
+  <S extends EvoluSchema>(
+    schema: ValidateSchema<S> extends never ? S : ValidateSchema<S>,
+    config: EvoluConfig,
+  ): Task<Evolu<S>, never, EvoluPlatformDeps> =>
+  async (run) => {
+    const {
+      appName,
+      appOwner,
+      memoryOnly = false,
+      transports = [{ type: "WebSocket", url: "wss://free.evoluhq.com" }],
+    } = config;
 
-    // Worker responses are delivered to all tabs. Each case must handle this
-    // properly (e.g., AppOwner promise resolves only once, tabId filtering).
-    dbWorker.onMessage((message) => {
-      switch (message.type) {
-        case "onError": {
-          errorStore.set(message.error);
-          break;
-        }
+    const name = Name.orThrow(`${appName}-${createIdFromString(appOwner.id)}`);
+    const console = run.deps.console.child(name).child("Evolu");
+    console.info("createEvolu");
 
-        case "onGetAppOwner": {
-          resolveAppOwner(message.appOwner);
-          break;
-        }
+    await using stack = new AsyncDisposableStack();
 
-        case "onQueryPatches": {
-          if (message.tabId !== getTabId()) return;
+    const rowsByQueryMapStore = stack.use(
+      createStore<RowsByQueryMap>(new Map()),
+    );
+    const subscribedQueriesRefCount = stack.use(createRefCountByKey<Query>());
+
+    interface LoadingPromise {
+      /**
+       * React tracks `status`/`value`/`reason` on thenables passed to `use`.
+       * Evolu mirrors that shape so cached promises can be unwrapped
+       * synchronously and to keep promise-cache behavior stable.
+       *
+       * React source:
+       * https://github.com/facebook/react/blob/main/packages/react-reconciler/src/ReactFiberThenable.js
+       */
+      promise: Promise<QueryRows> & {
+        status?: "pending" | "fulfilled" | "rejected";
+        value?: QueryRows;
+        reason?: unknown;
+      };
+      resolve: (rows: QueryRows) => void;
+      releaseOnResolve: boolean;
+    }
 
-          const state = rowsStore.get();
-          const nextState = new Map([
-            ...state,
-            ...message.queryPatches.map(
-              ({ query, patches }): [Query, ReadonlyArray<Row>] => [
-                query,
-                applyPatches(patches, state.get(query) ?? emptyRows),
-              ],
-            ),
-          ]);
+    /**
+     * Settle pending query loads during disposal so awaiting callers and React
+     * `use` thenables do not hang forever during teardown.
+     */
+    const loadingPromisesByQuery = stack.adopt(
+      new Map<Query, LoadingPromise>(),
+      (loadingPromisesByQuery) => {
+        for (const loadingPromise of loadingPromisesByQuery.values()) {
+          if (loadingPromise.promise.status === "fulfilled") continue;
+          fulfillLoadingPromise(loadingPromise, emptyArray);
+        }
+        loadingPromisesByQuery.clear();
+      },
+    );
 
-          for (const { query } of message.queryPatches) {
-            loadingPromises.resolve(query, nextState.get(query) ?? emptyRows);
-          }
+    const fulfillLoadingPromise = (
+      loadingPromise: LoadingPromise,
+      rows: QueryRows,
+    ): void => {
+      /**
+       * Pending promises must be resolved in place to preserve identity for
+       * current awaiters. Fulfilled promises are replaced with a new resolved
+       * promise so future loads see the latest rows.
+       */
+      if (loadingPromise.promise.status !== "fulfilled") {
+        loadingPromise.resolve(rows);
+      } else {
+        loadingPromise.promise = Promise.resolve(rows);
+      }
 
-          if (deps.flushSync && message.onCompleteIds.length > 0) {
-            deps.flushSync(() => {
-              rowsStore.set(nextState);
-            });
-          } else {
-            rowsStore.set(nextState);
-          }
+      /** See {@link LoadingPromise.promise}. */
+      void Object.assign(loadingPromise.promise, {
+        status: "fulfilled",
+        value: rows,
+      });
+    };
 
-          for (const id of message.onCompleteIds) {
-            onCompleteCallbacks.execute(id);
-          }
-          break;
+    /**
+     * Mutations and refreshes invalidate query snapshots. Keep loading promises
+     * only for actively subscribed queries and release unsubscribed ones.
+     *
+     * Fulfilled promises can be dropped immediately because no awaiter is
+     * waiting on them. Pending promises must stay alive until they resolve so
+     * current awaiters keep the same promise identity.
+     */
+    const releaseUnsubscribedLoadingPromises = (): void => {
+      for (const [query, loadingPromise] of loadingPromisesByQuery) {
+        if (subscribedQueriesRefCount.has(query)) continue;
+
+        if (loadingPromise.promise.status === "fulfilled") {
+          loadingPromisesByQuery.delete(query);
+        } else {
+          loadingPromise.releaseOnResolve = true;
         }
+      }
+    };
 
-        case "refreshQueries": {
-          if (message.tabId && message.tabId === getTabId()) return;
+    const onMutateCompleteCallbacks = stack.use(createCallbacks(run.deps));
 
-          const loadingPromisesQueries = loadingPromises.getQueries();
-          loadingPromises.releaseUnsubscribedOnMutation();
+    let exportDatabasePending = null as PromiseWithResolvers<
+      Uint8Array<ArrayBuffer>
+    > | null;
 
-          const queries = dedupeArray([
-            ...loadingPromisesQueries,
-            ...subscribedQueries.get(),
-          ]);
+    stack.defer(() => {
+      exportDatabasePending?.reject({ type: "EvoluDisposedError" });
+      exportDatabasePending = null;
+    });
 
-          if (isNonEmptyReadonlyArray(queries)) {
-            dbWorker.postMessage({ type: "query", tabId: getTabId(), queries });
-          }
+    const mutateBatch = stack.use(
+      createMicrotaskBatch<{
+        readonly change: MutationChange;
+        readonly onComplete: (() => void) | undefined;
+      }>((items) => {
+        console.debug("mutateBatch", { changeCount: items.length });
+        releaseUnsubscribedLoadingPromises();
+
+        postMessage({
+          type: "Mutate",
+          changes: mapArray(items, (item) => item.change),
+          onCompleteIds: items.flatMap((item) =>
+            item.onComplete
+              ? [onMutateCompleteCallbacks.register(item.onComplete)]
+              : [],
+          ),
+          subscribedQueries: subscribedQueriesRefCount.keys(),
+        });
+      }),
+    );
 
-          break;
-        }
+    const queryBatch = stack.use(
+      createMicrotaskBatch<Query>((queries) => {
+        const dedupedQueries = new Set(queries);
+        assert(
+          isNonEmptySet(dedupedQueries),
+          "Expected non-empty query batch.",
+        );
+        console.debug("queryBatch", { queryCount: dedupedQueries.size });
+        postMessage({ type: "Query", queries: dedupedQueries });
+      }),
+    );
 
-        case "onReset": {
-          if (message.reload) {
-            deps.reloadApp(reloadUrl);
-          } else {
-            onCompleteCallbacks.execute(message.onCompleteId);
-          }
-          break;
-        }
+    const useOwnerBatch = stack.use(
+      createMicrotaskBatch<
+        ExtractType<EvoluInput, "UseOwner">["actions"][number]
+      >((actions) => postMessage({ type: "UseOwner", actions })),
+    );
 
-        case "onExport": {
-          exportCallbacks.execute(
-            message.onCompleteId,
-            message.file as Uint8Array<ArrayBuffer>,
-          );
-          break;
-        }
+    let postMessage: (input: EvoluInput) => void;
+
+    // Scope worker/channel wiring and keep only postMessage outside.
+    {
+      const { createDbWorker, createMessageChannel, sharedWorker } = run.deps;
+      const dbWorkerChannel = stack.use(
+        createMessageChannel<DbWorkerOutput, DbWorkerInput>(),
+      );
+      const evoluChannel = stack.use(
+        createMessageChannel<EvoluInput, EvoluOutput>(),
+      );
+
+      evoluChannel.port1.onMessage = (message) => {
+        switch (message.type) {
+          case "OnPatchesByQuery": {
+            console.debug("onPatchesByQuery", {
+              queryCount: message.patchesByQuery.size,
+              onCompleteCount: message.onCompleteIds.length,
+            });
+            const state = rowsByQueryMapStore.get();
+            const nextRowsByQueryMap = new Map(state);
 
-        default:
-          exhaustiveCheck(message);
-      }
-    });
+            for (const [query, patches] of message.patchesByQuery) {
+              nextRowsByQueryMap.set(
+                query,
+                applyPatches(patches, state.get(query) ?? emptyArray),
+              );
+            }
 
-    const dbSchema = evoluSchemaToDbSchema(schema, indexes);
+            for (const query of message.patchesByQuery.keys()) {
+              const loadingPromise = loadingPromisesByQuery.get(query);
+              if (!loadingPromise) continue;
 
-    const mutationTypesCache = new Map<
-      MutationKind,
-      Map<string, ValidMutationSize<any>>
-    >();
+              const rows = nextRowsByQueryMap.get(query);
+              assert(rows, "Expected patched query rows to exist.");
 
-    // Lazy create mutation Types like this: `insertable(Schema.todo)`
-    const getMutationType = (table: string, kind: MutationKind) => {
-      let types = mutationTypesCache.get(kind);
-      if (!types) {
-        types = new Map();
-        mutationTypesCache.set(kind, types);
-      }
-      let type = types.get(table);
-      if (!type) {
-        type = { insert: insertable, update: updateable, upsert: upsertable }[
-          kind
-        ](schema[table]);
-        types.set(table, type);
-      }
-      return type;
-    };
+              fulfillLoadingPromise(loadingPromise, rows);
 
-    dbWorker.postMessage({ type: "init", config: dbConfig, dbSchema });
+              /**
+               * Release promises flagged during mutation when they finish
+               * resolving. This keeps in-flight promise identity stable and
+               * prevents stale cache entries after completion.
+               */
+              if (loadingPromise.releaseOnResolve) {
+                loadingPromisesByQuery.delete(query);
+              }
+            }
 
-    // We can't use `init` to get AppOwner because `init` runs only once per n tabs.
-    dbWorker.postMessage({ type: "getAppOwner" });
+            if (run.deps.flushSync && message.onCompleteIds.length > 0) {
+              run.deps.flushSync(() => {
+                rowsByQueryMapStore.set(nextRowsByQueryMap);
+              });
+            } else {
+              rowsByQueryMapStore.set(nextRowsByQueryMap);
+            }
 
-    const loadQueryMicrotaskQueue: Array<Query> = [];
+            for (const onCompleteId of message.onCompleteIds) {
+              onMutateCompleteCallbacks.execute(onCompleteId);
+            }
+            break;
+          }
 
-    const mutateMicrotaskQueue: Array<
-      [MutationChange | null, MutationOptions["onComplete"] | undefined]
-    > = [];
+          case "RefreshQueries": {
+            releaseUnsubscribedLoadingPromises();
 
-    const useOwnerMicrotaskQueue: Array<[SyncOwner, boolean, Uint8Array]> = [];
+            const queries = new Set<Query>([
+              ...loadingPromisesByQuery.keys(),
+              ...subscribedQueriesRefCount.keys(),
+            ]);
 
-    const createMutation =
-      <Kind extends MutationKind>(kind: Kind) =>
-      <TableName extends keyof typeof schema>(
-        table: TableName,
-        props: InferInput<
-          ObjectType<MutationMapping<(typeof schema)[TableName], Kind>>
-        >,
-        options?: MutationOptions,
-      ): Result<
-        { readonly id: InferType<(typeof schema)[TableName]["id"]> },
-        | ValidMutationSizeError
-        | InferErrors<
-            ObjectType<MutationMapping<(typeof schema)[TableName], Kind>>
-          >
-      > => {
-        const result = getMutationType(table, kind).fromUnknown(props);
-
-        const id =
-          kind === "insert"
-            ? createId(deps)
-            : (props as unknown as { id: Id }).id;
-
-        if (options?.onlyValidate !== true) {
-          if (!result.ok) {
-            // Mark the transaction as invalid by pushing null
-            mutateMicrotaskQueue.push([null, undefined]);
-          } else {
-            const { id: _, isDeleted, ...values } = result.value;
-
-            const dbChange = {
-              table,
-              id,
-              values,
-              isInsert: kind === "insert" || kind === "upsert",
-              isDelete: SqliteBoolean.is(isDeleted)
-                ? sqliteBooleanToBoolean(isDeleted)
-                : null,
-            };
+            if (isNonEmptySet(queries)) postMessage({ type: "Query", queries });
+            break;
+          }
 
+          case "OnExport": {
             assert(
-              DbChange.is(dbChange),
-              `Invalid DbChange for table '${table}': Please check schema type errors.`,
+              exportDatabasePending,
+              "OnExport received without pending export.",
             );
-
-            mutateMicrotaskQueue.push([
-              { ...dbChange, ownerId: options?.ownerId },
-              options?.onComplete,
-            ]);
+            exportDatabasePending.resolve(message.file);
+            exportDatabasePending = null;
+            break;
           }
 
-          if (mutateMicrotaskQueue.length === 1) {
-            queueMicrotask(processMutationQueue);
-          }
+          default:
+            exhaustiveCheck(message);
         }
+      };
+
+      sharedWorker.port.postMessage(
+        {
+          type: "CreateEvolu",
+          name,
+          evoluPort: evoluChannel.port2.native,
+          dbWorkerPort: dbWorkerChannel.port2.native,
+        },
+        [evoluChannel.port2.native, dbWorkerChannel.port2.native],
+      );
+
+      /**
+       * No stack.use because Evolu instances don't dispose DbWorker because
+       * it's SharedWorder responsibility. DbWorker can be used by another tab.
+       * That's required because SQLite WASM needs a single web worker.
+       */
+      createDbWorker().postMessage(
+        {
+          type: "Init",
+          name,
+          consoleLevel: console.getLevel(),
+          sqliteSchema: evoluSchemaToSqliteSchema(schema, config.indexes),
+          encryptionKey: appOwner.encryptionKey,
+          memoryOnly,
+          port: dbWorkerChannel.port1.native,
+        },
+        [dbWorkerChannel.port1.native],
+      );
+
+      postMessage = evoluChannel.port1.postMessage;
+
+      stack.defer(() => {
+        postMessage({ type: "Dispose" });
+      });
+    }
 
-        if (result.ok) return ok({ id });
+    const createMutation =
+      <Kind extends "insert" | "update" | "upsert">(
+        kind: Kind,
+      ): Mutation<S, Kind> =>
+      (table, values, options) => {
+        assertNotDisposed(moved);
+
+        const {
+          id = createId(run.deps),
+          isDeleted,
+          ...changeValues
+        } = values as { id?: Id; isDeleted?: unknown; [key: string]: unknown };
+
+        const dbChange = {
+          table,
+          id,
+          values: changeValues,
+          isInsert: kind === "insert" || kind === "upsert",
+          isDelete: SqliteBoolean.is(isDeleted)
+            ? sqliteBooleanToBoolean(isDeleted)
+            : null,
+        };
 
-        return err(
-          result.error as
-            | ValidMutationSizeError
-            | InferErrors<
-                ObjectType<MutationMapping<(typeof schema)[TableName], Kind>>
-              >,
+        assert(
+          DbChange.is(dbChange),
+          `Invalid DbChange for table '${String(table)}'.`,
         );
+
+        mutateBatch.push({
+          change: { ...dbChange, ownerId: options?.ownerId ?? appOwner.id },
+          onComplete: options?.onComplete,
+        });
+
+        return { id };
       };
 
-    const processMutationQueue = () => {
-      const changes: Array<MutationChange> = [];
-      const onCompletes = [];
+    const loadQuery = <R extends Row>(
+      query: Query<S, R>,
+    ): Promise<QueryRows<R>> => {
+      assertNotDisposed(moved);
 
-      for (const [change, onComplete] of mutateMicrotaskQueue) {
-        if (change !== null) changes.push(change);
-        if (onComplete) onCompletes.push(onComplete);
+      const loadingPromise = loadingPromisesByQuery.get(query);
+      if (loadingPromise) {
+        return loadingPromise.promise as Promise<QueryRows<R>>;
       }
 
-      const queueLength = mutateMicrotaskQueue.length;
-      mutateMicrotaskQueue.length = 0;
+      const { promise, resolve } = Promise.withResolvers<QueryRows>();
+      const typedPromise = promise as LoadingPromise["promise"];
+      typedPromise.status = "pending";
 
-      // Don't process any mutations if there was a validation error.
-      // All mutations within a queue run as a single transaction.
-      if (changes.length !== queueLength) {
-        return;
-      }
+      loadingPromisesByQuery.set(query, {
+        promise: typedPromise,
+        resolve,
+        releaseOnResolve: false,
+      });
+
+      queryBatch.push(query);
 
-      const onCompleteIds = onCompletes.map(onCompleteCallbacks.register);
-      loadingPromises.releaseUnsubscribedOnMutation();
+      return typedPromise as Promise<QueryRows<R>>;
+    };
 
-      if (!isNonEmptyArray(changes)) return;
+    const getQueryRows = <R extends Row>(query: Query<S, R>): QueryRows<R> => {
+      assertNotDisposed(moved);
 
-      dbWorker.postMessage({
-        type: "mutate",
-        tabId: getTabId(),
-        changes,
-        onCompleteIds,
-        subscribedQueries: subscribedQueries.get(),
-      });
+      return (rowsByQueryMapStore.get().get(query) ??
+        emptyArray) as QueryRows<R>;
     };
 
-    const evolu: InternalEvoluInstance = {
-      subscribeError: errorStore.subscribe,
-      getError: errorStore.get,
-
-      createQuery,
-
-      loadQuery: <R extends Row>(query: Query<R>): Promise<QueryRows<R>> => {
-        const { promise, isNew } = loadingPromises.get(query);
-
-        if (isNew) {
-          loadQueryMicrotaskQueue.push(query);
-          if (loadQueryMicrotaskQueue.length === 1) {
-            queueMicrotask(() => {
-              const queries = dedupeArray(loadQueryMicrotaskQueue);
-              loadQueryMicrotaskQueue.length = 0;
-              assertNonEmptyReadonlyArray(queries);
-              deps.console.log("[evolu]", "loadQuery", { queries });
-              dbWorker.postMessage({
-                type: "query",
-                tabId: getTabId(),
-                queries,
-              });
-            });
-          }
-        }
+    const useOwner = (
+      owner: ReadonlyOwner | Owner,
+      ownerTransports?: NonEmptyReadonlyArray<OwnerTransport>,
+    ): UnuseOwner => {
+      assertNotDisposed(moved);
+
+      const effectiveTransports = ownerTransports ?? transports;
+      assertNonEmptyReadonlyArray(
+        effectiveTransports,
+        "useOwner requires explicit non-empty transports when config.transports is empty.",
+      );
+
+      const syncOwner: SyncOwner = {
+        owner,
+        transports: effectiveTransports,
+      };
 
-        return promise;
-      },
+      useOwnerBatch.push({
+        owner: syncOwner,
+        action: "add",
+      });
 
-      loadQueries: <R extends Row, Q extends Queries<R>>(
-        queries: [...Q],
-      ): [...QueriesToQueryRowsPromises<Q>] =>
-        queries.map(evolu.loadQuery) as [...QueriesToQueryRowsPromises<Q>],
+      let isUsed = true;
 
-      subscribeQuery: (query) => (listener) => {
-        // Call the listener only if the result has been changed.
-        let previousRows: unknown = null;
-        const unsubscribe = subscribedQueries.subscribe(query)(() => {
-          const rows = evolu.getQueryRows(query);
-          if (previousRows === rows) return;
-          previousRows = rows;
-          listener();
+      return () => {
+        assert(isUsed, "UnuseOwner can be called only once.");
+        isUsed = false;
+        useOwnerBatch.push({
+          owner: syncOwner,
+          action: "remove",
         });
-        return () => {
-          previousRows = null;
-          unsubscribe();
-        };
-      },
+      };
+    };
 
-      getQueryRows: <R extends Row>(query: Query<R>): QueryRows<R> =>
-        (rowsStore.get().get(query) ?? emptyRows) as QueryRows<R>,
+    const moved = stack.move();
 
-      appOwner,
+    if (isNonEmptyArray(transports)) useOwner(appOwner);
 
-      // TODO: Update it for the owner-api
-      // subscribeSyncState: syncStore.subscribe,
-      // getSyncState: syncStore.get,
+    return ok({
+      name,
+      appOwner,
 
       insert: createMutation("insert"),
       update: createMutation("update"),
       upsert: createMutation("upsert"),
 
-      resetAppOwner: (options) => {
-        const { promise, resolve } = Promise.withResolvers<undefined>();
-        const onCompleteId = onCompleteCallbacks.register(resolve);
-        dbWorker.postMessage({
-          type: "reset",
-          onCompleteId,
-          reload: options?.reload ?? true,
-        });
-        return promise;
-      },
-
-      restoreAppOwner: (mnemonic, options) => {
-        const { promise, resolve } = Promise.withResolvers<undefined>();
-        const onCompleteId = onCompleteCallbacks.register(resolve);
-        dbWorker.postMessage({
-          type: "reset",
-          onCompleteId,
-          reload: options?.reload ?? true,
-          restore: { mnemonic, dbSchema },
-        });
-        return promise;
-      },
-
-      reloadApp: () => {
-        deps.reloadApp(reloadUrl);
-      },
-
-      ensureSchema: (schema) => {
-        mutationTypesCache.clear();
-        const dbSchema = evoluSchemaToDbSchema(schema);
-        dbWorker.postMessage({ type: "ensureDbSchema", dbSchema });
-      },
-
-      exportDatabase: () => {
-        const { promise, resolve } =
-          Promise.withResolvers<Uint8Array<ArrayBuffer>>();
-        const onCompleteId = exportCallbacks.register(resolve);
-        dbWorker.postMessage({ type: "export", onCompleteId });
-        return promise;
-      },
-
-      useOwner: (owner) => {
-        const scheduleOwnerQueueProcessing = () => {
-          if (useOwnerMicrotaskQueue.length !== 1) return;
-          queueMicrotask(() => {
-            const queue = [...useOwnerMicrotaskQueue];
-            useOwnerMicrotaskQueue.length = 0;
+      loadQuery,
+      loadQueries: <Q extends Queries<S>>(
+        queries: [...Q],
+      ): [...QueriesToQueryRowsPromises<Q>] =>
+        queries.map((query) => loadQuery(query)) as [
+          ...QueriesToQueryRowsPromises<Q>,
+        ],
 
-            const result: Array<[SyncOwner, boolean, Uint8Array]> = [];
-            const skipIndices = new Set<number>();
+      subscribeQuery: (query) => (listener) => {
+        assertNotDisposed(moved);
 
-            for (let i = 0; i < queue.length; i++) {
-              if (skipIndices.has(i)) continue;
+        subscribedQueriesRefCount.increment(query);
+        let isSubscribed = true;
 
-              const [currentOwner, currentUse, currentOwnerSerialized] =
-                queue[i];
+        let previousRows: unknown = null;
 
-              // Look for opposite action with same owner
-              for (let j = i + 1; j < queue.length; j++) {
-                if (skipIndices.has(j)) continue;
+        const unsubscribe = rowsByQueryMapStore.subscribe(() => {
+          const rows = getQueryRows(query);
+          if (previousRows === rows) return;
+          previousRows = rows;
+          listener();
+        });
 
-                const [, otherUse, otherOwnerSerialized] = queue[j];
+        return () => {
+          assert(
+            isSubscribed,
+            "subscribeQuery unsubscribe can be called only once.",
+          );
+          isSubscribed = false;
 
-                if (
-                  currentUse !== otherUse &&
-                  eqArrayNumber(currentOwnerSerialized, otherOwnerSerialized)
-                ) {
-                  // Found cancel-out pair, skip both
-                  skipIndices.add(i).add(j);
-                  break;
-                }
-              }
+          previousRows = null;
+          unsubscribe();
 
-              if (!skipIndices.has(i)) {
-                result.push([currentOwner, currentUse, currentOwnerSerialized]);
-              }
-            }
+          if (moved.disposed) return;
 
-            for (const [owner, use] of result) {
-              dbWorker.postMessage({ type: "useOwner", owner, use });
-            }
-          });
+          subscribedQueriesRefCount.decrement(query);
         };
+      },
+      getQueryRows,
 
-        useOwnerMicrotaskQueue.push([owner, true, pack(owner)]);
-        scheduleOwnerQueueProcessing();
-
-        const unuse = () => {
-          useOwnerMicrotaskQueue.push([owner, false, pack(owner)]);
-          scheduleOwnerQueueProcessing();
-        };
+      exportDatabase: () => {
+        assertNotDisposed(moved);
 
-        return unuse;
+        if (!exportDatabasePending) {
+          exportDatabasePending =
+            Promise.withResolvers<Uint8Array<ArrayBuffer>>();
+          postMessage({ type: "Export" });
+        }
+        return exportDatabasePending.promise;
       },
 
-      /** Disposal is not implemented yet. */
-      [Symbol.dispose]: () => {
-        throw new Error("Evolu instance disposal is not yet implemented");
+      deleteDatabase: () => {
+        assertNotDisposed(moved);
+        todo();
       },
-    };
-
-    return evolu;
-  };
-
-export const createQuery = <R extends Row>(
-  queryCallback: Parameters<CreateQuery<EvoluSchema>>[0],
-  options?: Parameters<CreateQuery<EvoluSchema>>[1],
-): Query<R> => {
-  const compiledQuery = queryCallback(kysely as IntentionalNever).compile();
-
-  if (isSqlMutation(compiledQuery.sql))
-    throw new Error(
-      "SQL mutation (INSERT, UPDATE, DELETE, etc.) isn't allowed in the Evolu `createQuery` function. Kysely suggests it because there is no read-only Kysely yet, and removing such an API is not possible. For mutations, use Evolu Mutation API.",
-    );
-
-  return serializeQuery({
-    sql: compiledQuery.sql as SafeSql,
-    parameters: compiledQuery.parameters as NonNullable<
-      SqliteQuery["parameters"]
-    >,
-    ...(options && { options }),
-  });
-};
 
-interface LoadingPromises {
-  get: <R extends Row>(
-    query: Query<R>,
-  ) => {
-    readonly promise: Promise<QueryRows<R>>;
-    readonly isNew: boolean;
-  };
-
-  resolve: (query: Query, rows: ReadonlyArray<Row>) => void;
-
-  releaseUnsubscribedOnMutation: () => void;
+      deleteOwner: (owner) => {
+        assertNotDisposed(moved);
+        void owner;
+        todo();
+      },
 
-  getQueries: () => ReadonlyArray<Query>;
-}
+      useOwner,
 
-interface LoadingPromise {
-  /** Promise with props for the React use hook. */
-  promise: Promise<QueryRows> & {
-    status?: "pending" | "fulfilled" | "rejected";
-    value?: QueryRows;
-    reason?: unknown;
+      [Symbol.asyncDispose]: () => {
+        console.info("dispose");
+        return moved.disposeAsync();
+      },
+    } as Evolu<S>);
   };
-  resolve: (rows: QueryRows) => void;
-  releaseOnResolve: boolean;
-}
-
-const createLoadingPromises = (
-  subscribedQueries: SubscribedQueries,
-): LoadingPromises => {
-  const loadingPromiseMap = new Map<Query, LoadingPromise>();
-
-  return {
-    get: <R extends Row>(
-      query: Query<R>,
-    ): {
-      readonly promise: Promise<QueryRows<R>>;
-      readonly isNew: boolean;
-    } => {
-      let loadingPromise = loadingPromiseMap.get(query);
-      const isNew = !loadingPromise;
-      if (!loadingPromise) {
-        const { promise, resolve } = Promise.withResolvers<QueryRows>();
-        loadingPromise = { resolve, promise, releaseOnResolve: false };
-        loadingPromiseMap.set(query, loadingPromise);
-      }
-      return {
-        promise: loadingPromise.promise as Promise<QueryRows<R>>,
-        isNew,
-      };
-    },
-
-    resolve: (query, rows) => {
-      const loadingPromise = loadingPromiseMap.get(query);
-      if (!loadingPromise) return;
-
-      if (loadingPromise.promise.status !== "fulfilled") {
-        loadingPromise.resolve(rows);
-      } else {
-        loadingPromise.promise = Promise.resolve(rows);
-      }
 
-      // Set status and value fields for React's `use` Hook to unwrap synchronously.
-      // While undocumented in React docs, React still uses these properties internally,
-      // and Evolu's own promise caching logic depends on checking `promise.status`.
-      // https://github.com/acdlite/rfcs/blob/first-class-promises/text/0000-first-class-support-for-promises.md
-      void Object.assign(loadingPromise.promise, {
-        status: "fulfilled",
-        value: rows,
-      });
-
-      if (loadingPromise.releaseOnResolve) {
-        loadingPromiseMap.delete(query);
-      }
-    },
-
-    releaseUnsubscribedOnMutation: () => {
-      [...loadingPromiseMap.entries()]
-        .filter(([query]) => !subscribedQueries.has(query))
-        .forEach(([query, loadingPromise]) => {
-          if (loadingPromise.promise.status === "fulfilled") {
-            loadingPromiseMap.delete(query);
-          } else {
-            loadingPromise.releaseOnResolve = true;
-          }
-        });
-    },
-
-    getQueries: () => Array.from(loadingPromiseMap.keys()),
-  };
-};
+//     case "onReset": {
+//       if (message.reload) {
+//         deps.reloadApp(reloadUrl);
+//       } else {
+//         onCompleteCallbacks.execute(message.onCompleteId);
+//       }
+//       break;
+//     }
+
+// resetAppOwner: (_options) => {
+//   const { promise, resolve } = Promise.withResolvers<undefined>();
+//   const _onCompleteId = onCompleteCallbacks.register(resolve);
+//   // dbWorker.postMessage({
+//   //   type: "reset",
+//   //   onCompleteId,
+//   //   reload: options?.reload ?? true,
+//   // });
+//   return promise;
+// },
+
+// restoreAppOwner: (_mnemonic, _options) => {
+//   const { promise, resolve } = Promise.withResolvers<undefined>();
+//   const _onCompleteId = onCompleteCallbacks.register(resolve);
+//   // dbWorker.postMessage({
+//   //   type: "reset",
+//   //   onCompleteId,
+//   //   reload: options?.reload ?? true,
+//   //   restore: { mnemonic, sqliteSchema },
+//   // });
+//   return promise;
+// },
+
+// reloadApp: () => {
+//   // TODO:
+//   // deps.reloadApp(reloadUrl);
+// },
+
+// ensureSchema: (schema) => {
+//   mutationTypesCache.clear();
+//   const sqliteSchema = evoluSchemaToSqliteSchema(schema);
+//   dbWorker.postMessage({ type: "ensureSqliteSchema", sqliteSchema });
+// },
+
+// /**
+//  * Delete {@link AppOwner} and all their data from the current device. After
+//  * the deletion, Evolu will purge the application state. For browsers, this
+//  * will reload all tabs using Evolu. For native apps, it will restart the
+//  * app.
+//  *
+//  * Reloading can be turned off via options if you want to provide a different
+//  * UX.
+//  */
+// readonly resetAppOwner: (options?: {
+//   readonly reload?: boolean;
+// }) => Promise<void>;
+
+// /**
+//  * Restore {@link AppOwner} with all their synced data. It uses
+//  * {@link Evolu.resetAppOwner}, so be careful.
+//  */
+// readonly restoreAppOwner: (
+//   mnemonic: Mnemonic,
+//   options?: {
+//     readonly reload?: boolean;
+//   },
+// ) => Promise<void>;