@nimbus-sh/worker 0.9.0 → 0.11.0

package/dist/facets/esbuild-transform.js

@@ -1,27 +1,85 @@
 import { CF_COMPAT_DATE } from '@nimbus-sh/core/constants.js';
-import { BUNDLER_VERSION, generateEsbuildTransformRuntimeSource, } from '@nimbus-sh/core/runtime/esbuild-service.js';
+import { EsbuildService, generateEsbuildFacetRuntimeSource, } from '@nimbus-sh/core/runtime/esbuild-service.js';
 import { ESBUILD_NAME_GLOBAL_SHIM } from '@nimbus-sh/core/_shared/esbuild-facet-shim.js';
-import { ESBUILD_WASM_JS_FN_BODY, ESBUILD_WASM_VERSION, } from '../esbuild-wasm-bundle.generated.js';
-export const ESBUILD_TRANSFORM_WORKER_ID = `nimbus-esbuild-transform:${ESBUILD_WASM_VERSION}:${BUNDLER_VERSION}`;
-/** Slim Worker Loader module whose DO class owns the esbuild wasm heap. */
-export function esbuildTransformWorkerCode(wasmBytes) {
+import { errorText } from '@nimbus-sh/core/_shared/error-text.js';
+import { supervisorEntrypoint } from '@nimbus-sh/fabric/composition.js';
+import { supervisorBindingProps } from '@nimbus-sh/fabric/supervisor-props.js';
+import { hashSource } from '@nimbus-sh/fabric/vendor/serialize.js';
+import { classifyDoCall } from '@nimbus-sh/platform/oom-classify.js';
+import { ESBUILD_WASM_VERSION } from '../esbuild-wasm-bundle.generated.js';
+import { ESBUILD_CLI_BUILD_ID } from '../esbuild-cli-artifact.generated.js';
+import { fetchEsbuildCliRunner, fetchEsbuildJsFnBody, fetchEsbuildWasmBytes } from '../runtime/esbuild-wasm-bytes.js';
+/**
+ * Everything of the facet's module but its staged parts: esbuild's JS adapter,
+ * which the wasm version keys, and the `esbuild` command's runner, which its
+ * build id keys. `wasmModule`, `newEsbuild` and `esbuild` are bound by the
+ * lines before it, and the runner installs `globalThis.__esbuildCliRun` and
+ * the dynamic-import rewrite transforms run after esbuild,
+ * `globalThis.__nimbusRewriteDynamicImports`.
+ *
+ * Transforms share one esbuild, whose heap only grows. A build or an
+ * `esbuild` command gets its own Go instance, dropped when it ends, so what
+ * it grew goes with it.
+ */
+const ESBUILD_FACET_BODY = [
+    ESBUILD_NAME_GLOBAL_SHIM,
+    generateEsbuildFacetRuntimeSource(),
+    'let initialized;',
+    // One initialization per facet, shared by every transform. A failed one is
+    // forgotten, as esbuild forgets it, so the next call retries.
+    'function ensureInitialized() {',
+    '  initialized ||= esbuild.initialize({ wasmModule, worker: false }).catch((e) => {',
+    '    initialized = undefined;',
+    '    throw e;',
+    '  });',
+    '  return initialized;',
+    '}',
+    'export class EsbuildFacet extends DurableObject {',
+    '  async transformMany(requests) {',
+    '    if (requests.some(({ options }) => !options?.rewriteOnly)) await ensureInitialized();',
+    '    const outcomes = [];',
+    '    for (const { code, options } of requests) {',
+    '      try {',
+    '        outcomes.push(await runTransformRequest(esbuild, code, options, globalThis.__nimbusRewriteDynamicImports));',
+    '      } catch (e) {',
+    '        outcomes.push({ error: String((e && e.message) || e) });',
+    '      }',
+    '    }',
+    '    return outcomes;',
+    '  }',
+    '  async build(options, plugin) {',
+    '    const own = newEsbuild();',
+    '    await own.initialize({ wasmModule, worker: false });',
+    '    try {',
+    '      return await buildWithEsbuild(own, options, plugin);',
+    '    } finally {',
+    '      await own.stop();',
+    '    }',
+    '  }',
+    '  async cli(args, supervisor, output) {',
+    '    return globalThis.__esbuildCliRun(args, supervisor, output, wasmModule);',
+    '  }',
+    '}',
+].join('\n');
+// The loader serves the code it cached under an id, so the id carries the code.
+export const ESBUILD_FACET_WORKER_ID = `nimbus-esbuild:${ESBUILD_WASM_VERSION}:${ESBUILD_CLI_BUILD_ID}:${hashSource(ESBUILD_FACET_BODY)}`;
+/** Source bytes per facet call: bounds what the caller's isolate holds for one round trip. */
+const TRANSFORM_BATCH_SOURCE_BYTES = 4 * 1024 * 1024;
+/**
+ * Slim Worker Loader module whose DO class owns the esbuild wasm.
+ * `jsFnBody` is the staged adapter (fetchEsbuildJsFnBody), compiled into a
+ * factory at startup, the one moment code may be generated from a string;
+ * each call of the factory is a separate esbuild. `cliRunner` is the staged
+ * runner of the `esbuild` command (fetchEsbuildCliRunner).
+ */
+export function esbuildFacetWorkerCode(wasmBytes, jsFnBody, cliRunner) {
     const source = [
         'import { DurableObject } from "cloudflare:workers";',
         'import wasmModule from "esbuild.wasm";',
-        `const esbuild = new Function(${JSON.stringify(ESBUILD_WASM_JS_FN_BODY)})();`,
-        ESBUILD_NAME_GLOBAL_SHIM,
-        generateEsbuildTransformRuntimeSource(),
-        'let initialized;',
-        'function ensureInitialized() {',
-        '  initialized ||= esbuild.initialize({ wasmModule, worker: false });',
-        '  return initialized;',
-        '}',
-        'export class EsbuildTransformFacet extends DurableObject {',
-        '  async transform(code, options) {',
-        '    await ensureInitialized();',
-        '    return transformWithEsbuild(esbuild, code, options);',
-        '  }',
-        '}',
+        `const newEsbuild = new Function(${JSON.stringify(jsFnBody)});`,
+        'const esbuild = newEsbuild();',
+        cliRunner,
+        ESBUILD_FACET_BODY,
     ].join('\n');
     return {
         compatibilityDate: CF_COMPAT_DATE,
@@ -34,3 +92,145 @@ export function esbuildTransformWorkerCode(wasmBytes) {
         globalOutbound: null,
     };
 }
+/**
+ * A Durable Object's esbuild facet: one loader-backed child that owns the
+ * esbuild wasm, so the object's own isolate never instantiates it. Needs
+ * `env.LOADER`, `env.ASSETS` and `ctx.facets`, and nothing of any host.
+ */
+async function esbuildFacet(ctx, env) {
+    const loader = Reflect.get(Object(env), 'LOADER');
+    if (!loader || typeof loader.get !== 'function') {
+        throw new Error('Nimbus: env.LOADER unavailable for the esbuild facet');
+    }
+    const assets = Reflect.get(Object(env), 'ASSETS');
+    if (!assets || typeof assets.fetch !== 'function') {
+        throw new Error('Nimbus: env.ASSETS unavailable for the esbuild facet');
+    }
+    const worker = await loader.get(ESBUILD_FACET_WORKER_ID, async () => {
+        const assetsEnv = { ASSETS: assets };
+        const [wasmBytes, jsFnBody, cliRunner] = await Promise.all([
+            fetchEsbuildWasmBytes(assetsEnv),
+            fetchEsbuildJsFnBody(assetsEnv),
+            fetchEsbuildCliRunner(assetsEnv),
+        ]);
+        return esbuildFacetWorkerCode(wasmBytes, jsFnBody, cliRunner);
+    });
+    const facetClass = worker.getDurableObjectClass('EsbuildFacet');
+    return ctx.facets.get(ESBUILD_FACET_WORKER_ID, async () => ({ class: facetClass }));
+}
+/**
+ * The one way to a Durable Object's esbuild facet: its transforms, builds,
+ * and `esbuild` commands share one stub, so a caller that starts
+ * while another is still loading the facet (fetching and verifying the 12 MiB
+ * wasm) waits on that load instead of starting a second one. A load or call
+ * that failed drops the entry; the next caller mints a fresh stub.
+ */
+const sharedFacets = new WeakMap();
+function sharedEsbuildFacet(ctx, env) {
+    const current = sharedFacets.get(ctx);
+    if (current)
+        return current;
+    const minted = esbuildFacet(ctx, env);
+    sharedFacets.set(ctx, minted);
+    minted.catch(() => forgetEsbuildFacet(ctx, minted));
+    return minted;
+}
+function forgetEsbuildFacet(ctx, stub) {
+    if (sharedFacets.get(ctx) === stub)
+        sharedFacets.delete(ctx);
+}
+/** One call on the shared facet; a call that throws drops the stub it used. */
+async function onEsbuildFacet(ctx, env, call) {
+    const stub = sharedEsbuildFacet(ctx, env);
+    try {
+        return await call(await stub);
+    }
+    catch (error) {
+        forgetEsbuildFacet(ctx, stub);
+        throw error;
+    }
+}
+/** Calls per slice: a slice whose call failed is sent once more. */
+const SLICE_ATTEMPTS = 2;
+/**
+ * The transform host a Durable Object's esbuild runs its transforms on: its
+ * esbuild facet, a slice per call. Transforms are pure, so a slice whose call
+ * failed (the facet reset, the connection dropped) is sent once more, to a
+ * freshly minted stub; an overloaded facet is not asked again. A slice that
+ * still fails answers each of its requests with a transient error, which is
+ * no verdict on the source, and the other slices keep their answers.
+ */
+export function esbuildTransformHost(ctx, env) {
+    return async (requests) => {
+        let facet = null;
+        const outcomes = [];
+        for (let start = 0; start < requests.length;) {
+            let end = start;
+            let bytes = 0;
+            while (end < requests.length && (end === start || bytes + requests[end].code.length <= TRANSFORM_BATCH_SOURCE_BYTES)) {
+                bytes += requests[end].code.length;
+                end++;
+            }
+            const slice = requests.slice(start, end);
+            let answered = null;
+            let failure = null;
+            for (let attempt = 1; answered === null && attempt <= SLICE_ATTEMPTS; attempt++) {
+                try {
+                    facet ??= sharedEsbuildFacet(ctx, env);
+                    answered = await (await facet).transformMany(slice);
+                }
+                catch (error) {
+                    // A stub that threw may be broken for good; the next call mints its own.
+                    if (facet)
+                        forgetEsbuildFacet(ctx, facet);
+                    facet = null;
+                    failure = error;
+                    if (classifyDoCall(error) === 'overloaded')
+                        break;
+                }
+            }
+            if (answered === null) {
+                const error = `esbuild facet unavailable: ${errorText(failure)}`;
+                answered = slice.map(() => ({ error, transient: true }));
+            }
+            for (const outcome of answered)
+                outcomes.push(outcome);
+            start = end;
+        }
+        return outcomes;
+    };
+}
+/**
+ * The build host a Durable Object's esbuild runs its builds on: its esbuild
+ * facet. The plugin, and with it every file read, stays with the caller.
+ */
+export function esbuildBuildHost(ctx, env) {
+    return async (options, plugin) => {
+        return onEsbuildFacet(ctx, env, (facet) => facet.build(options, plugin));
+    };
+}
+/**
+ * Runs one `esbuild` command in the Durable Object's esbuild facet, as
+ * process `pid`: its files go through a supervisor capability minted for that
+ * pid, the one IsolatePool mints for a facet, and its stdout and stderr come
+ * back through `output` as esbuild writes them. Resolves to its exit status.
+ */
+export async function runEsbuildCli(ctx, env, pid, args, output) {
+    const mint = supervisorEntrypoint();
+    if (!mint)
+        throw new Error('Nimbus: no supervisor entrypoint is composed, so the esbuild facet cannot reach the files');
+    const supervisor = mint({
+        props: supervisorBindingProps(ctx, pid),
+    });
+    return onEsbuildFacet(ctx, env, (facet) => facet.cli(args, supervisor, output));
+}
+/**
+ * The esbuild a Durable Object's supervisor shares: its transforms and its
+ * builds run in its esbuild facet, and build() reads `vfs` from here.
+ */
+export function supervisorEsbuildService(ctx, env, vfs) {
+    return new EsbuildService(vfs, {
+        transformHost: esbuildTransformHost(ctx, env),
+        buildHost: esbuildBuildHost(ctx, env),
+    });
+}

package/dist/facets/exec-telemetry.d.ts

@@ -47,8 +47,12 @@ export interface ExecTelemetryRecord {
      * map and pre-compiling every cell in it.
      */
     bundleBytes: number;
-    manifestBytes: number;
-    metadataBytes: number;
+    /**
+     * Synchronous fs calls the facet refused because its namespace was being
+     * rebuilt after a failed relist (a failure state, repaired at the next
+     * barrier). Zero in a healthy session.
+     */
+    namespaceRefusals: number;
     /** Supervisor RPC writes the facet issued (__queueRpcWrite calls). */
     rpcWrites: number;
     /** Supervisor fs READ round trips the facet issued. A whole-file async
@@ -74,7 +78,7 @@ export interface ExecTelemetryRecord {
  * The fields `_execViaLoader` fills in on its way through, for the caller to
  * fold into a record. Derived from the record so the two cannot drift.
  */
-export type ExecDiagSink = Pick<ExecTelemetryRecord, 'loadMs' | 'runMs' | 'moduleMapBytes' | 'bundleBytes' | 'manifestBytes' | 'metadataBytes'>;
+export type ExecDiagSink = Pick<ExecTelemetryRecord, 'loadMs' | 'runMs' | 'moduleMapBytes' | 'bundleBytes'>;
 /**
  * True when exec telemetry is enabled. Read once at exec entry; callers
  * skip building the record entirely when this is false so the path stays

package/dist/facets/exec-telemetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exec-telemetry.d.ts","sourceRoot":"","sources":["../../src/facets/exec-telemetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd;0EACsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;;;OASG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB;;gEAE4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAC7B,mBAAmB,EACnB,QAAQ,GAAG,OAAO,GAAG,gBAAgB,GAAG,aAAa,GAAG,eAAe,GAAG,eAAe,CAC1F,CAAC;AAKF;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,GAAG,IAAI,CAIlE;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,IAAI,mBAAmB,EAAE,CAEzD;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}
+{"version":3,"file":"exec-telemetry.d.ts","sourceRoot":"","sources":["../../src/facets/exec-telemetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd;0EACsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;;;OASG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB;;gEAE4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAC7B,mBAAmB,EACnB,QAAQ,GAAG,OAAO,GAAG,gBAAgB,GAAG,aAAa,CACtD,CAAC;AAKF;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,GAAG,IAAI,CAIlE;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,IAAI,mBAAmB,EAAE,CAEzD;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}