@evolu/common 8.0.0-next.3 → 8.0.0-next.5

package/src/local-first/Shared.ts

@@ -11,10 +11,12 @@ import {
   shiftFromArray,
   type NonEmptyReadonlyArray,
 } from "../Array.js";
-import { assert, assertNotDisposed } from "../Assert.js";
+import { assert, assertNotAborted, assertNotDisposed } from "../Assert.js";
+import type { Brand } from "../Brand.js";
 import { createCallbacks } from "../Callbacks.js";
 import type { ConsoleEntry, ConsoleLevel } from "../Console.js";
-import { exhaustiveCheck } from "../Function.js";
+import type { EncryptionKey } from "../Crypto.js";
+import { acquireLeaderLock, type LockManagerDep } from "../LockManager.js";
 import { structuralLookup, type StructuralLookupKey } from "../Lookup.js";
 import { createRefCountByKey, type RefCountByKey } from "../RefCount.js";
 import {
@@ -24,25 +26,29 @@ import {
   type SharedResourceByKeyWithClaims,
 } from "../Resource.js";
 import { ok, type Result } from "../Result.js";
-import { spaced } from "../Schedule.js";
 import type { NonEmptyReadonlySet } from "../Set.js";
+import type { SqliteSchema } from "../Sqlite.js";
+import { createStore, type Store } from "../Store.js";
 import {
-  repeat,
+  AbortError,
+  createMutex,
   unabortable,
-  type AbortError,
-  type Fiber,
+  type Mutex,
   type Task,
 } from "../Task.js";
-import { createId, type Id, type Name } from "../Type.js";
+import { type Id, type Name, type Typed } from "../Type.js";
 import type { Callback, ExtractType } from "../Types.js";
 import type { CreateWebSocketDep, WebSocket } from "../WebSocket.js";
 import type {
   SharedWorker as CommonSharedWorker,
+  CreateBroadcastChannelDep,
+  CreateMessageChannelDep,
   MessagePort,
   NativeMessagePort,
   SharedWorkerSelf,
   WorkerDeps,
 } from "../Worker.js";
+import type { DbWorkerInit } from "./Db.js";
 import type { EvoluError } from "./Error.js";
 import type { Owner, OwnerId, OwnerTransport, SyncOwner } from "./Owner.js";
 import {
@@ -57,42 +63,52 @@ import {
   makePatches,
   type Patch,
   type Query,
+  type Row,
   type RowsByQueryMap,
 } from "./Query.js";
 import type { MutationChange } from "./Schema.js";
 import type { CrdtMessage } from "./Storage.js";
 
-export type SharedWorker = CommonSharedWorker<SharedWorkerInput>;
+export type SharedWorker = CommonSharedWorker<
+  SharedWorkerInput,
+  SharedWorkerOutput
+>;
 
 export interface SharedWorkerDep {
   readonly sharedWorker: SharedWorker;
 }
 
-export type SharedWorkerDeps = WorkerDeps & CreateWebSocketDep;
-
 export type SharedWorkerInput =
   | {
-      readonly type: "InitTab";
+      readonly type: "AnnounceTabLeader";
       readonly consoleLevel: ConsoleLevel;
-      readonly port: NativeMessagePort<EvoluTabOutput>;
     }
   | {
       readonly type: "CreateEvolu";
       readonly name: Name;
+      readonly id: EvoluInstanceId;
+      readonly consoleLevel: ConsoleLevel;
+      readonly sqliteSchema: SqliteSchema;
+      readonly encryptionKey: EncryptionKey;
+      readonly memoryOnly: boolean;
       readonly evoluPort: NativeMessagePort<EvoluOutput, EvoluInput>;
-      readonly dbWorkerPort: NativeMessagePort<DbWorkerInput, DbWorkerOutput>;
     };
 
-export type EvoluTabOutput =
+export type SharedWorkerOutput = DbWorkerInit;
+
+export type ConsoleEntryOrError =
   | {
-      readonly type: "OnConsoleEntry";
+      readonly type: "ConsoleEntry";
       readonly entry: ConsoleEntry;
     }
   | {
-      readonly type: "OnError";
+      readonly type: "Error";
       readonly error: EvoluError;
     };
 
+export const consoleEntryOrErrorBroadcastChannelName =
+  "evolu:console-entry-or-error";
+
 export type EvoluInput =
   | {
       readonly type: "Mutate";
@@ -113,9 +129,6 @@ export type EvoluInput =
     }
   | {
       readonly type: "Export";
-    }
-  | {
-      readonly type: "Dispose";
     };
 
 export type EvoluOutput =
@@ -132,32 +145,158 @@ export type EvoluOutput =
       readonly file: Uint8Array<ArrayBuffer>;
     };
 
+export type DbWorkerInput =
+  | (Typed<"Request"> & {
+      readonly callbackId: Id;
+      readonly request: DbWorkerRequest;
+    })
+  | Typed<"Dispose">;
+
+export type DbWorkerRequest =
+  | {
+      readonly type: "ForEvolu";
+      readonly id: EvoluInstanceId;
+      readonly message: ExtractType<EvoluInput, "Mutate" | "Query" | "Export">;
+    }
+  | {
+      readonly type: "ForSharedWorker";
+      readonly message:
+        | {
+            readonly type: "CreateSyncMessages";
+            readonly owners: NonEmptyReadonlyArray<Owner>;
+          }
+        | {
+            readonly type: "ApplySyncMessage";
+            readonly owner: Owner;
+            readonly inputMessage: Uint8Array;
+          };
+    };
+
+export type DbWorkerOutput =
+  | {
+      readonly type: "LeaderAcquired";
+      readonly name: Name;
+    }
+  | {
+      readonly type: "OnQueuedResponse";
+      readonly callbackId: Id;
+      readonly response: DbWorkerQueuedResponse;
+    };
+
+export type DbWorkerQueuedResponse =
+  | {
+      readonly type: "ForEvolu";
+      readonly id: EvoluInstanceId;
+      readonly message:
+        | {
+            readonly type: "Mutate";
+            readonly messagesByOwnerId: ReadonlyMap<
+              OwnerId,
+              NonEmptyReadonlyArray<CrdtMessage>
+            >;
+            readonly rowsByQuery: RowsByQueryMap;
+          }
+        | {
+            readonly type: "Query";
+            readonly rowsByQuery: RowsByQueryMap;
+          }
+        | {
+            readonly type: "Export";
+            readonly file: Uint8Array<ArrayBuffer>;
+          };
+    }
+  | {
+      readonly type: "ForSharedWorker";
+      readonly message:
+        | {
+            readonly type: "CreateSyncMessages";
+            readonly protocolMessagesByOwnerId: ReadonlyMap<
+              OwnerId,
+              ProtocolMessage
+            >;
+          }
+        | {
+            readonly type: "ApplySyncMessage";
+            readonly ownerId: OwnerId;
+            readonly didWriteMessages: boolean;
+            readonly result: Result<
+              ApplyProtocolMessageAsClientResult,
+              ProtocolError | AbortError
+            >;
+          };
+    };
+
+export type SharedWorkerDeps = WorkerDeps &
+  CreateBroadcastChannelDep &
+  CreateMessageChannelDep &
+  CreateWebSocketDep &
+  LockManagerDep;
+
+interface EvoluTenant extends AsyncDisposable {
+  readonly addInstance: (
+    message: ExtractType<SharedWorkerInput, "CreateEvolu">,
+    onDisposed: () => void,
+  ) => void;
+
+  readonly requestCreateSyncMessages: (ownerIds: ReadonlySet<OwnerId>) => void;
+
+  readonly requestApplySyncMessage: (
+    ownerId: OwnerId,
+    inputMessage: Uint8Array,
+  ) => void;
+}
+
+type EvoluTenantDeps = SharedWorkerDeps &
+  PostConsoleEntryOrErrorDep &
+  TabLeaderPortStoreDep &
+  TransportsDep;
+
+interface PostConsoleEntryOrErrorDep {
+  readonly postConsoleEntryOrError: Callback<ConsoleEntryOrError>;
+}
+
+interface TabLeaderPortStoreDep {
+  readonly tabLeaderPortStore: Store<TabLeaderPort | null>;
+}
+
+type TabLeaderPort = Pick<MessagePort<DbWorkerInit>, "postMessage">;
+
+interface TransportsDep {
+  readonly transports: SharedResourceByKeyWithClaims<
+    OwnerTransport,
+    OwnerId,
+    WebSocket,
+    SharedWorkerDeps
+  >;
+}
+
+export type EvoluInstanceId = Id & Brand<"EvoluInstance">;
+
+export type SyncState = 123;
+
 export const initSharedWorker =
   (
-    self: SharedWorkerSelf<SharedWorkerInput>,
+    self: SharedWorkerSelf<SharedWorkerInput, SharedWorkerOutput>,
   ): Task<AsyncDisposableStack, never, SharedWorkerDeps> =>
   async (run) => {
-    const { createMessagePort, consoleStoreOutputEntry, createWebSocket } =
-      run.deps;
-    const console = run.deps.console.child("SharedWorker");
-    await using stack = new AsyncDisposableStack();
-    const sharedWorkerReady = Promise.withResolvers<void>();
+    const { deps } = run;
+    const console = deps.console.child("SharedWorker");
 
-    // TODO: Use heartbeat to detect and prune dead ports.
-    const tabPorts = new Set<MessagePort<EvoluTabOutput>>();
+    await using disposer = new AsyncDisposableStack();
 
-    // Buffer console/error outputs until the first tab connects its port.
-    const queuedTabOutputs: Array<EvoluTabOutput> = [];
-    const postTabOutput = (output: EvoluTabOutput): void => {
-      if (tabPorts.size === 0) queuedTabOutputs.push(output);
-      else for (const port of tabPorts) port.postMessage(output);
-    };
-    stack.defer(
-      consoleStoreOutputEntry.subscribe(() => {
-        const entry = consoleStoreOutputEntry.get();
-        if (entry) postTabOutput({ type: "OnConsoleEntry", entry });
-      }),
+    const tabLeaderPortStore = disposer.use(
+      createStore<TabLeaderPort | null>(null),
+    );
+    const consoleEntryOrErrorBroadcastChannel = disposer.use(
+      deps.createBroadcastChannel<ConsoleEntryOrError>(
+        consoleEntryOrErrorBroadcastChannelName,
+      ),
     );
+    const postConsoleEntryOrError = (output: ConsoleEntryOrError): void => {
+      consoleEntryOrErrorBroadcastChannel.postMessage(output);
+    };
+
+    const sharedWorkerReady = Promise.withResolvers<void>();
 
     // Register ASAP so the worker does not miss connections.
     self.onConnect = (port) => {
@@ -165,35 +304,23 @@ export const initSharedWorker =
         // The underlying port buffers messages until onMessage is assigned.
         port.onMessage = (message) => {
           switch (message.type) {
-            case "InitTab": {
-              /**
-               * One SharedWorker serves multiple tabs. The most recently
-               * initialized tab's level wins.
-               */
+            case "AnnounceTabLeader": {
               console.setLevel(message.consoleLevel);
-
-              const tabPort = createMessagePort<EvoluTabOutput>(message.port);
-              tabPorts.add(tabPort);
-              if (queuedTabOutputs.length > 0) {
-                queuedTabOutputs.forEach(postTabOutput);
-                queuedTabOutputs.length = 0;
-              }
+              tabLeaderPortStore.set(port);
+              console.info("tabLeaderAnnounced");
               break;
             }
 
             case "CreateEvolu": {
-              void sharedWorkerRunWithSharedEvoluDeps(async (run) => {
-                const sharedEvoluResult = await run(
-                  sharedEvolusByName.acquire(message.name),
+              void sharedWorkerRun(async (run) => {
+                const tenant = await run(
+                  unabortable(tenantsByName.acquire(message)),
                 );
-                if (!sharedEvoluResult.ok) return sharedEvoluResult;
-                sharedEvoluResult.value.createInstance(
-                  message.evoluPort,
-                  message.dbWorkerPort,
-                  () =>
-                    void sharedWorkerRunWithSharedEvoluDeps(
-                      sharedEvolusByName.release(message.name),
-                    ),
+                if (!tenant.ok) return tenant;
+
+                tenant.value.addInstance(
+                  message,
+                  () => void sharedWorkerRun(tenantsByName.release(message)),
                 );
                 return ok();
               });
@@ -206,10 +333,15 @@ export const initSharedWorker =
       });
     };
 
-    const initSharedWorkerRun = run.create();
+    disposer.defer(
+      deps.consoleStoreOutputEntry.subscribe(() => {
+        const entry = deps.consoleStoreOutputEntry.get();
+        if (entry) postConsoleEntryOrError({ type: "ConsoleEntry", entry });
+      }),
+    );
 
-    const transports = stack.use(
-      await initSharedWorkerRun.orThrow(
+    const transports = disposer.use(
+      await run.orThrow(
         createSharedResourceByKeyWithClaims<
           WebSocket,
           OwnerTransport,
@@ -218,7 +350,7 @@ export const initSharedWorker =
           StructuralLookupKey
         >(
           (transport) =>
-            createWebSocket(transport.url, {
+            deps.createWebSocket(transport.url, {
               binaryType: "arraybuffer",
 
               onOpen: () => {
@@ -228,39 +360,35 @@ export const initSharedWorker =
                   ownerIds: [...ownerIds],
                 });
 
-                forEachSharedEvolu((sharedEvolu) => {
-                  sharedEvolu.requestCreateSyncMessages(ownerIds);
+                forEachTenant((tenant) => {
+                  tenant.requestCreateSyncMessages(ownerIds);
                 });
               },
 
               onMessage(data) {
                 if (!(data instanceof ArrayBuffer)) return;
 
-                const inputMessage = new globalThis.Uint8Array(data);
-                const headerResult = parseProtocolHeader(
-                  new globalThis.Uint8Array(data),
-                );
+                const message = new Uint8Array(data);
+                const headerResult = parseProtocolHeader(message);
 
                 if (!headerResult.ok) {
                   console.debug("transportInvalidProtocolMessage", {
                     url: transport.url,
-                    byteLength: inputMessage.byteLength,
+                    byteLength: message.byteLength,
                   });
-
-                  // TODO: Propagate invalid protocol messages to sync state.
                   return;
                 }
 
                 console.debug("transportProtocolMessage", {
                   url: transport.url,
                   ownerId: headerResult.value.ownerId,
-                  byteLength: inputMessage.byteLength,
+                  byteLength: message.byteLength,
                 });
 
-                forEachSharedEvolu((sharedEvolu) => {
-                  sharedEvolu.requestApplySyncMessage(
+                forEachTenant((tenant) => {
+                  tenant.requestApplySyncMessage(
                     headerResult.value.ownerId,
-                    inputMessage,
+                    message,
                   );
                 });
               },
@@ -268,8 +396,8 @@ export const initSharedWorker =
           {
             onFirstClaimAdded: (ownerId, webSocket) => {
               if (!webSocket.isOpen()) return;
-              forEachSharedEvolu((sharedEvolu) => {
-                sharedEvolu.requestCreateSyncMessages(new Set([ownerId]));
+              forEachTenant((tenant) => {
+                tenant.requestCreateSyncMessages(new Set([ownerId]));
               });
             },
 
@@ -284,258 +412,209 @@ export const initSharedWorker =
       ),
     );
 
-    const sharedWorkerRunWithSharedEvoluDeps = initSharedWorkerRun.addDeps({
+    const sharedWorkerRun = run.create({
+      ...deps,
+      postConsoleEntryOrError,
+      tabLeaderPortStore,
       transports,
-      postTabOutput,
     });
 
-    const sharedEvolusByName = stack.use(
-      await sharedWorkerRunWithSharedEvoluDeps.orThrow(
-        createSharedResourceByKey(createSharedEvolu, {
-          lookup: structuralLookup,
+    const tenantsByName = disposer.use(
+      await sharedWorkerRun.orThrow(
+        createSharedResourceByKey(createEvoluTenant, {
+          idleDisposeAfter: "3s",
+          lookup: (message) => message.name,
         }),
       ),
     );
 
-    const forEachSharedEvolu = (
-      callback: Callback<BorrowedResource<SharedEvolu>>,
+    sharedWorkerReady.resolve();
+
+    const forEachTenant = (
+      callback: Callback<BorrowedResource<EvoluTenant>>,
     ): void => {
-      for (const sharedEvolu of sharedEvolusByName
-        .snapshot()
-        .resourcesByKey.values()) {
-        callback(sharedEvolu);
+      for (const tenant of tenantsByName.snapshot().resourcesByKey.values()) {
+        callback(tenant);
       }
     };
 
-    sharedWorkerReady.resolve();
-    console.info("initSharedWorker");
-
-    return ok(stack.move());
+    return ok(disposer.move());
   };
 
-interface SharedEvolu extends AsyncDisposable {
-  readonly createInstance: (
-    evoluPort: NativeMessagePort<EvoluOutput, EvoluInput>,
-    dbWorkerPort: NativeMessagePort<DbWorkerInput, DbWorkerOutput>,
-    releaseSharedEvolu: () => void,
-  ) => void;
-
-  readonly requestCreateSyncMessages: (ownerIds: ReadonlySet<OwnerId>) => void;
-
-  readonly requestApplySyncMessage: (
-    ownerId: OwnerId,
-    inputMessage: Uint8Array,
-  ) => void;
-}
+const createEvoluTenant =
+  ({
+    name,
+    consoleLevel,
+    sqliteSchema,
+    encryptionKey,
+    memoryOnly,
+  }: ExtractType<SharedWorkerInput, "CreateEvolu">): Task<
+    EvoluTenant,
+    never,
+    EvoluTenantDeps
+  > =>
+  async (run) => {
+    await using disposer = new AsyncDisposableStack();
+    const tenantRun = disposer.use(run.create());
 
-type SharedEvoluDeps = SharedWorkerDeps & PostTabOutputDep & TransportsDep;
+    const { deps } = run;
+    const console = deps.console.child(name).child("SharedWorker");
 
-interface PostTabOutputDep {
-  readonly postTabOutput: Callback<EvoluTabOutput>;
-}
+    interface EvoluInstance extends AsyncDisposable {
+      readonly id: EvoluInstanceId;
+      readonly onDisposed: () => void;
+      readonly port: MessagePort<EvoluOutput, EvoluInput>;
+      readonly useOwnerMutex: Mutex;
+      readonly usedSyncOwners: RefCountByKey<SyncOwner>;
+      rowsByQuery: Map<Query, ReadonlyArray<Row>>;
+    }
 
-interface TransportsDep {
-  readonly transports: SharedResourceByKeyWithClaims<
-    OwnerTransport,
-    OwnerId,
-    WebSocket,
-    SharedWorkerDeps
-  >;
-}
+    const instancesById = disposer.adopt(
+      new Map<EvoluInstanceId, EvoluInstance>(),
+      async (instancesById) => {
+        await using disposer = new AsyncDisposableStack();
+        for (const instance of [...instancesById.values()]) {
+          disposer.use(instance);
+        }
+      },
+    );
 
-export interface DbWorkerInput {
-  readonly callbackId: Id;
-  readonly request:
-    | {
-        readonly type: "ForEvolu";
-        readonly evoluPortId: Id;
-        readonly message: ExtractType<
-          EvoluInput,
-          "Mutate" | "Query" | "Export"
-        >;
-      }
-    | {
-        readonly type: "ForSharedWorker";
-        readonly message:
-          | {
-              readonly type: "CreateSyncMessages";
-              readonly owners: NonEmptyReadonlyArray<Owner>;
-            }
-          | {
-              readonly type: "ApplySyncMessage";
-              readonly owner: Owner;
-              readonly inputMessage: Uint8Array;
-            };
+    let dbWorkerPort = null as MessagePort<
+      DbWorkerInput,
+      DbWorkerOutput
+    > | null;
+    const dbWorkerInited = Promise.withResolvers<void>();
+
+    const initDbWorker = (): void => {
+      const tabLeaderPort = deps.tabLeaderPortStore.get();
+      assert(tabLeaderPort, "Expected tab leader port.");
+
+      const dbWorkerChannel = deps.createMessageChannel<
+        DbWorkerOutput,
+        DbWorkerInput
+      >();
+      const currentDbWorkerPort = dbWorkerChannel.port2;
+
+      currentDbWorkerPort.onMessage = (message) => {
+        switch (message.type) {
+          case "LeaderAcquired": {
+            assert(
+              dbWorkerPort !== currentDbWorkerPort,
+              "Expected a new DbWorker port.",
+            );
+            dbWorkerPort?.[Symbol.dispose]();
+            dbWorkerPort = currentDbWorkerPort;
+            queueRequestInFlight = false;
+            console.info("leaderAcquired");
+            dbWorkerInited.resolve();
+            runQueue();
+            break;
+          }
+          case "OnQueuedResponse": {
+            callbacks.execute(message.callbackId, message);
+            break;
+          }
+        }
       };
-}
 
-export type DbWorkerOutput =
-  | EvoluTabOutput
-  | {
-      readonly type: "LeaderAcquired";
-      readonly name: Name;
-    }
-  | {
-      readonly type: "OnQueuedResponse";
-      readonly callbackId: Id;
-      readonly response:
-        | {
-            readonly type: "ForEvolu";
-            readonly evoluPortId: Id;
-            readonly message:
-              | {
-                  readonly type: "Mutate";
-                  readonly messagesByOwnerId: ReadonlyMap<
-                    OwnerId,
-                    NonEmptyReadonlyArray<CrdtMessage>
-                  >;
-                  readonly rowsByQuery: RowsByQueryMap;
-                }
-              | {
-                  readonly type: "Query";
-                  readonly rowsByQuery: RowsByQueryMap;
-                }
-              | {
-                  readonly type: "Export";
-                  readonly file: Uint8Array<ArrayBuffer>;
-                };
-          }
-        | {
-            readonly type: "ForSharedWorker";
-            readonly message:
-              | {
-                  readonly type: "CreateSyncMessages";
-                  readonly protocolMessagesByOwnerId: ReadonlyMap<
-                    OwnerId,
-                    ProtocolMessage
-                  >;
-                }
-              | {
-                  readonly type: "ApplySyncMessage";
-                  readonly ownerId: OwnerId;
-                  readonly didWriteMessages: boolean;
-                  readonly result: Result<
-                    ApplyProtocolMessageAsClientResult,
-                    ProtocolError | AbortError
-                  >;
-                };
-          };
+      tabLeaderPort.postMessage(
+        {
+          type: "DbWorkerInit",
+          name,
+          consoleLevel,
+          sqliteSchema,
+          encryptionKey,
+          memoryOnly,
+          port: dbWorkerChannel.port1.native,
+        },
+        [dbWorkerChannel.port1.native],
+      );
     };
 
-export type SyncState = 123;
-
-const createSharedEvolu =
-  (name: Name): Task<SharedEvolu, never, SharedEvoluDeps> =>
-  (run) => {
-    const stack = new AsyncDisposableStack();
-    const sharedEvoluRun = run.create();
-
-    const console = run.deps.console.child(name).child("SharedWorker");
-    const { createMessagePort, postTabOutput, transports } = run.deps;
-
-    interface EvoluInstanceState {
-      readonly evoluPort: MessagePort<EvoluOutput, EvoluInput>;
-      readonly dbWorkerPort: MessagePort<DbWorkerInput, DbWorkerOutput>;
-      readonly releaseSharedEvolu: () => void;
-      rowsByQuery: RowsByQueryMap;
-      readonly usedSyncOwners: RefCountByKey<SyncOwner>;
-    }
-
-    const evoluInstancesByPortId = new Map<Id, EvoluInstanceState>();
-    const queue: Array<DbWorkerInput["request"]> = [];
-    const callbacks = stack.use(
+    const queue: Array<DbWorkerRequest> = [];
+    const callbacks = disposer.use(
       createCallbacks<ExtractType<DbWorkerOutput, "OnQueuedResponse">>(
         run.deps,
       ),
     );
+    let queueRequestInFlight = false;
 
-    let leaderDbWorkerPort = null as MessagePort<
-      DbWorkerInput,
-      DbWorkerOutput
-    > | null;
-    let queueProcessingFiber: Fiber<void, never, WorkerDeps> | null = null;
-
-    stack.use(sharedEvoluRun);
-    const moved = stack.move();
-
-    const ensureQueueProcessing = (): void => {
-      if (
-        queueProcessingFiber ||
-        !isNonEmptyArray(queue) ||
-        !leaderDbWorkerPort
-      ) {
+    const runQueue = (): void => {
+      if (queueRequestInFlight || !isNonEmptyArray(queue) || !dbWorkerPort) {
         return;
       }
 
-      const first = firstInArray(queue);
+      const request = firstInArray(queue);
 
       const callbackId = callbacks.register(({ response }) => {
-        queueProcessingFiber?.abort();
-        queueProcessingFiber = null;
-
         switch (response.type) {
           case "ForEvolu": {
-            handleResponseForEvolu(response, first);
+            handleResponseForEvolu(response, request);
             break;
           }
 
           case "ForSharedWorker":
             handleResponseForSharedWorker(response);
             break;
-
-          default:
-            exhaustiveCheck(response);
         }
 
         // Complete the current queue item and continue with the next one.
         shiftFromArray(queue);
-        ensureQueueProcessing();
+        queueRequestInFlight = false;
+        runQueue();
       });
 
-      /**
-       * The leader DbWorker can disappear at any time when its tab closes, so
-       * keep resending the current request until some leader answers. The
-       * response handler aborts this retry loop and advances the queue.
-       */
-      queueProcessingFiber = sharedEvoluRun.daemon(
-        repeat(() => {
-          assert(leaderDbWorkerPort, "Expected a leader DbWorker");
-          leaderDbWorkerPort.postMessage({ callbackId, request: first });
-          return ok();
-        }, spaced("5s")),
-      );
+      queueRequestInFlight = true;
+      dbWorkerPort.postMessage({ type: "Request", callbackId, request });
     };
 
+    disposer.defer(async () => {
+      dbWorkerPort?.postMessage({ type: "Dispose" });
+      dbWorkerPort = null;
+      queueRequestInFlight = false;
+
+      // The DbWorker holds this tenant leader lock while it is alive. Tenant
+      // disposal sends Dispose, then acquires the same lock to wait until the
+      // DbWorker releases it: either because Dispose was delivered or because
+      // the hosting tab closed. The wait is unabortable because tenant disposal
+      // must finish even after tenantRun receives an abort request.
+      const lock = await tenantRun(acquireLeaderLock(name));
+      // AbortError here means tenantRun was already disposed before this
+      // cleanup could start, violating the disposal ordering above.
+      assertNotAborted(lock);
+      await using _ = lock.value;
+    });
+
+    disposer.defer(deps.tabLeaderPortStore.subscribe(initDbWorker));
+
+    initDbWorker();
+    await dbWorkerInited.promise;
+    const disposables = disposer.move();
+
     const handleResponseForEvolu = (
-      response: ExtractType<
-        ExtractType<DbWorkerOutput, "OnQueuedResponse">["response"],
-        "ForEvolu"
-      >,
-      first: DbWorkerInput["request"],
+      response: ExtractType<DbWorkerQueuedResponse, "ForEvolu">,
+      first: DbWorkerRequest,
     ): void => {
-      const instance = evoluInstancesByPortId.get(response.evoluPortId);
-      const port = instance?.evoluPort;
-
-      if (!port) return;
+      const instance = instancesById.get(response.id);
+      if (!instance) return;
 
       switch (response.message.type) {
         case "Mutate":
         case "Query": {
-          const previousRowsByQuery = instance.rowsByQuery;
-          const nextRowsByQuery = new Map(previousRowsByQuery);
+          const nextRowsByQuery = new Map(instance.rowsByQuery);
           const patchesByQuery = new Map<Query, ReadonlyArray<Patch>>();
 
           for (const [query, rows] of response.message.rowsByQuery) {
             nextRowsByQuery.set(query, rows);
             patchesByQuery.set(
               query,
-              makePatches(previousRowsByQuery.get(query), rows),
+              makePatches(instance.rowsByQuery.get(query), rows),
             );
           }
 
           instance.rowsByQuery = nextRowsByQuery;
 
-          instance.evoluPort.postMessage({
+          instance.port.postMessage({
             type: "OnPatchesByQuery",
             patchesByQuery,
             onCompleteIds:
@@ -545,66 +624,52 @@ const createSharedEvolu =
           });
 
           if (response.message.type === "Mutate") {
-            const mutateResponse = response.message;
-
-            for (const [
-              otherEvoluPortId,
-              otherEvoluInstance,
-            ] of evoluInstancesByPortId) {
-              if (otherEvoluPortId === response.evoluPortId) continue;
-              otherEvoluInstance.evoluPort.postMessage({
+            for (const [instanceId, instance] of instancesById) {
+              if (instanceId === response.id) continue;
+              instance.port.postMessage({
                 type: "RefreshQueries",
               });
             }
 
-            sharedEvoluRun<void, never>((run) => {
-              const protocolMessagesByOwnerId = new Map<
-                OwnerId,
-                ProtocolMessage
-              >();
-
-              for (const syncOwner of instance.usedSyncOwners.keys()) {
-                const { owner } = syncOwner;
-                const messages = mutateResponse.messagesByOwnerId.get(owner.id);
-
-                // Skip owners this instance does not currently sync for
-                // writing. Read-only owners cannot produce protocol
-                // messages because they do not have a write key.
-                if (!messages || !("writeKey" in owner)) continue;
-
-                protocolMessagesByOwnerId.set(
-                  owner.id,
-                  createProtocolMessageFromCrdtMessages(run.deps)(
-                    owner,
-                    messages,
-                  ),
-                );
-              }
-
-              sendProtocolMessagesByOwnerId(protocolMessagesByOwnerId);
+            const protocolMessagesByOwnerId = new Map<
+              OwnerId,
+              ProtocolMessage
+            >();
+
+            for (const syncOwner of instance.usedSyncOwners.keys()) {
+              const { owner } = syncOwner;
+              const messages = response.message.messagesByOwnerId.get(owner.id);
+
+              // Skip owners this instance does not currently sync for
+              // writing. Read-only owners cannot produce protocol
+              // messages because they do not have a write key.
+              if (!messages || !("writeKey" in owner)) continue;
+
+              protocolMessagesByOwnerId.set(
+                owner.id,
+                createProtocolMessageFromCrdtMessages(run.deps)(
+                  owner,
+                  messages,
+                ),
+              );
+            }
 
-              return ok();
-            });
+            sendProtocolMessagesByOwnerId(protocolMessagesByOwnerId);
           }
           break;
         }
 
         case "Export":
-          port.postMessage({ type: "OnExport", file: response.message.file }, [
-            response.message.file.buffer,
-          ]);
+          instance.port.postMessage(
+            { type: "OnExport", file: response.message.file },
+            [response.message.file.buffer],
+          );
           break;
-
-        default:
-          exhaustiveCheck(response.message);
       }
     };
 
     const handleResponseForSharedWorker = (
-      response: ExtractType<
-        ExtractType<DbWorkerOutput, "OnQueuedResponse">["response"],
-        "ForSharedWorker"
-      >,
+      response: ExtractType<DbWorkerQueuedResponse, "ForSharedWorker">,
     ): void => {
       switch (response.message.type) {
         case "CreateSyncMessages":
@@ -615,13 +680,15 @@ const createSharedEvolu =
 
         case "ApplySyncMessage":
           if (response.message.didWriteMessages) {
-            refreshQueries();
+            for (const instance of instancesById.values()) {
+              instance.port.postMessage({ type: "RefreshQueries" });
+            }
           }
 
           if (!response.message.result.ok) {
             if (response.message.result.error.type !== "AbortError") {
-              postTabOutput({
-                type: "OnError",
+              deps.postConsoleEntryOrError({
+                type: "Error",
                 error: response.message.result.error,
               });
             }
@@ -641,15 +708,9 @@ const createSharedEvolu =
               case "Broadcast":
               case "NoResponse":
                 break;
-
-              default:
-                exhaustiveCheck(response.message.result.value);
             }
           }
           break;
-
-        default:
-          exhaustiveCheck(response.message);
       }
     };
 
@@ -657,8 +718,10 @@ const createSharedEvolu =
       protocolMessagesByOwnerId: ReadonlyMap<OwnerId, ProtocolMessage>,
     ): void => {
       for (const [ownerId, protocolMessage] of protocolMessagesByOwnerId) {
-        for (const transport of transports.getResourceKeysForClaim(ownerId)) {
-          const webSocket = transports.getResource(transport);
+        for (const transport of deps.transports.getResourceKeysForClaim(
+          ownerId,
+        )) {
+          const webSocket = deps.transports.getResource(transport);
           if (!webSocket?.isOpen()) continue;
 
           console.debug("sendProtocolMessage", {
@@ -672,192 +735,131 @@ const createSharedEvolu =
       }
     };
 
-    const refreshQueries = (): void => {
-      for (const evoluInstance of evoluInstancesByPortId.values()) {
-        evoluInstance.evoluPort.postMessage({ type: "RefreshQueries" });
-      }
-    };
-
     const getUsedOwnersById = (
       ownerIds: ReadonlySet<OwnerId>,
     ): ReadonlyMap<OwnerId, Owner> => {
       const ownersById = new Map<OwnerId, Owner>();
-
-      for (const evoluInstance of evoluInstancesByPortId.values()) {
-        for (const { owner } of evoluInstance.usedSyncOwners.keys()) {
+      for (const instance of instancesById.values()) {
+        for (const { owner } of instance.usedSyncOwners.keys()) {
           if (!ownerIds.has(owner.id) || !("writeKey" in owner)) continue;
-
           ownersById.set(owner.id, owner);
         }
       }
-
       return ownersById;
     };
 
-    const removeAllUsedSyncOwners = (
-      evoluInstance: EvoluInstanceState,
-    ): Task<void, never, SharedEvoluDeps> =>
-      unabortable(async (run) => {
-        for (const syncOwner of evoluInstance.usedSyncOwners.keys()) {
-          while (evoluInstance.usedSyncOwners.has(syncOwner)) {
-            await run(toggleUsedSyncOwner(evoluInstance, syncOwner, "remove"));
-          }
-        }
-        return ok();
-      });
-
-    const toggleUsedSyncOwner = (
-      evoluInstance: EvoluInstanceState,
-      syncOwner: SyncOwner,
-      action: "add" | "remove",
-    ): Task<void, never, SharedEvoluDeps> =>
-      unabortable(async (run) => {
+    const toggleSyncOwner =
+      (
+        instance: EvoluInstance,
+        syncOwner: SyncOwner,
+        action: "add" | "remove",
+      ): Task<void, never, EvoluTenantDeps> =>
+      async (run) => {
         if (action === "add") {
-          evoluInstance.usedSyncOwners.increment(syncOwner);
-          await run(
-            transports.addClaim(syncOwner.owner.id, syncOwner.transports),
+          instance.usedSyncOwners.increment(syncOwner);
+          return await run(
+            deps.transports.addClaim(syncOwner.owner.id, syncOwner.transports),
           );
         } else {
-          evoluInstance.usedSyncOwners.decrement(syncOwner);
-          await run(
-            transports.removeClaim(syncOwner.owner.id, syncOwner.transports),
+          instance.usedSyncOwners.decrement(syncOwner);
+          return await run(
+            deps.transports.removeClaim(
+              syncOwner.owner.id,
+              syncOwner.transports,
+            ),
           );
         }
-        return ok();
-      });
+      };
 
     return ok({
-      createInstance: (
-        nativeEvoluPort: NativeMessagePort<EvoluOutput, EvoluInput>,
-        nativeDbWorkerPort: NativeMessagePort<DbWorkerInput, DbWorkerOutput>,
-        releaseSharedEvolu: () => void,
-      ): void => {
-        assertNotDisposed(moved);
-
-        const evoluPort = createMessagePort<EvoluOutput, EvoluInput>(
-          nativeEvoluPort,
-        );
-        const dbWorkerPort = createMessagePort<DbWorkerInput, DbWorkerOutput>(
-          nativeDbWorkerPort,
-        );
-
-        const evoluPortId = createId(run.deps);
-
-        const evoluInstance: EvoluInstanceState = {
-          evoluPort,
-          dbWorkerPort,
-          releaseSharedEvolu,
-          rowsByQuery: new Map(),
+      addInstance: (message, onDisposed) => {
+        assertNotDisposed(disposables);
+
+        const instance: EvoluInstance = {
+          id: message.id,
+          port: deps.createMessagePort<EvoluOutput, EvoluInput>(
+            message.evoluPort,
+          ),
+          onDisposed,
+          rowsByQuery: new Map<Query, ReadonlyArray<Row>>(),
+          useOwnerMutex: createMutex(),
           usedSyncOwners: createRefCountByKey<SyncOwner, OwnerId>({
-            lookup: ({ owner: { id } }) => id,
+            lookup: (syncOwner) => syncOwner.owner.id,
           }),
+          [Symbol.asyncDispose]: () => disposer.disposeAsync(),
         };
 
-        evoluInstancesByPortId.set(evoluPortId, evoluInstance);
+        instancesById.set(instance.id, instance);
 
-        dbWorkerPort.onMessage = (message) => {
-          switch (message.type) {
-            case "LeaderAcquired": {
-              leaderDbWorkerPort = evoluInstance.dbWorkerPort;
-              console.info("leaderAcquired");
-              ensureQueueProcessing();
-              break;
-            }
+        const disposer = new AsyncDisposableStack();
 
-            case "OnQueuedResponse": {
-              callbacks.execute(message.callbackId, message);
-              break;
-            }
+        disposer.defer(instance.onDisposed);
+        disposer.use(instance.usedSyncOwners);
+        disposer.use(instance.useOwnerMutex);
 
-            case "OnConsoleEntry":
-            case "OnError": {
-              postTabOutput(message);
-              break;
-            }
+        disposer.defer(async () => {
+          await tenantRun(
+            instance.useOwnerMutex.withLock(async (run) => {
+              for (const syncOwner of instance.usedSyncOwners.keys()) {
+                while (instance.usedSyncOwners.has(syncOwner)) {
+                  await run(toggleSyncOwner(instance, syncOwner, "remove"));
+                }
+              }
+              return ok();
+            }),
+          );
+        });
 
-            default:
-              exhaustiveCheck(message);
-          }
-        };
+        disposer.defer(() => {
+          instancesById.delete(instance.id);
+          console.info("evoluDispose", { name, id: instance.id });
+        });
+        disposer.use(instance.port);
+
+        // The main-thread Evolu instance holds this per-instance leader lock
+        // while it is alive. Acquiring the same lock here means the main
+        // thread instance was disposed or its tab closed, so the tenant-side
+        // instance must dispose itself.
+        void tenantRun(acquireLeaderLock(message.id)).then((lock) => {
+          if (!lock.ok) return;
+
+          disposer.use(lock.value);
+          return disposer.disposeAsync();
+        });
 
-        evoluPort.onMessage = (evoluMessage) => {
-          switch (evoluMessage.type) {
+        instance.port.onMessage = (message) => {
+          switch (message.type) {
             case "Query":
             case "Export": {
-              queue.push({
-                type: "ForEvolu",
-                evoluPortId,
-                message: evoluMessage,
-              });
-              ensureQueueProcessing();
+              queue.push({ type: "ForEvolu", id: instance.id, message });
+              runQueue();
               break;
             }
-
             case "Mutate": {
               // TODO: Delegate do vsech evolu instances, co to pouzivaji
-              queue.push({
-                type: "ForEvolu",
-                evoluPortId,
-                message: evoluMessage,
-              });
-              ensureQueueProcessing();
+              queue.push({ type: "ForEvolu", id: instance.id, message });
+              runQueue();
               break;
             }
-
             case "UseOwner": {
-              const evoluInstance = evoluInstancesByPortId.get(evoluPortId);
-              if (!evoluInstance) break;
-
-              for (const { owner, action } of evoluMessage.actions) {
-                console.debug("useOwner", {
-                  evoluPortId,
-                  action,
-                  ownerId: owner.owner.id,
-                  transportUrls: owner.transports.map(({ url }) => url),
-                });
-
-                void sharedEvoluRun(
-                  toggleUsedSyncOwner(evoluInstance, owner, action),
-                );
-              }
+              void tenantRun(
+                instance.useOwnerMutex.withLock(async (run) => {
+                  for (const { owner, action } of message.actions) {
+                    console.debug("useOwner", {
+                      id: instance.id,
+                      action,
+                      ownerId: owner.owner.id,
+                      transportUrls: owner.transports.map(({ url }) => url),
+                    });
+
+                    await run(toggleSyncOwner(instance, owner, action));
+                  }
+
+                  return ok();
+                }),
+              );
               break;
             }
-
-            case "Dispose": {
-              const evoluInstance = evoluInstancesByPortId.get(evoluPortId);
-              if (!evoluInstance) break;
-
-              evoluInstancesByPortId.delete(evoluPortId);
-              const hadLastPort = evoluInstancesByPortId.size === 0;
-              console.info("evoluDispose", {
-                name,
-                evoluPortId,
-                hadLastPort,
-              });
-
-              // Potential plan: keep DbWorker ports in a SharedResource
-              // abstraction instead of deleting them eagerly here. DbWorkers use
-              // leader election because SQLite WASM needs a single active owner.
-              // When the last Evolu instance is disposed, broadcast shutdown to
-              // all DbWorkers so the current leader can dispose itself and the
-              // followers can clean up consistently.
-              sharedEvoluRun<void, never>(async (run) => {
-                await run(removeAllUsedSyncOwners(evoluInstance));
-                evoluInstance.usedSyncOwners[Symbol.dispose]();
-                return ok();
-              });
-
-              // if (hadLastPort) evoluInstance.releaseSharedEvolu();
-
-              // TODO: Dispose SharedEvolu on the last port.
-
-              // TODO: Decided what to do with DbWorker but probably dispose it, but
-              // https://bugs.webkit.org/show_bug.cgi?id=301520
-              break;
-            }
-
-            default:
-              exhaustiveCheck(evoluMessage);
           }
         };
       },
@@ -879,12 +881,11 @@ const createSharedEvolu =
           },
         });
 
-        ensureQueueProcessing();
+        runQueue();
       },
 
       requestApplySyncMessage: (ownerId, inputMessage): void => {
         const owner = getUsedOwnersById(new Set([ownerId])).get(ownerId);
-
         if (!owner) return;
 
         console.debug("requestApplySyncMessage", {
@@ -901,10 +902,10 @@ const createSharedEvolu =
           },
         });
 
-        ensureQueueProcessing();
+        runQueue();
       },
 
-      [Symbol.asyncDispose]: () => moved.disposeAsync(),
+      [Symbol.asyncDispose]: () => disposables.disposeAsync(),
     });
   };
 
@@ -930,3 +931,11 @@ const createSharedEvolu =
 //       readonly onCompleteId: CallbackId;
 //       readonly reload: boolean;
 //     })
+
+// TODO: Remaining SharedWorker lifetime issues.
+// - Investigate heartbeat for ports and where liveness tracking is needed.
+// - Sync state for monitoring.
+// - Propagate invalid protocol messages to sync state.
+// - Make DbWorker logically stateless by making all requests idempotent.
+// - Investigate WebKit bug 301520 relevance to DbWorker disposal. (again)
+//   https://bugs.webkit.org/show_bug.cgi?id=301520