@nimbus-sh/worker 0.12.0 → 0.13.1

package/dist/facets/esbuild-bundle-pool.js

@@ -1,80 +0,0 @@
-import { PRE_BUNDLE_CONCURRENCY } from '@nimbus-sh/platform/limits.js';
-function hasAssetsFetcher(env) {
-    if (typeof env !== 'object' || env === null)
-        return false;
-    const assets = Reflect.get(env, 'ASSETS');
-    return typeof assets === 'object' && assets !== null && typeof Reflect.get(assets, 'fetch') === 'function';
-}
-export class EsbuildBundlePool {
-    env;
-    ctx;
-    pool = null;
-    pending = null;
-    /** Bumped by dispose() so a construction it interrupted tears itself down. */
-    generation = 0;
-    constructor(env, ctx) {
-        this.env = env;
-        this.ctx = ctx;
-    }
-    acquire() {
-        if (this.pool)
-            return Promise.resolve(this.pool);
-        if (this.pending)
-            return this.pending;
-        const generation = this.generation;
-        const pending = this.construct().then((pool) => {
-            if (this.generation !== generation) {
-                // dispose() ran while the adapter was in flight.
-                try {
-                    pool.dispose();
-                }
-                catch { /* best-effort */ }
-                throw new Error('EsbuildBundlePool: disposed during construction');
-            }
-            this.pool = pool;
-            return pool;
-        }).finally(() => {
-            if (this.pending === pending)
-                this.pending = null;
-        });
-        this.pending = pending;
-        return pending;
-    }
-    async construct() {
-        if (!hasAssetsFetcher(this.env)) {
-            throw new Error('EsbuildBundlePool: env.ASSETS binding missing — the esbuild JS adapter cannot be fetched');
-        }
-        const env = this.env;
-        const [{ IsolatePool }, { preBundlePreamble }, { fetchEsbuildJsFnBody }, { esbuildWasmModule }] = await Promise.all([
-            import('@nimbus-sh/fabric/isolate-pool.js'),
-            import('../loaders/pre-bundle-preamble.js'),
-            import('../runtime/esbuild-wasm-bytes.js'),
-            import('../runtime/host-wasm.js'),
-        ]);
-        const [wasmModule, jsFnBody] = await Promise.all([esbuildWasmModule(), fetchEsbuildJsFnBody(env)]);
-        return new IsolatePool(env, this.ctx, {
-            concurrency: PRE_BUNDLE_CONCURRENCY,
-            timeoutMs: 60_000,
-            retries: 0,
-            tag: 'esbuild-bundle',
-            preamble: preBundlePreamble(jsFnBody),
-            wasmModules: { 'esbuild.wasm': wasmModule },
-        });
-    }
-    /**
-     * Tear the pool down with its host. A later acquire() constructs a fresh
-     * pool, so a session that installs again after a teardown still bundles.
-     */
-    dispose() {
-        this.generation++;
-        const pool = this.pool;
-        this.pool = null;
-        this.pending = null;
-        if (pool) {
-            try {
-                pool.dispose();
-            }
-            catch { /* best-effort */ }
-        }
-    }
-}

package/dist/loaders/pre-bundle-preamble.d.ts

@@ -1,44 +0,0 @@
-/**
- * pre-bundle-preamble.ts — preamble injected into IsolatePool isolates
- * that run src/pre-bundle-facet.ts.
- *
- * IsolatePool serialises the user function via fn.toString() and runs
- * it inside a dynamic worker built from inline modules. Names referenced
- * by the function at the module-top-level scope are NOT in that worker's
- * lexical scope at runtime — they must be re-declared in the preamble.
- *
- * Specifically prebundleOne references:
- *   - ESBUILD_WASM_JS_FN_BODY — function-body string (~117 KiB) that,
- *                               when run via new Function(...)(), returns
- *                               the esbuild namespace. Staged beside the
- *                               wasm and fetched by the supervisor at
- *                               pool construction (fetchEsbuildJsFnBody),
- *                               then spliced in here.
- *   - resolvePackageEntry     — the npm-resolver helper used by the
- *                               bare-specifier resolver
- *
- * NOT in the preamble:
- *   - ESBUILD_WASM_BASE64 / wasm BYTES — the wasm Module is shipped via
- *     IsolatePool's `wasmModules` option (LOADER `modules` map
- *     entry shape `{ wasm: ArrayBuffer }`). Workerd compiles it at
- *     module-load (startup phase) and the pool's generated worker.js
- *     exposes the resulting WebAssembly.Module on
- *     globalThis.__NIMBUS_WASM['esbuild.wasm']. The pre-bundle facet
- *     reads it at request time and passes to esb.initialize().
- *
- * resolvePackageEntry is a pure-JS function from src/_shared/exports-resolver.ts;
- * we inline its source here so the facet doesn't need to fault back
- * to the supervisor for it.
- *
- * Preamble bytes are part of the loader-cache key for IsolatePool.
- * Changing this file invalidates all warm slots in the pre-bundle pool;
- * fine — esbuild boot is the dominant cost and re-paying it once on a
- * deploy is acceptable.
- */
-/**
- * Preamble string injected ahead of the prebundleOne function in every
- * pre-bundle facet isolate. Must be passed via IsolatePool's
- * `preamble` option. `jsFnBody` is the staged esbuild adapter.
- */
-export declare function preBundlePreamble(jsFnBody: string): string;
-//# sourceMappingURL=pre-bundle-preamble.d.ts.map

