@oliphaunt/wasix-ts 0.1.0

package/lib/tool-worker.d.ts

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

package/lib/tool-worker.js

@@ -0,0 +1,10 @@
+/// <reference lib="webworker" />
+import * as host from './host/index.mjs';
+import { createWasixToolWorkerDispatcher, toolWorkerResponseTransfers, } from './tool-worker-common.js';
+const scope = globalThis;
+const dispatch = createWasixToolWorkerDispatcher(host);
+scope.addEventListener('message', (event) => {
+    void dispatch(event.data).then((response) => {
+        scope.postMessage(response, toolWorkerResponseTransfers(response));
+    });
+});

package/lib/types.d.ts

@@ -0,0 +1,230 @@
+import type { CommandResult, DescribeResult, ExecResult, InferQueryRow, ParameterOptions, QueryOptions, QueryParam, QueryResult, RawQueryResult } from './query.js';
+import type { PersistentWasixStorage, WasixStorage } from './storage.js';
+type QueryReadOptions = Omit<QueryOptions, 'encoders'>;
+export type BinaryInput = ArrayBuffer | ArrayBufferView | Uint8Array | ReadonlyArray<number>;
+/** A synchronous, serial raw-protocol consumer used as the backpressure acknowledgement. */
+export type ProtocolChunkCallback = (chunk: Uint8Array) => undefined;
+/** A host-neutral asset reference accepted by the portable WASIX carrier contract. */
+export type WasixAssetSource = string | URL | ArrayBuffer | Uint8Array;
+/** One exact archive carried by the portable WASIX runtime package. */
+export type WasixRuntimeArchive = Readonly<{
+    /** Canonical path recorded by the generated runtime manifest. */
+    archive: string;
+    sha256: string;
+    size: number;
+    source: WasixAssetSource;
+}>;
+/** The canonical generated manifest carried alongside the runtime archives. */
+export type WasixRuntimeManifest = Readonly<{
+    sha256: string;
+    size: number;
+    source: WasixAssetSource;
+}>;
+/**
+ * A package-authored runtime identity. The default value comes from
+ * `@oliphaunt/liboliphaunt-wasix`; callers normally never handle it directly.
+ */
+export type WasixRuntimeDescriptor = Readonly<{
+    schema: 'oliphaunt-wasix-runtime-v2';
+    runtime: 'wasix';
+    product: 'liboliphaunt-wasix';
+    version: string;
+    runtimeArchive: WasixRuntimeArchive;
+    standardSeedArchive: WasixRuntimeArchive;
+    standardSeedManifest: WasixRuntimeManifest;
+    manifest: WasixRuntimeManifest;
+}>;
+/** Explicit optional ICU closure authored by `@oliphaunt/wasix-icu`. */
+export type WasixIcuDescriptor = Readonly<{
+    schema: 'oliphaunt-wasix-icu-v1';
+    runtime: 'wasix';
+    product: 'oliphaunt-icu';
+    version: string;
+    compatibility: Readonly<{
+        runtimeProduct: 'liboliphaunt-wasix';
+        runtimeVersion: string;
+        postgresMajor: '18';
+        physicalFormat: 'wasix-pg18-v1';
+        compatibilityKey: 'wasix-pg18-datum32-v1';
+        dataVersion: '76.1';
+        dataForm: 'files-le';
+        dataTreeSha256: string;
+    }>;
+    dataArchive: WasixRuntimeArchive;
+    clusterSeedArchive: WasixRuntimeArchive;
+    clusterSeedManifest: WasixRuntimeManifest;
+}>;
+export type WasixExtensionCarrier = Readonly<{
+    /** Owning Oliphaunt release product, not the PostgreSQL SQL name. */
+    product: string;
+    /** Oliphaunt product version; upstream provenance stays release/evidence metadata. */
+    version: string;
+    sqlName: string;
+    /** Exact canonical manifest archive key, for example `extensions/pgtap.tar.zst`. */
+    archive: string;
+    sha256: string;
+    size: number;
+    /** Portable archive URL or bytes. The same descriptor can be hosted by Node or a browser. */
+    source: WasixAssetSource;
+    /** Exact install contract owned by this independently versioned carrier. */
+    install: WasixExtensionInstall;
+}>;
+export type WasixExtensionCompatibility = Readonly<{
+    extensionRuntimeContract: 'oliphaunt-extension-runtime-contract-v1';
+    postgresMajor: string;
+    wasixRuntimeProduct: 'liboliphaunt-wasix';
+    wasixRuntimeVersion: string;
+}>;
+export type WasixExtensionInstall = Readonly<{
+    schema: 'oliphaunt-wasix-extension-install-v1';
+    name: string;
+    nativeModule: string | null;
+    nativeModules: readonly WasixExtensionNativeModule[];
+    dependencies: readonly string[];
+    coreExportsRequired: readonly string[];
+    loadOrder: readonly string[];
+    lifecycle: WasixExtensionLifecycle;
+    installedFiles: readonly string[];
+    unresolvedImports: readonly WasixExtensionImport[];
+}>;
+export type WasixExtensionImport = Readonly<{
+    module: string;
+    name: string;
+    kind: string;
+}>;
+export type WasixExtensionNativeModule = Readonly<{
+    name: string;
+    path: string;
+    sha256: string;
+    moduleSha256: string;
+    size: number;
+}>;
+export type WasixExtensionDescriptorInput = Readonly<{
+    schema: 'oliphaunt-wasix-extension-v1';
+    runtime: 'wasix';
+    /** Product and version of the root carrier selected by `sqlName`. */
+    product: string;
+    version: string;
+    /** Exact WASIX runtime identity against which this descriptor was qualified. */
+    compatibility: WasixExtensionCompatibility;
+    sqlName: string;
+    /** Root carrier plus any extension carrier dependencies required by this import. */
+    carriers: readonly WasixExtensionCarrier[];
+}>;
+/**
+ * A package-authored, runtime-validated WASIX extension import. Applications
+ * obtain these from extension packages instead of constructing SQL strings.
+ * The schema and runtime literals discriminate it structurally, so generated
+ * carrier packages do not need a dependency on this binding.
+ */
+export type WasixExtensionDescriptor = WasixExtensionDescriptorInput;
+/** Lifecycle fields owned by an independently versioned extension carrier. */
+export type WasixExtensionLifecycle = {
+    createExtension: boolean;
+    createSchema: string | null;
+    loadSql: readonly string[];
+    postCreateSql: readonly string[];
+    startupConfig: readonly string[];
+    preloadRequired: boolean;
+    restartRequired: boolean;
+    sharedMemoryRequired: boolean;
+};
+/** Host-relevant subset of the generated liboliphaunt WASIX asset manifest. */
+export type WasixAssetManifest = {
+    'format-version': 2;
+    'source-fingerprint': string;
+    runtime: {
+        archive: string;
+        sha256: string;
+        /** Present when the canonical producer records the outer archive size. */
+        size?: number;
+        'module-sha256': string;
+        'postgres-version': string;
+        link: {
+            exports: readonly {
+                name: string;
+                kind: string;
+            }[];
+        };
+    };
+    'runtime-support': readonly {
+        name: string;
+        path: string;
+        sha256: string;
+    }[];
+    'cluster-seeds': Readonly<Record<'standard' | 'icu', {
+        'artifact-role': 'cluster-seed-standard' | 'cluster-seed-icu';
+        'catalog-profile': 'standard' | 'icu';
+        archive: string;
+        manifest: string;
+        sha256: string;
+        size: number;
+        'runtime-module-sha256': string;
+        'source-fingerprint': string;
+        'postgres-version': string;
+        'physical-format': 'wasix-pg18-v1';
+        'compatibility-key': 'wasix-pg18-datum32-v1';
+        'icu-data-tree-sha256'?: string;
+    }>>;
+    /** The core runtime carrier is intentionally extension-free. */
+    extensions: readonly [];
+};
+export type OpenConfig = {
+    /** Existing PostgreSQL role selected after the fixed superuser bootstrap. */
+    username?: string;
+    database?: string;
+    /** PostgreSQL `-c name=value` settings applied before the database opens. */
+    startupGUCs?: Readonly<Record<string, string>>;
+    /** Optional ICU data plus the matching PostgreSQL ICU-catalog cluster seed. */
+    icu?: WasixIcuDescriptor;
+    /** Selectively imported WASIX carriers. SQL strings are intentionally not accepted. */
+    extensions?: readonly WasixExtensionDescriptor[];
+    /** Fresh memory by default, or an explicitly imported host storage adapter. */
+    storage?: WasixStorage;
+};
+export type OliphauntDatabase = {
+    /**
+     * True after the terminal close attempt settles, including when teardown
+     * rejects, or as soon as a package-owned isolated host terminates unexpectedly.
+     */
+    readonly closed: boolean;
+    execute(sql: string, parameters?: ReadonlyArray<QueryParam>, options?: ParameterOptions): Promise<CommandResult>;
+    query<Row = never, const Options extends QueryOptions = {}>(sql: string, parameters?: ReadonlyArray<QueryParam>, options?: Options & QueryOptions): Promise<QueryResult<InferQueryRow<Options, Row>>>;
+    queryRaw(sql: string, parameters?: ReadonlyArray<QueryParam>, options?: ParameterOptions): Promise<RawQueryResult>;
+    exec<Row = never, const Options extends QueryReadOptions = {}>(sql: string, options?: Options & QueryReadOptions): Promise<ExecResult<InferQueryRow<Options, Row>>>;
+    describe(sql: string, parameterTypeOids?: ReadonlyArray<number>): Promise<DescribeResult>;
+    execProtocolRaw(input: BinaryInput): Promise<Uint8Array>;
+    execProtocolRawStream(input: BinaryInput, onChunk: ProtocolChunkCallback): Promise<void>;
+    /** Create a session-preserving PostgreSQL online physical backup. */
+    backup(): Promise<Uint8Array>;
+    /**
+     * Own the session for one callback. Use callback return/throw or rollback()
+     * for lifecycle; manual BEGIN/START/COMMIT/END/ABORT/PREPARE TRANSACTION and
+     * AND CHAIN are unsupported. SAVEPOINT and ROLLBACK TO are allowed.
+     */
+    transaction<T>(body: (transaction: OliphauntTransaction) => Promise<T> | T): Promise<T>;
+    /**
+     * Stop admitting work and perform one terminal teardown attempt.
+     * Concurrent and later calls return the same promise. A rejection reports
+     * cleanup failure; it does not make the handle reusable. Calling from an
+     * active transaction callback rejects before teardown begins; close the
+     * database after that callback settles.
+     */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+};
+/** A database session pinned to one callback-scoped PostgreSQL transaction. */
+export type OliphauntTransaction = {
+    readonly closed: boolean;
+    execute(sql: string, parameters?: ReadonlyArray<QueryParam>, options?: ParameterOptions): Promise<CommandResult>;
+    query<Row = never, const Options extends QueryOptions = {}>(sql: string, parameters?: ReadonlyArray<QueryParam>, options?: Options & QueryOptions): Promise<QueryResult<InferQueryRow<Options, Row>>>;
+    queryRaw(sql: string, parameters?: ReadonlyArray<QueryParam>, options?: ParameterOptions): Promise<RawQueryResult>;
+    exec<Row = never, const Options extends QueryReadOptions = {}>(sql: string, options?: Options & QueryReadOptions): Promise<ExecResult<InferQueryRow<Options, Row>>>;
+    describe(sql: string, parameterTypeOids?: ReadonlyArray<number>): Promise<DescribeResult>;
+    rollback(): Promise<void>;
+};
+export type OliphauntClient = {
+    open(config?: OpenConfig): Promise<OliphauntDatabase>;
+    restore(storage: PersistentWasixStorage, bytes: BinaryInput): Promise<void>;
+};
+export {};

