@nimbus-sh/worker 0.6.0 → 0.7.0

package/dist/facets/vite-dev-server.js

@@ -26,7 +26,7 @@ import { getSharedRuntimeExternals, BUNDLER_VERSION } from '@nimbus-sh/core/runt
 import { NpmCache } from '../npm/cache.js';
 import { sha256Base64Url } from '@nimbus-sh/core/_shared/crypto.js';
 import { LruMap } from '@nimbus-sh/core/_shared/lru-map.js';
-import { OnDemandBundleGate } from './on-demand-bundle-gate.js';
+import { acquireSupervisorAllocation } from '@nimbus-sh/platform/heavy-alloc-coord.js';
 import { VITE_MODULE_CACHE_MAX_ENTRIES, ON_DEMAND_SLICE_CAP_BYTES } from '@nimbus-sh/core/constants.js';
 import { countPackageFiles, BARREL_PKG_FILE_THRESHOLD, packageNameFromSpecifier } from '@nimbus-sh/core/runtime/barrel-detect.js';
 import { scanNamedImports, namedImportSignature, buildSyntheticEntry, buildScopedSliceForSynthetic, syntheticEntryPath, } from '../runtime/barrel-synthesizer.js';
@@ -1168,15 +1168,10 @@ export class ViteDevServer {
     npmCache = null;
     /** Inject React Router basename into entry files? Default: true. */
     injectBasename;
-    /** Worker env (LOADER, ctx.exports) for the on-demand-bundle facet path.
-     *  Null = legacy in-supervisor esbuild fallback. */
     env;
     ctx = null;
-    /** Lazily-constructed pool for on-demand bundling. Mirrors the
-     *  pre-bundle pool's wasm-modules-map shape. Created on first
-     *  cold-path /preview/@modules/<spec> request. */
-    onDemandPool = null;
-    onDemandPoolPromise = null;
+    /** The session's esbuild facet pool; null = legacy in-supervisor esbuild. */
+    bundlePool;
     /**
      * In-flight on-demand-bundle coalescing map. When the browser fires
      * multiple parallel requests for the same /preview/@modules/<spec>
@@ -1194,21 +1189,6 @@ export class ViteDevServer {
      * crashes the supervisor for N≥3 on a busy isolate.
      */
     pendingBundles = new Map();
-    /**
-     * Byte-budget admission gate for the on-demand bundle slow path.
-     * Replaces the former single-slot semaphore: instead of serializing
-     * every cold bundle (which made a fresh-React first load multi-second
-     * because each distinct /@modules/ spec waited for the previous), it
-     * bounds the TOTAL slice BYTES resident in the supervisor at once.
-     *
-     * Many small slices' facet RPC round-trips overlap; a single large
-     * (~28 MiB) slice still serializes the rest. Peak resident slice bytes
-     * never exceed ON_DEMAND_SLICE_CAP_BYTES — the same one-slice envelope
-     * the install-time pre-bundler proved safe on shared DO isolates — so
-     * this is a latency win with no supervisor-heap regression. Coupled
-     * with pendingBundles (same-spec coalescing) as before.
-     */
-    onDemandGate = new OnDemandBundleGate(ON_DEMAND_SLICE_CAP_BYTES);
     /**
      * process diagnostics support: the supervisor's per-PID log store. When set
      * (alongside `pid`), every diagnostic emitted by the dev server is
@@ -1238,6 +1218,7 @@ export class ViteDevServer {
         this.aliases = opts.aliases || {};
         this.env = opts.env;
         this.ctx = opts.ctx ?? null;
+        this.bundlePool = opts.bundlePool ?? null;
         if (opts.sql) {
             this.npmCache = new NpmCache(opts.sql);
         }
@@ -1262,48 +1243,16 @@ export class ViteDevServer {
         this.detectTailwind();
     }
     /**
-     * Lazily construct the IsolatePool used for on-demand bundling
-     * of /preview/@modules/<spec> requests that miss both the in-memory
-     * and pkg_esm_bundles caches. Mirrors the pre-bundle pool's
-     * configuration: 1 worker, internal pLimit not needed (one bundle
-     * per request), wasm shipped via wasmModules.
-     *
-     * Returns null when env/ctx aren't available (legacy fallback used).
+     * The session's shared esbuild pool for on-demand bundling of
+     * /preview/@modules/<spec> requests that miss both the in-memory and
+     * pkg_esm_bundles caches. Null when no pool was provided (legacy
+     * in-supervisor fallback). Acquired BEFORE the slice lease — see
+     * EsbuildBundlePool.acquire.
      */
     async ensureOnDemandPool() {
-        if (this.onDemandPool)
-            return this.onDemandPool;
-        if (this.onDemandPoolPromise)
-            return this.onDemandPoolPromise;
-        if (!this.env || !this.ctx)
+        if (!this.bundlePool)
             return null;
-        this.onDemandPoolPromise = (async () => {
-            const { IsolatePool } = await import('@nimbus-sh/fabric/isolate-pool.js');
-            const { PRE_BUNDLE_PREAMBLE } = await import('../loaders/pre-bundle-preamble.js');
-            const { fetchEsbuildWasmBytes } = await import('../runtime/esbuild-wasm-bytes.js');
-            const wasmBytes = await fetchEsbuildWasmBytes(this.env);
-            const pool = new IsolatePool(this.env, this.ctx, {
-                concurrency: 1,
-                timeoutMs: 60_000,
-                retries: 0,
-                // Use a distinct tag so the on-demand pool's cached worker
-                // doesn't collide with the install-time pre-bundle pool.
-                // Sharing fnHash + preamble + wasm fingerprint between pools
-                // would otherwise alias them in workerd's loader cache.
-                tag: 'on-demand-bundle',
-                preamble: PRE_BUNDLE_PREAMBLE,
-                wasmModules: { 'esbuild.wasm': wasmBytes },
-            });
-            this.onDemandPool = pool;
-            return pool;
-        })();
-        try {
-            return await this.onDemandPoolPromise;
-        }
-        catch (e) {
-            this.onDemandPoolPromise = null;
-            throw e;
-        }
+        return this.bundlePool.acquire();
     }
     /** Detect TailwindCSS usage in the project */
     detectTailwind() {
@@ -1756,39 +1705,40 @@ export class ViteDevServer {
                 });
             }
         }
