@lix-js/sdk 0.16.0 → 0.17.0

package/dist/wasm/lix_js_sdk_bg.wasm.d.ts

@@ -1,6 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_browsercomponenthost_free: (a: number, b: number) => void;
 export const __wbg_wasmlix_free: (a: number, b: number) => void;
 export const __wbg_wasmlixtransaction_free: (a: number, b: number) => void;
 export const __wbg_wasmobserveevents_free: (a: number, b: number) => void;
@@ -9,13 +10,16 @@ export const __wbg_wasmremotelixtransaction_free: (a: number, b: number) => void
 export const __wbg_wasmremoteobserveevents_free: (a: number, b: number) => void;
 export const __wbg_wasmsnapshotexport_free: (a: number, b: number) => void;
 export const __wbg_wasmsnapshotrestore_free: (a: number, b: number) => void;
+export const browsercomponenthost_call: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const createHosted: (a: number) => number;
 export const deleteHosted: (a: number) => number;
-export const openJsStorage: (a: number, b: number, c: number, d: number, e: number) => number;
-export const openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number) => number;
-export const openMemory: (a: number, b: number, c: number, d: number) => number;
-export const openMemoryFromSnapshot: (a: number, b: number, c: number) => number;
+export const inspectJsStorageRepository: (a: number) => number;
+export const openJsStorage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+export const openJsStorageFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const openMemory: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const openMemoryFromSnapshot: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
 export const openRemote: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const parseSqlScript: (a: number, b: number, c: number, d: number) => void;
 export const wasmlix_activeAccountId: (a: number) => number;
 export const wasmlix_activeBranchId: (a: number) => number;
 export const wasmlix_beginTransaction: (a: number) => number;
@@ -24,17 +28,22 @@ export const wasmlix_createBranch: (a: number, b: number) => number;
 export const wasmlix_createHosted: (a: number, b: number) => number;
 export const wasmlix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
 export const wasmlix_executeBatch: (a: number, b: number, c: number) => number;
+export const wasmlix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
 export const wasmlix_exportSnapshot: (a: number) => number;
 export const wasmlix_importFilesystemPaths: (a: number, b: number) => number;
 export const wasmlix_mergeBranch: (a: number, b: number) => number;
 export const wasmlix_mergeBranchPreview: (a: number, b: number) => number;
 export const wasmlix_observe: (a: number, b: number, c: number, d: number) => number;
-export const wasmlix_openAnotherSession: (a: number, b: number) => number;
+export const wasmlix_openAnotherSession: (a: number, b: number, c: number) => number;
 export const wasmlix_openReport: (a: number, b: number) => void;
+export const wasmlix_recoverReplica: (a: number, b: number, c: number) => number;
+export const wasmlix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
 export const wasmlix_redo: (a: number) => number;
+export const wasmlix_replicaRecoverySources: (a: number) => number;
 export const wasmlix_setTelemetryParent: (a: number, b: number, c: number) => void;
 export const wasmlix_switchBranch: (a: number, b: number) => number;
 export const wasmlix_syncDiskToLix: (a: number) => number;
+export const wasmlix_syncHealth: (a: number) => number;
 export const wasmlix_undo: (a: number) => number;
 export const wasmlixtransaction_commit: (a: number) => number;
 export const wasmlixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -49,16 +58,21 @@ export const wasmremotelix_close: (a: number) => number;
 export const wasmremotelix_createBranch: (a: number, b: number) => number;
 export const wasmremotelix_execute: (a: number, b: number, c: number, d: number, e: number) => number;
 export const wasmremotelix_executeBatch: (a: number, b: number, c: number) => number;
+export const wasmremotelix_exportReplicaRecovery: (a: number, b: number, c: number) => number;
 export const wasmremotelix_exportSnapshot: (a: number) => number;
 export const wasmremotelix_importFilesystemPaths: (a: number, b: number) => number;
 export const wasmremotelix_mergeBranch: (a: number, b: number) => number;
 export const wasmremotelix_mergeBranchPreview: (a: number, b: number) => number;
 export const wasmremotelix_observe: (a: number, b: number, c: number, d: number) => number;
 export const wasmremotelix_openAnotherSession: (a: number, b: number) => number;
+export const wasmremotelix_recoverReplica: (a: number, b: number, c: number) => number;
+export const wasmremotelix_recoverReplicaWithServer: (a: number, b: number, c: number, d: number) => number;
 export const wasmremotelix_redo: (a: number) => number;