package/lib/types.js

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

package/lib/wasix-runtime.d.ts

@@ -0,0 +1,24 @@
+import type { WasixDirectoryMount, WasixRuntimeLayout } from './archive.js';
+import type { Directory } from './host/index.mjs';
+import type { SerializedOpenOptions } from './rpc.js';
+/** @internal Verified-module compilation cache shared by direct opens in one JS realm. */
+export declare function compileWasixModule(module: Uint8Array, sha256: string): Promise<WebAssembly.Module>;
+/** @internal Materialize the exact runtime mounts shared by both execution surfaces. */
+export declare function materializeWasixMounts(DirectoryConstructor: typeof Directory, layout: WasixRuntimeLayout, pgdata: WasixDirectoryMount | undefined, createPgdataDirectory?: (DirectoryConstructor: typeof Directory) => Promise<Directory>): Promise<{
+    mounts: Record<string, Directory>;
+    baseDirectory: Directory;
+}>;
+/** @internal Materialize runtime support mounts for frontend tools. */
+export declare function materializeWasixSupportMounts(DirectoryConstructor: typeof Directory, layout: Pick<WasixRuntimeLayout, 'mounts'>): Promise<Record<string, Directory>>;
+/** @internal PostgreSQL argv shared by both execution surfaces. */
+export declare function wasixPostgresArgs(options: SerializedOpenOptions): string[];
+/** @internal PostgreSQL environment shared by both execution surfaces. */
+export declare function wasixPostgresEnvironment(options: SerializedOpenOptions, icuEnabled?: boolean): Record<string, string>;
+/** @internal Normalize lifecycle diagnostics without discarding structured primary errors. */
+export declare function describeError(error: unknown): string;
+/** @internal Preserve a structured primary while attaching cleanup diagnostics. */
+export declare function composeLifecycleFailure(primary: Error, label: string, secondary: unknown): Error;
+/** @internal Apply caller role after the direct bridge reaches ReadyForQuery. */
+export declare function configureWasixDatabase(options: SerializedOpenOptions, exec: (input: Uint8Array) => Promise<Uint8Array>): Promise<void>;
+/** @internal Restore the configured application role after DISCARD ALL. */
+export declare function configureWasixRole(username: string, exec: (input: Uint8Array) => Promise<Uint8Array>): Promise<void>;

