@oliphaunt/wasix-ts 0.1.0 → 0.2.0

package/lib/{descriptor-validation.js → resources/descriptor-validation.js}

@@ -59,7 +59,7 @@ export function serializeAssetSource(source) {
         return source.href;
     }
     if (source instanceof Uint8Array) {
-        return source.slice();
+        return new Uint8Array(source);
     }
     return new Uint8Array(source.slice(0));
 }

package/lib/{extension-descriptor.d.ts → resources/extension-descriptor.d.ts}

@@ -1,5 +1,5 @@
-import type { SerializedExtensionCarrier } from './rpc.js';
-import type { WasixExtensionDescriptor, WasixExtensionDescriptorInput } from './types.js';
+import type { SerializedExtensionCarrier } from '../workers/rpc.js';
+import type { WasixExtensionDescriptor, WasixExtensionDescriptorInput } from '../core/types.js';
 export type SerializedWasixExtensions = {
     selectedSqlNames: string[];
     carriers: Record<string, SerializedExtensionCarrier>;

package/lib/{extensions.d.ts → resources/extensions.d.ts}

@@ -1,7 +1,7 @@
 import { type ExtractedArchive, type WasixDirectoryMount, type WasixRuntimeLayout } from './archive.js';
-import type { SerializedOpenOptions, SerializedRuntimeDescriptor, SerializedToolRuntimeDescriptor } from './rpc.js';
-import { type WasixPhysicalIdentity } from './storage-provider.js';
-import type { WasixAssetManifest } from './types.js';
+import type { SerializedOpenOptions, SerializedRuntimeDescriptor, SerializedToolRuntimeDescriptor } from '../workers/rpc.js';
+import { type WasixPhysicalIdentity } from '../storage/database-root.js';
+import type { WasixAssetManifest } from '../core/types.js';
 type CatalogProfile = 'standard' | 'icu';
 /** Internal kebab-case projection used while installing an imported carrier. */
 type ProjectedExtensionLifecycle = {
@@ -33,7 +33,7 @@ export type ResolvedWasixExtensions = {
 };
 export type PreparedWasixRuntime = {
     layout: WasixRuntimeLayout;
-    loadClusterSeed(): Promise<WasixDirectoryMount>;
+    loadClusterSeed?: () => Promise<WasixDirectoryMount>;
     moduleSha256: string;
     catalogProfile: 'standard' | 'icu';
     icuEnabled: boolean;
@@ -47,6 +47,15 @@ export type PreparedWasixRuntime = {
  * configuration; database-local installation remains explicit application SQL.
  */
 export declare function prepareWasixRuntime(options: SerializedOpenOptions): Promise<PreparedWasixRuntime>;
+export declare function loadSeedBytes(seed: NonNullable<SerializedOpenOptions['seed']>): Promise<{
+    archive: Uint8Array<ArrayBufferLike>;
+    manifest: Uint8Array<ArrayBufferLike>;
+}>;
+export declare function loadIcuData(icu: NonNullable<SerializedOpenOptions['icu']>): Promise<{
+    data: Uint8Array<ArrayBufferLike>;
+    manifest: Uint8Array<ArrayBufferLike>;
+    treeSha256: string;
+}>;
 /** Require the package-authored archive identities to match the canonical manifest. */
 export declare function assertRuntimeDescriptorMatchesManifest(descriptor: SerializedRuntimeDescriptor, manifest: WasixAssetManifest): void;
 /** Verify only the runtime assets consumed by PostgreSQL frontend tools. */
@@ -59,8 +68,6 @@ export declare function overlayExtensionArchive(layout: WasixRuntimeLayout, arch
 export declare function mergeExtensionStartupGUCs(configured: Readonly<Record<string, string>>, extensions: readonly ProjectedExtensionInstall[]): Record<string, string>;
 /** @internal Validate the host-independent standard/ICU seed profile contract. */
 export declare function assertClusterSeedProfileContract(value: unknown, expectedProfile: CatalogProfile): void;
-/** @internal Verify that a separately distributed ICU carrier belongs to this runtime. */
-export declare function assertIcuDescriptorMatchesRuntime(runtime: SerializedRuntimeDescriptor, icu: NonNullable<SerializedOpenOptions['icu']>, manifest: WasixAssetManifest): void;
 /** @internal Validate and add exact-archive-verified ICU files to the runtime tree. */
 export declare function overlayIcuArchive(runtime: ExtractedArchive, icu: ExtractedArchive): void;
 /** @internal Shared verification for separately carried WASIX tool modules. */

package/lib/{extensions.js → resources/extensions.js}

@@ -1,5 +1,5 @@
 import { clusterSeedMount, decompressIfNeeded, extractTar, layoutRuntimeSupport, loadAsset, } from './archive.js';
-import { WASIX_PHYSICAL_IDENTITY } from './storage-provider.js';
+import { WASIX_PHYSICAL_IDENTITY } from '../storage/database-root.js';
 const decoder = new TextDecoder('utf-8', { fatal: true });
 const SQL_NAME = /^[a-z0-9][a-z0-9_-]*$/;
 const SHA256 = /^[a-f0-9]{64}$/;
@@ -13,45 +13,23 @@ const SHARED_PRELOAD_LIBRARIES = 'shared_preload_libraries';
 export async function prepareWasixRuntime(options) {
     const descriptor = options.runtime;
     const profile = options.icu === undefined ? 'standard' : 'icu';
-    const seedArchiveDescriptor = options.icu?.clusterSeedArchive ?? descriptor.standardSeedArchive;
-    const seedManifestDescriptor = options.icu?.clusterSeedManifest ?? descriptor.standardSeedManifest;
-    const prefetchedSeedAssets = options.storage.kind === 'memory'
-        ? loadClusterSeedAssets(profile, seedArchiveDescriptor, seedManifestDescriptor)
-        : undefined;
-    // Memory storage is always new, so overlap its required seed download with
-    // the runtime closure. Persistent providers must inspect storage first.
-    void prefetchedSeedAssets?.catch(() => undefined);
-    const [manifestBytes, runtimeBytes, icuDataBytes] = await Promise.all([
+    const [manifestBytes, runtimeBytes, icuData] = await Promise.all([
         loadAsset(descriptor.manifest.source, 'WASIX asset manifest'),
         loadAsset(descriptor.runtimeArchive.source, 'WASIX runtime archive'),
-        options.icu === undefined
-            ? Promise.resolve(undefined)
-            : loadAsset(options.icu.dataArchive.source, 'WASIX ICU data archive'),
+        options.icu === undefined ? Promise.resolve(undefined) : loadIcuData(options.icu),
     ]);
     await Promise.all([
         assertDeclaredAssetBytes(manifestBytes, descriptor.manifest.size, descriptor.manifest.sha256, 'WASIX asset manifest'),
         assertDeclaredAssetBytes(runtimeBytes, descriptor.runtimeArchive.size, descriptor.runtimeArchive.sha256, 'WASIX runtime archive'),
-        ...(options.icu === undefined || icuDataBytes === undefined
-            ? []
-            : [
-                assertDeclaredAssetBytes(icuDataBytes, options.icu.dataArchive.size, options.icu.dataArchive.sha256, 'WASIX ICU data archive'),
-            ]),
     ]);
     const manifest = parseWasixAssetManifest(manifestBytes);
     assertRuntimeDescriptorMatchesManifest(descriptor, manifest);
-    const selectedSeed = manifest['cluster-seeds'][profile];
-    assertRuntimeArchiveMatchesManifest(seedArchiveDescriptor, selectedSeed, `WASIX ${profile} cluster seed archive`);
-    if (options.icu !== undefined) {
-        assertIcuDescriptorMatchesRuntime(options.runtime, options.icu, manifest);
-    }
-    const eagerClusterSeed = prefetchedSeedAssets === undefined
-        ? undefined
-        : loadClusterSeed(options, manifest, selectedSeed, profile, seedArchiveDescriptor, seedManifestDescriptor, prefetchedSeedAssets);
-    void eagerClusterSeed?.catch(() => undefined);
     const runtime = extractTar(decompressIfNeeded(runtimeBytes));
-    if (options.icu !== undefined && icuDataBytes !== undefined) {
-        const icuArchive = extractTar(decompressIfNeeded(icuDataBytes));
-        overlayIcuArchive(runtime, icuArchive);
+    if (icuData !== undefined) {
+        overlayIcuArchive(runtime, {
+            files: new Map([['share/icu/icudt76l.dat', icuData.data]]),
+            directories: new Set(['share', 'share/icu']),
+        });
     }
     const layout = layoutRuntimeSupport(runtime);
     assertExtensionCarriersCompatible(descriptor, manifest, options.extensionCarriers);
@@ -79,7 +57,11 @@ export async function prepareWasixRuntime(options) {
     }
     return {
         layout,
-        loadClusterSeed: lazyClusterSeedLoader(options, manifest, selectedSeed, profile, seedArchiveDescriptor, seedManifestDescriptor, eagerClusterSeed),
+        ...(options.seed === undefined
+            ? {}
+            : {
+                loadClusterSeed: lazyClusterSeedLoader(options, manifest, profile, icuData?.treeSha256),
+            }),
         moduleSha256: manifest.runtime['module-sha256'],
         catalogProfile: profile,
         icuEnabled: options.icu !== undefined,
@@ -87,48 +69,70 @@ export async function prepareWasixRuntime(options) {
         physicalIdentity: WASIX_PHYSICAL_IDENTITY,
     };
 }
-function lazyClusterSeedLoader(options, manifest, selectedSeed, profile, archiveDescriptor, manifestDescriptor, eager) {
-    let cached = eager;
-    const forgetRejectedAttempt = (attempt) => {
-        void attempt.catch(() => {
-            if (cached === attempt)
-                cached = undefined;
-        });
-    };
-    if (cached !== undefined)
-        forgetRejectedAttempt(cached);
+function lazyClusterSeedLoader(options, runtime, profile, icuTree) {
+    let cached;
     return () => {
         if (cached === undefined) {
-            const attempt = loadClusterSeed(options, manifest, selectedSeed, profile, archiveDescriptor, manifestDescriptor);
-            cached = attempt;
-            forgetRejectedAttempt(attempt);
+            cached = loadClusterSeed(options, runtime, profile, icuTree);
+            void cached.catch(() => {
+                cached = undefined;
+            });
         }
         return cached;
     };
 }
-function loadClusterSeedAssets(profile, archiveDescriptor, manifestDescriptor) {
-    return Promise.all([
-        loadAsset(archiveDescriptor.source, `WASIX ${profile} cluster seed`),
-        loadAsset(manifestDescriptor.source, `WASIX ${profile} cluster seed manifest`),
+export async function loadSeedBytes(seed) {
+    const [archive, manifest] = await Promise.all([
+        loadAsset(seed.archive, 'WASIX seed archive'),
+        loadAsset(seed.manifest, 'WASIX seed manifest'),
     ]);
+    return { archive, manifest };
 }
-async function loadClusterSeed(options, manifest, selectedSeed, profile, archiveDescriptor, manifestDescriptor, assets) {
-    const [archiveBytes, manifestBytes] = await (assets ??
-        loadClusterSeedAssets(profile, archiveDescriptor, manifestDescriptor));
-    await Promise.all([
-        assertDeclaredAssetBytes(archiveBytes, archiveDescriptor.size, archiveDescriptor.sha256, `WASIX ${profile} cluster seed`),
-        assertDeclaredAssetBytes(manifestBytes, manifestDescriptor.size, manifestDescriptor.sha256, `WASIX ${profile} cluster seed manifest`),
+export async function loadIcuData(icu) {
+    const [data, manifest] = await Promise.all([
+        loadAsset(icu.data, 'ICU data'),
+        loadAsset(icu.manifest, 'ICU manifest'),
     ]);
-    const seedManifest = parseClusterSeedManifest(manifestBytes, profile);
-    verifyClusterSeedIdentity(options, manifest, selectedSeed, seedManifest, archiveDescriptor);
-    const seed = extractTar(decompressIfNeeded(archiveBytes));
-    verifyPostgresIdentity(manifest, selectedSeed, seed.files.get('PG_VERSION'));
-    return clusterSeedMount(seed);
+    const fields = new Map();
+    for (const line of decodeUtf8(manifest).split(/\r?\n/)) {
+        if (!line.trim() || line.startsWith('#'))
+            continue;
+        const at = line.indexOf('=');
+        if (at <= 0 || fields.has(line.slice(0, at)))
+            throw new Error('invalid ICU manifest');
+        fields.set(line.slice(0, at), line.slice(at + 1));
+    }
+    if (fields.get('schema') !== 'oliphaunt-icu-data-v1' ||
+        fields.get('artifactRole') !== 'icu-data' ||
+        fields.get('icuDataVersion') !== '76.1' ||
+        fields.get('icuDataForm') !== 'files-le') {
+        throw new Error('incompatible ICU data manifest');
+    }
+    const treeSha256 = requireSha256(fields.get('icuDataTreeSha256'), 'ICU logical tree');
+    const prefix = new TextEncoder().encode('icudt76l.dat\0' + data.length + '\0');
+    const tree = new Uint8Array(prefix.length + data.length + 1);
+    tree.set(prefix);
+    tree.set(data, prefix.length);
+    tree[tree.length - 1] = 10;
+    await assertSha256(tree, treeSha256, 'ICU data tree');
+    return { data, manifest, treeSha256 };
+}
+async function loadClusterSeed(options, runtime, profile, icuTree) {
+    if (options.seed === undefined)
+        throw new Error('new browser storage requires an explicit seed');
+    const { archive, manifest } = await loadSeedBytes(options.seed);
+    const seed = parseClusterSeedManifest(manifest, profile);
+    verifyClusterSeedIdentity(options, runtime, seed, icuTree);
+    await assertDeclaredAssetBytes(archive, seed.archive.compressedBytes, seed.archive.sha256, 'WASIX seed');
+    const unpacked = extractTar(decompressIfNeeded(archive));
+    verifyPostgresIdentity(runtime, seed.runtime.postgresMajor, unpacked.files.get('PG_VERSION'));
+    if (!unpacked.files.has('global/pg_control'))
+        throw new Error('WASIX seed is missing global/pg_control');
+    return clusterSeedMount(unpacked);
 }
 /** Require the package-authored archive identities to match the canonical manifest. */
 export function assertRuntimeDescriptorMatchesManifest(descriptor, manifest) {
     assertToolRuntimeDescriptorMatchesManifest(descriptor, manifest);
-    assertRuntimeArchiveMatchesManifest(descriptor.standardSeedArchive, manifest['cluster-seeds'].standard, 'WASIX standard cluster seed archive');
 }
 /** Verify only the runtime assets consumed by PostgreSQL frontend tools. */
 export function assertToolRuntimeDescriptorMatchesManifest(descriptor, manifest) {
@@ -172,33 +176,6 @@ export function parseWasixAssetManifest(bytes) {
         requireString(entry.name, `WASIX runtime export ${index} name`);
         requireString(entry.kind, `WASIX runtime export ${index} kind`);
     }
-    const seeds = requireObject(manifest['cluster-seeds'], 'WASIX asset manifest cluster-seeds');
-    requireExactKeys(seeds, ['icu', 'standard'], 'WASIX asset manifest cluster-seeds');
-    for (const profile of ['standard', 'icu']) {
-        const seed = requireObject(seeds[profile], `WASIX ${profile} cluster seed`);
-        const expectedRole = profile === 'standard' ? 'cluster-seed-standard' : 'cluster-seed-icu';
-        if (seed['catalog-profile'] !== profile || seed['artifact-role'] !== expectedRole) {
-            throw new Error(`WASIX ${profile} cluster seed has a mismatched profile or artifact role`);
-        }
-        requireAssetPath(seed.archive, `WASIX ${profile} cluster seed archive`);
-        requireAssetPath(seed.manifest, `WASIX ${profile} cluster seed manifest`);
-        requireSha256(seed.sha256, `WASIX ${profile} cluster seed archive`);
-        requireSafeInteger(seed.size, `WASIX ${profile} cluster seed archive size`);
-        requireSha256(seed['runtime-module-sha256'], `WASIX ${profile} seed runtime module`);
-        requireString(seed['postgres-version'], `WASIX ${profile} seed PostgreSQL version`);
-        requireString(seed['source-fingerprint'], `WASIX ${profile} seed source fingerprint`);
-        if (seed['physical-format'] !== 'wasix-pg18-v1' ||
-            seed['compatibility-key'] !== 'wasix-pg18-datum32-v1') {
-            throw new Error(`WASIX ${profile} cluster seed has an incompatible physical identity`);
-        }
-        if (profile === 'icu') {
-            requireSha256(seed['icu-data-tree-sha256'], 'WASIX ICU seed data tree');
-        }
-        else if (seed['icu-data-tree-sha256'] !== undefined) {
-            throw new Error('WASIX standard cluster seed must not identify ICU data');
-        }
-    }
-    requireString(manifest['source-fingerprint'], 'WASIX asset source fingerprint');
     const runtimeSupport = requireArray(manifest['runtime-support'], 'WASIX runtime-support entries');
     for (const [index, value] of runtimeSupport.entries()) {
         const support = requireObject(value, `WASIX runtime-support entry ${index}`);
@@ -402,19 +379,18 @@ function parseClusterSeedManifest(bytes, expectedProfile) {
         'catalogProfile',
         'extensions',
         'icu',
-        'initProfile',
         'requiredRuntimeFeatures',
         'runtime',
         'schema',
         'source',
     ], label);
     assertClusterSeedProfileContract(root, expectedProfile);
-    requireString(root.initProfile, `${label} init profile`);
     const runtime = requireObject(root.runtime, `${label} runtime`);
     requireExactKeys(runtime, [
         'compatibilityKey',
         'consumerSha256',
         'engineFamily',
+        'target',
         'initdbSha256',
         'physicalFormat',
         'postgresMajor',
@@ -436,8 +412,8 @@ function parseClusterSeedManifest(bytes, expectedProfile) {
         requireSha256(runtime[field], `${label} runtime ${field}`);
     }
     const source = requireObject(root.source, `${label} source`);
-    requireExactKeys(source, ['catalogVersion', 'fingerprint', 'lane', 'producer'], `${label} source`);
-    for (const field of ['catalogVersion', 'fingerprint', 'lane', 'producer']) {
+    requireExactKeys(source, ['producer'], `${label} source`);
+    for (const field of ['producer']) {
         requireString(source[field], `${label} source ${field}`);
     }
     const archive = requireObject(root.archive, `${label} archive`);
@@ -486,82 +462,32 @@ export function assertClusterSeedProfileContract(value, expectedProfile) {
         throw new Error(`${label} must require exactly the ICU runtime feature`);
     }
     const icu = requireObject(root.icu, `${label} ICU identity`);
-    requireExactKeys(icu, [
-        'artifactRole',
-        'dataForm',
-        'dataTreeSha256',
-        'dataVersion',
-        'sourceCommit',
-        'upstreamVersion',
-    ], `${label} ICU identity`);
-    for (const field of [
-        'artifactRole',
-        'dataForm',
-        'dataVersion',
-        'sourceCommit',
-        'upstreamVersion',
-    ]) {
+    for (const field of ['artifactRole', 'dataForm', 'dataVersion']) {
         requireString(icu[field], `${label} ICU ${field}`);
     }
     requireSha256(icu.dataTreeSha256, `${label} ICU data tree`);
     if (icu.artifactRole !== 'icu-data' ||
-        icu.upstreamVersion !== '76.1' ||
         icu.dataVersion !== '76.1' ||
         icu.dataForm !== 'files-le') {
         throw new Error(`${label} has an incompatible ICU identity`);
     }
 }
-/** @internal Verify that a separately distributed ICU carrier belongs to this runtime. */
-export function assertIcuDescriptorMatchesRuntime(runtime, icu, manifest) {
-    if (icu.compatibility.runtimeProduct !== runtime.product ||
-        icu.compatibility.runtimeVersion !== runtime.version) {
-        throw new Error(`WASIX ICU carrier targets ${icu.compatibility.runtimeProduct}@${icu.compatibility.runtimeVersion}, not ${runtime.product}@${runtime.version}`);
-    }
-    if (icu.compatibility.dataTreeSha256 !== manifest['cluster-seeds'].icu['icu-data-tree-sha256']) {
-        throw new Error('WASIX ICU data and ICU cluster seed identify different logical data trees');
-    }
-}
-function verifyClusterSeedIdentity(options, outer, selected, seed, archive) {
-    const profile = seed.catalogProfile;
+function verifyClusterSeedIdentity(options, outer, seed, icuTree) {
     if (seed.runtime.product !== options.runtime.product ||
         seed.runtime.version !== options.runtime.version ||
         seed.runtime.engineFamily !== 'wasix' ||
+        seed.runtime.target !== 'portable' ||
         seed.runtime.physicalFormat !== 'wasix-pg18-v1' ||
         seed.runtime.compatibilityKey !== 'wasix-pg18-datum32-v1' ||
-        seed.runtime.postgresMajor !== 18) {
-        throw new Error(`WASIX ${profile} cluster seed has an incompatible runtime identity`);
-    }
+        seed.runtime.postgresMajor !== 18 ||
+        seed.source.producer !== 'wasix-initdb')
+        throw new Error('WASIX seed has an incompatible runtime identity');
     if (seed.runtime.consumerSha256 !== seed.runtime.producerSha256 ||
-        seed.runtime.consumerSha256 !== outer.runtime['module-sha256'] ||
-        seed.runtime.consumerSha256 !== selected['runtime-module-sha256']) {
-        throw new Error(`WASIX ${profile} cluster seed was produced by a different runtime module`);
-    }
-    if (seed.source.fingerprint !== outer['source-fingerprint'] ||
-        seed.source.fingerprint !== selected['source-fingerprint']) {
-        throw new Error(`WASIX ${profile} cluster seed has a different source fingerprint`);
-    }
-    if (seed.archive.path !== archive.archive ||
-        seed.archive.path !== selected.archive ||
-        seed.archive.sha256 !== archive.sha256 ||
-        seed.archive.sha256 !== selected.sha256 ||
-        seed.archive.compressedBytes !== archive.size ||
-        seed.archive.compressedBytes !== selected.size) {
-        throw new Error(`WASIX ${profile} cluster seed archive identity is inconsistent`);
-    }
-    if (seed.archive.path !== `cluster-seeds/${profile}.tar.zst`) {
-        throw new Error(`WASIX ${profile} cluster seed has a non-canonical archive path`);
-    }
-    if (profile === 'icu') {
-        const icu = options.icu;
-        if (icu === undefined ||
-            seed.icu === null ||
-            seed.icu.artifactRole !== 'icu-data' ||
-            seed.icu.upstreamVersion !== icu.compatibility.dataVersion ||
-            seed.icu.dataVersion !== icu.compatibility.dataVersion ||
-            seed.icu.dataForm !== icu.compatibility.dataForm ||
-            seed.icu.dataTreeSha256 !== icu.compatibility.dataTreeSha256) {
-            throw new Error('WASIX ICU cluster seed does not match the selected ICU data carrier');
-        }
+        seed.runtime.consumerSha256 !== outer.runtime['module-sha256']) {
+        throw new Error('WASIX seed was produced by a different runtime module');
+    }
+    if (seed.catalogProfile === 'icu' && seed.icu?.dataTreeSha256 !== icuTree) {
+        throw new Error('WASIX ICU seed does not match the selected ICU data');
     }
 }
 /** @internal Validate and add exact-archive-verified ICU files to the runtime tree. */
@@ -620,14 +546,13 @@ async function assertDeclaredAssetBytes(bytes, expectedSize, expectedSha256, lab
     }
     await assertSha256(bytes, expectedSha256, label);
 }
-function verifyPostgresIdentity(manifest, seed, pgVersionBytes) {
+function verifyPostgresIdentity(manifest, seedMajor, pgVersionBytes) {
     if (pgVersionBytes === undefined) {
         throw new Error('WASIX cluster seed is missing PG_VERSION');
     }
     const pgVersion = decodeUtf8(pgVersionBytes).trim();
     const runtimeMajor = manifest.runtime['postgres-version'].split('.')[0];
-    const seedMajor = seed['postgres-version'].split('.')[0];
-    if (pgVersion !== runtimeMajor || pgVersion !== seedMajor) {
+    if (pgVersion !== runtimeMajor || pgVersion !== String(seedMajor)) {
         throw new Error(`WASIX runtime/cluster seed PostgreSQL major mismatch: runtime ${runtimeMajor}, seed ${seedMajor}, PG_VERSION ${pgVersion}`);
     }
 }

package/lib/resources/icu-descriptor.d.ts

@@ -0,0 +1,3 @@
+import type { SerializedIcuDescriptor, SerializedSeed } from '../workers/rpc.js';
+export declare function serializeWasixIcuDescriptor(value: unknown): SerializedIcuDescriptor;
+export declare function serializeWasixSeed(value: unknown): SerializedSeed;

package/lib/resources/icu-descriptor.js

@@ -0,0 +1,16 @@
+import { requireAssetSource, requireExactObject, serializeAssetSource, } from './descriptor-validation.js';
+function source(value, label) {
+    const size = value instanceof Uint8Array || value instanceof ArrayBuffer ? value.byteLength : 0;
+    return serializeAssetSource(requireAssetSource(value, label, size));
+}
+export function serializeWasixIcuDescriptor(value) {
+    const data = requireExactObject(value, ['data', 'manifest'], 'ICU data');
+    return { data: source(data.data, 'ICU data'), manifest: source(data.manifest, 'ICU manifest') };
+}
+export function serializeWasixSeed(value) {
+    const seed = requireExactObject(value, ['archive', 'manifest'], 'WASIX seed');
+    return {
+        archive: source(seed.archive, 'seed archive'),
+        manifest: source(seed.manifest, 'seed manifest'),
+    };
+}

package/lib/{runtime-descriptor.d.ts → resources/runtime-descriptor.d.ts}

@@ -1,3 +1,3 @@
-import type { SerializedRuntimeDescriptor } from './rpc.js';
+import type { SerializedRuntimeDescriptor } from '../workers/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 → resources/runtime-descriptor.js}

@@ -1,14 +1,5 @@
 import { requireAssetSource, requireExactObject, requireSafeRelativeAssetPath, requireSha256, requireSize, requireVersion, serializeAssetSource, } from './descriptor-validation.js';
-const DESCRIPTOR_FIELDS = [
-    'manifest',
-    'product',
-    'runtime',
-    'runtimeArchive',
-    'schema',
-    'standardSeedArchive',
-    'standardSeedManifest',
-    'version',
-];
+const DESCRIPTOR_FIELDS = ['manifest', 'product', 'runtime', 'runtimeArchive', 'schema', '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. */
@@ -20,8 +11,6 @@ export function serializeWasixRuntimeDescriptor(value) {
         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,
@@ -42,12 +31,7 @@ function validateRuntimeDescriptor(value, label) {
     }
     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);
@@ -70,10 +54,3 @@ function serializeArchive(archive) {
         source: serializeAssetSource(archive.source),
     };
 }
-function serializeManifest(manifest) {
-    return {
-        sha256: manifest.sha256,
-        size: manifest.size,
-        source: serializeAssetSource(manifest.source),
-    };
-}

package/lib/{tool-runtime.d.ts → resources/tool-runtime.d.ts}

@@ -1,10 +1,15 @@
-import type { Directory, RunWasixOptions } from './host/index.mjs';
-import type { SerializedAssetSource } from './rpc.js';
+import type { Directory, RunWasixOptions } from '../host/index.mjs';
+import type { SerializedAssetSource } from '../workers/rpc.js';
 export type WasixToolDescriptor = Readonly<{
     name: 'pg_dump' | 'psql';
     sha256: string;
     size: number;
     source: SerializedAssetSource;
+    /** Selected native target carrier; browser execution only needs source. */
+    aot?: Readonly<{
+        source: SerializedAssetSource;
+        manifest: SerializedAssetSource;
+    }>;
 }>;
 export type WasixToolProcessOptions = Readonly<{
     runtimeVersion: string;
@@ -12,6 +17,7 @@ export type WasixToolProcessOptions = Readonly<{
     args: readonly string[];
     /** @internal An exact ArrayBuffer-backed view is transferred and consumed. */
     stdin?: Uint8Array;
+    command?: string;
 }>;
 export type WasixToolProcessResult = Readonly<{
     exitCode: number;

package/lib/server.node.d.ts

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

package/lib/server.node.js

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

package/lib/{database-root.d.ts → storage/database-root.d.ts}

@@ -3,6 +3,14 @@ export declare const DATABASE_ROOT_SCHEMA = "oliphaunt-database-root-v1";
 export declare const DATABASE_ROOT_PGDATA = "pgdata";
 export declare const DATABASE_ROOT_POSTGRES_MAJOR: 18;
 export declare const WASIX_PHYSICAL_FORMAT: "wasix-pg18-v1";
+/** Stable fields that determine whether a WASIX runtime may open stored PGDATA. */
+export type WasixPhysicalIdentity = Readonly<{
+    schema: 'oliphaunt-physical-format-v1';
+    engineFamily: 'wasix';
+    postgresMajor: number;
+    physicalFormat: string;
+}>;
+export declare const WASIX_PHYSICAL_IDENTITY: WasixPhysicalIdentity;
 export declare const NATIVE_PHYSICAL_FORMAT = "native-pg18-v1";
 export type DatabaseRootDescriptor = Readonly<{
     schema: typeof DATABASE_ROOT_SCHEMA;

package/lib/{database-root.js → storage/database-root.js}

@@ -4,6 +4,12 @@ export const DATABASE_ROOT_SCHEMA = 'oliphaunt-database-root-v1';
 export const DATABASE_ROOT_PGDATA = 'pgdata';
 export const DATABASE_ROOT_POSTGRES_MAJOR = CARRIER_POSTGRES_MAJOR;
 export const WASIX_PHYSICAL_FORMAT = CARRIER_PHYSICAL_FORMAT;
+export const WASIX_PHYSICAL_IDENTITY = Object.freeze({
+    schema: 'oliphaunt-physical-format-v1',
+    engineFamily: 'wasix',
+    postgresMajor: DATABASE_ROOT_POSTGRES_MAJOR,
+    physicalFormat: WASIX_PHYSICAL_FORMAT,
+});
 export const NATIVE_PHYSICAL_FORMAT = 'native-pg18-v1';
 export function wasixDatabaseRootDescriptor() {
     return {

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

@@ -1,6 +1,6 @@
-import type { WasixStorageCommitState } from '../errors.js';
-import type { WasixClusterSeedLoader, WasixStorageLease } from '../storage-provider.js';
-import { type StorageDelta, type StoredSnapshot } from '../storage-snapshot.js';
+import type { WasixStorageCommitState } from '../core/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>;
 };

package/lib/storage/incremental-storage.js

@@ -1,5 +1,5 @@
-import { composeWasixStorageFailure, WasixStorageError } from '../errors.js';
-import { applyStorageDeltaToEntries, snapshotStorageDelta, snapshotToMount, } from '../storage-snapshot.js';
+import { composeWasixStorageFailure, WasixStorageError } from '../core/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,

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

@@ -1,5 +1,5 @@
-import { type WasixClusterSeedLoader, type WasixPhysicalIdentity, type WasixStorageLease } from '../storage-provider.js';
-import { type StorageDelta, type StoredSnapshot } from '../storage-snapshot.js';
+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';

package/lib/storage/indexed-db-provider.js

@@ -1,6 +1,6 @@
-import { WasixStorageError } from '../errors.js';
-import { assertWasixPhysicalIdentity, physicalIdentityMatches, } from '../storage-provider.js';
-import { requireRecord, validateStoredSnapshot, } from '../storage-snapshot.js';
+import { WasixStorageError } from '../core/errors.js';
+import { assertWasixPhysicalIdentity, physicalIdentityMatches, } from './storage-provider.js';
+import { requireRecord, validateStoredSnapshot, } from './storage-snapshot.js';
 import { acquireIncrementalStorage } from './incremental-storage.js';
 import { releaseRestoreLock } from './restore-cleanup.js';
 import { acquireExclusiveWebLock } from './web-lock.js';

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

@@ -1,9 +1,9 @@
-import { type PersistentWasixStorage } from '../storage.js';
+import { type PersistentWasixStorage } from './types.js';
 /**
  * Select an origin-scoped persistent database.
  *
  * Every completed protocol operation commits only journaled PGDATA path
  * changes in one atomic read-write IndexedDB transaction before its Promise resolves.
  */
-export declare function indexedDB(name: string): PersistentWasixStorage;
+export declare function indexedDB(name: string): PersistentWasixStorage<'indexed-db'>;
 export default indexedDB;

package/lib/storage/indexed-db.js

@@ -1,4 +1,4 @@
-import { defineIndexedDbStorage } from '../storage.js';
+import { defineIndexedDbStorage } from './types.js';
 /**
  * Select an origin-scoped persistent database.
  *

package/lib/storage/node.d.ts

@@ -1,4 +1,4 @@
-import { type PersistentWasixStorage } from '../storage.js';
+import { type PersistentWasixStorage } from './types.js';
 /**
  * Persist a managed database below a Node.js host directory.
  *
@@ -6,5 +6,5 @@ import { type PersistentWasixStorage } from '../storage.js';
  * and performs PostgreSQL-safe durable writes at each native operation
  * boundary. Network and cross-host shared filesystems are unsupported.
  */
-export declare function directory(path: string | URL): PersistentWasixStorage;
+export declare function directory(path: string | URL): PersistentWasixStorage<'directory'>;
 export default directory;

package/lib/storage/node.js

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'node:url';
-import { defineDirectoryStorage } from '../storage.js';
+import { defineDirectoryStorage } from './types.js';
 /**
  * Persist a managed database below a Node.js host directory.
  *