+export const wasmremotelix_replicaRecoverySources: (a: number) => number;
 export const wasmremotelix_setTelemetryParent: (a: number, b: number) => void;
 export const wasmremotelix_switchBranch: (a: number, b: number) => number;
 export const wasmremotelix_syncDiskToLix: (a: number) => number;
+export const wasmremotelix_syncHealth: (a: number) => number;
 export const wasmremotelix_undo: (a: number) => number;
 export const wasmremotelixtransaction_commit: (a: number) => number;
 export const wasmremotelixtransaction_execute: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -72,10 +86,10 @@ export const wasmsnapshotrestore_cancel: (a: number) => number;
 export const wasmsnapshotrestore_finish: (a: number) => number;
 export const wasmsnapshotrestore_isComplete: (a: number) => number;
 export const wasmsnapshotrestore_write: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_95597: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_95599: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_17533: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_17532: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_99617: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_99619: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_20812: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_20811: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/dist/worker/client.d.ts

@@ -1,7 +1,10 @@
+import { type HttpTransport } from "../http-transport.js";
 import type { LixBinding, LixStorageConfig } from "../binding-types.js";
 import type { LixTelemetryOptions, LixOpenProgress, LixOpenReport, LixServerOptions } from "../types.js";
-import { type WorkerConnection, type WorkerNotification, type WorkerOperation } from "./protocol.js";
-type SyncServerRuntimeOptions = LixServerOptions;
+import { type WorkerConnection, type WorkerNotification, type WorkerOperation, type WorkerSyncServerOptions } from "./protocol.js";
+type SyncServerRuntimeOptions = LixServerOptions & {
+    transport?: HttpTransport;
+};
 export declare function openLixWorker(storage: LixStorageConfig, onDisposed?: () => void, telemetry?: LixTelemetryOptions, server?: SyncServerRuntimeOptions, onProgress?: (progress: LixOpenProgress) => void, snapshot?: ReadableStream<Uint8Array>): Promise<LixWorkerClient>;
 export declare function pumpSnapshotToWorker(client: LixWorkerClient, reader: ReadableStreamDefaultReader<Uint8Array>, snapshotId: number, open: Promise<unknown>): Promise<void>;
 /** Opens the local worker transport behind the semantic Lix binding. */
