@oliphaunt/wasix-ts 0.1.0 → 0.2.1

package/lib/{direct-client-common.js → hosts/browser/direct-client-common.js}

@@ -1,14 +1,15 @@
-import { WasixDatabaseImpl, createWasixDeferred, normalizeWasixDatabaseIdentity, } from './database.js';
-import { WasixStorageError } from './errors.js';
-import { prepareWasixRuntime } from './extensions.js';
-import { assertSuccessfulStartupResponse, startupPacket } from './pgwire.js';
-import { BackupModeExitUnconfirmedError, createPhysicalArchive } from './physical-archive.js';
-import { simpleQuery } from './protocol.js';
-import { assertSuccessfulQueryResponse, PostgresError } from './query.js';
-import { acquireWasixStorage, canonicalJson, } from './storage-provider.js';
-import { serveWasixProtocolConnection, SynchronousPgDumpConnection, } from './pgwire-connection.js';
-import { materializeWasixToolMounts, prepareWasixToolAsset, releaseWasixToolMounts, validateWasixToolDescriptor, wasixToolAssetIdentity, wasixToolRunOptions, } from './tool-runtime.js';
-import { normalizeWasixStartupGUCs } from './startup-config.js';
+import { initializeWasixStorage } from './initialize.js';
+import { WasixDatabaseImpl, createWasixDeferred, normalizeWasixDatabaseIdentity, } from '../../core/database.js';
+import { WasixStorageError } from '../../core/errors.js';
+import { prepareWasixRuntime } from '../../resources/extensions.js';
+import { assertSuccessfulStartupResponse, startupPacket } from '../../protocol/pgwire.js';
+import { BackupModeExitUnconfirmedError, createPhysicalArchive, } from '../../storage/physical-archive.js';
+import { simpleQuery } from '../../protocol/protocol.js';
+import { assertSuccessfulQueryResponse, PostgresError } from '../../protocol/query.js';
+import { acquireWasixStorage, canonicalJson, } from '../../storage/storage-provider.js';
+import { serveWasixProtocolConnection, SynchronousPgDumpConnection, } from '../../protocol/pgwire-connection.js';
+import { materializeWasixToolMounts, prepareWasixToolAsset, releaseWasixToolMounts, validateWasixToolDescriptor, wasixToolAssetIdentity, wasixToolRunOptions, } from '../../resources/tool-runtime.js';
+import { normalizeWasixStartupGUCs } from '../../core/startup-config.js';
 import { compileWasixModule, composeLifecycleFailure, configureWasixDatabase, configureWasixRole, describeError, materializeWasixMounts, wasixPostgresArgs, wasixPostgresEnvironment, } from './wasix-runtime.js';
 const preparedRuntimes = new Map();
 const MAX_PREPARED_RUNTIMES = 1;
@@ -70,7 +71,7 @@ export class DirectWasixSession {
         }
         const prepared = await dependencies.prepareRuntime(options);
         const startupGUCs = normalizeWasixStartupGUCs(prepared.startupGUCs);
