@evolu/common 7.4.0 → 8.0.0-next.0

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

@@ -1,440 +1,510 @@
-import { pack } from "msgpackr";
-import { dedupeArray, isNonEmptyArray, isNonEmptyReadonlyArray, } from "../Array.js";
-import { assert, assertNonEmptyReadonlyArray } from "../Assert.js";
+/**
+ * Local-first platform.
+ *
+ * @module
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { emptyArray, isNonEmptyArray, mapArray, } from "../Array.js";
+import { assert, assertNonEmptyReadonlyArray, assertNotDisposed, } from "../Assert.js";
 import { createCallbacks } from "../Callbacks.js";
-import { eqArrayNumber } from "../Eq.js";
-import { exhaustiveCheck } from "../Function.js";
-import { createInstances } from "../Instances.js";
+import { createConsole } from "../Console.js";
+import { createUnknownError } from "../Error.js";
+import { exhaustiveCheck, todo } from "../Function.js";
+import { createMicrotaskBatch } from "../Microtask.js";
+import { createRefCountByKey } from "../RefCount.js";
 import { err, ok } from "../Result.js";
-import { isSqlMutation, SqliteBoolean, sqliteBooleanToBoolean, } from "../Sqlite.js";
+import { isNonEmptySet } from "../Set.js";
+import { SqliteBoolean, sqliteBooleanToBoolean } from "../Sqlite.js";
 import { createStore } from "../Store.js";
-import { createId, } from "../Type.js";
-import { defaultDbConfig } from "./Db.js";
-import { applyPatches, createSubscribedQueries, emptyRows, serializeQuery, } from "./Query.js";
-import { evoluSchemaToDbSchema, insertable, kysely, updateable, upsertable, } from "./Schema.js";
+import {} from "../Task.js";
+import { brand, createId, createIdFromString, Name, UrlSafeString, } from "../Type.js";
+import { createOwnerWebSocketTransport } from "./Owner.js";
+import { applyPatches } from "./Query.js";
+import { evoluSchemaToSqliteSchema } from "./Schema.js";
 import { DbChange } from "./Storage.js";
-import { initialSyncState } from "./Sync.js";
-const evoluInstances = createInstances();
 /**
- * Unique identifier for the current browser tab or app instance, lazily
- * initialized on first use to distinguish between multiple tabs.
- */
-let tabId = null;
-/**
- * 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>;
+ * Application name.
  *
- * const TodoCategoryId = id("TodoCategory");
- * type TodoCategoryId = InferType<typeof TodoCategoryId>;
+ * 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)}`.
  *
- * 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,
- *   },
- * };
- *
- * const evolu = createEvolu(evoluReactDeps)(Schema);
- * ```
+ * 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({ type: "AppName", value }));
+export const testAppName = /*#__PURE__*/ AppName.orThrow("AppName");
+/**
+ * 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) => (schema, config) => evoluInstances.ensure(config?.name ?? defaultDbConfig.name, () => createEvoluInstance(deps)(schema, config), (evolu) => {
-    // Hot reloading. Note that indexes are intentionally omitted.
-    evolu.ensureSchema(schema);
-});
-const createEvoluInstance = (deps) => (schema, config) => {
-    deps.console.enabled = config?.enableLogging ?? false;
-    const { indexes, reloadUrl = "/", ...partialDbConfig } = config ?? {};
-    const dbConfig = { ...defaultDbConfig, ...partialDbConfig };
-    deps.console.log("[evolu]", "createEvoluInstance", {
-        name: dbConfig.name,
-    });
-    const errorStore = createStore(null);
-    const rowsStore = createStore(new Map());
-    const { promise: appOwner, resolve: resolveAppOwner } = Promise.withResolvers();
-    if (config?.externalAppOwner) {
-        resolveAppOwner(config.externalAppOwner);
-    }
-    // TODO: Update it for the owner-api
-    const _syncStore = createStore(initialSyncState);
-    const subscribedQueries = createSubscribedQueries(rowsStore);
-    const loadingPromises = createLoadingPromises(subscribedQueries);
-    const onCompleteCallbacks = createCallbacks(deps);
-    const exportCallbacks = createCallbacks(deps);
-    const dbWorker = deps.createDbWorker(dbConfig.name);
-    const getTabId = () => {
-        tabId ??= createId(deps);
-        return tabId;
-    };
-    // 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) => {
+export const createEvoluDeps = (deps) => {
+    const { createMessageChannel, sharedWorker } = deps;
+    const console = deps.console ?? createConsole();
+    const stack = new DisposableStack();
+    stack.use(sharedWorker);
+    const evoluError = stack.use(createStore(null));
+    const tabChannel = stack.use(createMessageChannel());
+    tabChannel.port2.onMessage = (message) => {
         switch (message.type) {
-            case "onError": {
-                errorStore.set(message.error);
-                break;
-            }
-            case "onGetAppOwner": {
-                resolveAppOwner(message.appOwner);
-                break;
-            }
-            case "onQueryPatches": {
-                if (message.tabId !== getTabId())
-                    return;
-                const state = rowsStore.get();
-                const nextState = new Map([
-                    ...state,
-                    ...message.queryPatches.map(({ query, patches }) => [
-                        query,
-                        applyPatches(patches, state.get(query) ?? emptyRows),
-                    ]),
-                ]);
-                for (const { query } of message.queryPatches) {
-                    loadingPromises.resolve(query, nextState.get(query) ?? emptyRows);
-                }
-                if (deps.flushSync && message.onCompleteIds.length > 0) {
-                    deps.flushSync(() => {
-                        rowsStore.set(nextState);
-                    });
-                }
-                else {
-                    rowsStore.set(nextState);
-                }
-                for (const id of message.onCompleteIds) {
-                    onCompleteCallbacks.execute(id);
+            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;
-            }
-            case "refreshQueries": {
-                if (message.tabId && message.tabId === getTabId())
-                    return;
-                const loadingPromisesQueries = loadingPromises.getQueries();
-                loadingPromises.releaseUnsubscribedOnMutation();
-                const queries = dedupeArray([
-                    ...loadingPromisesQueries,
-                    ...subscribedQueries.get(),
-                ]);
-                if (isNonEmptyReadonlyArray(queries)) {
-                    dbWorker.postMessage({ type: "query", tabId: getTabId(), queries });
-                }
+            case "OnError":
+                evoluError.set(message.error);
+                // Keep typed errors visible in logs as operational failures.
+                console.error(message.error);
                 break;
-            }
-            case "onReset": {
-                if (message.reload) {
-                    deps.reloadApp(reloadUrl);
-                }
-                else {
-                    onCompleteCallbacks.execute(message.onCompleteId);
-                }
-                break;
-            }
-            case "onExport": {
-                exportCallbacks.execute(message.onCompleteId, message.file);
-                break;
-            }
             default:
                 exhaustiveCheck(message);
         }
-    });
-    const dbSchema = evoluSchemaToDbSchema(schema, indexes);
-    const mutationTypesCache = new Map();
-    // Lazy create mutation Types like this: `insertable(Schema.todo)`
-    const getMutationType = (table, kind) => {
-        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;
-    };
-    dbWorker.postMessage({ type: "init", config: dbConfig, dbSchema });
-    // We can't use `init` to get AppOwner because `init` runs only once per n tabs.
-    dbWorker.postMessage({ type: "getAppOwner" });
-    const loadQueryMicrotaskQueue = [];
-    const mutateMicrotaskQueue = [];
-    const useOwnerMicrotaskQueue = [];
-    const createMutation = (kind) => (table, props, options) => {
-        const result = getMutationType(table, kind).fromUnknown(props);
-        const id = kind === "insert"
-            ? createId(deps)
-            : props.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,
-                };
-                assert(DbChange.is(dbChange), `Invalid DbChange for table '${table}': Please check schema type errors.`);
-                mutateMicrotaskQueue.push([
-                    { ...dbChange, ownerId: options?.ownerId },
-                    options?.onComplete,
-                ]);
-            }
-            if (mutateMicrotaskQueue.length === 1) {
-                queueMicrotask(processMutationQueue);
-            }
-        }
-        if (result.ok)
-            return ok({ id });
-        return err(result.error);
     };
-    const processMutationQueue = () => {
-        const changes = [];
-        const onCompletes = [];
-        for (const [change, onComplete] of mutateMicrotaskQueue) {
-            if (change !== null)
-                changes.push(change);
-            if (onComplete)
-                onCompletes.push(onComplete);
-        }
-        const queueLength = mutateMicrotaskQueue.length;
-        mutateMicrotaskQueue.length = 0;
-        // 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;
-        }
-        const onCompleteIds = onCompletes.map(onCompleteCallbacks.register);
-        loadingPromises.releaseUnsubscribedOnMutation();
-        if (!isNonEmptyArray(changes))
-            return;
-        dbWorker.postMessage({
-            type: "mutate",
-            tabId: getTabId(),
-            changes,
-            onCompleteIds,
-            subscribedQueries: subscribedQueries.get(),
-        });
-    };
-    const evolu = {
-        subscribeError: errorStore.subscribe,
-        getError: errorStore.get,
-        createQuery,
-        loadQuery: (query) => {
-            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,
-                        });
-                    });
-                }
-            }
-            return promise;
-        },
-        loadQueries: (queries) => queries.map(evolu.loadQuery),
-        subscribeQuery: (query) => (listener) => {
-            // Call the listener only if the result has been changed.
-            let previousRows = null;
-            const unsubscribe = subscribedQueries.subscribe(query)(() => {
-                const rows = evolu.getQueryRows(query);
-                if (previousRows === rows)
-                    return;
-                previousRows = rows;
-                listener();
-            });
-            return () => {
-                previousRows = null;
-                unsubscribe();
-            };
-        },
-        getQueryRows: (query) => (rowsStore.get().get(query) ?? emptyRows),
-        appOwner,
-        // TODO: Update it for the owner-api
-        // subscribeSyncState: syncStore.subscribe,
-        // getSyncState: syncStore.get,
-        insert: createMutation("insert"),
-        update: createMutation("update"),
-        upsert: createMutation("upsert"),
-        resetAppOwner: (options) => {
-            const { promise, resolve } = Promise.withResolvers();
-            const onCompleteId = onCompleteCallbacks.register(resolve);
-            dbWorker.postMessage({
-                type: "reset",
-                onCompleteId,
-                reload: options?.reload ?? true,
-            });
-            return promise;
-        },
-        restoreAppOwner: (mnemonic, options) => {
-            const { promise, resolve } = Promise.withResolvers();
-            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();
-            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;
-                    const result = [];
-                    const skipIndices = new Set();
-                    for (let i = 0; i < queue.length; i++) {
-                        if (skipIndices.has(i))
-                            continue;
-                        const [currentOwner, currentUse, currentOwnerSerialized] = queue[i];
-                        // Look for opposite action with same owner
-                        for (let j = i + 1; j < queue.length; j++) {
-                            if (skipIndices.has(j))
-                                continue;
-                            const [, otherUse, otherOwnerSerialized] = queue[j];
-                            if (currentUse !== otherUse &&
-                                eqArrayNumber(currentOwnerSerialized, otherOwnerSerialized)) {
-                                // Found cancel-out pair, skip both
-                                skipIndices.add(i).add(j);
-                                break;
-                            }
-                        }
-                        if (!skipIndices.has(i)) {
-                            result.push([currentOwner, currentUse, currentOwnerSerialized]);
-                        }
-                    }
-                    for (const [owner, use] of result) {
-                        dbWorker.postMessage({ type: "useOwner", owner, use });
-                    }
-                });
-            };
-            useOwnerMicrotaskQueue.push([owner, true, pack(owner)]);
-            scheduleOwnerQueueProcessing();
-            const unuse = () => {
-                useOwnerMicrotaskQueue.push([owner, false, pack(owner)]);
-                scheduleOwnerQueueProcessing();
-            };
-            return unuse;
-        },
-        /** Disposal is not implemented yet. */
-        [Symbol.dispose]: () => {
-            throw new Error("Evolu instance disposal is not yet implemented");
-        },
+    sharedWorker.port.postMessage({
+        type: "InitTab",
+        consoleLevel: console.getLevel(),
+        port: tabChannel.port1.native,
+    }, [tabChannel.port1.native]);
+    const moved = stack.move();
+    return {
+        ...deps,
+        evoluError,
+        [Symbol.dispose]: () => moved.dispose(),
     };