@@ -18,6 +21,7 @@ export declare class BindingLease {
 export declare function workerBinding(client: LixWorkerClient, lease: BindingLease, sessionId: number): LixBinding;
 export declare class LixWorkerClient {
     private readonly connection;
+    readonly reusable: boolean;
     private nextRequestId;
     private nextSnapshotInputId;
     private readonly pending;
@@ -26,11 +30,14 @@ export declare class LixWorkerClient {
     private onDisposed?;
     private telemetry?;
     private syncServer?;
+    private scopedServers;
+    private nextTransportScope;
+    withRecoveryServer<T>(server: import("../binding-types.js").SyncServerBindingOptions, operation: (scope: number, server: WorkerSyncServerOptions) => Promise<T>): Promise<T>;
     private onProgress?;
     openReport: LixOpenReport | undefined;
     private readonly syncFetchControllers;
     private readonly syncFetchStreams;
-    constructor(connection?: WorkerConnection);
+    constructor(connection?: WorkerConnection, reusable?: boolean);
     get isDisposed(): boolean;
     allocateSnapshotInputId(): number;
     beginLease(onDisposed?: () => void, telemetry?: LixTelemetryOptions, syncServer?: SyncServerRuntimeOptions, onProgress?: (progress: LixOpenProgress) => void): void;
@@ -51,4 +58,6 @@ export declare class LixWorkerClient {
 export declare function hostedLixWorkerOperation<T>(operation: Extract<WorkerOperation, {
     kind: "hosted.create" | "hosted.delete";
 }>): Promise<T>;
+export declare function convertReplicaWorkerOperation(storage: LixStorageConfig, server: SyncServerRuntimeOptions, branchId?: string): Promise<void>;
+export declare function retryReplicaMigrationCleanupWorkerOperation(storage: LixStorageConfig, server: SyncServerRuntimeOptions): Promise<number>;
 export {};

package/dist/worker/client.js

@@ -1,4 +1,7 @@
-import { createWorkerConnection, openDirectLixBinding } from "#worker-factory";
+import { ADMISSION_PROTOCOL_EPOCH, ADMISSION_STORAGE_EPOCH } from "./shared-admission.js";
+import { observeOpenProgress, emitOpenProgress } from "../open-progress.js";
+import { fetchTransport } from "../http-transport.js";
+import { createWorkerConnection, createSharedWorkerConnection, openDirectLixBinding } from "#worker-factory";
 import { ownedSnapshotRestoreChunks } from "../snapshot-restore.js";
 import { deserializeWorkerError, serializeWorkerError, } from "./protocol.js";
 const MAX_IDLE_WORKERS = 1;
@@ -6,7 +9,12 @@ const MAX_IDLE_WORKERS = 1;
 // survives close(). Concurrent opens still receive isolated workers.
 const idleWorkers = [];
 export async function openLixWorker(storage, onDisposed, telemetry, server, onProgress, snapshot) {
-    let client = idleWorkers.pop();
+    const providerOptions = storage.kind === "jsStorage" ? storage.options : undefined;
+    const sharedKey = !snapshot && server && providerOptions && typeof providerOptions === "object"
+        && "sharedEngineKey" in providerOptions && typeof providerOptions.sharedEngineKey === "string"
+        && providerOptions.sharedEngineKey.startsWith("lix:opfs:") ? providerOptions.sharedEngineKey : undefined;
+    const sharedConnection = sharedKey ? createSharedWorkerConnection(`${sharedKey}:protocol-${ADMISSION_PROTOCOL_EPOCH}:storage-${ADMISSION_STORAGE_EPOCH}`) : undefined;
+    let client = sharedConnection ? new LixWorkerClient(sharedConnection, false) : idleWorkers.pop();
     while (client?.isDisposed)
         client = idleWorkers.pop();
     client ??= new LixWorkerClient();
@@ -104,6 +112,20 @@ export async function pumpSnapshotToWorker(client, reader, snapshotId, open) {
 }
 /** Opens the local worker transport behind the semantic Lix binding. */
 export async function openLixWorkerBinding(storage, onDisposed, telemetry, server, onProgress, snapshot) {
+    const progress = observeOpenProgress(onProgress);
+    const routed = server && onProgress ? { ...server,
+        transport: progress.transport(server.transport ?? fetchTransport(server.fetch)),
+    } : server;
+    try {
+        const binding = await openLixWorkerBindingInner(storage, onDisposed, telemetry, routed, onProgress ? value => emitOpenProgress(onProgress, value) : undefined, snapshot);
+        progress.complete();
+        return binding;
+    }
+    finally {
+        progress.stop();
+    }
+}
+async function openLixWorkerBindingInner(storage, onDisposed, telemetry, server, onProgress, snapshot) {
     if (openDirectLixBinding) {
         const telemetryDispatch = telemetry
             ? (span) => {
@@ -274,6 +296,11 @@ export function workerBinding(client, lease, sessionId) {
             });
             return workerTransactionBinding(request, transactionId);
         },
+        replicaRecoverySources: () => request({ kind: "replicaRecoverySources" }),
+        exportReplicaRecovery: (id) => request({ kind: "exportReplicaRecovery", id }),
+        recoverReplica: (id) => request({ kind: "recoverReplica", id }),
+        recoverReplicaWithServer: (id, server) => client.withRecoveryServer(server, (transportScope, serialized) => request({ kind: "recoverReplicaWithServer", id, server: serialized, transportScope })),
+        syncHealth: () => request({ kind: "syncHealth" }),
         activeBranchId: () => request({ kind: "activeBranchId" }),
         activeAccountId: () => request({ kind: "activeAccountId" }),
         createBranch: (options) => request({ kind: "createBranch", options }),
@@ -350,7 +377,7 @@ function workerObserveBinding(request, notify, observeId) {
 }
 async function releaseWorker(client) {
     client.endLease();
-    if (!client.isDisposed && idleWorkers.length < MAX_IDLE_WORKERS) {
+    if (client.reusable && !client.isDisposed && idleWorkers.length < MAX_IDLE_WORKERS) {
         idleWorkers.push(client);
         return;
     }
@@ -358,6 +385,7 @@ async function releaseWorker(client) {
 }
 export class LixWorkerClient {
     connection;
+    reusable;
     nextRequestId = 1;
     nextSnapshotInputId = 1;
     pending = new Map();
@@ -366,12 +394,26 @@ export class LixWorkerClient {
     onDisposed;
     telemetry;
     syncServer;
+    scopedServers = new Map();
+    nextTransportScope = 1;
+    async withRecoveryServer(server, operation) {
+        const scope = this.nextTransportScope++;
+        const runtime = { url: server.url, headers: server.headerProvider ?? server.headers, transport: server.transport };
+        this.scopedServers.set(scope, runtime);
+        try {
+            return await operation(scope, serializeSyncServer(runtime));
+        }
+        finally {
+            this.scopedServers.delete(scope);
+        }
+    }
     onProgress;
     openReport;
     syncFetchControllers = new Map();
     syncFetchStreams = new Map();
-    constructor(connection = createWorkerConnection()) {
+    constructor(connection = createWorkerConnection(), reusable = true) {
         this.connection = connection;
+        this.reusable = reusable;
         connection.onMessage((message) => this.handleMessage(message));
         connection.onFatal((error) => this.handleFatal(error));
     }
@@ -494,10 +536,10 @@ export class LixWorkerClient {
                 }
                 break;
             case "sync.headers":
-                void this.resolveSyncHeaders(message.requestId);
+                void this.resolveSyncHeaders(message.requestId, message.transportScope);
                 break;
             case "sync.fetch":
-                void this.resolveSyncFetch(message.requestId, message.request);
+                void this.resolveSyncFetch(message.requestId, message.request, message.transportScope);
                 break;
             case "sync.fetch.stream.pull":
                 void this.resolveSyncFetchStreamPull(message.requestId);
@@ -507,9 +549,11 @@ export class LixWorkerClient {
                 break;
         }
     }
-    async resolveSyncHeaders(requestId) {
+    async resolveSyncHeaders(requestId, transportScope) {
         try {
-            const source = this.syncServer?.headers;
+            if (transportScope !== undefined && !this.scopedServers.has(transportScope))
+                throw workerClosedError();
+            const source = (transportScope === undefined ? this.syncServer : this.scopedServers.get(transportScope))?.headers;
             const headers = typeof source === "function" ? await source() : source;
             this.notify({
                 kind: "sync.headers.result",
@@ -525,38 +569,33 @@ export class LixWorkerClient {
             });
         }
     }
-    async resolveSyncFetch(requestId, request) {
-        const fetcher = this.syncServer?.fetch;
-        if (!fetcher) {
-            this.notify({
-                kind: "sync.fetch.result",
-                requestId,
-                result: {
-                    ok: false,
-                    error: serializeWorkerError(new Error("Sync fetch bridge is unavailable")),
-                },
-            });
+    async resolveSyncFetch(requestId, request, transportScope) {
+        const server = transportScope === undefined ? this.syncServer : this.scopedServers.get(transportScope);
+        if (!server) {
+            this.notify({ kind: "sync.fetch.result", requestId, result: { ok: false, error: serializeWorkerError(workerClosedError()) } });
             return;
         }
+        const transport = server.transport ?? fetchTransport(server.fetch);
         const controller = new AbortController();
         this.syncFetchControllers.set(requestId, controller);
         let retainedStream = false;
         try {
-            const response = await fetcher(request.url, {
-                method: request.method,
-                headers: request.headers,
-                body: typeof request.body === "string"
-                    ? request.body
-                    : request.body?.slice().buffer,
-                credentials: request.credentials,
-                signal: controller.signal,
-            });
+            const response = await transport({ url: request.url, response: request.response, init: {
+                    method: request.method,
+                    headers: request.headers,
+                    body: typeof request.body === "string"
+                        ? request.body
+                        : request.body?.slice().buffer,
+                    credentials: request.credentials,
+                    signal: controller.signal,
+                    cache: request.cache, redirect: request.redirect,
+                } });
             if (this.syncFetchControllers.get(requestId) !== controller ||
                 controller.signal.aborted) {
                 await response.body?.cancel().catch(() => undefined);
                 return;
             }
-            if (request.responseMode === "stream") {
+            if (request.response.mode === "streaming") {
                 this.syncFetchStreams.set(requestId, response.body?.getReader());
                 retainedStream = true;
                 this.notify({
@@ -574,7 +613,7 @@ export class LixWorkerClient {
                 });
                 return;
             }
-            const body = await readSyncResponseBody(response, request.responseLimit, controller);
+            const body = new Uint8Array(await response.arrayBuffer());
             this.notify({
                 kind: "sync.fetch.result",
                 requestId,
@@ -590,6 +629,8 @@ export class LixWorkerClient {
             });
         }
         catch (error) {
+            if (isSyncResponseTooLarge(error))
+                controller.abort(error);
             if (!controller.signal.aborted || isSyncResponseTooLarge(error)) {
                 this.notify({
                     kind: "sync.fetch.result",
@@ -671,58 +712,10 @@ export class LixWorkerClient {
         this.connection.unref();
     }
 }
-async function readSyncResponseBody(response, limit, controller) {
-    if (!Number.isSafeInteger(limit) || limit <= 0) {
-        throw new TypeError("Browser sync fetch has no valid response limit");
-    }
-    const declaredLength = Number(response.headers.get("content-length"));
-    if (Number.isFinite(declaredLength) && declaredLength > limit) {
-        const error = syncResponseTooLarge(limit);
-        controller.abort(error);
-        throw error;
-    }
-    const stream = response.body;
-    if (!stream)
-        return new Uint8Array();
-    const reader = stream.getReader();
-    const chunks = [];
-    let total = 0;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            total += value.byteLength;
-            if (total > limit) {
-                const error = syncResponseTooLarge(limit);
-                controller.abort(error);
-                await reader.cancel(error).catch(() => undefined);
-                throw error;
-            }
-            chunks.push(value);
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    const body = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        body.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return body;
-}
-function syncResponseTooLarge(limit) {
-    const error = new Error(`sync fetch response exceeds ${limit} bytes`);
-    error.name = "LixError";
-    error.code = "LIX_ERROR_SYNC_RESPONSE_TOO_LARGE";
-    return error;
-}
 function isSyncResponseTooLarge(error) {
     return (error instanceof Error &&
         error.code ===
-            "LIX_ERROR_SYNC_RESPONSE_TOO_LARGE");
+            "LIX_TRANSPORT_RESPONSE_LIMIT");
 }
 function workerClosedError() {
     const error = new Error("Lix worker is closed");
@@ -739,7 +732,6 @@ function serializeSyncServer(server) {
             ? undefined
             : headerEntries(server.headers),
         dynamicHeaders: typeof server.headers === "function",
-        customFetch: server.fetch !== undefined,
     };
 }
 function headerEntries(headers) {
@@ -755,7 +747,7 @@ async function resolveDirectSyncServer(server) {
     return {
         url: new URL(server.url).toString(),
         headers: headerEntries(headers),
-        fetch: server.fetch,
+        transport: server.transport ?? (server.fetch ? fetchTransport(server.fetch) : undefined),
     };
 }
 export async function hostedLixWorkerOperation(operation) {
@@ -768,3 +760,28 @@ export async function hostedLixWorkerOperation(operation) {
         await client.terminate();
     }
 }
+export async function convertReplicaWorkerOperation(storage, server, branchId) {
+    const providerOptions = storage.kind === "jsStorage" ? storage.options : undefined;
+    const sharedKey = providerOptions && typeof providerOptions === "object"
+        && "sharedEngineKey" in providerOptions && typeof providerOptions.sharedEngineKey === "string"
+        && providerOptions.sharedEngineKey.startsWith("lix:opfs:") ? providerOptions.sharedEngineKey : undefined;
+    const connection = sharedKey ? createSharedWorkerConnection(`${sharedKey}:protocol-${ADMISSION_PROTOCOL_EPOCH}:storage-${ADMISSION_STORAGE_EPOCH}`) : undefined;
+    const client = connection ? new LixWorkerClient(connection, false) : new LixWorkerClient();
+    client.beginLease(undefined, undefined, server);
+    try {
+        await client.request({ kind: "replica.convert", storage, server: serializeSyncServer(server), branchId }, 0);
+    }
+    finally {
+        await client.terminate();
+    }
+}
+export async function retryReplicaMigrationCleanupWorkerOperation(storage, server) {
+    const client = new LixWorkerClient();
+    client.beginLease(undefined, undefined, server);
+    try {
+        return await client.request({ kind: "replica.cleanup", storage, server: serializeSyncServer(server) }, 0);
+    }
+    finally {
+        await client.terminate();
+    }
+}

package/dist/worker/durable-local-admission.d.ts

@@ -0,0 +1,20 @@
+import { type AdmissionIdentity } from "./shared-admission.js";
+export interface DurableLocalAdmissionStore {
+    get(key: string): Promise<unknown>;
+    put(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/** Durable local routing evidence only. Never grants or restores a remote lease. */
+export declare class DurableLocalAdmission {
+    private readonly scope;
+    private readonly store;
+    private readonly url;
+    private readonly repositoryId;
+    constructor(scope: string, url: string, store?: DurableLocalAdmissionStore);
+    private key;
+    private validIdentity;
+    read(headers: [string, string][]): Promise<AdmissionIdentity | undefined>;
+    /** Call only after actual storage/account validation, never after metadata admission alone. */
+    record(headers: [string, string][], identity: AdmissionIdentity): Promise<void>;
+    remove(headers: [string, string][]): Promise<void>;
+}

package/dist/worker/durable-local-admission.js

@@ -0,0 +1,87 @@
+import { ADMISSION_PROTOCOL_EPOCH, ADMISSION_STORAGE_EPOCH } from "./shared-admission.js";
+const anonymous = "00000000-0000-7000-8000-000000000002";
+const databaseName = "lix-local-admission-v1";
+const storeName = "proofs";
+/** Each operation closes its connection and resolves only after transaction commit. */
+class IndexedDbProofStore {
+    async operation(key, mode, value) {
+        const db = await new Promise((resolve, reject) => {
+            const request = indexedDB.open(databaseName, 1);
+            request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+        try {
+            return await new Promise((resolve, reject) => {
+                const transaction = db.transaction(storeName, mode === "get" ? "readonly" : "readwrite");
+                const store = transaction.objectStore(storeName);
+                const request = mode === "get" ? store.get(key) : mode === "put" ? store.put(value, key) : store.delete(key);
+                transaction.oncomplete = () => resolve(request.result);
+                transaction.onabort = () => reject(transaction.error ?? new Error("Local admission transaction aborted"));
+                transaction.onerror = () => reject(transaction.error ?? new Error("Local admission transaction failed"));
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    get(key) { return this.operation(key, "get"); }
+    async put(key, value) { await this.operation(key, "put", value); }
+    async delete(key) { await this.operation(key, "delete"); }
+}
+/** Durable local routing evidence only. Never grants or restores a remote lease. */
+export class DurableLocalAdmission {
+    scope;
+    store;
+    url;
+    repositoryId;
+    constructor(scope, url, store = new IndexedDbProofStore()) {
+        this.scope = scope;
+        this.store = store;
+        const parsed = new URL(url);
+        const id = parsed.pathname.match(/^\/lix\/([0-9a-f-]{36})\/?$/i)?.[1];
+        if (!scope || scope.length > 4096 || !id || !["https:", "http:"].includes(parsed.protocol) || parsed.search || parsed.hash || parsed.username || parsed.password) {
+            throw new Error("Invalid durable local admission scope");
+        }
+        parsed.pathname = `/lix/${id}`;
+        this.url = parsed.toString();
+        this.repositoryId = id;
+    }
+    async key(headers) {
+        const entries = [];
+        new Headers(headers).forEach((value, name) => entries.push([name, value]));
+        const bytes = new TextEncoder().encode(JSON.stringify([1, this.scope, this.url, entries, ADMISSION_PROTOCOL_EPOCH, ADMISSION_STORAGE_EPOCH]));
+        const digest = await crypto.subtle.digest("SHA-256", bytes);
+        return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, "0")).join("");
+    }
+    validIdentity(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const v = value;
+        return Object.keys(v).sort().join(",") === "principalId,protocolEpoch,repositoryId,storageEpoch" &&
+            v.repositoryId === this.repositoryId && typeof v.principalId === "string" && /^[\x21-\x7e]{1,255}$/.test(v.principalId) &&
+            v.protocolEpoch === ADMISSION_PROTOCOL_EPOCH && v.storageEpoch === ADMISSION_STORAGE_EPOCH;
+    }
+    async read(headers) {
+        const key = await this.key(headers);
+        const value = await this.store.get(key);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        const record = value;
+        if (Object.keys(record).sort().join(",") !== "identity,key,schemaVersion" || record.schemaVersion !== 1 || record.key !== key || !this.validIdentity(record.identity))
+            return undefined;
+        if (!new Headers(headers).get("authorization") && record.identity.principalId !== anonymous)
+            return undefined;
+        return { ...record.identity };
+    }
+    /** Call only after actual storage/account validation, never after metadata admission alone. */
+    async record(headers, identity) {
+        if (!this.validIdentity(identity))
+            throw new Error("Invalid durable local admission identity");
+        if (!new Headers(headers).get("authorization") && identity.principalId !== anonymous)
+            return;
+        const key = await this.key(headers);
+        await this.store.put(key, { schemaVersion: 1, key, identity: { ...identity } });
+    }
+    async remove(headers) { await this.store.delete(await this.key(headers)); }
+}

package/dist/worker/entry.shared.browser.d.ts

@@ -0,0 +1 @@
+export {};