-        const eagerClusterSeed = options.storage.kind === 'memory' ? prepared.loadClusterSeed() : undefined;
+        const eagerClusterSeed = options.storage.kind === 'memory' ? prepared.loadClusterSeed?.() : undefined;
         const [, module] = await Promise.all([
             initializeHost(host),
             dependencies.compileModule(prepared.layout.module, prepared.moduleSha256),
@@ -82,7 +83,7 @@ export class DirectWasixSession {
             if (options.username !== 'postgres') {
                 throw newStorageRoleError(options.username);
             }
-            return eagerClusterSeed ?? prepared.loadClusterSeed();
+            return (eagerClusterSeed ?? prepared.loadClusterSeed?.() ?? initializeWasixStorage(host, prepared));
         }, prepared.physicalIdentity);
         let instance;
         let baseDirectory;
@@ -608,6 +609,9 @@ function asError(error) {
 }
 /** @internal Cache verified runtime materialization without caching transient failures. */
 export function prepareRuntimeCached(options, prepare = prepareWasixRuntime) {
+    // Explicit resource URLs/bytes can change independently of the runtime carrier.
+    if (options.seed !== undefined || options.icu !== undefined)
+        return prepare(options);
     const identity = preparedRuntimeIdentity(options);
     let prepared = preparedRuntimes.get(identity);
     if (prepared === undefined) {
@@ -682,29 +686,11 @@ function preparedRuntimeIdentity(options) {
             product: runtime.product,
             version: runtime.version,
             runtimeArchive: assetIdentity(runtime.runtimeArchive),
-            standardSeedArchive: assetIdentity(runtime.standardSeedArchive),
-            standardSeedManifest: {
-                sha256: runtime.standardSeedManifest.sha256,
-                size: runtime.standardSeedManifest.size,
-            },
             manifest: {
                 sha256: runtime.manifest.sha256,
                 size: runtime.manifest.size,
             },
         },
-        icu: options.icu === undefined
-            ? null
-            : {
-                product: options.icu.product,
-                version: options.icu.version,
-                compatibility: options.icu.compatibility,
-                dataArchive: assetIdentity(options.icu.dataArchive),
-                clusterSeedArchive: assetIdentity(options.icu.clusterSeedArchive),
-                clusterSeedManifest: {
-                    sha256: options.icu.clusterSeedManifest.sha256,
-                    size: options.icu.clusterSeedManifest.size,
-                },
-            },
         extensions: options.extensions,
         carriers: Object.values(options.extensionCarriers)
             .sort((left, right) => left.sqlName.localeCompare(right.sqlName))

package/lib/hosts/browser/initialize.d.ts

@@ -0,0 +1,5 @@
+import type { PreparedWasixRuntime } from '../../resources/extensions.js';
+import type { WasixDirectoryMount } from '../../resources/archive.js';
+import type { DirectWasixHost } from './direct-client-common.js';
+/** Run the runtime's initdb in an isolated WASIX process tree for a new root. */
+export declare function initializeWasixStorage(host: DirectWasixHost, runtime: PreparedWasixRuntime): Promise<WasixDirectoryMount>;

package/lib/hosts/browser/initialize.js

@@ -0,0 +1,67 @@
+import { snapshotStorageDirectory, snapshotToMount } from '../../storage/storage-snapshot.js';
+import { materializeWasixMounts } from './wasix-runtime.js';
+import { releaseWasixToolMounts } from '../../resources/tool-runtime.js';
+/** Run the runtime's initdb in an isolated WASIX process tree for a new root. */
+export async function initializeWasixStorage(host, runtime) {
+    if (host.runWasix === undefined)
+        throw new Error('WASIX host does not provide initdb execution');
+    const initdb = runtime.layout.mounts['/bin']?.files.initdb;
+    if (initdb === undefined)
+        throw new Error('WASIX runtime archive is missing bin/initdb');
+    const { mounts, baseDirectory } = await materializeWasixMounts(host.Directory, runtime.layout, {
+        files: {},
+        directories: [],
+    });
+    let snapshot;
+    try {
+        const instance = await host.runWasix(initdb, {
+            program: '/bin/initdb',
+            cwd: '/',
+            stdin: '',
+            mount: mounts,
+            args: [
+                '--allow-group-access',
+                '--encoding',
+                'UTF8',
+                '--locale',
+                'C.UTF-8',
+                '--locale-provider',
+                'libc',
+                '--auth',
+                'trust',
+                '-D',
+                '/base',
+            ],
+            env: {
+                PGDATA: '/base',
+                PGSYSCONFDIR: '/base',
+                HOME: '/home/postgres',
+                USER: 'postgres',
+                LOGNAME: 'postgres',
+                PGCLIENTENCODING: 'UTF8',
+                PATH: '/bin',
+                LC_CTYPE: 'C.UTF-8',
+                TZ: 'UTC',
+                PGTZ: 'UTC',
+                PG_COLOR: 'never',
+                ...(runtime.icuEnabled
+                    ? { ICU_DATA: '/share/icu', OLIPHAUNT_INTERNAL_ICU_READY: '1' }
+                    : { OLIPHAUNT_INTERNAL_SKIP_ICU_DISCOVERY: '1' }),
+            },
+        });
+        // wait consumes the wasm-bindgen instance handle.
+        const output = await instance.wait();
+        if (!output.ok || output.code !== 0) {
+            throw new Error(`WASIX initdb failed (${output.code}): ${output.stderr.trim()}`);
+        }
+        if ((await baseDirectory.readTextFile('PG_VERSION')).trim() !== '18') {
+            throw new Error('WASIX initdb did not create a PostgreSQL 18 cluster');
+        }
+        snapshot = snapshotToMount(await snapshotStorageDirectory(baseDirectory));
+    }
+    catch (primary) {
+        releaseWasixToolMounts(mounts, { primary });
+    }
+    releaseWasixToolMounts(mounts);
+    return snapshot;
+}

package/lib/{internal-common.d.ts → hosts/browser/internal-common.d.ts}

@@ -1,7 +1,7 @@
-import type { OliphauntDatabase } from './types.js';
+import type { OliphauntDatabase } from '../../core/types.js';
 import type { WasixToolWorkerRequest, WasixToolWorkerResponse } from './tool-worker-common.js';
-import { type WasixToolProcessOptions, type WasixToolProcessResult } from './tool-runtime.js';
-export type { WasixToolDescriptor, WasixToolProcessOptions, WasixToolProcessResult, } from './tool-runtime.js';
+import { type WasixToolProcessOptions, type WasixToolProcessResult } from '../../resources/tool-runtime.js';
+export type { WasixToolDescriptor, WasixToolProcessOptions, WasixToolProcessResult, } from '../../resources/tool-runtime.js';
 export type WasixToolWorkerPort = Readonly<{
     postMessage(request: WasixToolWorkerRequest, transfer?: ArrayBuffer[]): void;
     terminate(): void | Promise<void>;

package/lib/{internal-common.js → hosts/browser/internal-common.js}

@@ -1,7 +1,7 @@
 import defaultWasixRuntime from '@oliphaunt/liboliphaunt-wasix';
-import { closeWasixByteChannel, createWasixByteChannel, failWasixByteChannel, wasixByteChannelProtocolOutcomeUnknown, } from './byte-channel.js';
-import { assertWasixProtocolConnectionTarget, registerWasixDatabaseResource, reserveWasixProtocolConnection, runWasixPgDumpProcess, } from './database.js';
-import { validateWasixToolDescriptor, } from './tool-runtime.js';
+import { closeWasixByteChannel, createWasixByteChannel, failWasixByteChannel, wasixByteChannelProtocolOutcomeUnknown, } from '../../protocol/byte-channel.js';
+import { assertWasixProtocolConnectionTarget, registerWasixDatabaseResource, reserveWasixProtocolConnection, runWasixPgDumpProcess, } from '../../core/database.js';
+import { validateWasixToolDescriptor, } from '../../resources/tool-runtime.js';
 const controllers = new WeakMap();
 /** @internal Shared browser/server tool orchestration; public API lives in the optional package. */
 export function runWasixToolProcess(database, options, createWorker) {

package/lib/{tool-worker-common.d.ts → hosts/browser/tool-worker-common.d.ts}

@@ -1,6 +1,6 @@
-import { type WasixByteChannel } from './byte-channel.js';
-import type { Directory, OliphauntPreparedTool, OliphauntToolOutput, RunWasixOptions } from './host/index.mjs';
-import { type WasixToolDescriptor } from './tool-runtime.js';
+import { type WasixByteChannel } from '../../protocol/byte-channel.js';
+import type { Directory, OliphauntPreparedTool, OliphauntToolOutput, RunWasixOptions } from '../../host/index.mjs';
+import { type WasixToolDescriptor } from '../../resources/tool-runtime.js';
 export type WasixToolWorkerRequest = WasixToolPrepareRequest | WasixToolRunRequest;
 export type WasixToolPrepareRequest = Readonly<{
     id: number;

package/lib/{tool-worker-common.js → hosts/browser/tool-worker-common.js}

@@ -1,5 +1,5 @@
-import { closeWasixByteChannel, failWasixByteChannel, markWasixByteChannelProtocolComplete, markWasixByteChannelProtocolStarted, readWasixByteChannelSync, wasixByteChannelProtocolOutcomeUnknown, writeWasixByteChannelSync, } from './byte-channel.js';
-import { materializeWasixToolMounts, prepareWasixToolAsset, releaseWasixToolMounts, wasixToolAssetIdentity, wasixToolRunOptions, } from './tool-runtime.js';
+import { closeWasixByteChannel, failWasixByteChannel, markWasixByteChannelProtocolComplete, markWasixByteChannelProtocolStarted, readWasixByteChannelSync, wasixByteChannelProtocolOutcomeUnknown, writeWasixByteChannelSync, } from '../../protocol/byte-channel.js';
+import { materializeWasixToolMounts, prepareWasixToolAsset, releaseWasixToolMounts, wasixToolAssetIdentity, wasixToolRunOptions, } from '../../resources/tool-runtime.js';
 /** @internal Stateful dispatcher owned by one persistent outer tool worker. */
 export function createWasixToolWorkerDispatcher(host) {
     let hostInitialization;

package/lib/{tool-worker.js → hosts/browser/tool-worker.js}

@@ -1,5 +1,5 @@
 /// <reference lib="webworker" />
-import * as host from './host/index.mjs';
+import * as host from '../../host/index.mjs';
 import { createWasixToolWorkerDispatcher, toolWorkerResponseTransfers, } from './tool-worker-common.js';
 const scope = globalThis;
 const dispatch = createWasixToolWorkerDispatcher(host);

package/lib/{wasix-runtime.d.ts → hosts/browser/wasix-runtime.d.ts}

@@ -1,6 +1,6 @@
-import type { WasixDirectoryMount, WasixRuntimeLayout } from './archive.js';
-import type { Directory } from './host/index.mjs';
-import type { SerializedOpenOptions } from './rpc.js';
+import type { WasixDirectoryMount, WasixRuntimeLayout } from '../../resources/archive.js';
+import type { Directory } from '../../host/index.mjs';
+import type { SerializedOpenOptions } from '../../workers/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. */

package/lib/{wasix-runtime.js → hosts/browser/wasix-runtime.js}

@@ -1,7 +1,8 @@
-import { WasixStorageError } from './errors.js';
-import { simpleQuery } from './protocol.js';
-import { assertSuccessfulQueryResponse, PostgresError } from './query.js';
-import { normalizeWasixStartupGUCs } from './startup-config.js';
+import { WasixStorageError } from '../../core/errors.js';
+import { simpleQuery } from '../../protocol/protocol.js';
+import { assertSuccessfulQueryResponse, PostgresError } from '../../protocol/query.js';
+import { normalizeWasixStartupGUCs } from '../../core/startup-config.js';
+import { releaseWasixToolMounts } from '../../resources/tool-runtime.js';
 let compiledModuleCache;
 /** @internal Verified-module compilation cache shared by direct opens in one JS realm. */
 export function compileWasixModule(module, sha256) {
@@ -22,18 +23,23 @@ export function compileWasixModule(module, sha256) {
 /** @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');
+    try {
+        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);
         }
-        baseDirectory = await materializeDirectory(DirectoryConstructor, pgdata);
+        mounts['/base'] = baseDirectory;
+        return { mounts, baseDirectory };
+    }
+    catch (primary) {
+        releaseWasixToolMounts(mounts, { primary });
     }
-    mounts['/base'] = baseDirectory;
-    return { mounts, baseDirectory };
 }
 /** @internal Materialize runtime support mounts for frontend tools. */
 export function materializeWasixSupportMounts(DirectoryConstructor, layout) {
@@ -41,23 +47,33 @@ export function materializeWasixSupportMounts(DirectoryConstructor, layout) {
 }
 async function materializeMountMap(DirectoryConstructor, layout) {
     const mounts = {};
-    for (const [mountPath, contents] of Object.entries(layout.mounts)) {
-        mounts[mountPath] = await materializeDirectory(DirectoryConstructor, contents);
+    try {
+        for (const [mountPath, contents] of Object.entries(layout.mounts)) {
+            mounts[mountPath] = await materializeDirectory(DirectoryConstructor, contents);
+        }
+        return mounts;
+    }
+    catch (primary) {
+        releaseWasixToolMounts(mounts, { primary });
     }
-    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;
+    try {
+        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);
         }
-        await directory.createDir(path);
-        existing.add(path);
+        return directory;
+    }
+    catch (primary) {
+        releaseWasixToolMounts({ directory }, { primary });
     }
-    return directory;
 }
 function directoriesImpliedByFiles(paths) {
     const directories = new Set();

package/lib/{worker-client.d.ts → hosts/browser/worker-client.d.ts}

@@ -1,4 +1,4 @@
-import type { OliphauntClient, OliphauntDatabase, OpenConfig } from './types.js';
+import type { OliphauntClient, OliphauntDatabase, OpenConfig } from './browser-public.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 → hosts/browser/worker-client.js}

@@ -1,14 +1,15 @@
-import { serializeOpenConfig } from './client-common.js';
-import { openWasixWithWorker, restoreWasixWithWorker } from './worker-rpc.js';
+import { requireBrowserStorage, serializeOpenConfig } from '../../core/open-config.js';
+import { openWasixWithWorker, restoreWasixWithWorker, } from '../../workers/worker-rpc.js';
 /** Open PostgreSQL in a package-owned browser Worker. */
 export async function openWasix(config = {}) {
     const openOptions = serializeOpenConfig(config);
+    requireBrowserStorage(openOptions);
     assertBrowserWorkerEnvironment();
-    return openWasixWithWorker(createBrowserWorker, openOptions);
+    return openWasixWithWorker(createBrowserWorker, openOptions, requireBrowserStorage);
 }
 async function restoreBrowserWasix(storage, bytes) {
     assertBrowserWorkerEnvironment();
-    return restoreWasixWithWorker(createBrowserWorker, storage, bytes);
+    return restoreWasixWithWorker(createBrowserWorker, storage, bytes, requireBrowserStorage);
 }
 function assertBrowserWorkerEnvironment() {
     if (globalThis.crossOriginIsolated !== true) {

package/lib/{worker.js → hosts/browser/worker.js}

@@ -1,7 +1,7 @@
 /// <reference lib="webworker" />
-import * as host from './host/index.mjs';
+import * as host from '../../host/index.mjs';
 import { openBrowserWorkerSession } from './direct-client-common.js';
-import { createWorkerSessionDispatcher } from './worker-dispatch.js';
+import { createWorkerSessionDispatcher } from '../../workers/worker-dispatch.js';
 const scope = globalThis;
 const directHost = {
     Directory: host.Directory,

package/lib/{direct-client.d.ts → hosts/node-api/direct-client.d.ts}

@@ -1,4 +1,4 @@
-import type { OliphauntClient, OliphauntDatabase, OpenConfig } from './types.js';
+import type { OliphauntClient, OliphauntDatabase, OpenConfig } from './native-public.js';
 /** Open PostgreSQL in the importing realm, where native work blocks its event loop. */
 export declare function openWasix(config?: OpenConfig): Promise<OliphauntDatabase>;
 export declare const Oliphaunt: OliphauntClient;

package/lib/{direct-client.js → hosts/node-api/direct-client.js}

@@ -1,4 +1,4 @@
-import { serializeOpenConfig } from './client-common.js';
+import { serializeOpenConfig } from '../../core/open-config.js';
 import { requireNodeStorage, restoreNodeWasixDirect } from './node-client-common.js';
 import { openNodeDirect } from './node-direct.js';
 /** Open PostgreSQL in the importing realm, where native work blocks its event loop. */

package/lib/{native-addon.d.ts → hosts/node-api/native-addon.d.ts}

@@ -4,6 +4,15 @@ export type NativeWasixStorage = Readonly<{
     kind: 'directory';
     path: string;
 }>;
+export type NativeWasixExtensionPackage = Readonly<{
+    sqlName: string;
+    product: string;
+    version: string;
+    packageJson: string;
+    aotPackageJson?: string;
+    archiveSha256: string;
+    archiveSize: number;
+}>;
 export type NativeProfile = 'standard' | 'icu';
 export type NativeWasixOpenOptions = Readonly<{
     profile: NativeProfile;
@@ -12,6 +21,15 @@ export type NativeWasixOpenOptions = Readonly<{
     database: string;
     startupGucs: Record<string, string>;
     extensions: string[];
+    extensionPackages?: NativeWasixExtensionPackage[];
+    seed?: {
+        archive: Uint8Array;
+        manifest: Uint8Array;
+    };
+    icuData?: {
+        data: Uint8Array;
+        manifest: Uint8Array;
+    };
 }>;
 export type NativeWasixServerListen = Readonly<{
     transport: 'tcp';
@@ -29,8 +47,8 @@ export type NativeWasixDatabaseHandle = {
     execProtocolRaw(request: Uint8Array): Uint8Array;
     execProtocolRawStream(request: Uint8Array, onChunk: (chunk: Uint8Array) => void): 'complete' | 'callbackAborted';
     backup(): Uint8Array;
-    pgDump(args: string[]): NativeWasixToolResult;
-    psql(args: string[], command?: string, script?: string): NativeWasixToolResult;
+    pgDump(args: readonly string[], assets: NativeWasixToolAssets): NativeWasixToolResult;
+    psql(args: readonly string[], assets: NativeWasixToolAssets, command?: string, script?: string): NativeWasixToolResult;
     close(): void;
 };
 export type NativeWasixActorDatabaseHandle = {
@@ -38,8 +56,8 @@ export type NativeWasixActorDatabaseHandle = {
     execProtocolRaw(request: Uint8Array): Promise<Uint8Array>;
     execProtocolRawStream(request: Uint8Array, onChunk: (chunk: Uint8Array) => void): Promise<'complete' | 'callbackAborted'>;
     backup(): Promise<Uint8Array>;
-    pgDump(args: string[]): Promise<NativeWasixToolResult>;
-    psql(args: string[], command?: string, script?: string): Promise<NativeWasixToolResult>;
+    pgDump(args: readonly string[], assets: NativeWasixToolAssets): Promise<NativeWasixToolResult>;
+    psql(args: readonly string[], assets: NativeWasixToolAssets, command?: string, script?: string): Promise<NativeWasixToolResult>;
     close(): Promise<void>;
 };
 export type NativeWasixToolResult = Readonly<{
@@ -47,6 +65,11 @@ export type NativeWasixToolResult = Readonly<{
     stdout: Uint8Array;
     stderr: Uint8Array;
 }>;
+export type NativeWasixToolAssets = Readonly<{
+    wasm: Uint8Array;
+    aot: Uint8Array;
+    manifest: string;
+}>;
 export type NativeWasixServerHandle = {
     readonly connectionString: string;
     readonly closed: boolean;
@@ -71,9 +94,8 @@ export type NativeWasixAddon = {
     nodeApiVersion(): number;
     runtimeVersion(): string;
     supportedProfiles(): readonly NativeProfile[];
-    payloadIdentity(component: 'runtimeArchive' | 'standardSeedArchive' | 'standardSeedManifest' | 'icuDataArchive' | 'icuSeedArchive' | 'icuSeedManifest'): string;
+    payloadIdentity(component: 'runtimeArchive'): string;
     extensionIdentity(sqlName: string): string;
-    toolIdentity(name: 'pg_dump' | 'psql'): string;
 };
 type WasixPackageMetadata = Readonly<{
     name?: string;

package/lib/{native-addon.js → hosts/node-api/native-addon.js}

@@ -86,11 +86,11 @@ export function optionalEnvironmentValue(name, read = (key) => process.env[key],
     }
 }
 function packageMetadata() {
-    const path = fileURLToPath(new URL('../package.json', import.meta.url));
+    const path = fileURLToPath(new URL('../../../package.json', import.meta.url));
     return JSON.parse(readFileSync(path, 'utf8'));
 }
 function packageAdjacentAddons() {
-    const here = dirname(fileURLToPath(import.meta.url));
+    const here = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
     const file = `${ADDON_STEM}.node`;
     return [join(here, file), join(here, '..', file)];
 }
@@ -186,12 +186,11 @@ export function validateNativeWasixAddon(addon, path, metadata) {
         typeof addon.runtimeVersion !== 'function' ||
         typeof addon.supportedProfiles !== 'function' ||
         typeof addon.payloadIdentity !== 'function' ||
-        typeof addon.extensionIdentity !== 'function' ||
-        typeof addon.toolIdentity !== 'function') {
+        typeof addon.extensionIdentity !== 'function') {
         throw new Error(`Oliphaunt WASIX native addon ${path} has an invalid export surface`);
     }
     const expectedAbi = metadata.oliphaunt?.wasixAddonAbiVersion;
-    if (expectedAbi !== 1 || addon.addonAbiVersion() !== expectedAbi) {
+    if (expectedAbi !== 3 || addon.addonAbiVersion() !== expectedAbi) {
         throw new Error(`Oliphaunt WASIX native addon ${path} has an incompatible addon ABI`);
     }
     const expectedNodeApi = metadata.oliphaunt?.nodeApiVersion;

package/lib/hosts/node-api/native-public.d.ts

@@ -0,0 +1,8 @@
+export * from '../../core/public.js';
+import type * as Types from '../../core/types.js';
+import type * as Storage from '../../storage/types.js';
+type StorageKind = 'memory' | 'directory';
+export type OpenConfig = Types.OpenConfig<StorageKind>;
+export type OliphauntClient = Types.OliphauntClient<StorageKind>;
+export type WasixStorage = Storage.WasixStorage<StorageKind>;
+export type PersistentWasixStorage = Storage.PersistentWasixStorage<Exclude<StorageKind, 'memory'>>;

package/lib/hosts/node-api/native-public.js

@@ -0,0 +1 @@
+export * from '../../core/public.js';

package/lib/{native-server.d.ts → hosts/node-api/native-server.d.ts}

@@ -1,4 +1,4 @@
-import type { OpenConfig } from './types.js';
+import type { OpenConfig } from './native-public.js';
 export type ServerListen = Readonly<{
     transport: 'tcp';
     port?: number;

package/lib/{native-server.js → hosts/node-api/native-server.js}

@@ -1,6 +1,6 @@
 import { resolve } from 'node:path';
-import { serializeOpenConfig } from './client-common.js';
-import { mapNativeError, nativeWasixOpenOptions, requireCompatibleNativeWasixAddon, } from './native-session.js';
+import { serializeOpenConfig } from '../../core/open-config.js';
+import { mapNativeError, nativeWasixOpenOptions, loadNativeResources, requireCompatibleNativeWasixAddon, } from './native-session.js';
 import { requireNodeStorage } from './node-client-common.js';
 /** Open the Rust WASIX local server without a JavaScript socket/protocol relay. */
 export async function openServer(config = {}) {
@@ -24,6 +24,7 @@ export async function openServer(config = {}) {
     try {
         handle = await addon.NativeWasixServer.open({
             ...nativeWasixOpenOptions(options, storage),
+            ...(await loadNativeResources(options)),
             listen,
         });
         connectionString = validateServerHandle(handle);

package/lib/{native-session.d.ts → hosts/node-api/native-session.d.ts}

@@ -1,8 +1,8 @@
 import { type NativeWasixAddon, type NativeWasixOpenOptions } from './native-addon.js';
-import { type WasixDatabaseIdentity, type WasixDatabaseSession, type WasixDatabaseSessionTerminalState, type WasixPersistenceMode, type WasixProtocolStreamOutcome } from './database.js';
-import type { SerializedOpenOptions } from './rpc.js';
-import type { WasixStorageSyncBoundary } from './storage-provider.js';
-import type { WasixPgDumpProcessOptions, WasixToolProcessOptions, WasixToolProcessResult } from './tool-runtime.js';
+import { type WasixDatabaseIdentity, type WasixDatabaseSession, type WasixDatabaseSessionTerminalState, type WasixPersistenceMode, type WasixProtocolStreamOutcome } from '../../core/database.js';
+import type { SerializedOpenOptions } from '../../workers/rpc.js';
+import type { WasixStorageSyncBoundary } from '../../storage/storage-provider.js';
+import type { WasixPgDumpProcessOptions, WasixToolProcessOptions, WasixToolProcessResult } from '../../resources/tool-runtime.js';
 /** @internal A synchronous Rust Oliphaunt owned by the importing JavaScript realm. */
 export declare class NativeWasixSession implements WasixDatabaseSession {
     #private;
@@ -53,6 +53,16 @@ export declare function restoreNativeWasixDirect(options: SerializedOpenOptions,
 export declare function restoreNativeWasixStorageDirect(storage: SerializedOpenOptions['storage'], bytes: Uint8Array, addon?: NativeWasixAddon): Promise<void>;
 /** @internal Validate serialized package descriptors against the selected addon. */
 export declare function requireCompatibleNativeWasixAddon(options: SerializedOpenOptions): NativeWasixAddon;
+export declare function loadNativeResources(options: SerializedOpenOptions): Promise<{
+    icuData?: {
+        data: Uint8Array<ArrayBufferLike>;
+        manifest: Uint8Array<ArrayBufferLike>;
+    } | undefined;
+    seed?: {
+        archive: Uint8Array<ArrayBufferLike>;
+        manifest: Uint8Array<ArrayBufferLike>;
+    } | undefined;
+}>;
 /** @internal Project already-validated TS config onto the narrow native ABI. */
 export declare function nativeWasixOpenOptions(options: SerializedOpenOptions, storage: NativeWasixOpenOptions['storage']): NativeWasixOpenOptions;
 /** @internal Translate only the exact tagged native storage contract. */