package/lib/wasix-runtime.js

@@ -0,0 +1,186 @@
+import { WasixStorageError } from './errors.js';
+import { simpleQuery } from './protocol.js';
+import { assertSuccessfulQueryResponse, PostgresError } from './query.js';
+import { normalizeWasixStartupGUCs } from './startup-config.js';
+let compiledModuleCache;
+/** @internal Verified-module compilation cache shared by direct opens in one JS realm. */
+export function compileWasixModule(module, sha256) {
+    if (compiledModuleCache?.sha256 !== sha256) {
+        const source = module.buffer instanceof ArrayBuffer
+            ? module
+            : Uint8Array.from(module);
+        const compiled = WebAssembly.compile(source);
+        compiledModuleCache = { sha256, module: compiled };
+        void compiled.catch(() => {
+            if (compiledModuleCache?.module === compiled) {
+                compiledModuleCache = undefined;
+            }
+        });
+    }
+    return compiledModuleCache.module;
+}
+/** @internal Materialize the exact runtime mounts shared by both execution surfaces. */
+export async function materializeWasixMounts(DirectoryConstructor, layout, pgdata, createPgdataDirectory) {
+    const mounts = await materializeMountMap(DirectoryConstructor, layout);
+    let baseDirectory;
+    if (createPgdataDirectory !== undefined) {
+        baseDirectory = await createPgdataDirectory(DirectoryConstructor);
+    }
+    else {
+        if (pgdata === undefined) {
+            throw new Error('portable WASIX storage did not provide a PGDATA mount');
+        }
+        baseDirectory = await materializeDirectory(DirectoryConstructor, pgdata);
+    }
+    mounts['/base'] = baseDirectory;
+    return { mounts, baseDirectory };
+}
+/** @internal Materialize runtime support mounts for frontend tools. */
+export function materializeWasixSupportMounts(DirectoryConstructor, layout) {
+    return materializeMountMap(DirectoryConstructor, layout);
+}
+async function materializeMountMap(DirectoryConstructor, layout) {
+    const mounts = {};
+    for (const [mountPath, contents] of Object.entries(layout.mounts)) {
+        mounts[mountPath] = await materializeDirectory(DirectoryConstructor, contents);
+    }
+    return mounts;
+}
+async function materializeDirectory(DirectoryConstructor, contents) {
+    const directory = new DirectoryConstructor(contents.files);
+    const existing = directoriesImpliedByFiles(Object.keys(contents.files));
+    const explicit = [...new Set(contents.directories)].sort(compareDirectoryDepth);
+    for (const path of explicit) {
+        if (existing.has(path)) {
+            continue;
+        }
+        await directory.createDir(path);
+        existing.add(path);
+    }
+    return directory;
+}
+function directoriesImpliedByFiles(paths) {
+    const directories = new Set();
+    for (const path of paths) {
+        const segments = path.split('/');
+        for (let index = 1; index < segments.length; index += 1) {
+            directories.add(segments.slice(0, index).join('/'));
+        }
+    }
+    return directories;
+}
+function compareDirectoryDepth(left, right) {
+    return left.split('/').length - right.split('/').length || left.localeCompare(right);
+}
+/** @internal PostgreSQL argv shared by both execution surfaces. */
+export function wasixPostgresArgs(options) {
+    const args = ['--single'];
+    if (options.storage.kind === 'memory')
+        args.push('-F');
+    args.push('-O', '-j');
+    const startupGUCs = normalizeWasixStartupGUCs(options.startupGUCs);
+    for (const [configuredName, configuredValue] of Object.entries(startupGUCs)) {
+        const managed = Object.entries(SINGLE_BACKEND_GUCS).find(([name]) => name === configuredName.toLowerCase());
+        if (managed === undefined)
+            continue;
+        const [, requiredValue] = managed;
+        if (configuredValue !== requiredValue) {
+            throw new Error(`PostgreSQL startup GUC ${JSON.stringify(configuredName)} is managed by @oliphaunt/wasix-ts and must remain ${JSON.stringify(requiredValue)}`);
+        }
+        delete startupGUCs[configuredName];
+    }
+    for (const [name, value] of Object.entries({
+        search_path: 'public',
+        log_checkpoints: 'false',
+        wal_buffers: '4MB',
+        min_wal_size: '80MB',
+        shared_buffers: '128MB',
+        ...SINGLE_BACKEND_GUCS,
+        ...startupGUCs,
+    })) {
+        args.push('-c', `${name}=${value}`);
+    }
+    // Keep a database name that begins with `-` out of PostgreSQL's option
+    // parser. PostgreSQL's bundled getopt honors this standard delimiter.
+    args.push('-D', '/base', '--', options.database);
+    return args;
+}
+const SINGLE_BACKEND_GUCS = {
+    exit_on_error: 'false',
+    max_wal_senders: '0',
+    max_worker_processes: '0',
+    max_parallel_workers: '0',
+    max_parallel_workers_per_gather: '0',
+    max_parallel_maintenance_workers: '0',
+    io_method: 'sync',
+};
+/** @internal PostgreSQL environment shared by both execution surfaces. */
+export function wasixPostgresEnvironment(options, icuEnabled = false) {
+    return {
+        PREFIX: '/',
+        PGDATA: '/base',
+        PGUSER: options.username,
+        PGDATABASE: options.database,
+        MODE: 'REACT',
+        REPL: 'N',
+        PGSYSCONFDIR: '/base',
+        PGCLIENTENCODING: 'UTF8',
+        HOME: '/home/postgres',
+        USER: options.username,
+        LOGNAME: options.username,
+        PATH: '/bin',
+        LC_CTYPE: 'C.UTF-8',
+        TZ: 'UTC',
+        PGTZ: 'UTC',
+        PG_COLOR: 'never',
+        PROJ_DATA: '/share/proj',
+        ...(icuEnabled ? { ICU_DATA: '/share/icu' } : {}),
+        // The canonical guest specializes backend atomics for a one-backend
+        // WebAssembly instance. Every host placement must enforce that invariant.
+        OLIPHAUNT_WASIX_SINGLE_BACKEND: '1',
+    };
+}
+/** @internal Normalize lifecycle diagnostics without discarding structured primary errors. */
+export function describeError(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const detailed = error.detailedMessage;
+    return typeof detailed === 'string' && detailed.length > 0 && detailed !== error.message
+        ? `${error.message}: ${detailed}`
+        : error.message;
+}
+/** @internal Preserve a structured primary while attaching cleanup diagnostics. */
+export function composeLifecycleFailure(primary, label, secondary) {
+    const message = `${primary.message}; ${label}: ${describeError(secondary)}`;
+    const cause = new AggregateError([primary, secondary], `${label} while handling ${primary.name || 'Error'}`);
+    if (primary instanceof PostgresError) {
+        const composed = new PostgresError(primary.fields.map((field) => ({ ...field })), [...primary.notices]);
+        Object.defineProperty(composed, 'cause', {
+            configurable: true,
+            value: cause,
+        });
+        return composed;
+    }
+    if (primary instanceof WasixStorageError) {
+        return new WasixStorageError(message, {
+            code: primary.code,
+            commitState: primary.commitState,
+            cause,
+        });
+    }
+    return new Error(message, { cause });
+}
+/** @internal Apply caller role after the direct bridge reaches ReadyForQuery. */
+export async function configureWasixDatabase(options, exec) {
+    // Extension selection owns files and startup configuration only. Database-
+    // local CREATE EXTENSION/LOAD/schema/migration SQL remains application-owned.
+    await configureWasixRole(options.username, exec);
+}
+/** @internal Restore the configured application role after DISCARD ALL. */
+export async function configureWasixRole(username, exec) {
+    if (username === 'postgres')
+        return;
+    const quoted = username.replaceAll('"', '""');
+    assertSuccessfulQueryResponse(await exec(simpleQuery(`SET ROLE "${quoted}"`)));
+}

