@nimbus-sh/worker 0.10.0 → 0.11.0

package/dist/runtime/esbuild-wasm-bytes.js

@@ -1,8 +1,9 @@
 /**
- * esbuild-wasm-bytes.ts — supervisor-side fetcher for the two esbuild-wasm
- * artifacts a transform facet is built from: the wasm binary and the JS
- * adapter that drives it. Both live in the static-assets layer
- * (env.ASSETS); this module hands them to the caller when needed.
+ * esbuild-wasm-bytes.ts — supervisor-side fetcher for the artifacts the
+ * esbuild facet is built from: the wasm binary, the JS adapter that drives
+ * it, and the runner of the `esbuild` command. All three live in the
+ * static-assets layer (env.ASSETS); this module hands them to the caller when
+ * needed.
  *
  * Cache strategy
  * ──────────────
@@ -32,7 +33,10 @@
  * The JS adapter followed the wasm for the same reason at a smaller
  * scale: the supervisor already imports esbuild-wasm's browser build as a
  * module for its own transforms, so carrying the same 117 KiB again as a
- * string literal for facets doubled it in the Worker bundle.
+ * string literal for facets doubled it in the Worker bundle. The CLI runner
+ * (32 KiB of Go glue and fs shim) only ever runs in the facet, so it is
+ * staged too; its name carries a prefix of its digest, because unlike the
+ * other two it changes without an esbuild upgrade.
  *
  * Each call to `fetchEsbuildWasmBytes(env)` now does:
  *   - one `caches.default.match()` — sub-millisecond on hit
@@ -49,8 +53,8 @@
  * digest the generator recorded before returning).
  */
 import { ESBUILD_JS_ASSET_PATH, ESBUILD_JS_SHA256, ESBUILD_WASM_ASSET_PATH, ESBUILD_WASM_SHA256, } from '../esbuild-wasm-bundle.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
-import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
+import { ESBUILD_CLI_ASSET_PATH, ESBUILD_CLI_SHA256 } from '../esbuild-cli-artifact.generated.js';
+import { fetchStagedBytes, fetchStagedText } from './staged-source.js';
 /**
  * Synthetic L2 cache keys for the esbuild-wasm assets, staged at
  * public/_assets/esbuild-<version>.{wasm,js} by scripts/bundle-esbuild-wasm.mjs
@@ -64,20 +68,28 @@ import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
  */
 export const ESBUILD_WASM_L2_KEY = `https://nimbus-cache.invalid${ESBUILD_WASM_ASSET_PATH}`;
 export const ESBUILD_JS_L2_KEY = `https://nimbus-cache.invalid${ESBUILD_JS_ASSET_PATH}`;
