@nimbus-sh/worker 0.7.0 → 0.9.0

package/dist/runtime/repl-session.js

@@ -11,46 +11,12 @@
  * live in src/runtime/<name>-repl.ts and implement the ReplAdapter
  * interface declared below.
  */
+import { errorText } from '@nimbus-sh/core/_shared/error-text.js';
 import { normalizeTerminalNewlines } from '@nimbus-sh/core/_shared/terminal.js';
-/**
- * Manages an interactive REPL session: stdin buffering with minimal
- * readline UX (line-mode), output routing to the WS terminal, prompt
- * rendering, and adapter dispatch.
- *
- * The shell creates a ReplSession when a runtime's `startRepl` hook
- * fires; the session installs a `replCallback` on the WebSocketTerminal
- * (via attachRepl()) and runs until the adapter signals 'exit' or the
- * user presses Ctrl-D on an empty line.
- *
- * No setTimeout in the read loop — the session is driven entirely by
- * keystroke arrival on the WS, with awaits gating the adapter's push().
- */
 export class ReplSession {
     adapter;
+    detachRepl = null;
     terminal;
-    detachReplCb = null;
-    /**
-     * REPL-R7-1 (2026-05-12): optional reference to the Nimbus shell.
-     *
-     * Required when the REPL is launched from a multi-line WS frame
-     * (e.g. user pastes `python\nexit(7)`). The shell input handler
-     * splits the frame on \r\n and pushes lines AFTER
-     * the first into `shell.pasteQueue`, which is drained ONLY when
-     * the shell becomes idle (after executeLine returns). While our
-     * REPL is running, those pasteQueue lines sit there waiting and
-     * the REPL itself receives no input → user sees a hung `>>> `
-     * prompt that never responds.
-     *
-     * If `shell` is provided, ReplSession will, immediately after
-     * attaching its replCallback, drain shell.pasteQueue and feed the
-     * lines into the callback (suffixed with \r each — matches what
-     * the WS frame originally would have looked like). This makes the
-     * paste path work transparently for REPL launches.
-     *
-     * The shell reference is optional so existing adapters (bun, node,
-     * ruby) that haven't been updated keep working with their
-     * pre-fix behavior.
-     */
     shellRef = null;
     /** Current line buffer (chars typed since the last enter). */
     lineBuf = '';
@@ -63,9 +29,11 @@ export class ReplSession {
     /** Per-session history ring (most recent first). Capped at 100. */
     history = [];
     historyIdx = -1;
-    /** Resolves when close() has been called and the session ended. */
     closedResolve = null;
     closedPromise;
+    pendingInterrupt = null;
+    activePush = null;
+    ending = null;
     /** Exit code captured from adapter's last 'exit' return. */
     exitCode = 0;
     /**
@@ -109,68 +77,64 @@ export class ReplSession {
         // 3. Install the input handler.
         // REPL-A1b: per-frame data appended to inputQueue; single drain
         // task ensures serial processing across multiple WS frames.
-        this.detachReplCb = this.terminal.attachRepl((data) => {
+        this.detachRepl = this.terminal.attachRepl((data) => {
+            // Ctrl-C is the one input byte that must not queue behind a busy
+            // push: it is the user's abort, and it only works if it runs now.
+            if (this.busy && data.includes('\x03')) {
+                this.inputQueue = '';
+                data = data.slice(data.lastIndexOf('\x03') + 1);
+                this.interruptBusy();
+                if (data.length === 0)
+                    return;
+            }
+            if (this.ending)
+                return;
             this.inputQueue += data;
             if (!this.draining) {
                 this.draining = true;
                 void this.drainInput();
             }
-        });
-        // REPL-R7-1: drain any input that the shell received in the SAME
-        // WS frame as the REPL-launching command (`python\nexit(7)` style
-        // pastes). Without this drain, those lines sit forever in
-        // shell.pasteQueue while the REPL hangs at `>>> `.
-        //
-        // Each pasteQueue entry is a single line (no \r/\n). We re-frame
-        // each into the replCallback as `line + \r` so handleInput
-        // processes it through the normal Enter-triggered submitLine
-        // path — same behavior as if the user had typed and pressed
-        // Enter for each line.
-        //
-        // Best-effort: if shellRef is null or pasteQueue is missing,
-        // skip silently. Mutate the queue (shift) so the shell doesn't
-        // try to re-process the same items when it drains its own queue
-        // after this REPL exits.
-        if (this.shellRef && Array.isArray(this.shellRef.pasteQueue)) {
-            const pq = this.shellRef.pasteQueue;
-            if (pq.length > 0) {
-                const drained = pq.splice(0).filter(line => line !== undefined && line !== null);
-                if (drained.length > 0) {
-                    // Feed via inputQueue + draining (same path as a real WS
-                    // frame). Each line ends with \r so handleInput's
-                    // submitLine fires per line.
-                    this.inputQueue += drained.join('\r') + '\r';
-                    if (!this.draining) {
-                        this.draining = true;
-                        void this.drainInput();
-                    }
-                }
+        }, () => this.endSession(this.exitCode));
+        const queued = this.shellRef?.takeQueuedInput() ?? [];
+        if (queued.length > 0) {
+            this.inputQueue += queued.join('\r') + '\r';
+            if (!this.draining) {
+                this.draining = true;
+                void this.drainInput();
             }
         }
         // 4. Wait until close() is called.
         await this.closedPromise;
         return this.exitCode;
     }
-    /**
-     * REPL-A1b: drain the input queue serially. Pulls data off
-     * inputQueue, runs handleInput, and reads any data that arrived
-     * during the await. Exits when queue is empty. Only ONE drainInput
-     * runs at a time (guarded by draining flag set in attachRepl
-     * callback).
-     */
     async drainInput() {
-        while (this.inputQueue.length > 0) {
-            const chunk = this.inputQueue;
-            this.inputQueue = '';
-            await this.handleInput(chunk);
+        try {
+            while (this.inputQueue.length > 0 && !this.ending) {
+                const chunk = this.inputQueue;
+                this.inputQueue = '';
+                await this.handleInput(chunk);
+            }
+        }
+        catch (error) {
+            if (!this.ending) {
+                this.terminal.write('[repl] ' + errorText(error) + '\r\n');
+                try {
+                    await this.endSession(1);
+                }
+                catch { /* run() reports the cleanup failure as exit 1. */ }
+            }
+        }
+        finally {
+            this.draining = false;
         }
-        this.draining = false;
     }
     /** Process an input chunk. May contain multiple characters (paste
      *  or rapid typing) — we iterate char-by-char to handle each
      *  control byte individually. */
     async handleInput(data) {
         for (let i = 0; i < data.length; i++) {
+            if (this.ending)
+                return;
             const ch = data[i];
             // CTRL-D (0x04): on empty line, close cleanly.
             if (ch === '\x04') {
@@ -185,10 +149,7 @@ export class ReplSession {
             // CTRL-C (0x03): cancel current line / block.
             if (ch === '\x03') {
                 if (this.busy) {
-                    // Mid-execution: we can't actually interrupt the wasm runtime
-                    // in v1 (no SIGINT plumbing). Buffer the cancel for after.
-                    // For now: just display ^C and let the runtime finish.
-                    this.terminal.write('^C\r\n');
+                    this.interruptBusy();
                     continue;
                 }
                 // Idle: discard current buffer, reset, fresh prompt.
@@ -255,7 +216,20 @@ export class ReplSession {
             }
         }
     }
-    /** Submit the current line buffer to the adapter. */
+    interruptBusy() {
+        if (this.ending || this.pendingInterrupt)
+            return;
+        this.terminal.write('^C\r\n');
+        this.terminal.flushNow();
+        if (!this.adapter.interrupt)
+            return;
+        try {
+            this.pendingInterrupt = Promise.resolve(this.adapter.interrupt()).then(() => ({ kind: 'interrupted' }), (error) => ({ kind: 'failed', message: errorText(error) }));
+        }
+        catch (error) {
+            this.pendingInterrupt = Promise.resolve({ kind: 'failed', message: errorText(error) });
+        }
+    }
     async submitLine() {
         this.terminal.write('\r\n');
         const line = this.lineBuf;
@@ -274,15 +248,31 @@ export class ReplSession {
         this.busy = true;
         let result;
         try {
-            result = await this.adapter.push(fullSource);
+            this.activePush = this.adapter.push(fullSource);
+            result = await this.activePush;
+        }
+        catch (error) {
+            result = { kind: 'error', stderr: '[repl] adapter threw: ' + errorText(error) + '\n' };
         }
-        catch (e) {
-            result = {
-                kind: 'error',
-                stderr: `[repl] adapter threw: ${e?.message || e}\n`,
-            };
+        finally {
+            this.activePush = null;
+        }
+        const pending = this.pendingInterrupt;
+        if (pending) {
+            const outcome = await pending;
+            if (this.pendingInterrupt === pending)
+                this.pendingInterrupt = null;
+            if (outcome.kind === 'interrupted') {
+                result = { kind: 'error', stderr: 'KeyboardInterrupt\n[repl] execution interrupted; interpreter state reset.\n' };
+            }
+            else {
+                this.terminal.write('[repl] interrupt failed: ' + outcome.message + '\r\n');
+                this.terminal.flushNow();
+            }
         }
         this.busy = false;
+        if (this.ending)
+            return;
         // REPL-A1 (master plan §1): emit stdout, stderr, and the next-prompt
         // as three discrete WS frames in deterministic order. Without
         // flushNow() between them, the 5 ms coalescer in WebSocketTerminal
@@ -364,23 +354,33 @@ export class ReplSession {
         this.cursorPos = text.length;
         this.terminal.write(text);
     }
-    /** Close the session: detach input hook, free adapter, resolve. */
-    async endSession(code) {
+    endSession(code) {
+        if (this.ending)
+            return this.ending;
         this.exitCode = code;
-        if (this.detachReplCb) {
+        this.inputQueue = '';
+        this.ending = Promise.resolve().then(async () => {
+            let failure = null;
             try {
-                this.detachReplCb();
+                await this.adapter.close();
             }
-            catch { /* fail-soft */ }
-            this.detachReplCb = null;
-        }
-        try {
-            await this.adapter.close();
-        }
-        catch { /* fail-soft */ }
-        if (this.closedResolve) {
-            this.closedResolve();
+            catch (error) {
+                failure = error instanceof Error ? error : new Error(String(error));
+                this.exitCode = 1;
+                this.terminal.write('[repl] cleanup failed: ' + failure.message + '\r\n');
+                this.terminal.flushNow();
+            }
+            if (this.activePush)
+                await this.activePush.catch(() => { });
+            if (this.pendingInterrupt)
+                await this.pendingInterrupt;
+            this.detachRepl?.();
+            this.detachRepl = null;
+            this.closedResolve?.();
             this.closedResolve = null;
-        }
+            if (failure)
+                throw failure;
+        });
+        return this.ending;
     }
 }

package/dist/runtime/ruby-repl.d.ts

@@ -24,12 +24,13 @@
  *   - Ctrl-C mid-execution.
  *   - irb history pickling.
  */
-import type { SqliteVFS } from '@nimbus-sh/core/vfs/sqlite-vfs.js';
 import type { FacetManager } from '../facets/manager.js';
 import type { WebSocketTerminal } from '../facets/ws-terminal.js';
+import { type NimbusFilesystemAuthority } from '@nimbus-sh/core/runtime/os-contracts.js';
 export interface RubyReplDeps {
     facetMgr: FacetManager;
-    vfs: SqliteVFS;
+    /** Owns the installed interpreter blob the prompt is booted from. */
+    authority: NimbusFilesystemAuthority;
     terminal: WebSocketTerminal;
     /** Per-user-VFS install dir for the ruby blob. */
     installRoot: string;

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

@@ -1 +1 @@
-{"version":3,"file":"ruby-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/ruby-repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAMlE,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8MD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAIrE"}
+{"version":3,"file":"ruby-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/ruby-repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,OAAO,EAAe,KAAK,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAGtG,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,YAAY,CAAC;IACvB,qEAAqE;IACrE,SAAS,EAAE,yBAAyB,CAAC;IACrC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8MD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAIrE"}

package/dist/runtime/ruby-repl.js

@@ -27,6 +27,7 @@
 import { ReplSession } from './repl-session.js';
 import { buildRubyPreamble } from '@nimbus-sh/core/runtime/ruby-runner.js';
 import { CRED_KERNEL } from '@nimbus-sh/core/runtime/os-contracts.js';
+import { withHostFilesystem } from '@nimbus-sh/core/shell/execution-fs.js';
 class RubyReplAdapter {
     pool = null;
     deps;
@@ -145,13 +146,13 @@ class RubyReplAdapter {
         if (this.pool)
             return;
         const { installRoot, facetMgr } = this.deps;
-        const vfs = this.deps.vfs.as(CRED_KERNEL);
         const wasmPath = `${installRoot}/share/ruby/ruby+stdlib.wasm`;
-        if (!vfs.exists(wasmPath)) {
-            throw new Error(`ruby+stdlib.wasm missing at ${wasmPath} (run 'nimbus install ruby')`);
-        }
-        const wasmBytes = vfs.readFile(wasmPath);
-        this.wasmBytesAB = toAB(wasmBytes);
+        this.wasmBytesAB = toAB(await withHostFilesystem(this.deps.authority, CRED_KERNEL, async (vfs) => {
+            if (!(await vfs.exists(wasmPath))) {
+                throw new Error(`ruby+stdlib.wasm missing at ${wasmPath} (run 'nimbus install ruby')`);
+            }
+            return vfs.readFile(wasmPath);
+        }));
         // The one canonical Ruby facet preamble. A hand-rolled copy here once
         // drifted (it lacked the language-prelude const __rubyRun requires, so
         // every REPL eval died on boot) — compose it in exactly one place.

package/dist/runtime/runtime-catalog.d.ts

@@ -46,6 +46,8 @@
  * makes a stale pin a cache miss rather than an outage.
  */
 import { type ManifestFile, type RuntimeManifest } from '@nimbus-sh/core/runtime/runtime-manifest.js';
+import { type RuntimeSource } from '@nimbus-sh/core/runtime/runtime-package.js';
+import { type RuntimePackageAbi } from '@nimbus-sh/core/runtime/os-contracts.js';
 /** Minimal R2Bucket shape we depend on. */
 type R2BucketLike = {
     get(key: string): Promise<{
@@ -102,5 +104,16 @@ export declare function fetchManifest(env: RuntimeCatalogEnv, entry: CatalogVers
  * execution in whichever session installs it.
  */
 export declare function fetchBlob(env: RuntimeCatalogEnv, file: ManifestFile): Promise<Uint8Array>;
+export declare function runtimeAbiForCatalogName(name: string): RuntimePackageAbi;
+/**
+ * The R2 catalog as a core `RuntimeSource` — the worker adapter half of the
+ * install path, so a workspace composed inside this Worker resolves
+ * `nimbus install <spec>` against the same bucket and digest chain the
+ * session's installer always used. Aliases resolve the way the old
+ * resolver did: `python` redirects to `cpython` unless a version pins it,
+ * and any bin a runtime's default manifest declares resolves to that
+ * runtime — except a superseded one, which never answers for a bin.
+ */
+export declare function runtimeCatalogSource(env: RuntimeCatalogEnv): RuntimeSource;
 export {};
 //# sourceMappingURL=runtime-catalog.d.ts.map

package/dist/runtime/runtime-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-catalog.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAKH,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,6CAA6C,CAAC;AAErD,2CAA2C;AAC3C,KAAK,YAAY,GAAG;IAClB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QACxB,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QACpC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KACzB,GAAG,IAAI,CAAC,CAAC;CACX,GAAG,IAAI,GAAG,SAAS,CAAC;AAErB,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,CAAC,EAAE,YAAY,CAAC;CACrC;AAID,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB;2EACuE;IACvE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAiBD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAElE;AA4DD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAuBlF;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,eAAe,CAAC,CA8B1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,UAAU,CAAC,CA4BrB"}
+{"version":3,"file":"runtime-catalog.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAKH,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,6CAA6C,CAAC;AAErD,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,yCAAyC,CAAC;AAEjD,2CAA2C;AAC3C,KAAK,YAAY,GAAG;IAClB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QACxB,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QACpC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KACzB,GAAG,IAAI,CAAC,CAAC;CACX,GAAG,IAAI,GAAG,SAAS,CAAC;AAErB,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,CAAC,EAAE,YAAY,CAAC;CACrC;AAID,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB;2EACuE;IACvE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CAC/C;AAiBD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAElE;AA4DD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAuBlF;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,eAAe,CAAC,CA8B1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,UAAU,CAAC,CA4BrB;AAID,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAExE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,iBAAiB,GAAG,aAAa,CAwE1E"}

package/dist/runtime/runtime-catalog.js

@@ -49,6 +49,9 @@ import { z } from 'zod/v4';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 import { RUNTIME_CATALOG_SHA256 } from '../runtime-catalog.generated.js';
 import { HexSha256Schema, parseRuntimeManifest, } from '@nimbus-sh/core/runtime/runtime-manifest.js';
+import { runtimeEntrypoints } from '@nimbus-sh/core/runtime/installed-runtimes.js';
+import { splitRuntimeSpec, SUPERSEDED_RUNTIMES, } from '@nimbus-sh/core/runtime/runtime-package.js';
+import { NIMBUS_RUNTIME_ABIS, NATIVE_UNSUPPORTED_ABI, } from '@nimbus-sh/core/runtime/os-contracts.js';
 const CatalogVersionEntrySchema = z.object({
     manifest: z.string().min(1),
     manifest_sha256: HexSha256Schema.optional(),
@@ -192,6 +195,91 @@ export async function fetchBlob(env, file) {
     await l2Put(verified, 'application/octet-stream');
     return verified.bytes;
 }
+// ── RuntimeSource ────────────────────────────────────────────────────
+export function runtimeAbiForCatalogName(name) {
+    return NIMBUS_RUNTIME_ABIS[name] ?? NATIVE_UNSUPPORTED_ABI;
+}
+/**
+ * The R2 catalog as a core `RuntimeSource` — the worker adapter half of the
+ * install path, so a workspace composed inside this Worker resolves
+ * `nimbus install <spec>` against the same bucket and digest chain the
+ * session's installer always used. Aliases resolve the way the old
+ * resolver did: `python` redirects to `cpython` unless a version pins it,
+ * and any bin a runtime's default manifest declares resolves to that
+ * runtime — except a superseded one, which never answers for a bin.
+ */
+export function runtimeCatalogSource(env) {
+    return {
+        async list() {
+            const catalog = await fetchCatalog(env);
+            return Object.entries(catalog.runtimes)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([name, entry]) => ({
+                name,
+                abi: runtimeAbiForCatalogName(name),
+                defaultVersion: entry.default,
+                // The publisher appends; the catalog's own order is publish order.
+                versions: Object.entries(entry.versions)
+                    .map(([version, v]) => ({
+                    version,
+                    sizeBytes: v.size_bytes,
+                    license: v.license,
+                })),
+            }));
+        },
+        async resolve(spec) {
+            const { name, versionOverride } = splitRuntimeSpec(spec);
+            const catalog = await fetchCatalog(env);
+            // `python` is CPython now: a bare spec follows the supersession, an
+            // explicit `python@<version>` is a deliberate request and bypasses it.
+            const superseding = versionOverride === null ? SUPERSEDED_RUNTIMES[name] : undefined;
+            const runtimeName = (superseding !== undefined && catalog.runtimes[superseding] ? superseding : null)
+                ?? (catalog.runtimes[name] ? name : null);
+            let resolved = runtimeName;
+            if (resolved === null) {
+                // Bin-name aliasing is catalog-driven: any command a runtime
+                // provides resolves to that runtime. A superseded runtime does not
+                // answer for a command name either — its runner is no longer
+                // registered, and the successor declares the same commands further
+                // down this same loop.
+                for (const [candidate, entry] of Object.entries(catalog.runtimes)) {
+                    if (versionOverride === null
+                        && SUPERSEDED_RUNTIMES[candidate] !== undefined
+                        && catalog.runtimes[SUPERSEDED_RUNTIMES[candidate]])
+                        continue;
+                    const versionEntry = entry.versions[entry.default];
+                    if (!versionEntry)
+                        continue;
+                    try {
+                        const manifest = await fetchManifest(env, versionEntry);
+                        if (runtimeEntrypoints(manifest).some((ep) => ep.binName === name)) {
+                            resolved = candidate;
+                            break;
+                        }
+                    }
+                    catch {
+                        // A bad manifest should not prevent canonical catalog names from
+                        // resolving; it only suppresses bin-name aliasing for that runtime.
+                    }
+                }
+            }
+            if (resolved === null)
+                return null;
+            const entry = catalog.runtimes[resolved];
+            const version = versionOverride ?? entry.default;
+            const versionEntry = entry.versions[version];
+            if (!versionEntry) {
+                throw new Error(`'${resolved}@${version}' not in catalog`);
+            }
+            const manifest = await fetchManifest(env, versionEntry);
+            const pkg = {
+                manifest,
+                readBlob: (file) => fetchBlob(env, file),
+            };
+            return pkg;
+        },
+    };
+}
 /** Read the entry at `address`, or null on miss, on a stripped Cache API,
  *  or when what came back does not hash to the key it was found under. */
 async function l2Get(address) {

package/dist/runtime/wasi/preamble.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../../../src/runtime/wasi/preamble.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAGV,OAAO,EAOP,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EAGtB,aAAa,EAEb,iBAAiB,EACjB,kBAAkB,EAInB,MAAM,uCAAuC,CAAC;AAwL/C,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI,CAE1E;AAsHD;;;;GAIG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAgB5D;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAOxD;AA+CD,wBAAgB,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAkGxD;AAgPD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAc1E;AAeD,eAAO,MAAM,OAAO,sBAA6B,CAAC;AAiMlD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,sBAAsB,GAAG,kBAAkB,CAwwDlF;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,aAAa,CAcxF;AAeD,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAyB5G"}
+{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../../../src/runtime/wasi/preamble.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAGV,OAAO,EAOP,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EAGtB,aAAa,EAEb,iBAAiB,EACjB,kBAAkB,EAInB,MAAM,uCAAuC,CAAC;AAkL/C,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI,CAE1E;AAsHD;;;;GAIG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAgB5D;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAOxD;AA+CD,wBAAgB,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAqGxD;AAgPD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAc1E;AAeD,eAAO,MAAM,OAAO,sBAA6B,CAAC;AAqMlD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,sBAAsB,GAAG,kBAAkB,CA8xDlF;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,aAAa,CAcxF;AAeD,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAyB5G"}