package/lib/worker-client.d.ts

@@ -0,0 +1,4 @@
+import type { OliphauntClient, OliphauntDatabase, OpenConfig } from './types.js';
+/** Open PostgreSQL in a package-owned browser Worker. */
+export declare function openWasix(config?: OpenConfig): Promise<OliphauntDatabase>;
+export declare const Oliphaunt: OliphauntClient;

package/lib/worker-client.js

@@ -0,0 +1,45 @@
+import { serializeOpenConfig } from './client-common.js';
+import { openWasixWithWorker, restoreWasixWithWorker } from './worker-rpc.js';
+/** Open PostgreSQL in a package-owned browser Worker. */
+export async function openWasix(config = {}) {
+    const openOptions = serializeOpenConfig(config);
+    assertBrowserWorkerEnvironment();
+    return openWasixWithWorker(createBrowserWorker, openOptions);
+}
+async function restoreBrowserWasix(storage, bytes) {
+    assertBrowserWorkerEnvironment();
+    return restoreWasixWithWorker(createBrowserWorker, storage, bytes);
+}
+function assertBrowserWorkerEnvironment() {
+    if (globalThis.crossOriginIsolated !== true) {
+        throw new Error('@oliphaunt/wasix-ts/worker requires COOP: same-origin and COEP: require-corp response headers');
+    }
+    if (typeof Worker === 'undefined') {
+        throw new Error('@oliphaunt/wasix-ts/worker requires a browser with Web Workers');
+    }
+}
+export const Oliphaunt = {
+    open: openWasix,
+    restore: restoreBrowserWasix,
+};
+function createBrowserWorker() {
+    const worker = new Worker(new URL('./worker.js', import.meta.url), {
+        type: 'module',
+        name: 'oliphaunt-wasix',
+    });
+    return {
+        postMessage: (message, transfer) => worker.postMessage(message, [...transfer]),
+        terminate: () => worker.terminate(),
+        onMessage: (listener) => {
+            worker.addEventListener('message', (event) => listener(event.data));
+        },
+        onFatal: (listener) => {
+            worker.addEventListener('error', (event) => {
+                listener(new Error(event.message || 'Oliphaunt WASIX browser worker crashed'));
+            });
+            worker.addEventListener('messageerror', () => {
+                listener(new Error('Oliphaunt WASIX browser worker returned an unreadable message'));
+            });
+        },
+    };
+}

package/lib/worker-dispatch.d.ts

@@ -0,0 +1,11 @@
+import { type WasixDatabaseSession } from './database.js';
+import { type SerializedOpenOptions, type WorkerRequest, type WorkerResponse } from './rpc.js';
+export type WorkerResponder = (response: WorkerResponse, transfer?: readonly ArrayBuffer[]) => void;
+export type WorkerSessionOpener = (options: SerializedOpenOptions) => Promise<WasixDatabaseSession>;
+export type WorkerStorageRestorer = (storage: SerializedOpenOptions['storage'], bytes: Uint8Array) => Promise<void>;
+export type WorkerDispatcherLifecycle = Readonly<{
+    /** Called only after close has settled and its response has been posted. */
+    onQuiescentClose?(): void;
+}>;
+/** @internal One request state machine shared by browser and server worker realms. */
+export declare function createWorkerSessionDispatcher(openSession: WorkerSessionOpener, respond: WorkerResponder, restore?: WorkerStorageRestorer, lifecycle?: WorkerDispatcherLifecycle): (request: WorkerRequest) => Promise<void>;