-const ESBUILD_WASM_ASSET = {
-    label: 'esbuild-wasm',
-    path: ESBUILD_WASM_ASSET_PATH,
-    l2Key: ESBUILD_WASM_L2_KEY,
-    sha256: ESBUILD_WASM_SHA256,
-    contentType: 'application/wasm',
-};
-const ESBUILD_JS_ASSET = {
-    label: 'esbuild-wasm JS adapter',
-    path: ESBUILD_JS_ASSET_PATH,
-    l2Key: ESBUILD_JS_L2_KEY,
-    sha256: ESBUILD_JS_SHA256,
-    contentType: 'text/javascript; charset=utf-8',
-};
+/** The CLI runner's key names its build id, so each rebuild lands a fresh entry. */
+export const ESBUILD_CLI_L2_KEY = `https://nimbus-cache.invalid${ESBUILD_CLI_ASSET_PATH}`;
+/** One esbuild artifact, verified against its pin (runtime/staged-source.ts). */
+function esbuildAsset(label, path, l2Key, sha256, contentType, stagedBy) {
+    return {
+        path,
+        l2Key,
+        sha256,
+        contentType,
+        poisonedCache: 'reject',
+        missingBinding: `Nimbus: the esbuild facet requires an env.ASSETS binding (serves ${path})`,
+        fetchFailed: (res) => `${label} asset fetch failed: ${res.status} ${res.statusText} ` +
+            `for ${path} — deploy is missing the asset`,
+        integrityFailed: (digest, from) => `${label} integrity check failed: expected ${sha256}, got ` +
+            `${digest} (${from}) for ${path} — ` +
+            'the staged asset is corrupt or out of sync; rerun ' +
+            `${stagedBy} and redeploy`,
+    };
+}
+const ESBUILD_WASM_ASSET = esbuildAsset('esbuild-wasm', ESBUILD_WASM_ASSET_PATH, ESBUILD_WASM_L2_KEY, ESBUILD_WASM_SHA256, 'application/wasm', 'scripts/bundle-esbuild-wasm.mjs');
+const ESBUILD_JS_ASSET = esbuildAsset('esbuild-wasm JS adapter', ESBUILD_JS_ASSET_PATH, ESBUILD_JS_L2_KEY, ESBUILD_JS_SHA256, 'text/javascript; charset=utf-8', 'scripts/bundle-esbuild-wasm.mjs');
+const ESBUILD_CLI_ASSET = esbuildAsset('esbuild CLI runner', ESBUILD_CLI_ASSET_PATH, ESBUILD_CLI_L2_KEY, ESBUILD_CLI_SHA256, 'text/javascript; charset=utf-8', 'scripts/bundle-facet-workers.mjs');
 /**
  * Fetch the esbuild-wasm bytes from the static-assets layer.
  *
@@ -92,84 +104,21 @@ const ESBUILD_JS_ASSET = {
  * always the correct source of truth.
  */
 export function fetchEsbuildWasmBytes(env) {
-    return fetchVerifiedAsset(env, ESBUILD_WASM_ASSET);
+    return fetchStagedBytes(env, ESBUILD_WASM_ASSET);
 }
 /**
  * Fetch the esbuild-wasm JS adapter: the function body that, wrapped in
  * `new Function(...)()`, returns the esbuild namespace. Facet sources
  * splice it in verbatim, so it is verified like the wasm it drives.
  */