package/dist/loaders/pre-bundle-preamble.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pre-bundle-preamble.d.ts","sourceRoot":"","sources":["../../src/loaders/pre-bundle-preamble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAsCH;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuC1D"}

package/dist/loaders/pre-bundle-preamble.js

@@ -1,116 +0,0 @@
-/**
- * pre-bundle-preamble.ts — preamble injected into IsolatePool isolates
- * that run src/pre-bundle-facet.ts.
- *
- * IsolatePool serialises the user function via fn.toString() and runs
- * it inside a dynamic worker built from inline modules. Names referenced
- * by the function at the module-top-level scope are NOT in that worker's
- * lexical scope at runtime — they must be re-declared in the preamble.
- *
- * Specifically prebundleOne references:
- *   - ESBUILD_WASM_JS_FN_BODY — function-body string (~117 KiB) that,
- *                               when run via new Function(...)(), returns
- *                               the esbuild namespace. Staged beside the
- *                               wasm and fetched by the supervisor at
- *                               pool construction (fetchEsbuildJsFnBody),
- *                               then spliced in here.
- *   - resolvePackageEntry     — the npm-resolver helper used by the
- *                               bare-specifier resolver
- *
- * NOT in the preamble:
- *   - ESBUILD_WASM_BASE64 / wasm BYTES — the wasm Module is shipped via
- *     IsolatePool's `wasmModules` option (LOADER `modules` map
- *     entry shape `{ wasm: ArrayBuffer }`). Workerd compiles it at
- *     module-load (startup phase) and the pool's generated worker.js
- *     exposes the resulting WebAssembly.Module on
- *     globalThis.__NIMBUS_WASM['esbuild.wasm']. The pre-bundle facet
- *     reads it at request time and passes to esb.initialize().
- *
- * resolvePackageEntry is a pure-JS function from src/_shared/exports-resolver.ts;
- * we inline its source here so the facet doesn't need to fault back
- * to the supervisor for it.
- *
- * Preamble bytes are part of the loader-cache key for IsolatePool.
- * Changing this file invalidates all warm slots in the pre-bundle pool;
- * fine — esbuild boot is the dominant cost and re-paying it once on a
- * deploy is acceptable.
- */
-import { ESBUILD_WASM_VERSION } from '../esbuild-wasm-bundle.generated.js';
-import { getExportsResolverJS } from '@nimbus-sh/core/_shared/exports-resolver.js';
-// NOTE: wasm BYTES deliberately NOT in this preamble. They live in
-// env.ASSETS at /_assets/esbuild-<version>.wasm and are fetched by
-// the supervisor at pool-construction time
-// (src/esbuild-wasm-bytes.ts), then handed to IsolatePool's
-// `wasmModules` option which registers them in the LOADER `modules`
-// map as `{ wasm: ArrayBuffer }`. workerd compiles during the
-// worker's module-load phase (where wasm code generation is
-// permitted) and exposes the resulting WebAssembly.Module via the
-// standard ESM import the pool prepends to worker.js.
-//
-// Earlier approaches that DIDN'T work (history kept for context):
-//   1. Inline the ~16 MiB base64 in this preamble — workerd allocates
-//      a 16 MiB module-source string per pool.submit dispatch which
-//      combined with post-install supervisor heap state OOM-killed
-//      the DO on entry to the pre-bundle phase (verified on prod).
-//   2. WebAssembly.compile() in the facet at request time — workerd's
-//      deployed config disallows wasm code generation at request time
-//      ("Wasm code generation disallowed by embedder").
-//   3. RPC of a pre-compiled WebAssembly.Module from supervisor —
-//      workerd's structured-clone refuses Module transfer in this
-//      deploy ("Unable to deserialize cloned data").
-//
-// Phase 2 A'.5 also moved the bytes OUT of the supervisor module
-// bundle (was a 16 MiB base64 string in the generated TS file → 21
-// MiB UTF-16 in supervisor module scope). Now they only live where
-// they're needed: in the LOADER cache after pool construction, and
-// in env.ASSETS at rest.
-/**
- * Resolver helpers, sourced from src/_shared/exports-resolver.ts via
- * getExportsResolverJS(). The pre-bundle facet uses `resolvePackageEntry`.
- */
-const RESOLVER_HELPERS_SRC = getExportsResolverJS();
-/**
- * Preamble string injected ahead of the prebundleOne function in every
- * pre-bundle facet isolate. Must be passed via IsolatePool's
- * `preamble` option. `jsFnBody` is the staged esbuild adapter.
- */
-export function preBundlePreamble(jsFnBody) {
-    return `
-// ── pre-bundle facet preamble (auto-generated) ──────────────────────────
-// Esbuild JS helpers (small ~117 KiB). The wasm BYTES are NOT here —
-// they ride IsolatePool's wasmModules option to keep the per-dispatch
-// worker module source under ~120 KiB instead of ~16 MiB. See this
-// file's header for why.
-const ESBUILD_WASM_VERSION = ${JSON.stringify(ESBUILD_WASM_VERSION)};
-const ESBUILD_WASM_JS_FN_BODY = ${JSON.stringify(jsFnBody)};
-
-// ── Materialise esbuild namespace at MODULE STARTUP ─────────────────────
-// workerd's deployed config disallows \"Code generation from strings\" at
-// request time inside dynamic workers (verified via prod repro: pre-bundle
-// fn body called \`new Function(jsBody)()\` and got
-// \"Code generation from strings disallowed for this context\" for every
-// spec). The codebase already documents this constraint at
-// src/runtime/node-shims.ts.
-//
-// Workaround: run \`new Function(...)()\` here in the preamble — preambles
-// execute at module-load time (the worker's startup phase) where eval IS
-// permitted. We capture the resulting esbuild namespace in a module-scope
-// const that the user fn references at request time. Same pattern as
-// src/facets/manager.ts (USER_CODE is compiled in the generated module
-// scope, not inside the request handler).
-//
-// Fail-safe: if even startup-time eval is blocked, set the cache to a
-// sentinel object that the user fn detects and surfaces as a loud error
-// (rather than passing undefined and crashing on .initialize).
-let __NIMBUS_ESBUILD_NS = null;
-let __NIMBUS_ESBUILD_INIT_ERR = null;
-try {
-  __NIMBUS_ESBUILD_NS = (new Function(ESBUILD_WASM_JS_FN_BODY))();
-} catch (e) {
-  __NIMBUS_ESBUILD_INIT_ERR = String((e && e.message) || e);
-}
-
-${RESOLVER_HELPERS_SRC}
-// ── end pre-bundle facet preamble ───────────────────────────────────────
-`;
-}

