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

package/dist/src/local-first/Shared.js

@@ -56,67 +56,49 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { emptyArray, firstInArray, isNonEmptyArray, shiftFromArray, } from "../Array.js";
-import { assert, assertNotDisposed } from "../Assert.js";
+import { assert, assertNotAborted, assertNotDisposed } from "../Assert.js";
 import { createCallbacks } from "../Callbacks.js";
-import { exhaustiveCheck } from "../Function.js";
+import { acquireLeaderLock } from "../LockManager.js";
 import { structuralLookup } from "../Lookup.js";
 import { createRefCountByKey } from "../RefCount.js";
 import { createSharedResourceByKey, createSharedResourceByKeyWithClaims, } from "../Resource.js";
 import { ok } from "../Result.js";
-import { spaced } from "../Schedule.js";
-import { repeat, unabortable, } from "../Task.js";
-import { createId } from "../Type.js";
+import { createStore } from "../Store.js";
+import { AbortError, createMutex, unabortable, } from "../Task.js";
+import {} from "../Type.js";
 import { createProtocolMessageForUnsubscribe, createProtocolMessageFromCrdtMessages, parseProtocolHeader, } from "./Protocol.js";
 import { makePatches, } from "./Query.js";
+export const consoleEntryOrErrorBroadcastChannelName = "evolu:console-entry-or-error";
 export const initSharedWorker = (self) => async (run) => {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const { createMessagePort, consoleStoreOutputEntry, createWebSocket } = run.deps;
-        const console = run.deps.console.child("SharedWorker");
-        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
-        const sharedWorkerReady = Promise.withResolvers();
-        // TODO: Use heartbeat to detect and prune dead ports.
-        const tabPorts = new Set();
-        // Buffer console/error outputs until the first tab connects its port.
-        const queuedTabOutputs = [];
-        const postTabOutput = (output) => {
-            if (tabPorts.size === 0)
-                queuedTabOutputs.push(output);
-            else
-                for (const port of tabPorts)
-                    port.postMessage(output);
+        const { deps } = run;
+        const console = deps.console.child("SharedWorker");
+        const disposer = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const tabLeaderPortStore = disposer.use(createStore(null));
+        const consoleEntryOrErrorBroadcastChannel = disposer.use(deps.createBroadcastChannel(consoleEntryOrErrorBroadcastChannelName));
+        const postConsoleEntryOrError = (output) => {
+            consoleEntryOrErrorBroadcastChannel.postMessage(output);
         };
-        stack.defer(consoleStoreOutputEntry.subscribe(() => {
-            const entry = consoleStoreOutputEntry.get();
-            if (entry)
-                postTabOutput({ type: "OnConsoleEntry", entry });
-        }));
+        const sharedWorkerReady = Promise.withResolvers();
         // Register ASAP so the worker does not miss connections.
         self.onConnect = (port) => {
             void sharedWorkerReady.promise.then(() => {
                 // 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(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));
-                                if (!sharedEvoluResult.ok)
-                                    return sharedEvoluResult;
-                                sharedEvoluResult.value.createInstance(message.evoluPort, message.dbWorkerPort, () => void sharedWorkerRunWithSharedEvoluDeps(sharedEvolusByName.release(message.name)));
+                            void sharedWorkerRun(async (run) => {
+                                const tenant = await run(unabortable(tenantsByName.acquire(message)));
+                                if (!tenant.ok)
+                                    return tenant;
+                                tenant.value.addInstance(message, () => void sharedWorkerRun(tenantsByName.release(message)));
                                 return ok();
                             });
                             break;
@@ -127,8 +109,12 @@ export const initSharedWorker = (self) => async (run) => {
                 };
             });
         };
-        const initSharedWorkerRun = run.create();
-        const transports = stack.use(await initSharedWorkerRun.orThrow(createSharedResourceByKeyWithClaims((transport) => createWebSocket(transport.url, {
+        disposer.defer(deps.consoleStoreOutputEntry.subscribe(() => {
+            const entry = deps.consoleStoreOutputEntry.get();
+            if (entry)
+                postConsoleEntryOrError({ type: "ConsoleEntry", entry });
+        }));
+        const transports = disposer.use(await run.orThrow(createSharedResourceByKeyWithClaims((transport) => deps.createWebSocket(transport.url, {
             binaryType: "arraybuffer",
             onOpen: () => {
                 const ownerIds = transports.getClaimsForResource(transport);
@@ -136,38 +122,37 @@ export const initSharedWorker = (self) => async (run) => {
                     url: transport.url,
                     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(headerResult.value.ownerId, inputMessage);
+                forEachTenant((tenant) => {
+                    tenant.requestApplySyncMessage(headerResult.value.ownerId, message);
                 });
             },
         }), {
             onFirstClaimAdded: (ownerId, webSocket) => {
                 if (!webSocket.isOpen())
                     return;
-                forEachSharedEvolu((sharedEvolu) => {
-                    sharedEvolu.requestCreateSyncMessages(new Set([ownerId]));
+                forEachTenant((tenant) => {
+                    tenant.requestCreateSyncMessages(new Set([ownerId]));
                 });
             },
             onLastClaimRemoved: (ownerId, webSocket) => {
@@ -177,23 +162,23 @@ export const initSharedWorker = (self) => async (run) => {
             idleDisposeAfter: "3s",
             resourceLookup: structuralLookup,
         })));
-        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) => {
-            for (const sharedEvolu of sharedEvolusByName
-                .snapshot()
-                .resourcesByKey.values()) {
-                callback(sharedEvolu);
+        sharedWorkerReady.resolve();
+        const forEachTenant = (callback) => {
+            for (const tenant of tenantsByName.snapshot().resourcesByKey.values()) {
+                callback(tenant);
             }
         };
-        sharedWorkerReady.resolve();
-        console.info("initSharedWorker");
-        return ok(stack.move());
+        return ok(disposer.move());
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -205,91 +190,156 @@ export const initSharedWorker = (self) => async (run) => {
             await result_1;
     }
 };
-const createSharedEvolu = (name) => (run) => {
-    const stack = new AsyncDisposableStack();
-    const sharedEvoluRun = run.create();
-    const console = run.deps.console.child(name).child("SharedWorker");
-    const { createMessagePort, postTabOutput, transports } = run.deps;
-    const evoluInstancesByPortId = new Map();
-    const queue = [];
-    const callbacks = stack.use(createCallbacks(run.deps));
-    let leaderDbWorkerPort = null;
-    let queueProcessingFiber = null;
-    stack.use(sharedEvoluRun);
-    const moved = stack.move();
-    const ensureQueueProcessing = () => {
-        if (queueProcessingFiber ||
-            !isNonEmptyArray(queue) ||
-            !leaderDbWorkerPort) {
-            return;
-        }
-        const first = firstInArray(queue);
-        const callbackId = callbacks.register(({ response }) => {
-            queueProcessingFiber?.abort();
-            queueProcessingFiber = null;
-            switch (response.type) {
-                case "ForEvolu": {
-                    handleResponseForEvolu(response, first);
-                    break;
+const createEvoluTenant = ({ name, consoleLevel, sqliteSchema, encryptionKey, memoryOnly, }) => async (run) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const disposer = __addDisposableResource(env_2, new AsyncDisposableStack(), true);
+        const tenantRun = disposer.use(run.create());
+        const { deps } = run;
+        const console = deps.console.child(name).child("SharedWorker");
+        const instancesById = disposer.adopt(new Map(), async (instancesById) => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const disposer = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
+                for (const instance of [...instancesById.values()]) {
+                    disposer.use(instance);
                 }
-                case "ForSharedWorker":
-                    handleResponseForSharedWorker(response);
-                    break;
-                default:
-                    exhaustiveCheck(response);
             }
-            // Complete the current queue item and continue with the next one.
-            shiftFromArray(queue);
-            ensureQueueProcessing();
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                const result_3 = __disposeResources(env_3);
+                if (result_3)
+                    await result_3;
+            }
         });
-        /**
-         * 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")));
-    };
-    const handleResponseForEvolu = (response, first) => {
-        const instance = evoluInstancesByPortId.get(response.evoluPortId);
-        const port = instance?.evoluPort;
-        if (!port)
-            return;
-        switch (response.message.type) {
-            case "Mutate":
-            case "Query": {
-                const previousRowsByQuery = instance.rowsByQuery;
-                const nextRowsByQuery = new Map(previousRowsByQuery);
-                const patchesByQuery = new Map();
-                for (const [query, rows] of response.message.rowsByQuery) {
-                    nextRowsByQuery.set(query, rows);
-                    patchesByQuery.set(query, makePatches(previousRowsByQuery.get(query), rows));
+        let dbWorkerPort = null;
+        const dbWorkerInited = Promise.withResolvers();
+        const initDbWorker = () => {
+            const tabLeaderPort = deps.tabLeaderPortStore.get();
+            assert(tabLeaderPort, "Expected tab leader port.");
+            const dbWorkerChannel = deps.createMessageChannel();
+            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;
+                    }
                 }
-                instance.rowsByQuery = nextRowsByQuery;
-                instance.evoluPort.postMessage({
-                    type: "OnPatchesByQuery",
-                    patchesByQuery,
-                    onCompleteIds: first.message.type === "Mutate"
-                        ? first.message.onCompleteIds
-                        : emptyArray,
-                });
-                if (response.message.type === "Mutate") {
-                    const mutateResponse = response.message;
-                    for (const [otherEvoluPortId, otherEvoluInstance,] of evoluInstancesByPortId) {
-                        if (otherEvoluPortId === response.evoluPortId)
-                            continue;
-                        otherEvoluInstance.evoluPort.postMessage({
-                            type: "RefreshQueries",
-                        });
+            };
+            tabLeaderPort.postMessage({
+                type: "DbWorkerInit",
+                name,
+                consoleLevel,
+                sqliteSchema,
+                encryptionKey,
+                memoryOnly,
+                port: dbWorkerChannel.port1.native,
+            }, [dbWorkerChannel.port1.native]);
+        };
+        const queue = [];
+        const callbacks = disposer.use(createCallbacks(run.deps));
+        let queueRequestInFlight = false;
+        const runQueue = () => {
+            if (queueRequestInFlight || !isNonEmptyArray(queue) || !dbWorkerPort) {
+                return;
+            }
+            const request = firstInArray(queue);
+            const callbackId = callbacks.register(({ response }) => {
+                switch (response.type) {
+                    case "ForEvolu": {
+                        handleResponseForEvolu(response, request);
+                        break;
                     }
-                    sharedEvoluRun((run) => {
+                    case "ForSharedWorker":
+                        handleResponseForSharedWorker(response);
+                        break;
+                }
+                // Complete the current queue item and continue with the next one.
+                shiftFromArray(queue);
+                queueRequestInFlight = false;
+                runQueue();
+            });
+            queueRequestInFlight = true;
+            dbWorkerPort.postMessage({ type: "Request", callbackId, request });
+        };
+        disposer.defer(async () => {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                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);
+                const _ = __addDisposableResource(env_4, lock.value, true);
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                const result_4 = __disposeResources(env_4);
+                if (result_4)
+                    await result_4;
+            }
+        });
+        disposer.defer(deps.tabLeaderPortStore.subscribe(initDbWorker));
+        initDbWorker();
+        await dbWorkerInited.promise;
+        const disposables = disposer.move();
+        const handleResponseForEvolu = (response, first) => {
+            const instance = instancesById.get(response.id);
+            if (!instance)
+                return;
+            switch (response.message.type) {
+                case "Mutate":
+                case "Query": {
+                    const nextRowsByQuery = new Map(instance.rowsByQuery);
+                    const patchesByQuery = new Map();
+                    for (const [query, rows] of response.message.rowsByQuery) {
+                        nextRowsByQuery.set(query, rows);
+                        patchesByQuery.set(query, makePatches(instance.rowsByQuery.get(query), rows));
+                    }
+                    instance.rowsByQuery = nextRowsByQuery;
+                    instance.port.postMessage({
+                        type: "OnPatchesByQuery",
+                        patchesByQuery,
+                        onCompleteIds: first.message.type === "Mutate"
+                            ? first.message.onCompleteIds
+                            : emptyArray,
+                    });
+                    if (response.message.type === "Mutate") {
+                        for (const [instanceId, instance] of instancesById) {
+                            if (instanceId === response.id)
+                                continue;
+                            instance.port.postMessage({
+                                type: "RefreshQueries",
+                            });
+                        }
                         const protocolMessagesByOwnerId = new Map();
                         for (const syncOwner of instance.usedSyncOwners.keys()) {
                             const { owner } = syncOwner;
-                            const messages = mutateResponse.messagesByOwnerId.get(owner.id);
+                            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.
@@ -298,252 +348,209 @@ const createSharedEvolu = (name) => (run) => {
                             protocolMessagesByOwnerId.set(owner.id, createProtocolMessageFromCrdtMessages(run.deps)(owner, messages));
                         }
                         sendProtocolMessagesByOwnerId(protocolMessagesByOwnerId);
-                        return ok();
-                    });
+                    }
+                    break;
                 }
-                break;
+                case "Export":
+                    instance.port.postMessage({ type: "OnExport", file: response.message.file }, [response.message.file.buffer]);
+                    break;
             }
-            case "Export":
-                port.postMessage({ type: "OnExport", file: response.message.file }, [
-                    response.message.file.buffer,
-                ]);
-                break;
-            default:
-                exhaustiveCheck(response.message);
-        }
-    };
-    const handleResponseForSharedWorker = (response) => {
-        switch (response.message.type) {
-            case "CreateSyncMessages":
-                sendProtocolMessagesByOwnerId(response.message.protocolMessagesByOwnerId);
-                break;
-            case "ApplySyncMessage":
-                if (response.message.didWriteMessages) {
-                    refreshQueries();
-                }
-                if (!response.message.result.ok) {
-                    if (response.message.result.error.type !== "AbortError") {
-                        postTabOutput({
-                            type: "OnError",
-                            error: response.message.result.error,
-                        });
+        };
+        const handleResponseForSharedWorker = (response) => {
+            switch (response.message.type) {
+                case "CreateSyncMessages":
+                    sendProtocolMessagesByOwnerId(response.message.protocolMessagesByOwnerId);
+                    break;
+                case "ApplySyncMessage":
+                    if (response.message.didWriteMessages) {
+                        for (const instance of instancesById.values()) {
+                            instance.port.postMessage({ type: "RefreshQueries" });
+                        }
                     }
-                }
-                else {
-                    switch (response.message.result.value.type) {
-                        case "Response":
-                            sendProtocolMessagesByOwnerId(new Map([
-                                [
-                                    response.message.ownerId,
-                                    response.message.result.value.message,
-                                ],
-                            ]));
-                            break;
-                        case "Broadcast":
-                        case "NoResponse":
-                            break;
-                        default:
-                            exhaustiveCheck(response.message.result.value);
+                    if (!response.message.result.ok) {
+                        if (response.message.result.error.type !== "AbortError") {
+                            deps.postConsoleEntryOrError({
+                                type: "Error",
+                                error: response.message.result.error,
+                            });
+                        }
+                    }
+                    else {
+                        switch (response.message.result.value.type) {
+                            case "Response":
+                                sendProtocolMessagesByOwnerId(new Map([
+                                    [
+                                        response.message.ownerId,
+                                        response.message.result.value.message,
+                                    ],
+                                ]));
+                                break;
+                            case "Broadcast":
+                            case "NoResponse":
+                                break;
+                        }
                     }
+                    break;
+            }
+        };
+        const sendProtocolMessagesByOwnerId = (protocolMessagesByOwnerId) => {
+            for (const [ownerId, protocolMessage] of protocolMessagesByOwnerId) {
+                for (const transport of deps.transports.getResourceKeysForClaim(ownerId)) {
+                    const webSocket = deps.transports.getResource(transport);
+                    if (!webSocket?.isOpen())
+                        continue;
+                    console.debug("sendProtocolMessage", {
+                        ownerId,
+                        url: transport.url,
+                        byteLength: protocolMessage.byteLength,
+                    });
+                    webSocket.send(protocolMessage);
                 }
-                break;
-            default:
-                exhaustiveCheck(response.message);
-        }
-    };
-    const sendProtocolMessagesByOwnerId = (protocolMessagesByOwnerId) => {
-        for (const [ownerId, protocolMessage] of protocolMessagesByOwnerId) {
-            for (const transport of transports.getResourceKeysForClaim(ownerId)) {
-                const webSocket = transports.getResource(transport);
-                if (!webSocket?.isOpen())
-                    continue;
-                console.debug("sendProtocolMessage", {
-                    ownerId,
-                    url: transport.url,
-                    byteLength: protocolMessage.byteLength,
-                });
-                webSocket.send(protocolMessage);
             }
-        }
-    };
-    const refreshQueries = () => {
-        for (const evoluInstance of evoluInstancesByPortId.values()) {
-            evoluInstance.evoluPort.postMessage({ type: "RefreshQueries" });
-        }
-    };
-    const getUsedOwnersById = (ownerIds) => {
-        const ownersById = new Map();
-        for (const evoluInstance of evoluInstancesByPortId.values()) {
-            for (const { owner } of evoluInstance.usedSyncOwners.keys()) {
-                if (!ownerIds.has(owner.id) || !("writeKey" in owner))
-                    continue;
-                ownersById.set(owner.id, owner);
+        };
+        const getUsedOwnersById = (ownerIds) => {
+            const ownersById = new Map();
+            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) => unabortable(async (run) => {
-        for (const syncOwner of evoluInstance.usedSyncOwners.keys()) {
-            while (evoluInstance.usedSyncOwners.has(syncOwner)) {
-                await run(toggleUsedSyncOwner(evoluInstance, syncOwner, "remove"));
+            return ownersById;
+        };
+        const toggleSyncOwner = (instance, syncOwner, action) => async (run) => {
+            if (action === "add") {
+                instance.usedSyncOwners.increment(syncOwner);
+                return await run(deps.transports.addClaim(syncOwner.owner.id, syncOwner.transports));
             }
-        }
-        return ok();
-    });
-    const toggleUsedSyncOwner = (evoluInstance, syncOwner, action) => unabortable(async (run) => {
-        if (action === "add") {
-            evoluInstance.usedSyncOwners.increment(syncOwner);
-            await run(transports.addClaim(syncOwner.owner.id, syncOwner.transports));
-        }
-        else {
-            evoluInstance.usedSyncOwners.decrement(syncOwner);
-            await run(transports.removeClaim(syncOwner.owner.id, syncOwner.transports));
-        }
-        return ok();
-    });
-    return ok({
-        createInstance: (nativeEvoluPort, nativeDbWorkerPort, releaseSharedEvolu) => {
-            assertNotDisposed(moved);
-            const evoluPort = createMessagePort(nativeEvoluPort);
-            const dbWorkerPort = createMessagePort(nativeDbWorkerPort);
-            const evoluPortId = createId(run.deps);
-            const evoluInstance = {
-                evoluPort,
-                dbWorkerPort,
-                releaseSharedEvolu,
-                rowsByQuery: new Map(),
-                usedSyncOwners: createRefCountByKey({
-                    lookup: ({ owner: { id } }) => id,
-                }),
-            };
-            evoluInstancesByPortId.set(evoluPortId, evoluInstance);
-            dbWorkerPort.onMessage = (message) => {
-                switch (message.type) {
-                    case "LeaderAcquired": {
-                        leaderDbWorkerPort = evoluInstance.dbWorkerPort;
-                        console.info("leaderAcquired");
-                        ensureQueueProcessing();
-                        break;
-                    }
-                    case "OnQueuedResponse": {
-                        callbacks.execute(message.callbackId, message);
-                        break;
-                    }
-                    case "OnConsoleEntry":
-                    case "OnError": {
-                        postTabOutput(message);
-                        break;
-                    }
-                    default:
-                        exhaustiveCheck(message);
-                }
-            };
-            evoluPort.onMessage = (evoluMessage) => {
-                switch (evoluMessage.type) {
-                    case "Query":
-                    case "Export": {
-                        queue.push({
-                            type: "ForEvolu",
-                            evoluPortId,
-                            message: evoluMessage,
-                        });
-                        ensureQueueProcessing();
-                        break;
-                    }
-                    case "Mutate": {
-                        // TODO: Delegate do vsech evolu instances, co to pouzivaji
-                        queue.push({
-                            type: "ForEvolu",
-                            evoluPortId,
-                            message: evoluMessage,
-                        });
-                        ensureQueueProcessing();
-                        break;
-                    }
-                    case "UseOwner": {
-                        const evoluInstance = evoluInstancesByPortId.get(evoluPortId);
-                        if (!evoluInstance)
+            else {
+                instance.usedSyncOwners.decrement(syncOwner);
+                return await run(deps.transports.removeClaim(syncOwner.owner.id, syncOwner.transports));
+            }
+        };
+        return ok({
+            addInstance: (message, onDisposed) => {
+                assertNotDisposed(disposables);
+                const instance = {
+                    id: message.id,
+                    port: deps.createMessagePort(message.evoluPort),
+                    onDisposed,
+                    rowsByQuery: new Map(),
+                    useOwnerMutex: createMutex(),
+                    usedSyncOwners: createRefCountByKey({
+                        lookup: (syncOwner) => syncOwner.owner.id,
+                    }),
+                    [Symbol.asyncDispose]: () => disposer.disposeAsync(),
+                };
+                instancesById.set(instance.id, instance);
+                const disposer = new AsyncDisposableStack();
+                disposer.defer(instance.onDisposed);
+                disposer.use(instance.usedSyncOwners);
+                disposer.use(instance.useOwnerMutex);
+                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();
+                    }));
+                });
+                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();
+                });
+                instance.port.onMessage = (message) => {
+                    switch (message.type) {
+                        case "Query":
+                        case "Export": {
+                            queue.push({ type: "ForEvolu", id: instance.id, message });
+                            runQueue();
                             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));
                         }
-                        break;
-                    }
-                    case "Dispose": {
-                        const evoluInstance = evoluInstancesByPortId.get(evoluPortId);
-                        if (!evoluInstance)
+                        case "Mutate": {
+                            // TODO: Delegate do vsech evolu instances, co to pouzivaji
+                            queue.push({ type: "ForEvolu", id: instance.id, message });
+                            runQueue();
                             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(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;
+                        }
+                        case "UseOwner": {
+                            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;
+                        }
                     }
-                    default:
-                        exhaustiveCheck(evoluMessage);
-                }
-            };
-        },
-        requestCreateSyncMessages: (ownerIds) => {
-            const ownersToSync = [...getUsedOwnersById(ownerIds).values()];
-            if (!isNonEmptyArray(ownersToSync))
-                return;
-            console.debug("requestCreateSyncMessages", {
-                ownerIds: ownersToSync.map(({ id }) => id),
-            });
-            queue.push({
-                type: "ForSharedWorker",
-                message: {
-                    type: "CreateSyncMessages",
-                    owners: ownersToSync,
-                },
-            });
-            ensureQueueProcessing();
-        },
-        requestApplySyncMessage: (ownerId, inputMessage) => {
-            const owner = getUsedOwnersById(new Set([ownerId])).get(ownerId);
-            if (!owner)
-                return;
-            console.debug("requestApplySyncMessage", {
-                ownerId,
-                byteLength: inputMessage.byteLength,
-            });
-            queue.push({
-                type: "ForSharedWorker",
-                message: {
-                    type: "ApplySyncMessage",
-                    owner,
-                    inputMessage,
-                },
-            });
-            ensureQueueProcessing();
-        },
-        [Symbol.asyncDispose]: () => moved.disposeAsync(),
-    });
+                };
+            },
+            requestCreateSyncMessages: (ownerIds) => {
+                const ownersToSync = [...getUsedOwnersById(ownerIds).values()];
+                if (!isNonEmptyArray(ownersToSync))
+                    return;
+                console.debug("requestCreateSyncMessages", {
+                    ownerIds: ownersToSync.map(({ id }) => id),
+                });
+                queue.push({
+                    type: "ForSharedWorker",
+                    message: {
+                        type: "CreateSyncMessages",
+                        owners: ownersToSync,
+                    },
+                });
+                runQueue();
+            },
+            requestApplySyncMessage: (ownerId, inputMessage) => {
+                const owner = getUsedOwnersById(new Set([ownerId])).get(ownerId);
+                if (!owner)
+                    return;
+                console.debug("requestApplySyncMessage", {
+                    ownerId,
+                    byteLength: inputMessage.byteLength,
+                });
+                queue.push({
+                    type: "ForSharedWorker",
+                    message: {
+                        type: "ApplySyncMessage",
+                        owner,
+                        inputMessage,
+                    },
+                });
+                runQueue();
+            },
+            [Symbol.asyncDispose]: () => disposables.disposeAsync(),
+        });
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
+    }
 };
 //   | (Typed<"reset"> & {
 //       readonly onCompleteId: CallbackId;
@@ -567,3 +574,10 @@ const createSharedEvolu = (name) => (run) => {
 //       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