-        // ── Cold path coalescing + byte-budget admission ──────────────
+        // ── Cold path coalescing ──────────────────────────────────────
         // Multiple parallel browser requests for the same module are
         // common on first preview load; coalesce so exactly ONE bundle
-        // attempt runs per spec. Across DIFFERENT specs, the byte-budget
-        // gate bounds total resident slice bytes so small slices overlap
-        // while peak supervisor memory stays at one slice. See
-        // `pendingBundles` and `onDemandGate` field docs for context.
+        // attempt runs per spec. Across DIFFERENT specs, the cold path
+        // leases its slice bytes from the shared supervisor allocation
+        // budget before building, so it queues behind every other heavy
+        // owner in this isolate (the pre-bundler included) instead of
+        // stacking slices beside them. See `pendingBundles`.
+        //
+        // The shared promise resolves to a Response nobody consumes
+        // directly: a Response body is readable once, so every coalesced
+        // consumer — the initiator included — takes its own clone.
         const inflight = this.pendingBundles.get(cacheKey);
         if (inflight)
-            return inflight;
-        const coldPromise = this.onDemandGate.run((admit) => this.serveModuleCold(specifier, headers, base, barrelInfo, admit));
+            return inflight.then((response) => response.clone());
+        const coldPromise = this.serveModuleCold(specifier, headers, base, barrelInfo);
         this.pendingBundles.set(cacheKey, coldPromise);