package/dist/runtime/host-wasm.d.ts

@@ -1,8 +0,0 @@
-/**
- * esbuild's wasm, the module core's EsbuildService initializes from. Imported
- * on first use, like core's own import of it: outside a wrangler bundle (bun,
- * node) the specifier does not resolve to a module, and a static import would
- * fail every importer there.
- */
-export declare function esbuildWasmModule(): Promise<WebAssembly.Module>;
-//# sourceMappingURL=host-wasm.d.ts.map

package/dist/runtime/host-wasm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"host-wasm.d.ts","sourceRoot":"","sources":["../../src/runtime/host-wasm.ts"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAW/D"}

package/dist/runtime/host-wasm.js

@@ -1,33 +0,0 @@
-/**
- * host-wasm.ts — the WebAssembly modules this Worker bundles, handed to
- * dynamic workers compiled.
- *
- * wrangler bundles a `.wasm` import as a compiled module, and workerd
- * compiles it once, at script startup, in every isolate of the script
- * (https://developers.cloudflare.com/workers/wrangler/bundling/). A Worker
- * Loader module map accepts that WebAssembly.Module as a member and the
- * dynamic worker shares its compiled code (workerd src/workerd/api/
- * worker-loader.c++, extractWasmModuleContent), so a facet built on it
- * needs no second copy of the bytes, no fetch of them, and no compile.
- * Each module is described (@nimbus-sh/fabric/host-wasm.js) with its wire
- * size, which still counts toward the 64 MiB dynamic-worker code limit.
- */
-import { describeHostWasm } from '@nimbus-sh/fabric/host-wasm.js';
-import { ESBUILD_WASM_BYTES, ESBUILD_WASM_VERSION } from '../esbuild-wasm-bundle.generated.js';
-let esbuild = null;
-/**
- * esbuild's wasm, the module core's EsbuildService initializes from. Imported
- * on first use, like core's own import of it: outside a wrangler bundle (bun,
- * node) the specifier does not resolve to a module, and a static import would
- * fail every importer there.
- */
-export function esbuildWasmModule() {
-    esbuild ??= import('esbuild-wasm/esbuild.wasm').then(({ default: module }) => {
-        if (!(module instanceof WebAssembly.Module)) {
-            throw new Error('esbuild-wasm/esbuild.wasm did not import as a WebAssembly.Module; '
-                + 'the Worker must be bundled by wrangler, which compiles it at startup');
-        }
-        return describeHostWasm(module, { id: `esbuild-wasm@${ESBUILD_WASM_VERSION}`, bytes: ESBUILD_WASM_BYTES });
-    });
-    return esbuild;
-}