@oliphaunt/wasix-ts 0.1.0

package/lib/rpc.d.ts

@@ -0,0 +1,203 @@
+import type { WasixPersistenceMode, WasixProtocolConnectionMode, WasixProtocolStreamOutcome } from './database.js';
+import { WasixStorageError } from './errors.js';
+import { type PostgresErrorField } from './query.js';
+import type { SerializedWasixStorage } from './storage.js';
+import type { WasixStorageSyncBoundary } from './storage-provider.js';
+import type { WasixProtocolConnection } from './pgwire-connection.js';
+import type { WasixToolDescriptor, WasixToolProcessOptions, WasixToolProcessResult } from './tool-runtime.js';
+export type SerializedAssetSource = string | Uint8Array;
+export type SerializedExtensionCarrier = {
+    product: string;
+    version: string;
+    sqlName: string;
+    archive: string;
+    sha256: string;
+    size: number;
+    source: SerializedAssetSource;
+    compatibility: {
+        extensionRuntimeContract: string;
+        postgresMajor: string;
+        wasixRuntimeProduct: 'liboliphaunt-wasix';
+        wasixRuntimeVersion: string;
+    };
+    install: {
+        schema: 'oliphaunt-wasix-extension-install-v1';
+        name: string;
+        nativeModule: string | null;
+        nativeModules: {
+            name: string;
+            path: string;
+            sha256: string;
+            moduleSha256: string;
+            size: number;
+        }[];
+        dependencies: string[];
+        coreExportsRequired: string[];
+        loadOrder: string[];
+        lifecycle: {
+            createExtension: boolean;
+            createSchema?: string | null;
+            loadSql: string[];
+            postCreateSql: string[];
+            startupConfig: string[];
+            preloadRequired: boolean;
+            restartRequired: boolean;
+            sharedMemoryRequired: boolean;
+        };
+        installedFiles: string[];
+        unresolvedImports: {
+            module: string;
+            name: string;
+            kind: string;
+        }[];
+    };
+};
+export type SerializedRuntimeArchive = {
+    archive: string;
+    sha256: string;
+    size: number;
+    source: SerializedAssetSource;
+};
+export type SerializedRuntimeDescriptor = {
+    schema: 'oliphaunt-wasix-runtime-v2';
+    runtime: 'wasix';
+    product: 'liboliphaunt-wasix';
+    version: string;
+    runtimeArchive: SerializedRuntimeArchive;
+    standardSeedArchive: SerializedRuntimeArchive;
+    standardSeedManifest: {
+        sha256: string;
+        size: number;
+        source: SerializedAssetSource;
+    };
+    manifest: {
+        sha256: string;
+        size: number;
+        source: SerializedAssetSource;
+    };
+};
+/** Runtime subset required by PostgreSQL frontend tools. */
+export type SerializedToolRuntimeDescriptor = Pick<SerializedRuntimeDescriptor, 'product' | 'version' | 'runtimeArchive' | 'manifest'>;
+export type SerializedIcuDescriptor = {
+    schema: 'oliphaunt-wasix-icu-v1';
+    runtime: 'wasix';
+    product: 'oliphaunt-icu';
+    version: string;
+    compatibility: {
+        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: SerializedRuntimeArchive;
+    clusterSeedArchive: SerializedRuntimeArchive;
+    clusterSeedManifest: {
+        sha256: string;
+        size: number;
+        source: SerializedAssetSource;
+    };
+};
+/** Host-ready open options shared by both public execution surfaces. */
+export type SerializedOpenOptions = {
+    runtime: SerializedRuntimeDescriptor;
+    icu?: SerializedIcuDescriptor;
+    /** Exact imported carrier closure, keyed by PostgreSQL SQL name. */
+    extensionCarriers: Record<string, SerializedExtensionCarrier>;
+    extensions: string[];
+    username: string;
+    database: string;
+    startupGUCs: Record<string, string>;
+    storage: SerializedWasixStorage;
+};
+export type WorkerRequest = {
+    id: number;
+    method: 'open';
+    options: SerializedOpenOptions;
+} | {
+    id: number;
+    method: 'restore';
+    storage: SerializedWasixStorage;
+    bytes: Uint8Array;
+} | {
+    id: number;
+    method: 'exec';
+    input: Uint8Array;
+    persistence: WasixPersistenceMode;
+} | {
+    id: number;
+    method: 'execStream';
+    input: Uint8Array;
+    persistence: WasixPersistenceMode;
+    control: SharedArrayBuffer;
+} | {
+    id: number;
+    method: 'sync';
+    boundary: WasixStorageSyncBoundary;
+} | {
+    id: number;
+    method: 'backup';
+} | {
+    id: number;
+    method: 'runPgDump';
+    tool: WasixToolDescriptor;
+    args: string[];
+} | {
+    id: number;
+    method: 'runTool';
+    options: WasixToolProcessOptions;
+} | {
+    id: number;
+    method: 'serve';
+    connection: WasixProtocolConnection;
+    mode: WasixProtocolConnectionMode;
+} | {
+    id: number;
+    method: 'close';
+};
+export type SerializedWorkerError = {
+    name: 'WasixStorageError';
+    message: string;
+    code: WasixStorageError['code'];
+    commitState: WasixStorageError['commitState'];
+    phase?: NonNullable<WasixStorageError['phase']>;
+} | {
+    name: 'OliphauntWasixToolError';
+    message: string;
+    code: 'tool-error';
+    tool: string;
+    exitCode: number | null;
+    stdout: Uint8Array;
+    stderr: Uint8Array;
+} | {
+    name: 'PostgresError';
+    fields: PostgresErrorField[];
+} | {
+    name: 'Error';
+    message: string;
+    errorName?: string;
+    stack?: string;
+};
+export type WorkerResponse = {
+    id: number;
+    kind: 'chunk';
+    sequence: number;
+    value: Uint8Array;
+} | {
+    id: number;
+    ok: true;
+    streamOutcome: WasixProtocolStreamOutcome;
+} | {
+    id: number;
+    ok: true;
+    value?: Uint8Array | WasixToolProcessResult;
+} | {
+    id: number;
+    ok: false;
+    error: SerializedWorkerError;
+};
+export declare function serializeWorkerError(error: unknown): SerializedWorkerError;
+export declare function deserializeWorkerError(error: SerializedWorkerError): Error;

package/lib/rpc.js

@@ -0,0 +1,84 @@
+import { WasixStorageError } from './errors.js';
+import { PostgresError } from './query.js';
+export function serializeWorkerError(error) {
+    if (error instanceof WasixStorageError) {
+        return {
+            name: 'WasixStorageError',
+            message: error.message,
+            code: error.code,
+            commitState: error.commitState,
+            ...(error.phase === undefined ? {} : { phase: error.phase }),
+        };
+    }
+    if (error instanceof PostgresError) {
+        return {
+            name: 'PostgresError',
+            fields: error.fields.map((field) => ({ ...field })),
+        };
+    }
+    const nativeTool = nativeToolError(error);
+    if (nativeTool !== undefined) {
+        return {
+            name: 'OliphauntWasixToolError',
+            message: nativeTool.message,
+            code: 'tool-error',
+            tool: nativeTool.tool,
+            exitCode: nativeTool.exitCode,
+            stdout: nativeTool.stdout.slice(),
+            stderr: nativeTool.stderr.slice(),
+        };
+    }
+    const generic = {
+        name: 'Error',
+        message: error instanceof Error ? error.message : String(error),
+        ...(error instanceof Error && error.name !== 'Error' ? { errorName: error.name } : {}),
+        ...(error instanceof Error && error.stack !== undefined ? { stack: error.stack } : {}),
+    };
+    return generic;
+}
+export function deserializeWorkerError(error) {
+    if (error.name === 'WasixStorageError') {
+        return new WasixStorageError(error.message, {
+            code: error.code,
+            commitState: error.commitState,
+            ...(error.phase === undefined ? {} : { phase: error.phase }),
+        });
+    }
+    if (error.name === 'PostgresError') {
+        return new PostgresError(error.fields);
+    }
+    if (error.name === 'OliphauntWasixToolError') {
+        const restored = new Error(error.message);
+        restored.name = error.name;
+        return Object.assign(restored, {
+            oliphauntWasixError: 'tool',
+            oliphauntWasixAddonAbi: 1,
+            code: error.code,
+            tool: error.tool,
+            exitCode: error.exitCode,
+            stdout: error.stdout.slice(),
+            stderr: error.stderr.slice(),
+        });
+    }
+    const restored = new Error(error.message);
+    restored.name = error.errorName ?? 'Error';
+    if (error.stack !== undefined)
+        restored.stack = error.stack;
+    return restored;
+}
+function nativeToolError(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const candidate = error;
+    if (candidate.oliphauntWasixError !== 'tool' ||
+        candidate.oliphauntWasixAddonAbi !== 1 ||
+        candidate.code !== 'tool-error' ||
+        typeof candidate.message !== 'string' ||
+        typeof candidate.tool !== 'string' ||
+        (candidate.exitCode !== null && !Number.isSafeInteger(candidate.exitCode)) ||
+        !(candidate.stdout instanceof Uint8Array) ||
+        !(candidate.stderr instanceof Uint8Array)) {
+        return undefined;
+    }
+    return candidate;
+}

package/lib/runtime-descriptor.d.ts

@@ -0,0 +1,3 @@
+import type { SerializedRuntimeDescriptor } from './rpc.js';
+/** Validate an imported runtime carrier before any bytes cross the worker boundary. */
+export declare function serializeWasixRuntimeDescriptor(value: unknown): SerializedRuntimeDescriptor;

package/lib/runtime-descriptor.js

@@ -0,0 +1,79 @@
+import { requireAssetSource, requireExactObject, requireSafeRelativeAssetPath, requireSha256, requireSize, requireVersion, serializeAssetSource, } from './descriptor-validation.js';
+const DESCRIPTOR_FIELDS = [
+    'manifest',
+    'product',
+    'runtime',
+    'runtimeArchive',
+    'schema',
+    'standardSeedArchive',
+    'standardSeedManifest',
+    'version',
+];
+const ARCHIVE_FIELDS = ['archive', 'sha256', 'size', 'source'];
+const MANIFEST_FIELDS = ['sha256', 'size', 'source'];
+/** Validate an imported runtime carrier before any bytes cross the worker boundary. */
+export function serializeWasixRuntimeDescriptor(value) {
+    validateRuntimeDescriptor(value, 'WASIX runtime descriptor');
+    return {
+        schema: value.schema,
+        runtime: value.runtime,
+        product: value.product,
+        version: value.version,
+        runtimeArchive: serializeArchive(value.runtimeArchive),
+        standardSeedArchive: serializeArchive(value.standardSeedArchive),
+        standardSeedManifest: serializeManifest(value.standardSeedManifest),
+        manifest: {
+            sha256: value.manifest.sha256,
+            size: value.manifest.size,
+            source: serializeAssetSource(value.manifest.source),
+        },
+    };
+}
+function validateRuntimeDescriptor(value, label) {
+    const descriptor = requireExactObject(value, DESCRIPTOR_FIELDS, label);
+    if (descriptor.schema !== 'oliphaunt-wasix-runtime-v2') {
+        throw new Error(`${label} has unsupported schema`);
+    }
+    if (descriptor.runtime !== 'wasix') {
+        throw new Error(`${label} must target runtime 'wasix'`);
+    }
+    if (descriptor.product !== 'liboliphaunt-wasix') {
+        throw new Error(`${label} product must be 'liboliphaunt-wasix'`);
+    }
+    requireVersion(descriptor.version, `${label} version`);
+    validateArchive(descriptor.runtimeArchive, `${label} runtime archive`);
+    validateArchive(descriptor.standardSeedArchive, `${label} standard cluster seed archive`);
+    validateManifest(descriptor.standardSeedManifest, `${label} standard cluster seed manifest`);
+    validateManifest(descriptor.manifest, `${label} manifest`);
+    if (descriptor.runtimeArchive.archive === descriptor.standardSeedArchive.archive) {
+        throw new Error(`${label} runtime and standard cluster seed archives must have distinct paths`);
+    }
+}
+function validateArchive(value, label) {
+    const archive = requireExactObject(value, ARCHIVE_FIELDS, label);
+    requireSafeRelativeAssetPath(archive.archive, `${label} path`);
+    requireSha256(archive.sha256, `${label} SHA-256`);
+    const size = requireSize(archive.size, `${label} size`);
+    requireAssetSource(archive.source, `${label} source`, size);
+}
+function validateManifest(value, label) {
+    const manifest = requireExactObject(value, MANIFEST_FIELDS, label);
+    requireSha256(manifest.sha256, `${label} SHA-256`);
+    const size = requireSize(manifest.size, `${label} size`);
+    requireAssetSource(manifest.source, `${label} source`, size);
+}
+function serializeArchive(archive) {
+    return {
+        archive: archive.archive,
+        sha256: archive.sha256,
+        size: archive.size,
+        source: serializeAssetSource(archive.source),
+    };
+}
+function serializeManifest(manifest) {
+    return {
+        sha256: manifest.sha256,
+        size: manifest.size,
+        source: serializeAssetSource(manifest.source),
+    };
+}

package/lib/server.node.d.ts

@@ -0,0 +1 @@
+export { type OliphauntServer, openServer, type ServerListen, type ServerOpenConfig, } from './native-server.js';

package/lib/server.node.js

@@ -0,0 +1 @@
+export { openServer, } from './native-server.js';

package/lib/startup-config.d.ts

@@ -0,0 +1,2 @@
+/** @internal Canonicalize PostgreSQL's case-insensitive startup-GUC namespace. */
+export declare function normalizeWasixStartupGUCs(gucs: Readonly<Record<string, string>>): Record<string, string>;

package/lib/startup-config.js

@@ -0,0 +1,19 @@
+const STORAGE_OWNED_GUCS = new Set(['config_file', 'data_directory']);
+/** @internal Canonicalize PostgreSQL's case-insensitive startup-GUC namespace. */
+export function normalizeWasixStartupGUCs(gucs) {
+    const normalized = {};
+    for (const [providedName, value] of Object.entries(gucs)) {
+        const name = providedName.trim().toLowerCase();
+        if (!/^[a-z_][a-z0-9_$]*(?:\.[a-z_][a-z0-9_$]*)*$/u.test(name)) {
+            throw new Error(`PostgreSQL startup GUC name ${JSON.stringify(providedName)} must use dot-separated components that start with an ASCII letter or '_' and continue with ASCII letters, digits, '_', or '$'`);
+        }
+        if (value.includes('\0')) {
+            throw new Error(`PostgreSQL startup GUC ${JSON.stringify(name)} contains a NUL byte`);
+        }
+        if (STORAGE_OWNED_GUCS.has(name)) {
+            throw new Error(`@oliphaunt/wasix-ts owns PostgreSQL startup GUC ${JSON.stringify(name)}; configure the database through Oliphaunt's storage API`);
+        }
+        normalized[name] = value;
+    }
+    return normalized;
+}

package/lib/storage/bun.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Select native Rust-owned directory storage for Bun.
+ *
+ * Bun uses the same managed-root format and OS advisory lock as Node.js.
+ */
+export { directory } from './node.js';

package/lib/storage/bun.js

@@ -0,0 +1,6 @@
+/**
+ * Select native Rust-owned directory storage for Bun.
+ *
+ * Bun uses the same managed-root format and OS advisory lock as Node.js.
+ */
+export { directory } from './node.js';

package/lib/storage/deno.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Select native Rust-owned directory storage for Deno.
+ *
+ * Deno uses the same managed-root format and OS advisory lock as Node.js. The
+ * application must grant read and write permissions for the selected directory.
+ */
+export { directory } from './node.js';

package/lib/storage/deno.js

@@ -0,0 +1,7 @@
+/**
+ * Select native Rust-owned directory storage for Deno.
+ *
+ * Deno uses the same managed-root format and OS advisory lock as Node.js. The
+ * application must grant read and write permissions for the selected directory.
+ */
+export { directory } from './node.js';

package/lib/storage/incremental-storage.d.ts

@@ -0,0 +1,25 @@
+import type { WasixStorageCommitState } from '../errors.js';
+import type { WasixClusterSeedLoader, WasixStorageLease } from '../storage-provider.js';
+import { type StorageDelta, type StoredSnapshot } from '../storage-snapshot.js';
+export type ExclusiveStorageLock = {
+    release(): Promise<void>;
+};
+export type IncrementalStorageStore = {
+    read(): Promise<StoredSnapshot | undefined>;
+    /** Override snapshot presence when a direct provider has incomplete setup state. */
+    initializationState?(snapshot: StoredSnapshot | undefined): 'new' | 'existing';
+    apply(delta: StorageDelta): Promise<void>;
+    close(): void | Promise<void>;
+};
+export type IncrementalStorageBackend = {
+    acquireLock(): Promise<ExclusiveStorageLock>;
+    openStore(): Promise<IncrementalStorageStore>;
+    /** Atomic stores retain `not-persisted`; filesystem stores report `unknown`. */
+    writeFailureCommitState?: WasixStorageCommitState;
+};
+/**
+ * Shared lifecycle for browser stores backed by the Wasmer mutation journal.
+ * Providers own their atomicity and validation; this layer owns delta capture,
+ * cleanup ordering, and consistent failure semantics.
+ */
+export declare function acquireIncrementalStorage(label: string, loadClusterSeed: WasixClusterSeedLoader, backend: IncrementalStorageBackend): Promise<WasixStorageLease>;

package/lib/storage/incremental-storage.js

@@ -0,0 +1,154 @@
+import { composeWasixStorageFailure, WasixStorageError } from '../errors.js';
+import { applyStorageDeltaToEntries, snapshotStorageDelta, snapshotToMount, } from '../storage-snapshot.js';
+/**
+ * Shared lifecycle for browser stores backed by the Wasmer mutation journal.
+ * Providers own their atomicity and validation; this layer owns delta capture,
+ * cleanup ordering, and consistent failure semantics.
+ */
+export async function acquireIncrementalStorage(label, loadClusterSeed, backend) {
+    const lock = await backend.acquireLock();
+    let store;
+    try {
+        store = await backend.openStore();
+        const snapshot = await store.read();
+        const state = store.initializationState?.(snapshot) ?? (snapshot === undefined ? 'new' : 'existing');
+        const mount = snapshot === undefined ? await loadClusterSeed() : snapshotToMount(snapshot);
+        return new IncrementalStorageLease(label, store, lock, mount, snapshot !== undefined, state, backend.writeFailureCommitState ?? 'not-persisted');
+    }
+    catch (error) {
+        let primary = error instanceof WasixStorageError
+            ? error
+            : new WasixStorageError(`could not open ${label}: ${describeError(error)}`, {
+                code: 'unavailable',
+                commitState: 'unchanged',
+                cause: error,
+            });
+        try {
+            await store?.close();
+        }
+        catch (closeError) {
+            primary = composeWasixStorageFailure(primary, 'storage connection cleanup also failed', closeError);
+        }
+        try {
+            await lock.release();
+        }
+        catch (releaseError) {
+            throw composeWasixStorageFailure(primary, 'ownership release also failed', releaseError);
+        }
+        throw primary;
+    }
+}
+class IncrementalStorageLease {
+    state;
+    mount;
+    #label;
+    #store;
+    #lock;
+    #persistedEntries = new Map();
+    #writeFailureCommitState;
+    #closed = false;
+    #hasStoredGeneration;
+    #initializationPending;
+    constructor(label, store, lock, mount, hasStoredGeneration, state, writeFailureCommitState) {
+        this.#label = label;
+        this.#store = store;
+        this.#lock = lock;
+        this.state = state;
+        this.mount = mount;
+        this.#hasStoredGeneration = hasStoredGeneration;
+        this.#initializationPending = state === 'new';
+        this.#writeFailureCommitState = writeFailureCommitState;
+        if (hasStoredGeneration) {
+            for (const path of mount.directories)
+                this.#persistedEntries.set(path, 'dir');
+            for (const path of Object.keys(mount.files))
+                this.#persistedEntries.set(path, 'file');
+        }
+    }
+    async sync(directory, _boundary) {
+        if (this.#closed) {
+            throw new WasixStorageError(`${this.#label} is closed`, {
+                code: 'unavailable',
+                commitState: 'unchanged',
+            });
+        }
+        let failureCommitState = this.#writeFailureCommitState;
+        try {
+            const delta = await snapshotStorageDelta(directory, this.#persistedEntries, !this.#hasStoredGeneration);
+            if (!this.#initializationPending &&
+                this.#hasStoredGeneration &&
+                delta.directories.length === 0 &&
+                delta.files.length === 0 &&
+                delta.deleted.length === 0) {
+                failureCommitState = 'unchanged';
+                await directory.clearChanges?.();
+                return;
+            }
+            await this.#store.apply(delta);
+            applyStorageDeltaToEntries(this.#persistedEntries, delta);
+            this.#hasStoredGeneration = true;
+            this.#initializationPending = false;
+            failureCommitState = 'persisted';
+            // The backend commit is the acknowledgement point. Keeping the journal
+            // intact until now makes a failed publication retryable on close and
+            // prevents successful paths from being republished on every operation.
+            await directory.clearChanges?.();
+        }
+        catch (error) {
+            if (error instanceof WasixStorageError)
+                throw error;
+            throw new WasixStorageError(`could not persist ${this.#label}: ${describeError(error)}`, {
+                code: 'publication-failed',
+                commitState: failureCommitState,
+                cause: error,
+            });
+        }
+    }
+    async close(directory, outcome) {
+        if (this.#closed)
+            return;
+        let failure;
+        try {
+            if (outcome === 'clean') {
+                if (directory === undefined) {
+                    throw new WasixStorageError(`cannot persist ${this.#label} without PGDATA`, {
+                        code: 'publication-failed',
+                        commitState: 'not-persisted',
+                    });
+                }
+                await this.sync(directory, 'close');
+            }
+        }
+        catch (error) {
+            failure = error;
+        }
+        finally {
+            this.#closed = true;
+            try {
+                await this.#store.close();
+            }
+            catch (error) {
+                failure = combineCleanupFailure(failure, `${this.#label} could not close its storage connection`, 'storage connection cleanup also failed', error, this.#hasStoredGeneration);
+            }
+            try {
+                await this.#lock.release();
+            }
+            catch (error) {
+                failure = combineCleanupFailure(failure, `${this.#label} closed but its ownership lock could not be released`, 'ownership release also failed', error, this.#hasStoredGeneration);
+            }
+        }
+        if (failure !== undefined)
+            throw failure;
+    }
+}
+function combineCleanupFailure(prior, message, detail, cause, persisted) {
+    const cleanup = new WasixStorageError(message, {
+        code: 'unavailable',
+        commitState: persisted ? 'persisted' : 'unchanged',
+        cause,
+    });
+    return prior instanceof Error ? composeWasixStorageFailure(prior, detail, cleanup) : cleanup;
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/storage/indexed-db-provider.d.ts

@@ -0,0 +1,40 @@
+import { type WasixClusterSeedLoader, type WasixPhysicalIdentity, type WasixStorageLease } from '../storage-provider.js';
+import { type StorageDelta, type StoredSnapshot } from '../storage-snapshot.js';
+import { type ExclusiveStorageLock } from './incremental-storage.js';
+type StoredMetadata = {
+    schema: 'oliphaunt-wasix-indexed-db-v1';
+    name: string;
+    physicalIdentity: WasixPhysicalIdentity;
+};
+type StoredEntry = {
+    path: string;
+    type: 'dir';
+} | {
+    path: string;
+    type: 'file';
+    bytes: Uint8Array;
+};
+export type StoredDatabase = StoredMetadata & {
+    entries: StoredEntry[];
+};
+export type HeldLock = ExclusiveStorageLock;
+export type StoredDatabaseStore = {
+    read(): Promise<unknown | undefined>;
+    apply(identity: WasixPhysicalIdentity, delta: StorageDelta): Promise<void>;
+    close(): void;
+};
+export type IndexedDbStorageBackend = {
+    acquireLock(name: string): Promise<HeldLock>;
+    openDatabase(name: string): Promise<StoredDatabaseStore>;
+};
+export declare function acquireIndexedDbStorage(name: string, loadClusterSeed: WasixClusterSeedLoader, identity: WasixPhysicalIdentity): Promise<WasixStorageLease>;
+export declare function restoreIndexedDbStorage(name: string, snapshot: StoredSnapshot, identity: WasixPhysicalIdentity): Promise<void>;
+/** @internal Narrow dependency seam for deterministic provider failure tests. */
+export declare function acquireIndexedDbStorageWithBackend(name: string, loadClusterSeed: WasixClusterSeedLoader, identity: WasixPhysicalIdentity, backend: IndexedDbStorageBackend): Promise<WasixStorageLease>;
+/** @internal Validate IndexedDB rows before any bytes reach Wasmer. */
+export declare function validateStoredDatabase(value: unknown, name: string, identity: WasixPhysicalIdentity): StoredSnapshot;
+/** @internal Stable physical IndexedDB name for one logical Oliphaunt database. */
+export declare function indexedDbDatabaseName(name: string): string;
+export declare function readStoredDatabase(database: IDBDatabase, name: string): Promise<StoredDatabase | undefined>;
+export declare function applyStoredDatabaseDelta(database: IDBDatabase, name: string, identity: WasixPhysicalIdentity, delta: StorageDelta): Promise<void>;
+export {};