-    return evolu;
-};
-export const createQuery = (queryCallback, options) => {
-    const compiledQuery = queryCallback(kysely).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,
-        parameters: compiledQuery.parameters,
-        ...(options && { options }),
-    });
 };
-const createLoadingPromises = (subscribedQueries) => {
-    const loadingPromiseMap = new Map();
-    return {
-        get: (query) => {
-            let loadingPromise = loadingPromiseMap.get(query);
-            const isNew = !loadingPromise;
-            if (!loadingPromise) {
-                const { promise, resolve } = Promise.withResolvers();
-                loadingPromise = { resolve, promise, releaseOnResolve: false };
-                loadingPromiseMap.set(query, loadingPromise);
+/**
+ * Creates an {@link Evolu} instance from {@link EvoluSchema} and
+ * {@link EvoluConfig}.
+ */
+export const createEvolu = (schema, config) => async (run) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { appName, appOwner, memoryOnly = false, transports = [{ type: "WebSocket", url: "wss://free.evoluhq.com" }], } = config;
+        const name = Name.orThrow(`${appName}-${createIdFromString(appOwner.id)}`);
+        const console = run.deps.console.child(name).child("Evolu");
+        console.info("createEvolu");
+        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        const rowsByQueryMapStore = stack.use(createStore(new Map()));
+        const subscribedQueriesRefCount = stack.use(createRefCountByKey());
+        /**
+         * 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(), (loadingPromisesByQuery) => {
+            for (const loadingPromise of loadingPromisesByQuery.values()) {
+                if (loadingPromise.promise.status === "fulfilled")
+                    continue;
+                fulfillLoadingPromise(loadingPromise, emptyArray);
             }
-            return {
-                promise: loadingPromise.promise,
-                isNew,
-            };
-        },
-        resolve: (query, rows) => {
-            const loadingPromise = loadingPromiseMap.get(query);
-            if (!loadingPromise)
-                return;
+            loadingPromisesByQuery.clear();
+        });
+        const fulfillLoadingPromise = (loadingPromise, rows) => {
+            /**
+             * 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);
             }
-            // 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
+            /** See {@link LoadingPromise.promise}. */
             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]) => {
+        };
+        /**
+         * 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 = () => {
+            for (const [query, loadingPromise] of loadingPromisesByQuery) {
+                if (subscribedQueriesRefCount.has(query))
+                    continue;
                 if (loadingPromise.promise.status === "fulfilled") {
-                    loadingPromiseMap.delete(query);
+                    loadingPromisesByQuery.delete(query);
                 }
                 else {
                     loadingPromise.releaseOnResolve = true;
                 }
+            }
+        };
+        const onMutateCompleteCallbacks = stack.use(createCallbacks(run.deps));
+        let exportDatabasePending = null;
+        stack.defer(() => {
+            exportDatabasePending?.reject({ type: "EvoluDisposedError" });
+            exportDatabasePending = null;
+        });
+        const mutateBatch = stack.use(createMicrotaskBatch((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(),
             });
-        },
-        getQueries: () => Array.from(loadingPromiseMap.keys()),
-    };
+        }));
+        const queryBatch = stack.use(createMicrotaskBatch((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 });
+        }));
+        const useOwnerBatch = stack.use(createMicrotaskBatch((actions) => postMessage({ type: "UseOwner", actions })));
+        let postMessage;
+        // Scope worker/channel wiring and keep only postMessage outside.
+        {
+            const { createDbWorker, createMessageChannel, sharedWorker } = run.deps;
+            const dbWorkerChannel = stack.use(createMessageChannel());
+            const evoluChannel = stack.use(createMessageChannel());
+            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);
+                        for (const [query, patches] of message.patchesByQuery) {
+                            nextRowsByQueryMap.set(query, applyPatches(patches, state.get(query) ?? emptyArray));
+                        }
+                        for (const query of message.patchesByQuery.keys()) {
+                            const loadingPromise = loadingPromisesByQuery.get(query);
+                            if (!loadingPromise)
+                                continue;
+                            const rows = nextRowsByQueryMap.get(query);
+                            assert(rows, "Expected patched query rows to exist.");
+                            fulfillLoadingPromise(loadingPromise, rows);
+                            /**
+                             * 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);
+                            }
+                        }
+                        if (run.deps.flushSync && message.onCompleteIds.length > 0) {
+                            run.deps.flushSync(() => {
+                                rowsByQueryMapStore.set(nextRowsByQueryMap);
+                            });
+                        }
+                        else {
+                            rowsByQueryMapStore.set(nextRowsByQueryMap);
+                        }
+                        for (const onCompleteId of message.onCompleteIds) {
+                            onMutateCompleteCallbacks.execute(onCompleteId);
+                        }
+                        break;
+                    }
+                    case "RefreshQueries": {
+                        releaseUnsubscribedLoadingPromises();
+                        const queries = new Set([
+                            ...loadingPromisesByQuery.keys(),
+                            ...subscribedQueriesRefCount.keys(),
+                        ]);
+                        if (isNonEmptySet(queries))
+                            postMessage({ type: "Query", queries });
+                        break;
+                    }
+                    case "OnExport": {
+                        assert(exportDatabasePending, "OnExport received without pending export.");
+                        exportDatabasePending.resolve(message.file);
+                        exportDatabasePending = null;
+                        break;
+                    }
+                    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" });
+            });
+        }
+        const createMutation = (kind) => (table, values, options) => {
+            assertNotDisposed(moved);
+            const { id = createId(run.deps), isDeleted, ...changeValues } = values;
+            const dbChange = {
+                table,
+                id,
+                values: changeValues,
+                isInsert: kind === "insert" || kind === "upsert",
+                isDelete: SqliteBoolean.is(isDeleted)
+                    ? sqliteBooleanToBoolean(isDeleted)
+                    : null,
+            };
+            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 loadQuery = (query) => {
+            assertNotDisposed(moved);
+            const loadingPromise = loadingPromisesByQuery.get(query);
+            if (loadingPromise) {
+                return loadingPromise.promise;
+            }
+            const { promise, resolve } = Promise.withResolvers();
+            const typedPromise = promise;
+            typedPromise.status = "pending";
+            loadingPromisesByQuery.set(query, {
+                promise: typedPromise,
+                resolve,
+                releaseOnResolve: false,
+            });
+            queryBatch.push(query);
+            return typedPromise;
+        };
+        const getQueryRows = (query) => {
+            assertNotDisposed(moved);
+            return (rowsByQueryMapStore.get().get(query) ??
+                emptyArray);
+        };
+        const useOwner = (owner, ownerTransports) => {
+            assertNotDisposed(moved);
+            const effectiveTransports = ownerTransports ?? transports;
+            assertNonEmptyReadonlyArray(effectiveTransports, "useOwner requires explicit non-empty transports when config.transports is empty.");
+            const syncOwner = {
+                owner,
+                transports: effectiveTransports,
+            };
+            useOwnerBatch.push({
+                owner: syncOwner,
+                action: "add",
+            });
+            let isUsed = true;
+            return () => {
+                assert(isUsed, "UnuseOwner can be called only once.");
+                isUsed = false;
+                useOwnerBatch.push({
+                    owner: syncOwner,
+                    action: "remove",
+                });
+            };
+        };
+        const moved = stack.move();
+        if (isNonEmptyArray(transports))
+            useOwner(appOwner);
+        return ok({
+            name,
+            appOwner,
+            insert: createMutation("insert"),
+            update: createMutation("update"),
+            upsert: createMutation("upsert"),
+            loadQuery,
+            loadQueries: (queries) => queries.map((query) => loadQuery(query)),
+            subscribeQuery: (query) => (listener) => {
+                assertNotDisposed(moved);
+                subscribedQueriesRefCount.increment(query);
+                let isSubscribed = true;
+                let previousRows = null;
+                const unsubscribe = rowsByQueryMapStore.subscribe(() => {
+                    const rows = getQueryRows(query);
+                    if (previousRows === rows)
+                        return;
+                    previousRows = rows;
+                    listener();
+                });
+                return () => {
+                    assert(isSubscribed, "subscribeQuery unsubscribe can be called only once.");
+                    isSubscribed = false;
+                    previousRows = null;
+                    unsubscribe();
+                    if (moved.disposed)
+                        return;
+                    subscribedQueriesRefCount.decrement(query);
+                };
+            },
+            getQueryRows,
+            exportDatabase: () => {
+                assertNotDisposed(moved);
+                if (!exportDatabasePending) {
+                    exportDatabasePending =
+                        Promise.withResolvers();
+                    postMessage({ type: "Export" });
+                }
+                return exportDatabasePending.promise;
+            },
+            deleteDatabase: () => {
+                assertNotDisposed(moved);
+                todo();
+            },
+            deleteOwner: (owner) => {
+                assertNotDisposed(moved);
+                void owner;
+                todo();
+            },
+            useOwner,
+            [Symbol.asyncDispose]: () => {
+                console.info("dispose");
+                return moved.disposeAsync();
+            },
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
 };
+//     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>;