-        coldPromise.finally(() => {
-            // Drop the coalescing entry once settled. Subsequent requests
-            // for the same spec will hit the moduleCache (set inside the
-            // cold path) on the hot path, not re-enter the slow path.
-            this.pendingBundles.delete(cacheKey);
-        });
-        return coldPromise;
+        // Drop the coalescing entry once settled. Subsequent requests
+        // for the same spec will hit the moduleCache (set inside the
+        // cold path) on the hot path, not re-enter the slow path.
+        coldPromise.then(() => this.pendingBundles.delete(cacheKey), () => this.pendingBundles.delete(cacheKey));
+        return coldPromise.then((response) => response.clone());
     }
     /**
      * Cold path of serveModule: package resolution → on-demand facet
      * bundle (synthetic-entry for barrels) → hard-error if bundle fails.
      * NO CDN fallback (100% edge contract). Extracted so the coalescing
-     * + gate wrapper in serveModule() reads cleanly. Always runs inside
-     * the on-demand byte-budget gate — see serveModule's wrapper.
-     *
-     * `admit` reserves the built slice's real byte size against the gate's
-     * budget and releases the build lock for the next spec. It is called
-     * exactly once, right after the slice is built and before the facet
-     * submit; bail-out paths that never build a slice simply never call it.
+     * wrapper in serveModule() reads cleanly. The slice this body builds is
+     * leased from the shared supervisor allocation budget for its worst
+     * case before it is built, shrunk to its real size once built, and
+     * released only after the facet result has been rewritten, cached and
+     * wrapped in the Response — the pre-bundler's per-slice pattern.
      */