-export async function fetchEsbuildJsFnBody(env) {
-    return new TextDecoder().decode(await fetchVerifiedAsset(env, ESBUILD_JS_ASSET));
+export function fetchEsbuildJsFnBody(env) {
+    return fetchStagedText(env, ESBUILD_JS_ASSET);
 }
-async function fetchVerifiedAsset(env, asset) {
-    const caches = globalThis.caches;
-    // ── L2 fast path ────────────────────────────────────────────────
-    let ab = null;
-    try {
-        if (caches?.default) {
-            const hit = await caches.default.match(new Request(asset.l2Key));
-            if (hit && hit.ok)
-                ab = await hit.arrayBuffer();
-        }
-    }
-    catch { /* fall through to ASSETS */ }
-    const fromCache = ab !== null;
-    if (!ab) {
-        // ── L4 path (env.ASSETS) ──────────────────────────────────────
-        // Construct a synthetic request — env.ASSETS routes by pathname only;
-        // the host is ignored. Using `.invalid` per RFC-2606 makes it
-        // unambiguous that this URL is internal-binding-only.
-        const url = `https://nimbus-internal.invalid${asset.path}`;
-        const res = await env.ASSETS.fetch(new Request(url));
-        try {
-            if (!res.ok) {
-                throw new Error(`${asset.label} asset fetch failed: ${res.status} ${res.statusText} ` +
-                    `for ${asset.path} — deploy is missing the asset`);
-            }
-            // Read the bytes once (Response body is a one-shot stream). The
-            // caller needs the ArrayBuffer to hand to workerd's LOADER; we
-            // also use it to write through to L2.
-            ab = await res.arrayBuffer();
-        }
-        finally {
-            disposeRpcResource(res);
-        }
-    }
-    const digest = await sha256Hex(ab);
-    if (digest !== asset.sha256) {
-        throw new Error(`${asset.label} integrity check failed: expected ${asset.sha256}, got ` +
-            `${digest} (${fromCache ? 'L2 cache' : 'ASSETS'}) for ${asset.path} — ` +
-            'the staged asset is corrupt or out of sync; rerun ' +
-            'scripts/bundle-esbuild-wasm.mjs and redeploy');
-    }
-    if (!fromCache) {
-        // ── L2 write-back ────────────────────────────────────────────
-        // Eternal immutable TTL: the URL is version-pinned so a new
-        // ESBUILD_VERSION lands a fresh cache entry; the old one naturally
-        // evicts on TTL. The cache layer holds its own copy (workerd
-        // structured-clones the body during put), so the supervisor's
-        // reference to `ab` is unaffected.
-        // Best-effort: a write failure does NOT block the caller.
-        try {
-            if (caches?.default) {
-                // We pass a fresh Uint8Array view over the same buffer; the
-                // cache stores a copy at put time. Returning `ab` to the
-                // caller stays valid because Response constructor doesn't
-                // detach the buffer (only ReadableStream consumption would).
-                const writeBack = new Response(new Uint8Array(ab), {
-                    headers: {
-                        'Content-Type': asset.contentType,
-                        'Cache-Control': 'public, max-age=31536000, immutable',
-                    },
-                });
-                // Awaited so subsequent reads strictly hit L2 (no
-                // double-fetch race). The wasm payload is 12 MiB; workerd
-                // structured-clones it into the cache, ~1-5 ms locally.
-                await caches.default.put(new Request(asset.l2Key), writeBack);
-            }
-        }
-        catch { /* silent */ }
-    }
-    return ab;
+/**
+ * Fetch the `esbuild` command's runner: Go's wasm_exec.js and the typed fs
+ * shim, a script that installs `globalThis.__esbuildCliRun` when the esbuild
+ * facet evaluates it. Verified like the adapter it sits beside.
+ */
+export function fetchEsbuildCliRunner(env) {
+    return fetchStagedText(env, ESBUILD_CLI_ASSET);
 }

package/dist/runtime/git-bundle-artifact.d.ts

@@ -0,0 +1,17 @@
+/**
+ * git-bundle-artifact.ts — supervisor-side fetcher for the staged git module
+ * the git network facet imports as `git-bundle.js`.
+ *
+ * scripts/bundle-git.mjs builds one module: vendor/git.generated.mjs, which the
+ * supervisor imports, and a byte-identical copy staged under
+ * public/_assets/runtime/ for the facet, which only receives modules as source
+ * text. Staging keeps that text out of the Worker bundle's size gate.
+ */
+import { type StagedSourceEnv } from './staged-source.js';
+/**
+ * The git module's source text for the network facet's `modules` record.
+ * Memoized per isolate; a failed fetch clears the memo so the next git
+ * operation retries instead of pinning the error.
+ */
+export declare const fetchGitBundleSource: (env: StagedSourceEnv) => Promise<string>;
+//# sourceMappingURL=git-bundle-artifact.d.ts.map

package/dist/runtime/git-bundle-artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-bundle-artifact.d.ts","sourceRoot":"","sources":["../../src/runtime/git-bundle-artifact.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAW5B;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,MAAM,CACO,CAAC"}

package/dist/runtime/git-bundle-artifact.js

@@ -0,0 +1,25 @@
+/**
+ * git-bundle-artifact.ts — supervisor-side fetcher for the staged git module
+ * the git network facet imports as `git-bundle.js`.
+ *
+ * scripts/bundle-git.mjs builds one module: vendor/git.generated.mjs, which the
+ * supervisor imports, and a byte-identical copy staged under
+ * public/_assets/runtime/ for the facet, which only receives modules as source
+ * text. Staging keeps that text out of the Worker bundle's size gate.
+ */
+import { GIT_BUNDLE_BUILD_ID, GIT_BUNDLE_ENTRY, GIT_BUNDLE_SHA256 } from '../git-bundle.generated.js';
+import { fetchStagedText, memoizeUntilRejected, stagedRuntimeSource, } from './staged-source.js';
+const GIT_BUNDLE = stagedRuntimeSource({
+    label: 'git-bundle',
+    entry: GIT_BUNDLE_ENTRY,
+    buildId: GIT_BUNDLE_BUILD_ID,
+    sha256: GIT_BUNDLE_SHA256,
+    stagedBy: 'scripts/bundle-git.mjs',
+    requiredBy: 'the git network facet',
+});
+/**
+ * The git module's source text for the network facet's `modules` record.
+ * Memoized per isolate; a failed fetch clears the memo so the next git
+ * operation retries instead of pinning the error.
+ */
+export const fetchGitBundleSource = memoizeUntilRejected((env) => fetchStagedText(env, GIT_BUNDLE));

package/dist/runtime/node-repl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/node-repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AA2RD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAIrE"}
+{"version":3,"file":"node-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/node-repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAuQD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAIrE"}

package/dist/runtime/node-repl.js

@@ -21,7 +21,7 @@
  *   - Tab-completion
  *   - History pickling
  */
-import { ReplSession } from './repl-session.js';
+import { ReplSession, replPushResult } from './repl-session.js';
 import { NODE_VERSION } from '@nimbus-sh/core/constants.js';
 class NodeReplAdapter {
     pool = null;
@@ -84,18 +84,7 @@ class NodeReplAdapter {
         catch (e) {
             return { kind: 'error', stderr: `[node-repl] push dispatch failed: ${e?.message || e}\n` };
         }
-        if (result.exit) {
-            return {
-                kind: 'exit',
-                exitCode: result.exitCode || 0,
-                stdout: result.stdout,
-                stderr: result.stderr,
-            };
-        }
-        if (result.incomplete) {
-            return { kind: 'incomplete' };
-        }
-        return { kind: 'output', stdout: result.stdout || '', stderr: result.stderr || '' };
+        return replPushResult(result);
     }
     async close() {
         if (this.pool) {

package/dist/runtime/node-shims-artifact.d.ts

@@ -1,30 +1,29 @@
 /**
- * node-shims-artifact.ts — supervisor-side fetcher for the staged node-compat
- * shim source.
+ * node-shims-artifact.ts — supervisor-side fetcher for the staged sources of
+ * the node-compat layer: the shims, the VFS write ledger and the resident store.
  *
- * The ~230 KiB generateShimsCode() output is staged as a static asset by
- * scripts/bundle-node-shims.mjs (promoted out of the worker bundle for the
- * ≤6 MiB bundle gate). Every node facet's generated worker text interpolates
- * it, so this fetch sits on the exec hot path: the result is memoized at
- * module scope (one fetch per isolate), fronted by L2 (caches.default) keyed
- * on the content-hash build id, with ASSETS as the source of truth and a
- * sha-256 integrity check so a stale or partial asset can never reach a facet.
- *
- * Mirrors opencode-artifact.ts / sqlite-wasm-bytes.ts. ASSETS is already a
- * mandatory embed binding (it serves the shell, sqlite wasm, opencode
- * artifacts); a missing binding fails loud here rather than producing a
- * facet with no node-compat layer.
+ * All three are staged as static assets by scripts/bundle-node-shims.mjs and
+ * promoted out of the worker bundle for its size gate: only a node facet ever
+ * runs them, and every node facet's generated worker text splices them. This
+ * fetch therefore sits on the exec hot path: the result is memoized at module
+ * scope (one fetch per isolate); each source is read and verified by
+ * runtime/staged-source.ts. A missing ASSETS binding fails loud rather than
+ * producing a facet with no node-compat layer.
  */
-/** Minimal env shape — any env with an ASSETS Fetcher binding. */
-export interface NodeShimsAssetEnv {
-    ASSETS?: {
-        fetch(req: Request): Promise<Response>;
-    };
+import { type StagedSourceEnv } from './staged-source.js';
+/** What a node facet's generated worker text splices around the program. */
+export interface NodeFacetSources {
+    /** The node-compat shims: node-shims.ts generateShimsCode(). */
+    shims: string;
+    /** The write ledger the shims' filesystem writes go through: core VFS_WRITE_LEDGER_SOURCE. */
+    ledger: string;
+    /** A resident facet's SQLite-backed resident set: vfs/facet-resident-store.ts FACET_RESIDENT_STORE_SOURCE. */
+    residentStore: string;
 }
 /**
- * The node-compat shim source for facet worker codegen. Memoized per isolate;
- * a failed fetch clears the memo so the next exec retries instead of pinning
- * the error.
+ * The node-compat layer's sources for facet worker codegen. Memoized per
+ * isolate; a failed fetch clears the memo so the next exec retries instead of
+ * pinning the error.
  */
-export declare function fetchNodeShimsCode(env: NodeShimsAssetEnv): Promise<string>;
+export declare const fetchNodeFacetSources: (env: StagedSourceEnv) => Promise<NodeFacetSources>;
 //# sourceMappingURL=node-shims-artifact.d.ts.map

package/dist/runtime/node-shims-artifact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-shims-artifact.d.ts","sourceRoot":"","sources":["../../src/runtime/node-shims-artifact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAUH,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE;QAAE,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;KAAE,CAAC;CACrD;AAgED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ1E"}
+{"version":3,"file":"node-shims-artifact.d.ts","sourceRoot":"","sources":["../../src/runtime/node-shims-artifact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAaH,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAE5B,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,8FAA8F;IAC9F,MAAM,EAAE,MAAM,CAAC;IACf,8GAA8G;IAC9G,aAAa,EAAE,MAAM,CAAC;CACvB;AA8BD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,gBAAgB,CAQlF,CAAC"}

package/dist/runtime/node-shims-artifact.js

@@ -1,83 +1,53 @@
 /**
- * node-shims-artifact.ts — supervisor-side fetcher for the staged node-compat
- * shim source.
+ * node-shims-artifact.ts — supervisor-side fetcher for the staged sources of
+ * the node-compat layer: the shims, the VFS write ledger and the resident store.
  *
- * The ~230 KiB generateShimsCode() output is staged as a static asset by
- * scripts/bundle-node-shims.mjs (promoted out of the worker bundle for the
- * ≤6 MiB bundle gate). Every node facet's generated worker text interpolates
- * it, so this fetch sits on the exec hot path: the result is memoized at
- * module scope (one fetch per isolate), fronted by L2 (caches.default) keyed
- * on the content-hash build id, with ASSETS as the source of truth and a
- * sha-256 integrity check so a stale or partial asset can never reach a facet.
- *
- * Mirrors opencode-artifact.ts / sqlite-wasm-bytes.ts. ASSETS is already a
- * mandatory embed binding (it serves the shell, sqlite wasm, opencode
- * artifacts); a missing binding fails loud here rather than producing a
- * facet with no node-compat layer.
+ * All three are staged as static assets by scripts/bundle-node-shims.mjs and
+ * promoted out of the worker bundle for its size gate: only a node facet ever
+ * runs them, and every node facet's generated worker text splices them. This
+ * fetch therefore sits on the exec hot path: the result is memoized at module
+ * scope (one fetch per isolate); each source is read and verified by
+ * runtime/staged-source.ts. A missing ASSETS binding fails loud rather than
+ * producing a facet with no node-compat layer.
  */
-import { NODE_SHIMS_BUILD_ID, NODE_SHIMS_ENTRY, NODE_SHIMS_SHA256, } from '../node-shims-artifact.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
-import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
-const L2_KEY = `https://nimbus-cache.invalid${NODE_SHIMS_ENTRY}?build=${NODE_SHIMS_BUILD_ID}`;
-const ASSET_URL = `https://nimbus-internal.invalid${NODE_SHIMS_ENTRY}`;
-let memo = null;
-async function fetchAndVerify(env) {
-    if (!env.ASSETS) {
-        throw new Error('Nimbus: the node runtime requires an env.ASSETS binding (serves the ' +
-            'staged node-compat shim at ' + NODE_SHIMS_ENTRY + ') — add the assets ' +
-            'binding from the embed config (see packages/worker README)');
-    }
-    const caches = globalThis.caches;
-    let text = null;
-    try {
-        if (caches?.default) {
-            const hit = await caches.default.match(new Request(L2_KEY));
-            if (hit && hit.ok)
-                text = await hit.text();
-        }
-    }
-    catch { /* fall through to ASSETS */ }
-    if (text === null) {
-        const res = await env.ASSETS.fetch(new Request(ASSET_URL));
-        try {
-            if (!res.ok) {
-                throw new Error(`node-shims asset fetch failed: ${res.status} ${res.statusText} for ` +
-                    `${NODE_SHIMS_ENTRY} — deploy is missing the staged shim ` +
-                    `(run scripts/bundle-node-shims.mjs)`);
-            }
-            text = await res.text();
-        }
-        finally {
-            disposeRpcResource(res);
-        }
-        try {
-            if (caches?.default) {
-                await caches.default.put(new Request(L2_KEY), new Response(text, {
-                    headers: { 'Cache-Control': 'public, max-age=31536000, immutable' },
-                }));
-            }
-        }
-        catch { /* silent */ }
-    }
-    const digest = await sha256Hex(text);
-    if (digest !== NODE_SHIMS_SHA256) {
-        throw new Error(`node-shims asset integrity mismatch for ${NODE_SHIMS_ENTRY}: ` +
-            `expected ${NODE_SHIMS_SHA256.slice(0, 16)}…, got ${digest.slice(0, 16)}… — ` +
-            'the staged asset is stale; rerun scripts/bundle-node-shims.mjs and redeploy');
-    }
-    return text;
-}
+import { NODE_SHIMS_BUILD_ID, NODE_SHIMS_ENTRY, NODE_SHIMS_SHA256, RESIDENT_STORE_BUILD_ID, RESIDENT_STORE_ENTRY, RESIDENT_STORE_SHA256, VFS_WRITE_LEDGER_BUILD_ID, VFS_WRITE_LEDGER_ENTRY, VFS_WRITE_LEDGER_SHA256, } from '../node-shims-artifact.generated.js';
+import { fetchStagedText, memoizeUntilRejected, stagedRuntimeSource, } from './staged-source.js';
+const STAGED_BY = 'scripts/bundle-node-shims.mjs';
+const REQUIRED_BY = 'the node runtime';
+const NODE_SHIMS = stagedRuntimeSource({
+    label: 'node-shims',
+    entry: NODE_SHIMS_ENTRY,
+    buildId: NODE_SHIMS_BUILD_ID,
+    sha256: NODE_SHIMS_SHA256,
+    stagedBy: STAGED_BY,
+    requiredBy: REQUIRED_BY,
+});
+const VFS_WRITE_LEDGER = stagedRuntimeSource({
+    label: 'vfs-write-ledger',
+    entry: VFS_WRITE_LEDGER_ENTRY,
+    buildId: VFS_WRITE_LEDGER_BUILD_ID,
+    sha256: VFS_WRITE_LEDGER_SHA256,
+    stagedBy: STAGED_BY,
+    requiredBy: REQUIRED_BY,
+});
+const RESIDENT_STORE = stagedRuntimeSource({
+    label: 'resident-store',
+    entry: RESIDENT_STORE_ENTRY,
+    buildId: RESIDENT_STORE_BUILD_ID,
+    sha256: RESIDENT_STORE_SHA256,
+    stagedBy: STAGED_BY,
+    requiredBy: REQUIRED_BY,
+});
 /**
- * The node-compat shim source for facet worker codegen. Memoized per isolate;
- * a failed fetch clears the memo so the next exec retries instead of pinning
- * the error.
+ * The node-compat layer's sources for facet worker codegen. Memoized per
+ * isolate; a failed fetch clears the memo so the next exec retries instead of
+ * pinning the error.
  */
-export function fetchNodeShimsCode(env) {
-    if (!memo) {
-        memo = fetchAndVerify(env).catch((e) => {
-            memo = null;
-            throw e;
-        });
-    }
-    return memo;
-}
+export const fetchNodeFacetSources = memoizeUntilRejected(async (env) => {
+    const [shims, ledger, residentStore] = await Promise.all([
+        fetchStagedText(env, NODE_SHIMS),
+        fetchStagedText(env, VFS_WRITE_LEDGER),
+        fetchStagedText(env, RESIDENT_STORE),
+    ]);
+    return { shims, ledger, residentStore };
+});

package/dist/runtime/node-shims.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-shims.d.ts","sourceRoot":"","sources":["../../src/runtime/node-shims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAiDH,wBAAgB,iBAAiB,IAAI,MAAM,CAmrQ1C"}
+{"version":3,"file":"node-shims.d.ts","sourceRoot":"","sources":["../../src/runtime/node-shims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AA2DH,wBAAgB,iBAAiB,IAAI,MAAM,CA22R1C"}