-    async serveModuleCold(specifier, headers, base, knownBarrelInfo = null, admit) {
+    async serveModuleCold(specifier, headers, base, knownBarrelInfo = null) {
         const JS_CT = 'application/javascript; charset=utf-8';
         const cacheKey = this.ck(base, `@modules/${specifier}`);
         // 3. On-demand bundle (cold path — resolve from node_modules, bundle via esbuild)
@@ -1797,12 +1747,13 @@ export class ViteDevServer {
         // supervisor isolate. For large modules (lucide-react, ~18 MiB
         // unpacked) that OOM'd the supervisor and surfaced as CF error
         // 1101 on /preview/@modules/lucide-react, taking down the entire
-        // preview. We now dispatch the bundle work to a IsolatePool
-        // isolate via its own 128 MiB heap — same pattern as install-time
-        // pre-bundling. Supervisor never bundles esbuild for any path.
+        // preview. We now dispatch the bundle work to the session's shared
+        // esbuild IsolatePool — the same pool, isolate and 128 MiB heap the
+        // install-time pre-bundler uses. Supervisor never bundles esbuild
+        // for any path.
         //
-        // Falls back to in-supervisor esbuild ONLY if env/ctx aren't
-        // available (e.g. legacy callers / tests).
+        // Falls back to in-supervisor esbuild ONLY if no bundle pool was
+        // provided (legacy callers / tests).
         const resolved = this.resolvePackage(specifier);
         // Barrel packages (lucide-react, @phosphor-icons/react, react-icons,
         // @mui/icons-material, …) ship hundreds/thousands of tiny re-export
@@ -1894,148 +1845,163 @@ export class ViteDevServer {
                 this.log('warn', `[vite-dev] synthesized entry for ${specifier} ` +
                     `(barrel: ${fileCount} files; ${names.size} static imports → tree-shaken bundle)`);
             }
-            if (onDemandPool) {
-                // Facet path — supervisor stays at 0 esbuild bytes.
-                try {
-                    const { buildSliceForSpecifierWithCap, prebundleOne, BUNDLER_VERSION, } = await import('../npm/pre-bundle-facet.js');
-                    const SLICE_CAP_BYTES = ON_DEMAND_SLICE_CAP_BYTES;
-                    const projDir = this.root;
-                    const nmDir = projDir + '/node_modules';
-                    let slice = null;
-                    if (synthetic && syntheticReferencedFiles) {
-                        // SCOPED slice: only the files the synthetic entry directly
-                        // references (+ transitive relative imports + package.json).
-                        // Skips the full package walk so icon-libraries with
-                        // thousands of files don't blow the 28 MiB cap.
-                        const scoped = buildScopedSliceForSynthetic(this.vfs, nmDir, pkgName, syntheticReferencedFiles);
-                        const built = {
-                            slice: scoped.entries,
-                            totalBytes: scoped.totalBytes,
-                        };
-                        try {
-                            const bytes = this.vfs.readFile(bundleEntryPath);
-                            const parentDir = bundleEntryPath.substring(0, bundleEntryPath.lastIndexOf('/'));
-                            built.slice.push({ path: '/' + parentDir.replace(/^\/+/, ''), isDir: true });
-                            built.slice.push({
-                                path: '/' + bundleEntryPath.replace(/^\/+/, ''),
-                                bytes,
-                                isDir: false,
-                            });
-                            built.totalBytes += bytes.length + bundleEntryPath.length;
+            // Held from before the slice is built until the Response wrapping
+            // its bundle exists — see the method doc. Null on the legacy path.
+            let sliceLease = null;
+            try {
+                if (onDemandPool) {
+                    // Facet path — supervisor stays at 0 esbuild bytes.
+                    try {
+                        const { buildSliceForSpecifierWithCap, prebundleOne, BUNDLER_VERSION, } = await import('../npm/pre-bundle-facet.js');
+                        const SLICE_CAP_BYTES = ON_DEMAND_SLICE_CAP_BYTES;
+                        const projDir = this.root;
+                        const nmDir = projDir + '/node_modules';
+                        // Lease the slice's worst-case supervisor footprint BEFORE it is
+                        // allocated. FIFO byte credit is what stops this slice from
+                        // stacking beside a pre-bundle slice, a streamed install write or
+                        // a VFS read that independently claimed the same shared-isolate
+                        // headroom. The pool was acquired above, so nothing this waits
+                        // on is waiting on us.
+                        sliceLease = await acquireSupervisorAllocation(SLICE_CAP_BYTES);
+                        let slice = null;
+                        if (synthetic && syntheticReferencedFiles) {
+                            // SCOPED slice: only the files the synthetic entry directly
+                            // references (+ transitive relative imports + package.json).
+                            // Skips the full package walk so icon-libraries with
+                            // thousands of files don't blow the 28 MiB cap.
+                            const scoped = buildScopedSliceForSynthetic(this.vfs, nmDir, pkgName, syntheticReferencedFiles);
+                            const built = {
+                                slice: scoped.entries,
+                                totalBytes: scoped.totalBytes,
+                            };
+                            try {
+                                const bytes = this.vfs.readFile(bundleEntryPath);
+                                const parentDir = bundleEntryPath.substring(0, bundleEntryPath.lastIndexOf('/'));
+                                built.slice.push({ path: '/' + parentDir.replace(/^\/+/, ''), isDir: true });
+                                built.slice.push({
+                                    path: '/' + bundleEntryPath.replace(/^\/+/, ''),
+                                    bytes,
+                                    isDir: false,
+                                });
+                                built.totalBytes += bytes.length + bundleEntryPath.length;
+                            }
+                            catch (e) {
+                                this.log('error', '[vite-dev] synthetic entry unreadable for ' + specifier + ': ' + (e?.message || e));
+                            }
+                            slice = built;
+                        }
+                        else {
+                            slice = buildSliceForSpecifierWithCap(this.vfs, specifier, nmDir, SLICE_CAP_BYTES);
                         }
-                        catch (e) {
-                            this.log('error', '[vite-dev] synthetic entry unreadable for ' + specifier + ': ' + (e?.message || e));
+                        if (slice) {
+                            // The real size is known now: give back the credit the slice
+                            // did not use so smaller owners can proceed beside it. The
+                            // lease only shrinks to a positive size no larger than itself.
+                            if (slice.totalBytes > 0 && slice.totalBytes < sliceLease.bytes) {
+                                sliceLease.shrinkTo(slice.totalBytes);
+                            }
+                            // Build the spec, then drop our supervisor-side handle to
+                            // the slice array immediately — `spec` is the only thing
+                            // that needs to keep it alive until the RPC structured-clone
+                            // completes. Mirrors the install-time runSlot pattern (see
+                            // commit 40cfc01); the lease above keeps every other budget
+                            // owner from allocating beside it until the Response exists.
+                            let spec = {
+                                specifier,
+                                entryPath: bundleEntryPath,
+                                externals,
+                                slice: slice.slice,
+                                bundlerVersion: BUNDLER_VERSION,
+                                // Base-neutral: the @modules bundle is persisted raw and shared
+                                // across mounts, so BASE_URL is fixed to '/' here (module URLs
+                                // get the per-request base applied at serve time, not baked in).
+                                define: this.defineFor(''),
+                            };
+                            slice = null;
+                            let result = null;
+                            try {
+                                result = await onDemandPool.submit(prebundleOne, spec);
+                            }
+                            finally {
+                                spec = null;
+                            }
+                            if (result && result.ok && result.esmCode) {
+                                bundled = result.esmCode;
+                            }
+                            else if (result && result.errorText) {
+                                this.log('error', '[vite-dev] facet bundle failed for ' + specifier + ': ' + result.errorText);
+                            }
+                            result = null;
+                        }
+                        else {
+                            this.log('error', '[vite-dev] slice walker exceeded cap for ' + specifier);
                         }
-                        slice = built;
                     }
-                    else {
-                        slice = buildSliceForSpecifierWithCap(this.vfs, specifier, nmDir, SLICE_CAP_BYTES);
+                    catch (e) {
+                        this.log('error', '[vite-dev] on-demand facet dispatch failed for ' + specifier + ': ' + (e?.message || e));
                     }
-                    if (slice) {
-                        // Slice is built and its real size is known — reserve that
-                        // many bytes against the gate's budget (blocking if a large
-                        // slice is already in flight) and release the build lock so
-                        // the next spec can build while this one's facet RPC runs.
-                        if (admit)
-                            await admit(slice.totalBytes);
-                        // Build the spec, then drop our supervisor-side handle to
-                        // the slice array immediately — `spec` is the only thing
-                        // that needs to keep it alive until the RPC structured-clone
-                        // completes. Mirrors the install-time runSlot pattern (see
-                        // commit 40cfc01) so peak supervisor heap during a flurry of
-                        // /preview/@modules/* requests stays bounded by the gate.
-                        let spec = {
-                            specifier,
-                            entryPath: bundleEntryPath,
-                            externals,
-                            slice: slice.slice,
-                            bundlerVersion: BUNDLER_VERSION,
-                            // Base-neutral: the @modules bundle is persisted raw and shared
-                            // across mounts, so BASE_URL is fixed to '/' here (module URLs
-                            // get the per-request base applied at serve time, not baked in).
+                }
+                else {
+                    // Legacy fallback — in-supervisor esbuild. Used only when no
+                    // bundle pool was provided.
+                    try {
+                        const result = await this.esbuild.build([bundleEntryPath], {
+                            bundle: true,
+                            format: 'esm',
+                            platform: 'browser',
+                            target: 'esnext',
+                            // Base-neutral (see the pooled build above).
                             define: this.defineFor(''),
-                        };
-                        slice = null;
-                        let result = null;
-                        try {
-                            result = await onDemandPool.submit(prebundleOne, spec);
-                        }
-                        finally {
-                            spec = null;
-                        }
-                        if (result && result.ok && result.esmCode) {
-                            bundled = result.esmCode;
-                        }
-                        else if (result && result.errorText) {
-                            this.log('error', '[vite-dev] facet bundle failed for ' + specifier + ': ' + result.errorText);
+                            external: externals.length > 0 ? externals : undefined,
+                        });
+                        if (result.outputFiles?.length) {
+                            bundled = result.outputFiles[0].contents;
                         }
-                        result = null;
                     }
-                    else {
-                        this.log('error', '[vite-dev] slice walker exceeded cap for ' + specifier);
+                    catch (e) {
+                        this.log('error', '[vite-dev] esbuild bundle failed for ' + specifier + ': ' + (e?.message || e));
                     }
                 }
-                catch (e) {
-                    this.log('error', '[vite-dev] on-demand facet dispatch failed for ' + specifier + ': ' + (e?.message || e));
-                }
-            }
-            else {
-                // Legacy fallback — in-supervisor esbuild. Used only when
-                // env/ctx weren't passed in (no facet pool can be built).
-                try {
-                    const result = await this.esbuild.build([bundleEntryPath], {
-                        bundle: true,
-                        format: 'esm',
-                        platform: 'browser',
-                        target: 'esnext',
-                        // Base-neutral (see the pooled build above).
-                        define: this.defineFor(''),
-                        external: externals.length > 0 ? externals : undefined,
-                    });
-                    if (result.outputFiles?.length) {
-                        bundled = result.outputFiles[0].contents;
+                if (bundled !== null) {
+                    // Persist the RAW esbuild output. It is base-independent — the only
+                    // base-dependent step is the module-URL rewrite below, applied at
+                    // serve time — so one persisted bundle serves every mount (the
+                    // `/preview/` path and the `<port>--<sid>` host alike). Caching the
+                    // post-rewrite text instead would pin the bundle to whichever base
+                    // built it first and 404 the other. Cache ONLY successful bundles;
+                    // a failed build left `bundled` null and never reaches here.
+                    if (this.npmCache) {
+                        try {
+                            this.npmCache.putEsmBundle({
+                                specifier,
+                                bundleHash: BUNDLER_VERSION,
+                                esmCode: bundled,
+                                builtAt: Date.now(),
+                                inputHash: barrelInfo?.inputHash ?? '',
+                            });
+                        }
+                        catch { /* non-fatal */ }
                     }
-                }
-                catch (e) {
-                    this.log('error', '[vite-dev] esbuild bundle failed for ' + specifier + ': ' + (e?.message || e));
+                    // Convert `__require("external")` calls (from CJS source with esbuild
+                    // externals) into ESM `import * as` + dispatch, and rewrite any bare
+                    // imports esbuild marked external so they carry the mount base.
+                    // Without the base prefix, `import X from "scheduler"` 404s.
+                    let code = rewriteExternalRequires(bundled, base);
+                    code = rewriteAllImports(code, this.aliases, base);
+                    // For CJS-only packages (react, react-dom), esbuild's __commonJS
+                    // wrapper only emits `export default` — named imports like
+                    // `import { createRoot } from "react-dom/client"` would fail. Statically
+                    // scan the bundled source for CJS export patterns and synthesize
+                    // named exports.
+                    code = synthesizeCjsNamedExports(code);
+                    this.moduleCache.set(cacheKey, { code, timestamp: Date.now(), inputHash: barrelInfo?.inputHash ?? '' });
+                    return new Response(code, {
+                        headers: { ...headers, 'Content-Type': JS_CT },
+                    });
                 }
             }
-            if (bundled !== null) {
-                // Persist the RAW esbuild output. It is base-independent — the only
-                // base-dependent step is the module-URL rewrite below, applied at
-                // serve time — so one persisted bundle serves every mount (the
-                // `/preview/` path and the `<port>--<sid>` host alike). Caching the
-                // post-rewrite text instead would pin the bundle to whichever base
-                // built it first and 404 the other. Cache ONLY successful bundles;
-                // a failed build left `bundled` null and never reaches here.
-                if (this.npmCache) {
-                    try {
-                        this.npmCache.putEsmBundle({
-                            specifier,
-                            bundleHash: BUNDLER_VERSION,
-                            esmCode: bundled,
-                            builtAt: Date.now(),
-                            inputHash: barrelInfo?.inputHash ?? '',
-                        });
-                    }
-                    catch { /* non-fatal */ }
-                }
-                // Convert `__require("external")` calls (from CJS source with esbuild
-                // externals) into ESM `import * as` + dispatch, and rewrite any bare
-                // imports esbuild marked external so they carry the mount base.
-                // Without the base prefix, `import X from "scheduler"` 404s.
-                let code = rewriteExternalRequires(bundled, base);
-                code = rewriteAllImports(code, this.aliases, base);
-                // For CJS-only packages (react, react-dom), esbuild's __commonJS
-                // wrapper only emits `export default` — named imports like
-                // `import { createRoot } from "react-dom/client"` would fail. Statically
-                // scan the bundled source for CJS export patterns and synthesize
-                // named exports.
-                code = synthesizeCjsNamedExports(code);
-                this.moduleCache.set(cacheKey, { code, timestamp: Date.now(), inputHash: barrelInfo?.inputHash ?? '' });
-                return new Response(code, {
-                    headers: { ...headers, 'Content-Type': JS_CT },
-                });
+            finally {
+                sliceLease?.release();
             }
             // Bundle failed — fall through to the hard-error response below.
             // Previously fell through to a CDN fallback (esm.sh) but that

package/dist/facets/wasm-image-digest.d.ts

@@ -0,0 +1,25 @@
+/**
+ * wasm-image-digest.ts — the content key a wasm image is registered under.
+ *
+ * A launch stages every wasm image its program's closure holds as a
+ * module-map member, compiled by the loader, and registers it by VFS path
+ * AND by a digest of its bytes. The node-shims WebAssembly seam answers
+ * `new WebAssembly.Module(bytes)` / `WebAssembly.compile(bytes)` with the
+ * compiled module when the bytes match a registered digest — whether the
+ * program read them off the filesystem, inlined them as base64 in its own
+ * source, or received them some other way. The key is what wasm IS, not how
+ * it arrived.
+ *
+ * Length and FNV-1a over every byte. Synchronous because
+ * `new WebAssembly.Module(bytes)` is, and SubtleCrypto is not. Duplicated in
+ * node-shims.ts (`__nimbusWasmDigest`) because that copy runs inside a facet
+ * with no imports; both must compute the same value, which a unit test pins.
+ */
+export declare function wasmImageDigest(bytes: Uint8Array): string;
+/** One wasm image a launch registers: where the program reads it, and its content key. */
+export interface WasmImageRecord {
+    /** Absolute VFS path (leading slash). */
+    vfsPath: string;
+    digest: string;
+}
+//# sourceMappingURL=wasm-image-digest.d.ts.map

package/dist/facets/wasm-image-digest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-image-digest.d.ts","sourceRoot":"","sources":["../../src/facets/wasm-image-digest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAOzD;AAED,0FAA0F;AAC1F,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB"}

package/dist/facets/wasm-image-digest.js

@@ -0,0 +1,25 @@
+/**
+ * wasm-image-digest.ts — the content key a wasm image is registered under.
+ *
+ * A launch stages every wasm image its program's closure holds as a
+ * module-map member, compiled by the loader, and registers it by VFS path
+ * AND by a digest of its bytes. The node-shims WebAssembly seam answers
+ * `new WebAssembly.Module(bytes)` / `WebAssembly.compile(bytes)` with the
+ * compiled module when the bytes match a registered digest — whether the
+ * program read them off the filesystem, inlined them as base64 in its own
+ * source, or received them some other way. The key is what wasm IS, not how
+ * it arrived.
+ *
+ * Length and FNV-1a over every byte. Synchronous because
+ * `new WebAssembly.Module(bytes)` is, and SubtleCrypto is not. Duplicated in
+ * node-shims.ts (`__nimbusWasmDigest`) because that copy runs inside a facet
+ * with no imports; both must compute the same value, which a unit test pins.
+ */
+export function wasmImageDigest(bytes) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < bytes.length; i++) {
+        hash ^= bytes[i];
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return bytes.length + ':' + hash.toString(16);
+}