@nimbus-sh/core 0.3.0 → 0.5.0

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

@@ -40,6 +40,7 @@ import type { SqliteVFS } from '../vfs/sqlite-vfs.js';
 import { type VfsCred } from './os-contracts.js';
 import type { EsbuildService } from './esbuild-service.js';
 import { type FacetBundleProfile } from './bundle-profile.js';
+import type { Command, CommandContext } from '../substrate/lifo/commands/types.js';
 /**
  * Result shape that runtime-registry expects from a runner. Mirrors
  * the existing RunFreshResult / RunBunResult shapes — kept narrow so
@@ -96,7 +97,7 @@ export declare function resolveRuntimeScriptPath(fs: ScriptResolutionFs, cwd: st
  * to the very same execution path `bun <file>` takes, rather than growing
  * a second one.
  */
-export type RuntimeSubcommand = (ctx: any, registry: ShellRegistry, runAsRuntime: (args: string[]) => Promise<number>) => Promise<number>;
+export type RuntimeSubcommand = (ctx: CommandContext, registry: ShellRegistry, runAsRuntime: (args: string[]) => Promise<number>) => Promise<number>;
 export interface RuntimeSpec {
     /** Shell-command name: 'node' / 'bun' / 'wasm-runner' / 'python'. */
     name: string;
@@ -142,7 +143,7 @@ export interface RuntimeSpec {
  * shell registry type tree when the runtime path only needs resolve().
  */
 export interface ShellRegistry {
-    resolve(name: string): Promise<any> | any;
+    resolve(name: string): Promise<Command | null | undefined> | Command | null | undefined;
 }
 /**
  * Build a shell-handler function for a runtime. The returned function
@@ -158,5 +159,5 @@ export declare function buildRuntimeHandler(spec: RuntimeSpec, ctx0: {
      *  the module is loaded eagerly or on this call. */
     getEsbuild(): EsbuildService | Promise<EsbuildService>;
     registry: ShellRegistry;
-}): (ctx: any) => Promise<number>;
+}): Command;
 //# sourceMappingURL=runtime-registry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runtime-registry.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"runtime-registry.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-registry.ts"],"names":[],"mappings":"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"}

package/dist/runtime/runtime-registry.js

@@ -40,6 +40,7 @@ import { normalizeVfsPath, resolveVfsPath, vfsPathExtension } from '../vfs/path.
 import { CRED_KERNEL } from './os-contracts.js';
 import { parseFacetBundleProfile } from './bundle-profile.js';
 import { bindImportMetaResolve, importMetaDefines } from './import-meta-transform.js';
+import { errorText } from '../_shared/error-text.js';
 /** Extensions probed when a target names no exact file, in Node's order. */
 const SCRIPT_RESOLUTION_CANDIDATES = ['.js', '.ts', '.tsx', '.mjs', '.jsx', '/index.js', '/index.ts'];
 /**
@@ -311,7 +312,7 @@ export function buildRuntimeHandler(spec, ctx0) {
                 code = bindImportMetaResolve(transformed.code, absUrl);
             }
             catch (e) {
-                ctx.stderr.write(`${name}: transform error for ${scriptPath}: ${e?.message}\n`);
+                ctx.stderr.write(`${name}: transform error for ${scriptPath}: ${errorText(e)}\n`);
                 return 1;
             }
         }

package/dist/runtime/session-process-supervisor.d.ts

@@ -55,6 +55,8 @@ export declare class SessionProcessSupervisor {
     private terminators;
     /** Fires after every appendOutput/markExit once log persistence is wired. */
     private logActivity;
+    /** Fires once per pid on its first terminal transition; see setOnTerminal. */
+    private onTerminalCb;
     /** Allocate a PID and register a new process. */
     spawn(command: string, argv: string[], cwd: string, opts?: ProcessSpawnOptions): ProcessEntry;
     /** Mark an existing entry as long-running. Idempotent. */
@@ -76,6 +78,19 @@ export declare class SessionProcessSupervisor {
     private terminate;
     cred(pid: number): VfsCred;
     setUmask(pid: number, umask: number): number;
+    /**
+     * Observe every pid's FIRST transition out of `running`, whichever door it
+     * leaves by — exit(), kill(), a facet's self-reported exit, a timeout abort:
+     * all of them end here, which is what makes this one callback a complete
+     * seam for per-pid durable state (the resident-launch journal) that must be
+     * released exactly when the process ends and never before.
+     *
+     * One slot, owned by the FacetManager. A second subscriber would mean two
+     * owners of process-end policy; grow this into a list only when a second
+     * genuine owner exists.
+     */
+    setOnTerminal(cb: (pid: number) => void): void;
+    private fireTerminal;
     /** Mark a process as exited. First terminal state wins. */
     exit(pid: number, exitCode: number): void;
     /**

package/dist/runtime/session-process-supervisor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-process-supervisor.d.ts","sourceRoot":"","sources":["../../src/runtime/session-process-supervisor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"session-process-supervisor.d.ts","sourceRoot":"","sources":["../../src/runtime/session-process-supervisor.ts"],"names":[],"mappings":"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"}

package/dist/runtime/session-process-supervisor.js

@@ -30,6 +30,8 @@ export class SessionProcessSupervisor {
     terminators = new Map();
     /** Fires after every appendOutput/markExit once log persistence is wired. */
     logActivity = null;
+    /** Fires once per pid on its first terminal transition; see setOnTerminal. */
+    onTerminalCb = null;
     // ── Lifecycle / PID authority ─────────────────────────────────────────
     /** Allocate a PID and register a new process. */
     spawn(command, argv, cwd, opts = {}) {
@@ -86,19 +88,47 @@ export class SessionProcessSupervisor {
     setUmask(pid, umask) {
         return this.table.setUmask(pid, umask);
     }
+    /**
+     * Observe every pid's FIRST transition out of `running`, whichever door it
+     * leaves by — exit(), kill(), a facet's self-reported exit, a timeout abort:
+     * all of them end here, which is what makes this one callback a complete
+     * seam for per-pid durable state (the resident-launch journal) that must be
+     * released exactly when the process ends and never before.
+     *
+     * One slot, owned by the FacetManager. A second subscriber would mean two
+     * owners of process-end policy; grow this into a list only when a second
+     * genuine owner exists.
+     */
+    setOnTerminal(cb) {
+        this.onTerminalCb = cb;
+    }
+    fireTerminal(pid, wasRunning) {
+        if (!wasRunning || !this.onTerminalCb)
+            return;
+        if (this.table.get(pid)?.state === 'running')
+            return;
+        try {
+            this.onTerminalCb(pid);
+        }
+        catch { /* the process is gone regardless */ }
+    }
     /** Mark a process as exited. First terminal state wins. */
     exit(pid, exitCode) {
+        const wasRunning = this.table.get(pid)?.state === 'running';
         this.table.exit(pid, exitCode);
         this.terminators.delete(pid);
+        this.fireTerminal(pid, wasRunning);
     }
     /**
      * Mark a process as killed and tear down its input channel so queued
      * stdin can't outlive the process.
      */
     kill(pid) {
+        const wasRunning = this.table.get(pid)?.state === 'running';
         const killed = this.table.kill(pid);
         this.terminate(pid);
         this.input.close(pid);
+        this.fireTerminal(pid, wasRunning);
         return killed;
     }
     /** Clean up exited processes older than maxAge ms. */

package/dist/runtime/sqlite-runtime-fs-bridge.js

@@ -414,11 +414,7 @@ function normalizeOpenFlags(flags) {
     };
 }
 function fsError(code, syscall, path) {
-    const err = new Error(`${code}: ${syscall} '${path}'`);
-    err.code = code;
-    err.syscall = syscall;
-    err.path = path;
-    return err;
+    return Object.assign(new Error(`${code}: ${syscall} '${path}'`), { code, syscall, path });
 }
 function hasErrorCode(error, code) {
     return typeof error === 'object' && error !== null && 'code' in error && error.code === code;

package/dist/runtime/virtual-socket-kernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-socket-kernel.d.ts","sourceRoot":"","sources":["../../src/runtime/virtual-socket-kernel.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"virtual-socket-kernel.d.ts","sourceRoot":"","sources":["../../src/runtime/virtual-socket-kernel.ts"],"names":[],"mappings":"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"}

package/dist/runtime/virtual-socket-kernel.generated.d.ts

@@ -8,7 +8,7 @@
  * Consumed by python-runner.ts and ruby-runner.ts: spliced into the
  * socket process worker module source passed to NimbusLoaderPool.
  *
- * Size: 33.72 KiB
+ * Size: 33.76 KiB
  */
 export declare const VIRTUAL_SOCKET_KERNEL_SRC: string;
 //# sourceMappingURL=virtual-socket-kernel.generated.d.ts.map

package/dist/runtime/virtual-socket-kernel.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-socket-kernel.generated.d.ts","sourceRoot":"","sources":["../../src/runtime/virtual-socket-kernel.generated.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,yBAAyB,EAAE,MAAu5lC,CAAC"}
+{"version":3,"file":"virtual-socket-kernel.generated.d.ts","sourceRoot":"","sources":["../../src/runtime/virtual-socket-kernel.generated.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,yBAAyB,EAAE,MAAo8lC,CAAC"}

package/dist/runtime/virtual-socket-kernel.generated.js

@@ -8,6 +8,6 @@
  * Consumed by python-runner.ts and ruby-runner.ts: spliced into the
  * socket process worker module source passed to NimbusLoaderPool.
  *
- * Size: 33.72 KiB
+ * Size: 33.76 KiB
  */
-export const VIRTUAL_SOCKET_KERNEL_SRC = "(() => {\n  // ../core/src/runtime/virtual-socket-kernel.ts\n  var DEFAULT_LIMITS = {\n    responseTimeoutMs: 3e4,\n    maxRequestBodyBytes: 32 * 1024 * 1024,\n    maxResponseBufferBytes: 64 * 1024 * 1024\n  };\n  var EMPTY_BYTES = new Uint8Array(0);\n  var Deferred = class {\n    promise;\n    resolve;\n    reject;\n    constructor() {\n      let resolve = () => {\n      };\n      let reject = () => {\n      };\n      this.promise = new Promise((res, rej) => {\n        resolve = res;\n        reject = rej;\n      });\n      this.resolve = resolve;\n      this.reject = reject;\n    }\n  };\n  function isPyodideProxyLike(value) {\n    return value !== null && typeof value === \"object\" && typeof value.toJs === \"function\";\n  }\n  function toBytes(value) {\n    if (value instanceof Uint8Array) return value;\n    if (value instanceof ArrayBuffer) return new Uint8Array(value);\n    if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    if (Array.isArray(value)) return Uint8Array.from(value);\n    if (typeof value === \"string\") return new TextEncoder().encode(value);\n    if (isPyodideProxyLike(value)) return toBytes(value.toJs());\n    return EMPTY_BYTES;\n  }\n  function concatBytes(parts) {\n    let length = 0;\n    for (const part of parts) length += part.byteLength;\n    const out = new Uint8Array(length);\n    let offset = 0;\n    for (const part of parts) {\n      out.set(part, offset);\n      offset += part.byteLength;\n    }\n    return out;\n  }\n  function responseCanHaveBody(requestMethod, status) {\n    if (requestMethod.toUpperCase() === \"HEAD\") return false;\n    return status !== 204 && status !== 205 && status !== 304;\n  }\n  function encodeHttpRequest(request, body) {\n    const url = new URL(request.url);\n    const path = (url.pathname || \"/\") + url.search;\n    const headers = new Headers(request.headers);\n    if (!headers.has(\"Host\")) headers.set(\"Host\", url.host || \"nimbus.local\");\n    if (body.byteLength > 0 && !headers.has(\"Content-Length\")) {\n      headers.set(\"Content-Length\", String(body.byteLength));\n    }\n    const lines = [`${request.method} ${path} HTTP/1.1`];\n    headers.forEach((value, key) => lines.push(`${key}: ${value}`));\n    lines.push(\"\", \"\");\n    return concatBytes([new TextEncoder().encode(lines.join(\"\\r\\n\")), body]);\n  }\n  function encodeHttpResponseHead(status, statusText, headers, chunkedBody) {\n    const lines = [`HTTP/1.1 ${status} ${statusText}`];\n    headers.forEach((value, key) => lines.push(`${key}: ${value}`));\n    if (chunkedBody) lines.push(\"Transfer-Encoding: chunked\");\n    lines.push(\"Connection: close\");\n    lines.push(\"\", \"\");\n    return new TextEncoder().encode(lines.join(\"\\r\\n\"));\n  }\n  function encodeChunkedFrame(bytes) {\n    return concatBytes([\n      new TextEncoder().encode(`${bytes.byteLength.toString(16)}\\r\n`),\n      bytes,\n      new TextEncoder().encode(\"\\r\\n\")\n    ]);\n  }\n  var CHUNKED_TERMINATOR = new TextEncoder().encode(\"0\\r\\n\\r\\n\");\n  var LOOPBACK_READ_HIGH_WATER_BYTES = 1024 * 1024;\n  var LOOPBACK_STREAM_CHUNK_BYTES = 64 * 1024;\n  var ByteChunkQueue = class {\n    constructor(limitTotalBytes, overflowLabel) {\n      this.limitTotalBytes = limitTotalBytes;\n      this.overflowLabel = overflowLabel;\n    }\n    limitTotalBytes;\n    overflowLabel;\n    chunks = [];\n    headOffset = 0;\n    enqueuedTotalBytes = 0;\n    undrainedBytes = 0;\n    /** Bytes enqueued but not yet read. Drives flow control on streamed queues. */\n    get pendingBytes() {\n      return this.undrainedBytes;\n    }\n    enqueue(bytes) {\n      if (bytes.byteLength === 0) return;\n      if (this.enqueuedTotalBytes + bytes.byteLength > this.limitTotalBytes) {\n        throw new Error(\n          `Nimbus virtual socket: ${this.overflowLabel} exceeds ${this.limitTotalBytes} bytes`\n        );\n      }\n      this.enqueuedTotalBytes += bytes.byteLength;\n      this.undrainedBytes += bytes.byteLength;\n      this.chunks.push(bytes);\n    }\n    /** Drain up to maxBytes from the head chunk; empty result means no data is queued. */\n    readUpTo(maxBytes) {\n      const head = this.chunks[0];\n      if (!head) return EMPTY_BYTES;\n      const available = head.byteLength - this.headOffset;\n      const take = Math.min(available, Math.max(1, maxBytes));\n      const out = head.subarray(this.headOffset, this.headOffset + take);\n      this.headOffset += take;\n      this.undrainedBytes -= take;\n      if (this.headOffset >= head.byteLength) {\n        this.chunks.shift();\n        this.headOffset = 0;\n      }\n      return out;\n    }\n  };\n  var HttpMessageParser = class {\n    phase = \"headers\";\n    settled = null;\n    headerBuffer = EMPTY_BYTES;\n    headerScanOffset = 0;\n    headerPairs = [];\n    framing = \"none\";\n    expectedBodyBytes = 0;\n    bodyChunks = [];\n    bodyByteCount = 0;\n    chunkState = \"size\";\n    chunkSizeLine = [];\n    chunkDataRemaining = 0;\n    get outcome() {\n      return this.settled;\n    }\n    feed(chunk) {\n      if (this.phase === \"done\" || chunk.byteLength === 0) return;\n      if (this.phase === \"headers\") {\n        this.feedHeaders(chunk);\n        return;\n      }\n      this.feedBody(chunk);\n    }\n    /** EOF from the peer closing the connection (or the request being torn down). */\n    finish() {\n      if (this.phase === \"done\") return;\n      if (this.phase === \"headers\") {\n        this.fail(`connection closed before ${this.messageLabel} headers`);\n        return;\n      }\n      if (this.framing === \"until-close\") {\n        this.completeWithBody(concatBytes(this.bodyChunks));\n        return;\n      }\n      this.fail(`connection closed before the ${this.messageLabel} completed`);\n    }\n    feedHeaders(chunk) {\n      this.headerBuffer = concatBytes([this.headerBuffer, chunk]);\n      const headerEnd = this.findHeaderEnd();\n      if (headerEnd < 0) {\n        this.headerScanOffset = Math.max(0, this.headerBuffer.byteLength - 3);\n        return;\n      }\n      const parsed = this.parseHeaderBlock(this.headerBuffer.subarray(0, headerEnd));\n      const leftover = this.headerBuffer.subarray(headerEnd);\n      this.headerBuffer = EMPTY_BYTES;\n      if (!parsed) return;\n      if (!this.bodyAllowed()) {\n        this.completeWithBody(null);\n        return;\n      }\n      const transferEncoding = this.headerValue(\"Transfer-Encoding\");\n      if (transferEncoding !== null && /chunked/i.test(transferEncoding)) {\n        this.framing = \"chunked\";\n      } else {\n        const contentLength = this.headerValue(\"Content-Length\");\n        const expected = contentLength === null ? Number.NaN : parseInt(contentLength, 10);\n        if (Number.isFinite(expected) && expected >= 0) {\n          this.framing = \"content-length\";\n          this.expectedBodyBytes = expected;\n          if (expected === 0) {\n            this.completeWithBody(EMPTY_BYTES);\n            return;\n          }\n        } else {\n          this.framing = this.defaultFramingWhenUnframed();\n          if (this.framing === \"none\") {\n            this.completeWithBody(null);\n            return;\n          }\n        }\n      }\n      this.phase = \"body\";\n      this.feedBody(leftover);\n    }\n    feedBody(chunk) {\n      if (this.framing === \"chunked\") {\n        this.feedChunkedBody(chunk);\n        return;\n      }\n      if (chunk.byteLength === 0) return;\n      if (this.framing === \"content-length\") {\n        const needed = this.expectedBodyBytes - this.bodyByteCount;\n        this.appendBody(chunk.subarray(0, Math.min(needed, chunk.byteLength)));\n        if (this.bodyByteCount >= this.expectedBodyBytes) {\n          this.completeWithBody(concatBytes(this.bodyChunks));\n        }\n        return;\n      }\n      this.appendBody(chunk);\n    }\n    feedChunkedBody(chunk) {\n      let i = 0;\n      while (i < chunk.byteLength && this.phase === \"body\") {\n        if (this.chunkState === \"size\") {\n          const byte = chunk[i++];\n          if (byte === 10) {\n            const line = new TextDecoder().decode(Uint8Array.from(this.chunkSizeLine)).trim();\n            this.chunkSizeLine.length = 0;\n            const size = parseInt(line.split(\";\", 1)[0], 16);\n            if (!Number.isFinite(size) || size < 0) {\n              this.fail(\"malformed chunked transfer encoding\");\n              return;\n            }\n            if (size === 0) {\n              this.completeWithBody(concatBytes(this.bodyChunks));\n              return;\n            }\n            this.chunkState = \"data\";\n            this.chunkDataRemaining = size;\n          } else if (byte !== 13) {\n            this.chunkSizeLine.push(byte);\n          }\n        } else if (this.chunkState === \"data\") {\n          const take = Math.min(this.chunkDataRemaining, chunk.byteLength - i);\n          this.appendBody(chunk.subarray(i, i + take));\n          i += take;\n          this.chunkDataRemaining -= take;\n          if (this.chunkDataRemaining === 0) this.chunkState = \"data-end\";\n        } else {\n          const byte = chunk[i++];\n          if (byte === 10) {\n            this.chunkState = \"size\";\n          } else if (byte !== 13) {\n            this.fail(\"malformed chunked transfer encoding\");\n            return;\n          }\n        }\n      }\n    }\n    appendBody(bytes) {\n      if (bytes.byteLength === 0) return;\n      this.bodyChunks.push(bytes);\n      this.bodyByteCount += bytes.byteLength;\n    }\n    findHeaderEnd() {\n      const bytes = this.headerBuffer;\n      for (let i = this.headerScanOffset; i + 3 < bytes.byteLength; i++) {\n        if (bytes[i] === 13 && bytes[i + 1] === 10 && bytes[i + 2] === 13 && bytes[i + 3] === 10) {\n          return i + 4;\n        }\n      }\n      return -1;\n    }\n    /** Returns false when the start line is malformed (the parser has already failed). */\n    parseHeaderBlock(headerBytes) {\n      const headerText = new TextDecoder().decode(headerBytes);\n      const lines = headerText.replace(/\\r\\n/g, \"\\n\").split(\"\\n\").filter((line) => line.length > 0);\n      const startLine = lines.shift() ?? \"\";\n      if (!this.parseStartLine(startLine)) return false;\n      for (const line of lines) {\n        const separator = line.indexOf(\":\");\n        if (separator <= 0) continue;\n        this.headerPairs.push([line.slice(0, separator), line.slice(separator + 1).trimStart()]);\n      }\n      return true;\n    }\n    headerValue(name) {\n      const target = name.toLowerCase();\n      for (const [key, value] of this.headerPairs) {\n        if (key.toLowerCase() === target) return value;\n      }\n      return null;\n    }\n    completeWithBody(body) {\n      this.phase = \"done\";\n      this.settled = { kind: \"message\", message: this.buildMessage(body) };\n    }\n    fail(message) {\n      this.phase = \"done\";\n      this.settled = { kind: \"failed\", message };\n    }\n  };\n  var HttpResponseParser = class extends HttpMessageParser {\n    constructor(requestMethod) {\n      super();\n      this.requestMethod = requestMethod;\n    }\n    requestMethod;\n    status = 200;\n    statusText = \"\";\n    get messageLabel() {\n      return \"response\";\n    }\n    parseStartLine(line) {\n      const match = /^HTTP\\/\\d(?:\\.\\d)?\\s+(\\d{3})(?:\\s+(.*))?$/.exec(line || \"HTTP/1.1 200 OK\");\n      this.status = match ? parseInt(match[1], 10) : 200;\n      this.statusText = match?.[2] ?? \"\";\n      return true;\n    }\n    bodyAllowed() {\n      return responseCanHaveBody(this.requestMethod, this.status);\n    }\n    defaultFramingWhenUnframed() {\n      return \"until-close\";\n    }\n    buildMessage(body) {\n      return { status: this.status, statusText: this.statusText, headerPairs: this.headerPairs, body };\n    }\n  };\n  var HttpRequestParser = class extends HttpMessageParser {\n    method = \"GET\";\n    target = \"/\";\n    get messageLabel() {\n      return \"request\";\n    }\n    parseStartLine(line) {\n      const match = /^([A-Za-z]+)\\s+(\\S+)\\s+HTTP\\/\\d(?:\\.\\d)?$/.exec(line);\n      if (!match) {\n        this.fail(`malformed HTTP request line: ${JSON.stringify(line.slice(0, 120))}`);\n        return false;\n      }\n      this.method = match[1].toUpperCase();\n      this.target = match[2];\n      return true;\n    }\n    bodyAllowed() {\n      return true;\n    }\n    defaultFramingWhenUnframed() {\n      return \"none\";\n    }\n    buildMessage(body) {\n      return { method: this.method, target: this.target, headerPairs: this.headerPairs, body };\n    }\n  };\n  function errorResponse(status, message) {\n    return {\n      status,\n      statusText: \"\",\n      headerPairs: [[\"content-type\", \"text/plain; charset=utf-8\"]],\n      body: new TextEncoder().encode(`Nimbus virtual socket: ${message}`)\n    };\n  }\n  function toResponse(settled) {\n    const headers = new Headers();\n    for (const [key, value] of settled.headerPairs) headers.append(key, value);\n    return new Response(settled.body, {\n      status: settled.status,\n      statusText: settled.statusText,\n      headers\n    });\n  }\n  var VirtualConnection = class {\n    constructor(id, requestMethod, requestBytes, limits) {\n      this.id = id;\n      this.inbound = new ByteChunkQueue(requestBytes.byteLength, \"request buffer\");\n      this.inbound.enqueue(requestBytes);\n      this.outbound = new ByteChunkQueue(limits.maxResponseBufferBytes, \"response buffer\");\n      this.parser = new HttpResponseParser(requestMethod);\n    }\n    id;\n    /** Request bytes the guest server reads; filled in one shot in stage 1. */\n    inbound;\n    /** Response bytes the guest server writes; drained into the parser. */\n    outbound;\n    parser;\n    responseReady = new Deferred();\n    settled = false;\n    closed = false;\n    read(maxBytes) {\n      return Array.from(this.inbound.readUpTo(Math.max(1, maxBytes | 0)));\n    }\n    /** The whole request is buffered before the connection is accepted, so nothing is ever awaited. */\n    readAsync(maxBytes) {\n      return Promise.resolve(this.read(maxBytes));\n    }\n    readBytesAsync(maxBytes) {\n      return Promise.resolve(this.inbound.readUpTo(Math.max(1, maxBytes | 0)));\n    }\n    /** Same reason: an empty read on an accepted connection is always genuine EOF. */\n    atEof() {\n      return true;\n    }\n    write(bytesLike) {\n      const bytes = toBytes(bytesLike);\n      if (bytes.byteLength === 0 || this.settled || this.closed) return bytes.byteLength;\n      this.outbound.enqueue(bytes.slice());\n      this.pumpParser();\n      return bytes.byteLength;\n    }\n    /** EOF from the server side (or request teardown); completes until-close bodies. */\n    close() {\n      if (this.closed) return;\n      this.closed = true;\n      if (this.settled) return;\n      this.parser.finish();\n      this.pumpParser();\n    }\n    /** Abort propagation: settle the pending preview request with a terminal status. */\n    abort(message, status) {\n      this.closed = true;\n      this.settle(errorResponse(status, message));\n    }\n    async response(timeoutMs) {\n      const timer = setTimeout(() => {\n        this.settle(errorResponse(504, \"timed out waiting for response\"));\n      }, Math.max(1, timeoutMs));\n      try {\n        return toResponse(await this.responseReady.promise);\n      } finally {\n        clearTimeout(timer);\n      }\n    }\n    pumpParser() {\n      for (; ; ) {\n        const chunk = this.outbound.readUpTo(Number.MAX_SAFE_INTEGER);\n        if (chunk.byteLength === 0) break;\n        this.parser.feed(chunk);\n      }\n      const outcome = this.parser.outcome;\n      if (!outcome) return;\n      if (outcome.kind === \"failed\") {\n        this.settle(errorResponse(502, outcome.message));\n        return;\n      }\n      const { status, statusText, headerPairs, body } = outcome.message;\n      this.settle({\n        status,\n        statusText,\n        // The framing is consumed here; the Worker Response re-frames the body itself.\n        headerPairs: headerPairs.filter(([key]) => !/^transfer-encoding$/i.test(key)),\n        body\n      });\n    }\n    settle(response) {\n      if (this.settled) return;\n      this.settled = true;\n      this.responseReady.resolve(response);\n    }\n  };\n  var LoopbackClientConnection = class {\n    constructor(id, port, route, limits) {\n      this.id = id;\n      this.port = port;\n      this.route = route;\n      this.limits = limits;\n    }\n    id;\n    port;\n    route;\n    limits;\n    parser = new HttpRequestParser();\n    /** Response bytes the guest client reads. */\n    inbound = new ByteChunkQueue(Number.MAX_SAFE_INTEGER, \"loopback response buffer\");\n    readable = null;\n    drained = null;\n    dispatched = false;\n    eof = false;\n    closed = false;\n    write(bytesLike) {\n      const bytes = toBytes(bytesLike);\n      if (bytes.byteLength === 0 || this.closed) return bytes.byteLength;\n      if (this.dispatched) {\n        throw new Error(\n          `Nimbus loopback socket: port ${this.port} answered with \"Connection: close\"; open a new connection for the next request`\n        );\n      }\n      this.parser.feed(bytes.slice());\n      const outcome = this.parser.outcome;\n      if (!outcome) return bytes.byteLength;\n      this.dispatched = true;\n      if (outcome.kind === \"failed\") this.failWith(400, outcome.message);\n      else void this.dispatch(outcome.message);\n      return bytes.byteLength;\n    }\n    read(maxBytes) {\n      return Array.from(this.readBytes(maxBytes));\n    }\n    /** Byte-array read. The fd-backed path uses this so a stream never round-trips through number[]. */\n    readBytes(maxBytes) {\n      const out = this.inbound.readUpTo(Math.max(1, maxBytes | 0));\n      if (this.drained && this.inbound.pendingBytes <= LOOPBACK_READ_HIGH_WATER_BYTES) {\n        const waiter = this.drained;\n        this.drained = null;\n        waiter.resolve();\n      }\n      return out;\n    }\n    atEof() {\n      return (this.eof || this.closed) && this.inbound.pendingBytes === 0;\n    }\n    /** Blocks the guest until response bytes arrive; an empty result is EOF. */\n    async readAsync(maxBytes) {\n      return Array.from(await this.readBytesAsync(maxBytes));\n    }\n    async readBytesAsync(maxBytes) {\n      for (; ; ) {\n        const chunk = this.readBytes(maxBytes);\n        if (chunk.byteLength > 0) return chunk;\n        if (this.eof || this.closed) return EMPTY_BYTES;\n        if (!this.dispatched) {\n          throw new Error(\n            \"Nimbus loopback socket: read before a complete HTTP request was written (loopback sockets carry HTTP requests, not arbitrary byte streams)\"\n          );\n        }\n        const waiter = this.readable ??= new Deferred();\n        await waiter.promise;\n      }\n    }\n    close() {\n      if (this.closed) return;\n      this.closed = true;\n      this.wakeReader();\n      if (this.drained) {\n        const waiter = this.drained;\n        this.drained = null;\n        waiter.resolve();\n      }\n    }\n    async dispatch(parsed) {\n      let request;\n      try {\n        request = this.buildRequest(parsed);\n      } catch (error) {\n        this.failWith(400, describeError(error));\n        return;\n      }\n      let response;\n      try {\n        response = await this.withTimeout(this.route(this.port, request));\n      } catch (error) {\n        this.failWith(502, describeError(error));\n        return;\n      }\n      await this.streamResponse(request.method, response);\n    }\n    buildRequest(parsed) {\n      const headers = new Headers();\n      let authority = `127.0.0.1:${this.port}`;\n      for (const [key, value] of parsed.headerPairs) {\n        if (/^host$/i.test(key)) {\n          authority = value;\n          continue;\n        }\n        if (/^(transfer-encoding|connection|content-length|keep-alive)$/i.test(key)) continue;\n        headers.append(key, value);\n      }\n      const target = parsed.target.startsWith(\"/\") ? parsed.target : `/${parsed.target}`;\n      const url = /^https?:\\/\\//i.test(parsed.target) ? parsed.target : `http://${authority}${target}`;\n      const body = parsed.body && parsed.body.byteLength > 0 ? parsed.body : null;\n      const methodTakesBody = parsed.method !== \"GET\" && parsed.method !== \"HEAD\";\n      return new Request(url, {\n        method: parsed.method,\n        headers,\n        body: methodTakesBody ? body : null\n      });\n    }\n    async streamResponse(method, response) {\n      const withBody = responseCanHaveBody(method, response.status) && response.body !== null;\n      const headers = new Headers(response.headers);\n      for (const hopByHop of [\"transfer-encoding\", \"content-length\", \"connection\", \"keep-alive\"]) {\n        headers.delete(hopByHop);\n      }\n      this.pushBytes(encodeHttpResponseHead(response.status, response.statusText, headers, withBody));\n      if (!withBody || !response.body) {\n        this.finishStream();\n        return;\n      }\n      const reader = response.body.getReader();\n      try {\n        for (; ; ) {\n          const { value, done } = await reader.read();\n          if (done) break;\n          if (this.closed) return;\n          const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);\n          if (bytes.byteLength === 0) continue;\n          this.pushBytes(encodeChunkedFrame(bytes));\n          await this.awaitDrain();\n        }\n        this.pushBytes(CHUNKED_TERMINATOR);\n      } catch {\n      } finally {\n        try {\n          await reader.cancel();\n        } catch {\n        }\n        this.finishStream();\n      }\n    }\n    /** Synthesize a complete response so the guest sees an HTTP error, never a hang. */\n    failWith(status, detail) {\n      const body = new TextEncoder().encode(`Nimbus loopback socket: ${detail}`);\n      const headers = new Headers({\n        \"content-type\": \"text/plain; charset=utf-8\",\n        \"content-length\": String(body.byteLength)\n      });\n      this.pushBytes(encodeHttpResponseHead(status, \"\", headers, false));\n      this.pushBytes(body);\n      this.finishStream();\n    }\n    pushBytes(bytes) {\n      if (this.closed) return;\n      this.inbound.enqueue(bytes);\n      this.wakeReader();\n    }\n    finishStream() {\n      this.eof = true;\n      this.wakeReader();\n    }\n    wakeReader() {\n      const waiter = this.readable;\n      if (!waiter) return;\n      this.readable = null;\n      waiter.resolve();\n    }\n    /** Pause the body pump while the guest is behind, so a big stream cannot grow unbounded. */\n    awaitDrain() {\n      if (this.inbound.pendingBytes <= LOOPBACK_READ_HIGH_WATER_BYTES) return Promise.resolve();\n      return (this.drained ??= new Deferred()).promise;\n    }\n    withTimeout(promise) {\n      let timer = null;\n      const timeout = new Promise((_resolve, reject) => {\n        timer = setTimeout(\n          () => reject(new Error(`port ${this.port} did not respond within ${this.limits.responseTimeoutMs}ms`)),\n          Math.max(1, this.limits.responseTimeoutMs)\n        );\n      });\n      return Promise.race([promise, timeout]).finally(() => {\n        if (timer !== null) clearTimeout(timer);\n      });\n    }\n  };\n  function describeError(error) {\n    return error instanceof Error ? error.message : String(error);\n  }\n  function socketStreamFor(conn) {\n    return {\n      // Neither direction has a handshake: an accepted connection already holds\n      // the request, and a dialed one starts its exchange on the first write.\n      opened: Promise.resolve(),\n      readable: new ReadableStream(\n        {\n          async pull(controller) {\n            const bytes = await conn.readBytesAsync(LOOPBACK_STREAM_CHUNK_BYTES);\n            if (bytes.byteLength === 0) controller.close();\n            else controller.enqueue(bytes);\n          },\n          cancel() {\n            conn.close();\n          }\n        },\n        // highWaterMark 0 so the stream never pulls speculatively. A default\n        // strategy pulls once at construction, which on a client connection\n        // means reading before the guest has written its request.\n        { highWaterMark: 0 }\n      ),\n      writable: new WritableStream({\n        write(chunk) {\n          conn.write(chunk);\n        },\n        abort() {\n          conn.close();\n        }\n      }),\n      close() {\n        conn.close();\n        return Promise.resolve();\n      }\n    };\n  }\n  var VirtualListener = class {\n    constructor(port) {\n      this.port = port;\n    }\n    port;\n    queue = [];\n    acceptWaiters = [];\n    push(conn) {\n      const waiter = this.acceptWaiters.shift();\n      if (waiter) waiter.resolve(conn);\n      else this.queue.push(conn);\n    }\n    accept() {\n      const queued = this.queue.shift();\n      if (queued) return Promise.resolve(queued);\n      const waiter = new Deferred();\n      this.acceptWaiters.push(waiter);\n      return waiter.promise;\n    }\n    take() {\n      return this.queue.shift() ?? null;\n    }\n    pending() {\n      return this.queue.length;\n    }\n    drainQueued() {\n      return this.queue.splice(0);\n    }\n    rejectPendingAccepts(error) {\n      for (const waiter of this.acceptWaiters.splice(0)) waiter.reject(error);\n    }\n  };\n  var VirtualSocketKernel = class {\n    constructor(host, limits) {\n      this.host = host;\n      this.limits = { ...DEFAULT_LIMITS, ...limits };\n    }\n    host;\n    /** Public: runner glue inspects listeners.keys() for the default preview port. */\n    listeners = /* @__PURE__ */ new Map();\n    connections = /* @__PURE__ */ new Map();\n    limits;\n    nextConnectionId = 1;\n    nextEphemeralPort = 49152;\n    listenWaiters = [];\n    readableWaiters = /* @__PURE__ */ new Set();\n    listen(port) {\n      let n = Number(port);\n      if (!Number.isInteger(n) || n < 0 || n >= 65536) throw new Error(`invalid port: ${port}`);\n      if (n === 0) {\n        while (this.listeners.has(this.nextEphemeralPort)) {\n          this.nextEphemeralPort++;\n          if (this.nextEphemeralPort >= 65535) this.nextEphemeralPort = 49152;\n        }\n        n = this.nextEphemeralPort++;\n        if (this.nextEphemeralPort >= 65535) this.nextEphemeralPort = 49152;\n      }\n      if (!this.listeners.has(n)) {\n        this.listeners.set(n, new VirtualListener(n));\n        try {\n          this.host.__nimbusVirtualSocketDidListen?.(n);\n        } catch {\n        }\n        for (const waiter of this.listenWaiters.splice(0)) waiter.resolve(n);\n      }\n      return n;\n    }\n    closeListener(port) {\n      const n = Number(port);\n      const listener = this.listeners.get(n);\n      if (!listener) return;\n      this.listeners.delete(n);\n      for (const conn of listener.drainQueued()) {\n        this.connections.delete(conn.id);\n        conn.abort(`listener closed on port ${n}`, 502);\n      }\n      listener.rejectPendingAccepts(new Error(`port is not listening: ${n}`));\n    }\n    async accept(port) {\n      const listener = this.listeners.get(Number(port));\n      if (!listener) throw new Error(`port is not listening: ${port}`);\n      const conn = await listener.accept();\n      return { id: conn.id, host: \"127.0.0.1\", port: 0 };\n    }\n    acceptNow(port) {\n      const listener = this.listeners.get(Number(port));\n      if (!listener) throw new Error(`port is not listening: ${port}`);\n      const conn = listener.take();\n      return conn ? { id: conn.id, host: \"127.0.0.1\", port: 0 } : null;\n    }\n    /**\n     * Open a client connection to `port` on the session's loopback.\n     *\n     * The returned id is an ordinary connection id: send() writes the\n     * request, recv()/recvAsync() read the response, close() releases it.\n     * Only HTTP/1.1 crosses a loopback connection - see\n     * LoopbackClientConnection for why - and each one carries a single\n     * request/response exchange.\n     */\n    connect(port) {\n      const conn = this.openLoopbackClient(port);\n      this.connections.set(conn.id, conn);\n      return conn.id;\n    }\n    /**\n     * The same client connection as `connect`, handed back in Cloudflare's\n     * `Socket` shape.\n     *\n     * Guests whose sockets are real WASI file descriptors (ruby.wasm, and any\n     * future wasm32-wasi program) reach loopback through this: the WASI shim\n     * stores it in exactly the fd slot a `cloudflare:sockets` connection would\n     * occupy, so `fd_read` on an in-session port is the same suspending read as\n     * `fd_read` on a remote host.\n     */\n    connectStream(port) {\n      return socketStreamFor(this.openLoopbackClient(port));\n    }\n    /**\n     * An already-accepted connection in the same `Socket` shape, so a server's\n     * accepted socket is the same kind of file descriptor as a client's dialed\n     * one. `accept`/`acceptNow` still hand out the connection id, because accept\n     * itself stays on the cooperative pump - this only binds the result.\n     */\n    streamFor(id) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) throw new Error(`connection is closed: ${id}`);\n      return socketStreamFor(conn);\n    }\n    openLoopbackClient(port) {\n      const n = Number(port);\n      if (!Number.isInteger(n) || n <= 0 || n >= 65536) throw new Error(`invalid port: ${port}`);\n      const route = this.host.__nimbusVirtualSocketRouteLoopback;\n      if (typeof route !== \"function\") {\n        throw new Error(\"Nimbus loopback sockets are unavailable in this runtime\");\n      }\n      return new LoopbackClientConnection(this.nextConnectionId++, n, route, this.limits);\n    }\n    /** Plain number array: Pyodide bytes() and the ruby.wasm base64 bridge both consume it. */\n    recv(id, maxBytes) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) return [];\n      return conn.read(Number(maxBytes));\n    }\n    /**\n     * Suspending read. A client connection has nothing to hand back until\n     * the loopback response arrives, so guests that can suspend (Pyodide\n     * `run_sync`, a JSPI-suspending WASI call) await this instead of\n     * spinning on recv(). An empty result is EOF.\n     */\n    async recvAsync(id, maxBytes) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) return [];\n      return conn.readAsync(Number(maxBytes));\n    }\n    /**\n     * Whether an empty recv() means end-of-response rather than \"not yet\".\n     * Guests that poll instead of suspending (ruby.wasm, whose JS bridge is\n     * synchronous) need the two apart to avoid truncating a response.\n     */\n    atEof(id) {\n      const conn = this.connections.get(Number(id));\n      return conn ? conn.atEof() : true;\n    }\n    send(id, bytesLike) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) throw new Error(`connection is closed: ${id}`);\n      return conn.write(bytesLike);\n    }\n    close(id) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) return;\n      conn.close();\n      this.connections.delete(Number(id));\n    }\n    pending(port) {\n      return this.listeners.get(Number(port))?.pending() ?? 0;\n    }\n    firstListeningPort() {\n      for (const port of this.listeners.keys()) return port;\n      return null;\n    }\n    /** select()-style readiness: resolves ports with queued connections, [] on timeout. */\n    waitReadable(ports, timeoutSeconds) {\n      const normalized = (Array.isArray(ports) ? ports : []).map((p) => Number(p)).filter((p) => Number.isInteger(p));\n      const readyNow = normalized.filter((port) => this.pending(port) > 0);\n      if (readyNow.length > 0) return Promise.resolve(readyNow);\n      const timeoutMs = timeoutSeconds == null ? this.limits.responseTimeoutMs : Math.max(0, Number(timeoutSeconds) * 1e3);\n      const deferred = new Deferred();\n      const waiter = {\n        ports: normalized,\n        deferred,\n        timer: setTimeout(() => {\n          this.readableWaiters.delete(waiter);\n          deferred.resolve([]);\n        }, timeoutMs)\n      };\n      this.readableWaiters.add(waiter);\n      return deferred.promise;\n    }\n    async waitForListen(timeoutMs) {\n      const existing = this.firstListeningPort();\n      if (existing) return existing;\n      const waiter = new Deferred();\n      this.listenWaiters.push(waiter);\n      let timer = null;\n      const timeout = new Promise((resolve) => {\n        timer = setTimeout(() => resolve(null), Math.max(1, timeoutMs ?? 5e3));\n      });\n      try {\n        return await Promise.race([waiter.promise, timeout]);\n      } finally {\n        if (timer !== null) clearTimeout(timer);\n      }\n    }\n    async handleHttpRequest(port, request) {\n      const n = Number(port);\n      let listener = this.listeners.get(n);\n      if (!listener) {\n        try {\n          await this.host.__nimbusVirtualSocketEnsureListener?.(n);\n        } catch {\n        }\n        listener = this.listeners.get(n);\n      }\n      if (!listener) {\n        return new Response(`Nimbus virtual socket: no listener on port ${port}`, { status: 502 });\n      }\n      const body = request.method === \"GET\" || request.method === \"HEAD\" ? EMPTY_BYTES : new Uint8Array(await request.arrayBuffer());\n      if (body.byteLength > this.limits.maxRequestBodyBytes) {\n        return new Response(\n          `Nimbus virtual socket: request body exceeds ${this.limits.maxRequestBodyBytes} bytes`,\n          { status: 413 }\n        );\n      }\n      const id = this.nextConnectionId++;\n      const conn = new VirtualConnection(id, request.method, encodeHttpRequest(request, body), this.limits);\n      this.connections.set(id, conn);\n      listener.push(conn);\n      this.notifyReadable(n);\n      const signal = request.signal;\n      const onAbort = () => conn.abort(\"client aborted the request\", 499);\n      if (signal?.aborted) onAbort();\n      else signal?.addEventListener(\"abort\", onAbort);\n      try {\n        try {\n          const accepted = await this.host.__nimbusVirtualSocketRequestQueued?.(n);\n          if (accepted === false) {\n            const detail = typeof this.host.__nimbusVirtualSocketLastError === \"string\" ? this.host.__nimbusVirtualSocketLastError.trim() : \"\";\n            const suffix = detail ? `: ${detail}` : \"\";\n            return new Response(\n              `Nimbus virtual socket: runtime handler did not accept the request${suffix}`,\n              { status: 502 }\n            );\n          }\n        } catch {\n        }\n        return await conn.response(this.limits.responseTimeoutMs);\n      } finally {\n        signal?.removeEventListener(\"abort\", onAbort);\n        conn.close();\n        this.connections.delete(id);\n      }\n    }\n    notifyReadable(port) {\n      for (const waiter of Array.from(this.readableWaiters)) {\n        if (!waiter.ports.includes(port)) continue;\n        const ready = waiter.ports.filter((p) => this.pending(p) > 0);\n        if (ready.length === 0) continue;\n        clearTimeout(waiter.timer);\n        this.readableWaiters.delete(waiter);\n        waiter.deferred.resolve(ready);\n      }\n    }\n  };\n  function installVirtualSocketKernel(scope = globalThis) {\n    if (!scope.__nimbusVirtualSockets) {\n      scope.__nimbusVirtualSockets = new VirtualSocketKernel(scope);\n    }\n    return scope.__nimbusVirtualSockets;\n  }\n\n  // <stdin>\n  installVirtualSocketKernel();\n})();\n";
+export const VIRTUAL_SOCKET_KERNEL_SRC = "(() => {\n  // ../core/src/runtime/virtual-socket-kernel.ts\n  var DEFAULT_LIMITS = {\n    responseTimeoutMs: 3e4,\n    maxRequestBodyBytes: 32 * 1024 * 1024,\n    maxResponseBufferBytes: 64 * 1024 * 1024\n  };\n  var EMPTY_BYTES = new Uint8Array(0);\n  var Deferred = class {\n    promise;\n    resolve;\n    reject;\n    constructor() {\n      let resolve = () => {\n      };\n      let reject = () => {\n      };\n      this.promise = new Promise((res, rej) => {\n        resolve = res;\n        reject = rej;\n      });\n      this.resolve = resolve;\n      this.reject = reject;\n    }\n  };\n  function isPyodideProxyLike(value) {\n    return value !== null && typeof value === \"object\" && typeof value.toJs === \"function\";\n  }\n  function toBytes(value) {\n    if (value instanceof Uint8Array) return value;\n    if (value instanceof ArrayBuffer) return new Uint8Array(value);\n    if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    if (Array.isArray(value)) return Uint8Array.from(value);\n    if (typeof value === \"string\") return new TextEncoder().encode(value);\n    if (isPyodideProxyLike(value)) return toBytes(value.toJs());\n    return EMPTY_BYTES;\n  }\n  function concatBytes(parts) {\n    let length = 0;\n    for (const part of parts) length += part.byteLength;\n    const out = new Uint8Array(length);\n    let offset = 0;\n    for (const part of parts) {\n      out.set(part, offset);\n      offset += part.byteLength;\n    }\n    return out;\n  }\n  function responseCanHaveBody(requestMethod, status) {\n    if (requestMethod.toUpperCase() === \"HEAD\") return false;\n    return status !== 204 && status !== 205 && status !== 304;\n  }\n  function encodeHttpRequest(request, body) {\n    const url = new URL(request.url);\n    const path = (url.pathname || \"/\") + url.search;\n    const headers = new Headers(request.headers);\n    if (!headers.has(\"Host\")) headers.set(\"Host\", url.host || \"nimbus.local\");\n    if (body.byteLength > 0 && !headers.has(\"Content-Length\")) {\n      headers.set(\"Content-Length\", String(body.byteLength));\n    }\n    const lines = [`${request.method} ${path} HTTP/1.1`];\n    headers.forEach((value, key) => {\n      lines.push(`${key}: ${value}`);\n    });\n    lines.push(\"\", \"\");\n    return concatBytes([new TextEncoder().encode(lines.join(\"\\r\\n\")), body]);\n  }\n  function encodeHttpResponseHead(status, statusText, headers, chunkedBody) {\n    const lines = [`HTTP/1.1 ${status} ${statusText}`];\n    headers.forEach((value, key) => {\n      lines.push(`${key}: ${value}`);\n    });\n    if (chunkedBody) lines.push(\"Transfer-Encoding: chunked\");\n    lines.push(\"Connection: close\");\n    lines.push(\"\", \"\");\n    return new TextEncoder().encode(lines.join(\"\\r\\n\"));\n  }\n  function encodeChunkedFrame(bytes) {\n    return concatBytes([\n      new TextEncoder().encode(`${bytes.byteLength.toString(16)}\\r\n`),\n      bytes,\n      new TextEncoder().encode(\"\\r\\n\")\n    ]);\n  }\n  var CHUNKED_TERMINATOR = new TextEncoder().encode(\"0\\r\\n\\r\\n\");\n  var LOOPBACK_READ_HIGH_WATER_BYTES = 1024 * 1024;\n  var LOOPBACK_STREAM_CHUNK_BYTES = 64 * 1024;\n  var ByteChunkQueue = class {\n    constructor(limitTotalBytes, overflowLabel) {\n      this.limitTotalBytes = limitTotalBytes;\n      this.overflowLabel = overflowLabel;\n    }\n    limitTotalBytes;\n    overflowLabel;\n    chunks = [];\n    headOffset = 0;\n    enqueuedTotalBytes = 0;\n    undrainedBytes = 0;\n    /** Bytes enqueued but not yet read. Drives flow control on streamed queues. */\n    get pendingBytes() {\n      return this.undrainedBytes;\n    }\n    enqueue(bytes) {\n      if (bytes.byteLength === 0) return;\n      if (this.enqueuedTotalBytes + bytes.byteLength > this.limitTotalBytes) {\n        throw new Error(\n          `Nimbus virtual socket: ${this.overflowLabel} exceeds ${this.limitTotalBytes} bytes`\n        );\n      }\n      this.enqueuedTotalBytes += bytes.byteLength;\n      this.undrainedBytes += bytes.byteLength;\n      this.chunks.push(bytes);\n    }\n    /** Drain up to maxBytes from the head chunk; empty result means no data is queued. */\n    readUpTo(maxBytes) {\n      const head = this.chunks[0];\n      if (!head) return EMPTY_BYTES;\n      const available = head.byteLength - this.headOffset;\n      const take = Math.min(available, Math.max(1, maxBytes));\n      const out = head.subarray(this.headOffset, this.headOffset + take);\n      this.headOffset += take;\n      this.undrainedBytes -= take;\n      if (this.headOffset >= head.byteLength) {\n        this.chunks.shift();\n        this.headOffset = 0;\n      }\n      return out;\n    }\n  };\n  var HttpMessageParser = class {\n    phase = \"headers\";\n    settled = null;\n    headerBuffer = EMPTY_BYTES;\n    headerScanOffset = 0;\n    headerPairs = [];\n    framing = \"none\";\n    expectedBodyBytes = 0;\n    bodyChunks = [];\n    bodyByteCount = 0;\n    chunkState = \"size\";\n    chunkSizeLine = [];\n    chunkDataRemaining = 0;\n    get outcome() {\n      return this.settled;\n    }\n    feed(chunk) {\n      if (this.phase === \"done\" || chunk.byteLength === 0) return;\n      if (this.phase === \"headers\") {\n        this.feedHeaders(chunk);\n        return;\n      }\n      this.feedBody(chunk);\n    }\n    /** EOF from the peer closing the connection (or the request being torn down). */\n    finish() {\n      if (this.phase === \"done\") return;\n      if (this.phase === \"headers\") {\n        this.fail(`connection closed before ${this.messageLabel} headers`);\n        return;\n      }\n      if (this.framing === \"until-close\") {\n        this.completeWithBody(concatBytes(this.bodyChunks));\n        return;\n      }\n      this.fail(`connection closed before the ${this.messageLabel} completed`);\n    }\n    feedHeaders(chunk) {\n      this.headerBuffer = concatBytes([this.headerBuffer, chunk]);\n      const headerEnd = this.findHeaderEnd();\n      if (headerEnd < 0) {\n        this.headerScanOffset = Math.max(0, this.headerBuffer.byteLength - 3);\n        return;\n      }\n      const parsed = this.parseHeaderBlock(this.headerBuffer.subarray(0, headerEnd));\n      const leftover = this.headerBuffer.subarray(headerEnd);\n      this.headerBuffer = EMPTY_BYTES;\n      if (!parsed) return;\n      if (!this.bodyAllowed()) {\n        this.completeWithBody(null);\n        return;\n      }\n      const transferEncoding = this.headerValue(\"Transfer-Encoding\");\n      if (transferEncoding !== null && /chunked/i.test(transferEncoding)) {\n        this.framing = \"chunked\";\n      } else {\n        const contentLength = this.headerValue(\"Content-Length\");\n        const expected = contentLength === null ? Number.NaN : parseInt(contentLength, 10);\n        if (Number.isFinite(expected) && expected >= 0) {\n          this.framing = \"content-length\";\n          this.expectedBodyBytes = expected;\n          if (expected === 0) {\n            this.completeWithBody(EMPTY_BYTES);\n            return;\n          }\n        } else {\n          this.framing = this.defaultFramingWhenUnframed();\n          if (this.framing === \"none\") {\n            this.completeWithBody(null);\n            return;\n          }\n        }\n      }\n      this.phase = \"body\";\n      this.feedBody(leftover);\n    }\n    feedBody(chunk) {\n      if (this.framing === \"chunked\") {\n        this.feedChunkedBody(chunk);\n        return;\n      }\n      if (chunk.byteLength === 0) return;\n      if (this.framing === \"content-length\") {\n        const needed = this.expectedBodyBytes - this.bodyByteCount;\n        this.appendBody(chunk.subarray(0, Math.min(needed, chunk.byteLength)));\n        if (this.bodyByteCount >= this.expectedBodyBytes) {\n          this.completeWithBody(concatBytes(this.bodyChunks));\n        }\n        return;\n      }\n      this.appendBody(chunk);\n    }\n    feedChunkedBody(chunk) {\n      let i = 0;\n      while (i < chunk.byteLength && this.phase === \"body\") {\n        if (this.chunkState === \"size\") {\n          const byte = chunk[i++];\n          if (byte === 10) {\n            const line = new TextDecoder().decode(Uint8Array.from(this.chunkSizeLine)).trim();\n            this.chunkSizeLine.length = 0;\n            const size = parseInt(line.split(\";\", 1)[0], 16);\n            if (!Number.isFinite(size) || size < 0) {\n              this.fail(\"malformed chunked transfer encoding\");\n              return;\n            }\n            if (size === 0) {\n              this.completeWithBody(concatBytes(this.bodyChunks));\n              return;\n            }\n            this.chunkState = \"data\";\n            this.chunkDataRemaining = size;\n          } else if (byte !== 13) {\n            this.chunkSizeLine.push(byte);\n          }\n        } else if (this.chunkState === \"data\") {\n          const take = Math.min(this.chunkDataRemaining, chunk.byteLength - i);\n          this.appendBody(chunk.subarray(i, i + take));\n          i += take;\n          this.chunkDataRemaining -= take;\n          if (this.chunkDataRemaining === 0) this.chunkState = \"data-end\";\n        } else {\n          const byte = chunk[i++];\n          if (byte === 10) {\n            this.chunkState = \"size\";\n          } else if (byte !== 13) {\n            this.fail(\"malformed chunked transfer encoding\");\n            return;\n          }\n        }\n      }\n    }\n    appendBody(bytes) {\n      if (bytes.byteLength === 0) return;\n      this.bodyChunks.push(bytes);\n      this.bodyByteCount += bytes.byteLength;\n    }\n    findHeaderEnd() {\n      const bytes = this.headerBuffer;\n      for (let i = this.headerScanOffset; i + 3 < bytes.byteLength; i++) {\n        if (bytes[i] === 13 && bytes[i + 1] === 10 && bytes[i + 2] === 13 && bytes[i + 3] === 10) {\n          return i + 4;\n        }\n      }\n      return -1;\n    }\n    /** Returns false when the start line is malformed (the parser has already failed). */\n    parseHeaderBlock(headerBytes) {\n      const headerText = new TextDecoder().decode(headerBytes);\n      const lines = headerText.replace(/\\r\\n/g, \"\\n\").split(\"\\n\").filter((line) => line.length > 0);\n      const startLine = lines.shift() ?? \"\";\n      if (!this.parseStartLine(startLine)) return false;\n      for (const line of lines) {\n        const separator = line.indexOf(\":\");\n        if (separator <= 0) continue;\n        this.headerPairs.push([line.slice(0, separator), line.slice(separator + 1).trimStart()]);\n      }\n      return true;\n    }\n    headerValue(name) {\n      const target = name.toLowerCase();\n      for (const [key, value] of this.headerPairs) {\n        if (key.toLowerCase() === target) return value;\n      }\n      return null;\n    }\n    completeWithBody(body) {\n      this.phase = \"done\";\n      this.settled = { kind: \"message\", message: this.buildMessage(body) };\n    }\n    fail(message) {\n      this.phase = \"done\";\n      this.settled = { kind: \"failed\", message };\n    }\n  };\n  var HttpResponseParser = class extends HttpMessageParser {\n    constructor(requestMethod) {\n      super();\n      this.requestMethod = requestMethod;\n    }\n    requestMethod;\n    status = 200;\n    statusText = \"\";\n    get messageLabel() {\n      return \"response\";\n    }\n    parseStartLine(line) {\n      const match = /^HTTP\\/\\d(?:\\.\\d)?\\s+(\\d{3})(?:\\s+(.*))?$/.exec(line || \"HTTP/1.1 200 OK\");\n      this.status = match ? parseInt(match[1], 10) : 200;\n      this.statusText = match?.[2] ?? \"\";\n      return true;\n    }\n    bodyAllowed() {\n      return responseCanHaveBody(this.requestMethod, this.status);\n    }\n    defaultFramingWhenUnframed() {\n      return \"until-close\";\n    }\n    buildMessage(body) {\n      return { status: this.status, statusText: this.statusText, headerPairs: this.headerPairs, body };\n    }\n  };\n  var HttpRequestParser = class extends HttpMessageParser {\n    method = \"GET\";\n    target = \"/\";\n    get messageLabel() {\n      return \"request\";\n    }\n    parseStartLine(line) {\n      const match = /^([A-Za-z]+)\\s+(\\S+)\\s+HTTP\\/\\d(?:\\.\\d)?$/.exec(line);\n      if (!match) {\n        this.fail(`malformed HTTP request line: ${JSON.stringify(line.slice(0, 120))}`);\n        return false;\n      }\n      this.method = match[1].toUpperCase();\n      this.target = match[2];\n      return true;\n    }\n    bodyAllowed() {\n      return true;\n    }\n    defaultFramingWhenUnframed() {\n      return \"none\";\n    }\n    buildMessage(body) {\n      return { method: this.method, target: this.target, headerPairs: this.headerPairs, body };\n    }\n  };\n  function errorResponse(status, message) {\n    return {\n      status,\n      statusText: \"\",\n      headerPairs: [[\"content-type\", \"text/plain; charset=utf-8\"]],\n      body: new TextEncoder().encode(`Nimbus virtual socket: ${message}`)\n    };\n  }\n  function toResponse(settled) {\n    const headers = new Headers();\n    for (const [key, value] of settled.headerPairs) headers.append(key, value);\n    return new Response(settled.body, {\n      status: settled.status,\n      statusText: settled.statusText,\n      headers\n    });\n  }\n  var VirtualConnection = class {\n    constructor(id, requestMethod, requestBytes, limits) {\n      this.id = id;\n      this.inbound = new ByteChunkQueue(requestBytes.byteLength, \"request buffer\");\n      this.inbound.enqueue(requestBytes);\n      this.outbound = new ByteChunkQueue(limits.maxResponseBufferBytes, \"response buffer\");\n      this.parser = new HttpResponseParser(requestMethod);\n    }\n    id;\n    /** Request bytes the guest server reads; filled in one shot in stage 1. */\n    inbound;\n    /** Response bytes the guest server writes; drained into the parser. */\n    outbound;\n    parser;\n    responseReady = new Deferred();\n    settled = false;\n    closed = false;\n    read(maxBytes) {\n      return Array.from(this.inbound.readUpTo(Math.max(1, maxBytes | 0)));\n    }\n    /** The whole request is buffered before the connection is accepted, so nothing is ever awaited. */\n    readAsync(maxBytes) {\n      return Promise.resolve(this.read(maxBytes));\n    }\n    readBytesAsync(maxBytes) {\n      return Promise.resolve(this.inbound.readUpTo(Math.max(1, maxBytes | 0)));\n    }\n    /** Same reason: an empty read on an accepted connection is always genuine EOF. */\n    atEof() {\n      return true;\n    }\n    write(bytesLike) {\n      const bytes = toBytes(bytesLike);\n      if (bytes.byteLength === 0 || this.settled || this.closed) return bytes.byteLength;\n      this.outbound.enqueue(bytes.slice());\n      this.pumpParser();\n      return bytes.byteLength;\n    }\n    /** EOF from the server side (or request teardown); completes until-close bodies. */\n    close() {\n      if (this.closed) return;\n      this.closed = true;\n      if (this.settled) return;\n      this.parser.finish();\n      this.pumpParser();\n    }\n    /** Abort propagation: settle the pending preview request with a terminal status. */\n    abort(message, status) {\n      this.closed = true;\n      this.settle(errorResponse(status, message));\n    }\n    async response(timeoutMs) {\n      const timer = setTimeout(() => {\n        this.settle(errorResponse(504, \"timed out waiting for response\"));\n      }, Math.max(1, timeoutMs));\n      try {\n        return toResponse(await this.responseReady.promise);\n      } finally {\n        clearTimeout(timer);\n      }\n    }\n    pumpParser() {\n      for (; ; ) {\n        const chunk = this.outbound.readUpTo(Number.MAX_SAFE_INTEGER);\n        if (chunk.byteLength === 0) break;\n        this.parser.feed(chunk);\n      }\n      const outcome = this.parser.outcome;\n      if (!outcome) return;\n      if (outcome.kind === \"failed\") {\n        this.settle(errorResponse(502, outcome.message));\n        return;\n      }\n      const { status, statusText, headerPairs, body } = outcome.message;\n      this.settle({\n        status,\n        statusText,\n        // The framing is consumed here; the Worker Response re-frames the body itself.\n        headerPairs: headerPairs.filter(([key]) => !/^transfer-encoding$/i.test(key)),\n        body\n      });\n    }\n    settle(response) {\n      if (this.settled) return;\n      this.settled = true;\n      this.responseReady.resolve(response);\n    }\n  };\n  var LoopbackClientConnection = class {\n    constructor(id, port, route, limits) {\n      this.id = id;\n      this.port = port;\n      this.route = route;\n      this.limits = limits;\n    }\n    id;\n    port;\n    route;\n    limits;\n    parser = new HttpRequestParser();\n    /** Response bytes the guest client reads. */\n    inbound = new ByteChunkQueue(Number.MAX_SAFE_INTEGER, \"loopback response buffer\");\n    readable = null;\n    drained = null;\n    dispatched = false;\n    eof = false;\n    closed = false;\n    write(bytesLike) {\n      const bytes = toBytes(bytesLike);\n      if (bytes.byteLength === 0 || this.closed) return bytes.byteLength;\n      if (this.dispatched) {\n        throw new Error(\n          `Nimbus loopback socket: port ${this.port} answered with \"Connection: close\"; open a new connection for the next request`\n        );\n      }\n      this.parser.feed(bytes.slice());\n      const outcome = this.parser.outcome;\n      if (!outcome) return bytes.byteLength;\n      this.dispatched = true;\n      if (outcome.kind === \"failed\") this.failWith(400, outcome.message);\n      else void this.dispatch(outcome.message);\n      return bytes.byteLength;\n    }\n    read(maxBytes) {\n      return Array.from(this.readBytes(maxBytes));\n    }\n    /** Byte-array read. The fd-backed path uses this so a stream never round-trips through number[]. */\n    readBytes(maxBytes) {\n      const out = this.inbound.readUpTo(Math.max(1, maxBytes | 0));\n      if (this.drained && this.inbound.pendingBytes <= LOOPBACK_READ_HIGH_WATER_BYTES) {\n        const waiter = this.drained;\n        this.drained = null;\n        waiter.resolve();\n      }\n      return out;\n    }\n    atEof() {\n      return (this.eof || this.closed) && this.inbound.pendingBytes === 0;\n    }\n    /** Blocks the guest until response bytes arrive; an empty result is EOF. */\n    async readAsync(maxBytes) {\n      return Array.from(await this.readBytesAsync(maxBytes));\n    }\n    async readBytesAsync(maxBytes) {\n      for (; ; ) {\n        const chunk = this.readBytes(maxBytes);\n        if (chunk.byteLength > 0) return chunk;\n        if (this.eof || this.closed) return EMPTY_BYTES;\n        if (!this.dispatched) {\n          throw new Error(\n            \"Nimbus loopback socket: read before a complete HTTP request was written (loopback sockets carry HTTP requests, not arbitrary byte streams)\"\n          );\n        }\n        this.readable ??= new Deferred();\n        await this.readable.promise;\n      }\n    }\n    close() {\n      if (this.closed) return;\n      this.closed = true;\n      this.wakeReader();\n      if (this.drained) {\n        const waiter = this.drained;\n        this.drained = null;\n        waiter.resolve();\n      }\n    }\n    async dispatch(parsed) {\n      let request;\n      try {\n        request = this.buildRequest(parsed);\n      } catch (error) {\n        this.failWith(400, describeError(error));\n        return;\n      }\n      let response;\n      try {\n        response = await this.withTimeout(this.route(this.port, request));\n      } catch (error) {\n        this.failWith(502, describeError(error));\n        return;\n      }\n      await this.streamResponse(request.method, response);\n    }\n    buildRequest(parsed) {\n      const headers = new Headers();\n      let authority = `127.0.0.1:${this.port}`;\n      for (const [key, value] of parsed.headerPairs) {\n        if (/^host$/i.test(key)) {\n          authority = value;\n          continue;\n        }\n        if (/^(transfer-encoding|connection|content-length|keep-alive)$/i.test(key)) continue;\n        headers.append(key, value);\n      }\n      const target = parsed.target.startsWith(\"/\") ? parsed.target : `/${parsed.target}`;\n      const url = /^https?:\\/\\//i.test(parsed.target) ? parsed.target : `http://${authority}${target}`;\n      const body = parsed.body && parsed.body.byteLength > 0 ? parsed.body : null;\n      const methodTakesBody = parsed.method !== \"GET\" && parsed.method !== \"HEAD\";\n      return new Request(url, {\n        method: parsed.method,\n        headers,\n        body: methodTakesBody ? body : null\n      });\n    }\n    async streamResponse(method, response) {\n      const withBody = responseCanHaveBody(method, response.status) && response.body !== null;\n      const headers = new Headers(response.headers);\n      for (const hopByHop of [\"transfer-encoding\", \"content-length\", \"connection\", \"keep-alive\"]) {\n        headers.delete(hopByHop);\n      }\n      this.pushBytes(encodeHttpResponseHead(response.status, response.statusText, headers, withBody));\n      if (!withBody || !response.body) {\n        this.finishStream();\n        return;\n      }\n      const reader = response.body.getReader();\n      try {\n        for (; ; ) {\n          const { value, done } = await reader.read();\n          if (done) break;\n          if (this.closed) return;\n          const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);\n          if (bytes.byteLength === 0) continue;\n          this.pushBytes(encodeChunkedFrame(bytes));\n          await this.awaitDrain();\n        }\n        this.pushBytes(CHUNKED_TERMINATOR);\n      } catch {\n      } finally {\n        try {\n          await reader.cancel();\n        } catch {\n        }\n        this.finishStream();\n      }\n    }\n    /** Synthesize a complete response so the guest sees an HTTP error, never a hang. */\n    failWith(status, detail) {\n      const body = new TextEncoder().encode(`Nimbus loopback socket: ${detail}`);\n      const headers = new Headers({\n        \"content-type\": \"text/plain; charset=utf-8\",\n        \"content-length\": String(body.byteLength)\n      });\n      this.pushBytes(encodeHttpResponseHead(status, \"\", headers, false));\n      this.pushBytes(body);\n      this.finishStream();\n    }\n    pushBytes(bytes) {\n      if (this.closed) return;\n      this.inbound.enqueue(bytes);\n      this.wakeReader();\n    }\n    finishStream() {\n      this.eof = true;\n      this.wakeReader();\n    }\n    wakeReader() {\n      const waiter = this.readable;\n      if (!waiter) return;\n      this.readable = null;\n      waiter.resolve();\n    }\n    /** Pause the body pump while the guest is behind, so a big stream cannot grow unbounded. */\n    awaitDrain() {\n      if (this.inbound.pendingBytes <= LOOPBACK_READ_HIGH_WATER_BYTES) return Promise.resolve();\n      this.drained ??= new Deferred();\n      return this.drained.promise;\n    }\n    withTimeout(promise) {\n      let timer = null;\n      const timeout = new Promise((_resolve, reject) => {\n        timer = setTimeout(\n          () => reject(new Error(`port ${this.port} did not respond within ${this.limits.responseTimeoutMs}ms`)),\n          Math.max(1, this.limits.responseTimeoutMs)\n        );\n      });\n      return Promise.race([promise, timeout]).finally(() => {\n        if (timer !== null) clearTimeout(timer);\n      });\n    }\n  };\n  function describeError(error) {\n    return error instanceof Error ? error.message : String(error);\n  }\n  function socketStreamFor(conn) {\n    return {\n      // Neither direction has a handshake: an accepted connection already holds\n      // the request, and a dialed one starts its exchange on the first write.\n      opened: Promise.resolve(),\n      readable: new ReadableStream(\n        {\n          async pull(controller) {\n            const bytes = await conn.readBytesAsync(LOOPBACK_STREAM_CHUNK_BYTES);\n            if (bytes.byteLength === 0) controller.close();\n            else controller.enqueue(bytes);\n          },\n          cancel() {\n            conn.close();\n          }\n        },\n        // highWaterMark 0 so the stream never pulls speculatively. A default\n        // strategy pulls once at construction, which on a client connection\n        // means reading before the guest has written its request.\n        { highWaterMark: 0 }\n      ),\n      writable: new WritableStream({\n        write(chunk) {\n          conn.write(chunk);\n        },\n        abort() {\n          conn.close();\n        }\n      }),\n      close() {\n        conn.close();\n        return Promise.resolve();\n      }\n    };\n  }\n  var VirtualListener = class {\n    constructor(port) {\n      this.port = port;\n    }\n    port;\n    queue = [];\n    acceptWaiters = [];\n    push(conn) {\n      const waiter = this.acceptWaiters.shift();\n      if (waiter) waiter.resolve(conn);\n      else this.queue.push(conn);\n    }\n    accept() {\n      const queued = this.queue.shift();\n      if (queued) return Promise.resolve(queued);\n      const waiter = new Deferred();\n      this.acceptWaiters.push(waiter);\n      return waiter.promise;\n    }\n    take() {\n      return this.queue.shift() ?? null;\n    }\n    pending() {\n      return this.queue.length;\n    }\n    drainQueued() {\n      return this.queue.splice(0);\n    }\n    rejectPendingAccepts(error) {\n      for (const waiter of this.acceptWaiters.splice(0)) waiter.reject(error);\n    }\n  };\n  var VirtualSocketKernel = class {\n    constructor(host, limits) {\n      this.host = host;\n      this.limits = { ...DEFAULT_LIMITS, ...limits };\n    }\n    host;\n    /** Public: runner glue inspects listeners.keys() for the default preview port. */\n    listeners = /* @__PURE__ */ new Map();\n    connections = /* @__PURE__ */ new Map();\n    limits;\n    nextConnectionId = 1;\n    nextEphemeralPort = 49152;\n    listenWaiters = [];\n    readableWaiters = /* @__PURE__ */ new Set();\n    listen(port) {\n      let n = Number(port);\n      if (!Number.isInteger(n) || n < 0 || n >= 65536) throw new Error(`invalid port: ${port}`);\n      if (n === 0) {\n        while (this.listeners.has(this.nextEphemeralPort)) {\n          this.nextEphemeralPort++;\n          if (this.nextEphemeralPort >= 65535) this.nextEphemeralPort = 49152;\n        }\n        n = this.nextEphemeralPort++;\n        if (this.nextEphemeralPort >= 65535) this.nextEphemeralPort = 49152;\n      }\n      if (!this.listeners.has(n)) {\n        this.listeners.set(n, new VirtualListener(n));\n        try {\n          this.host.__nimbusVirtualSocketDidListen?.(n);\n        } catch {\n        }\n        for (const waiter of this.listenWaiters.splice(0)) waiter.resolve(n);\n      }\n      return n;\n    }\n    closeListener(port) {\n      const n = Number(port);\n      const listener = this.listeners.get(n);\n      if (!listener) return;\n      this.listeners.delete(n);\n      for (const conn of listener.drainQueued()) {\n        this.connections.delete(conn.id);\n        conn.abort(`listener closed on port ${n}`, 502);\n      }\n      listener.rejectPendingAccepts(new Error(`port is not listening: ${n}`));\n    }\n    async accept(port) {\n      const listener = this.listeners.get(Number(port));\n      if (!listener) throw new Error(`port is not listening: ${port}`);\n      const conn = await listener.accept();\n      return { id: conn.id, host: \"127.0.0.1\", port: 0 };\n    }\n    acceptNow(port) {\n      const listener = this.listeners.get(Number(port));\n      if (!listener) throw new Error(`port is not listening: ${port}`);\n      const conn = listener.take();\n      return conn ? { id: conn.id, host: \"127.0.0.1\", port: 0 } : null;\n    }\n    /**\n     * Open a client connection to `port` on the session's loopback.\n     *\n     * The returned id is an ordinary connection id: send() writes the\n     * request, recv()/recvAsync() read the response, close() releases it.\n     * Only HTTP/1.1 crosses a loopback connection - see\n     * LoopbackClientConnection for why - and each one carries a single\n     * request/response exchange.\n     */\n    connect(port) {\n      const conn = this.openLoopbackClient(port);\n      this.connections.set(conn.id, conn);\n      return conn.id;\n    }\n    /**\n     * The same client connection as `connect`, handed back in Cloudflare's\n     * `Socket` shape.\n     *\n     * Guests whose sockets are real WASI file descriptors (ruby.wasm, and any\n     * future wasm32-wasi program) reach loopback through this: the WASI shim\n     * stores it in exactly the fd slot a `cloudflare:sockets` connection would\n     * occupy, so `fd_read` on an in-session port is the same suspending read as\n     * `fd_read` on a remote host.\n     */\n    connectStream(port) {\n      return socketStreamFor(this.openLoopbackClient(port));\n    }\n    /**\n     * An already-accepted connection in the same `Socket` shape, so a server's\n     * accepted socket is the same kind of file descriptor as a client's dialed\n     * one. `accept`/`acceptNow` still hand out the connection id, because accept\n     * itself stays on the cooperative pump - this only binds the result.\n     */\n    streamFor(id) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) throw new Error(`connection is closed: ${id}`);\n      return socketStreamFor(conn);\n    }\n    openLoopbackClient(port) {\n      const n = Number(port);\n      if (!Number.isInteger(n) || n <= 0 || n >= 65536) throw new Error(`invalid port: ${port}`);\n      const route = this.host.__nimbusVirtualSocketRouteLoopback;\n      if (typeof route !== \"function\") {\n        throw new Error(\"Nimbus loopback sockets are unavailable in this runtime\");\n      }\n      return new LoopbackClientConnection(this.nextConnectionId++, n, route, this.limits);\n    }\n    /** Plain number array: Pyodide bytes() and the ruby.wasm base64 bridge both consume it. */\n    recv(id, maxBytes) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) return [];\n      return conn.read(Number(maxBytes));\n    }\n    /**\n     * Suspending read. A client connection has nothing to hand back until\n     * the loopback response arrives, so guests that can suspend (Pyodide\n     * `run_sync`, a JSPI-suspending WASI call) await this instead of\n     * spinning on recv(). An empty result is EOF.\n     */\n    async recvAsync(id, maxBytes) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) return [];\n      return conn.readAsync(Number(maxBytes));\n    }\n    /**\n     * Whether an empty recv() means end-of-response rather than \"not yet\".\n     * Guests that poll instead of suspending (ruby.wasm, whose JS bridge is\n     * synchronous) need the two apart to avoid truncating a response.\n     */\n    atEof(id) {\n      const conn = this.connections.get(Number(id));\n      return conn ? conn.atEof() : true;\n    }\n    send(id, bytesLike) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) throw new Error(`connection is closed: ${id}`);\n      return conn.write(bytesLike);\n    }\n    close(id) {\n      const conn = this.connections.get(Number(id));\n      if (!conn) return;\n      conn.close();\n      this.connections.delete(Number(id));\n    }\n    pending(port) {\n      return this.listeners.get(Number(port))?.pending() ?? 0;\n    }\n    firstListeningPort() {\n      for (const port of this.listeners.keys()) return port;\n      return null;\n    }\n    /** select()-style readiness: resolves ports with queued connections, [] on timeout. */\n    waitReadable(ports, timeoutSeconds) {\n      const normalized = (Array.isArray(ports) ? ports : []).map((p) => Number(p)).filter((p) => Number.isInteger(p));\n      const readyNow = normalized.filter((port) => this.pending(port) > 0);\n      if (readyNow.length > 0) return Promise.resolve(readyNow);\n      const timeoutMs = timeoutSeconds == null ? this.limits.responseTimeoutMs : Math.max(0, Number(timeoutSeconds) * 1e3);\n      const deferred = new Deferred();\n      const waiter = {\n        ports: normalized,\n        deferred,\n        timer: setTimeout(() => {\n          this.readableWaiters.delete(waiter);\n          deferred.resolve([]);\n        }, timeoutMs)\n      };\n      this.readableWaiters.add(waiter);\n      return deferred.promise;\n    }\n    async waitForListen(timeoutMs) {\n      const existing = this.firstListeningPort();\n      if (existing) return existing;\n      const waiter = new Deferred();\n      this.listenWaiters.push(waiter);\n      let timer = null;\n      const timeout = new Promise((resolve) => {\n        timer = setTimeout(() => resolve(null), Math.max(1, timeoutMs ?? 5e3));\n      });\n      try {\n        return await Promise.race([waiter.promise, timeout]);\n      } finally {\n        if (timer !== null) clearTimeout(timer);\n      }\n    }\n    async handleHttpRequest(port, request) {\n      const n = Number(port);\n      let listener = this.listeners.get(n);\n      if (!listener) {\n        try {\n          await this.host.__nimbusVirtualSocketEnsureListener?.(n);\n        } catch {\n        }\n        listener = this.listeners.get(n);\n      }\n      if (!listener) {\n        return new Response(`Nimbus virtual socket: no listener on port ${port}`, { status: 502 });\n      }\n      const body = request.method === \"GET\" || request.method === \"HEAD\" ? EMPTY_BYTES : new Uint8Array(await request.arrayBuffer());\n      if (body.byteLength > this.limits.maxRequestBodyBytes) {\n        return new Response(\n          `Nimbus virtual socket: request body exceeds ${this.limits.maxRequestBodyBytes} bytes`,\n          { status: 413 }\n        );\n      }\n      const id = this.nextConnectionId++;\n      const conn = new VirtualConnection(id, request.method, encodeHttpRequest(request, body), this.limits);\n      this.connections.set(id, conn);\n      listener.push(conn);\n      this.notifyReadable(n);\n      const signal = request.signal;\n      const onAbort = () => conn.abort(\"client aborted the request\", 499);\n      if (signal?.aborted) onAbort();\n      else signal?.addEventListener(\"abort\", onAbort);\n      try {\n        try {\n          const accepted = await this.host.__nimbusVirtualSocketRequestQueued?.(n);\n          if (accepted === false) {\n            const detail = typeof this.host.__nimbusVirtualSocketLastError === \"string\" ? this.host.__nimbusVirtualSocketLastError.trim() : \"\";\n            const suffix = detail ? `: ${detail}` : \"\";\n            return new Response(\n              `Nimbus virtual socket: runtime handler did not accept the request${suffix}`,\n              { status: 502 }\n            );\n          }\n        } catch {\n        }\n        return await conn.response(this.limits.responseTimeoutMs);\n      } finally {\n        signal?.removeEventListener(\"abort\", onAbort);\n        conn.close();\n        this.connections.delete(id);\n      }\n    }\n    notifyReadable(port) {\n      for (const waiter of Array.from(this.readableWaiters)) {\n        if (!waiter.ports.includes(port)) continue;\n        const ready = waiter.ports.filter((p) => this.pending(p) > 0);\n        if (ready.length === 0) continue;\n        clearTimeout(waiter.timer);\n        this.readableWaiters.delete(waiter);\n        waiter.deferred.resolve(ready);\n      }\n    }\n  };\n  function installVirtualSocketKernel(scope = globalThis) {\n    if (!scope.__nimbusVirtualSockets) {\n      scope.__nimbusVirtualSockets = new VirtualSocketKernel(scope);\n    }\n    return scope.__nimbusVirtualSockets;\n  }\n\n  // <stdin>\n  installVirtualSocketKernel();\n})();\n";

package/dist/runtime/virtual-socket-kernel.js

@@ -99,7 +99,9 @@ function encodeHttpRequest(request, body) {
         headers.set('Content-Length', String(body.byteLength));
     }
     const lines = [`${request.method} ${path} HTTP/1.1`];
-    headers.forEach((value, key) => lines.push(`${key}: ${value}`));
+    headers.forEach((value, key) => {
+        lines.push(`${key}: ${value}`);
+    });
     lines.push('', '');
     return concatBytes([new TextEncoder().encode(lines.join('\r\n')), body]);
 }
@@ -115,7 +117,9 @@ function encodeHttpRequest(request, body) {
  */
 function encodeHttpResponseHead(status, statusText, headers, chunkedBody) {
     const lines = [`HTTP/1.1 ${status} ${statusText}`];
-    headers.forEach((value, key) => lines.push(`${key}: ${value}`));
+    headers.forEach((value, key) => {
+        lines.push(`${key}: ${value}`);
+    });
     if (chunkedBody)
         lines.push('Transfer-Encoding: chunked');
     lines.push('Connection: close');
@@ -647,8 +651,8 @@ class LoopbackClientConnection {
                 throw new Error('Nimbus loopback socket: read before a complete HTTP request was written ' +
                     '(loopback sockets carry HTTP requests, not arbitrary byte streams)');
             }
-            const waiter = (this.readable ??= new Deferred());
-            await waiter.promise;
+            this.readable ??= new Deferred();
+            await this.readable.promise;
         }
     }
     close() {
@@ -775,7 +779,8 @@ class LoopbackClientConnection {
     awaitDrain() {
         if (this.inbound.pendingBytes <= LOOPBACK_READ_HIGH_WATER_BYTES)
             return Promise.resolve();
-        return (this.drained ??= new Deferred()).promise;
+        this.drained ??= new Deferred();
+        return this.drained.promise;
     }
     withTimeout(promise) {
         let timer = null;

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

@@ -1 +1 @@
-{"version":3,"file":"wasm-runner.d.ts","sourceRoot":"","sources":["../../src/runtime/wasm-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC3F,OAAO,KAAK,EAAS,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAkDtD,eAAO,MAAM,mBAAmB,UAAU,CAAC;AAE3C,eAAO,MAAM,gBAAgB,QAoCwC,CAAC;AAEtE,wBAAgB,wBAAwB,IAAI,MAAM,CASjD;AAyCD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,GAAG,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,SAAS,EAAE,wBAAwB,CAAC;CACrC,IAEG,OAAO,MAAM,EACb,MAAM,cAAc,KACnB,OAAO,CAAC,gBAAgB,CAAC,CAslB7B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,GAAG,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,SAAS,EAAE,wBAAwB,CAAC;CACrC,GAAG,WAAW,CAgBd"}
+{"version":3,"file":"wasm-runner.d.ts","sourceRoot":"","sources":["../../src/runtime/wasm-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC3F,OAAO,KAAK,EAAS,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAmDtD,eAAO,MAAM,mBAAmB,UAAU,CAAC;AAE3C,eAAO,MAAM,gBAAgB,QAoCwC,CAAC;AAEtE,wBAAgB,wBAAwB,IAAI,MAAM,CASjD;AAyCD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,GAAG,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,SAAS,EAAE,wBAAwB,CAAC;CACrC,IAEG,OAAO,MAAM,EACb,MAAM,cAAc,KACnB,OAAO,CAAC,gBAAgB,CAAC,CA+mB7B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,GAAG,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,SAAS,EAAE,wBAAwB,CAAC;CACrC,GAAG,WAAW,CAgBd"}

package/dist/runtime/wasm-runner.js

@@ -50,6 +50,7 @@ import { requireVfsCred, WASM32_WASI_NIMBUS_ABI } from './os-contracts.js';
 import { WASI_INSTANCE_PREAMBLE_SRC, WASI_IMPLEMENTED_FNS, WASI_ABI_NAMESPACE } from './wasi-instance.js';
 import { inspectWasmThreads, wasiThreadsLoadError } from './wasi-threads.js';
 import { withMemoryLimit, DEFAULT_WASM_PROCESS_LIMIT_BYTES } from './wasm-memory.js';
+import { errorText } from '../_shared/error-text.js';
 export const WASM_RUNNER_VERSION = '0.3.0';
 export const WASM_RUNNER_HELP = 'Usage: wasm-runner [options] <file.wasm> [exportName] [int args...]\n' +
     '       wasm-runner --version\n' +
@@ -271,6 +272,12 @@ export function makeWasmRunner(deps) {
         // overly conservative; cast to ArrayBuffer is correct.
         const buf = limited.buffer.slice(limited.byteOffset, limited.byteOffset + limited.byteLength);
         const facetFn = async function wasmFacetCall(args, facetEnv) {
+            // This body is serialized into the facet isolate, where the supervisor's
+            // module graph — and so _shared/error-text.js — does not exist. Same
+            // fallback as errorText, spelled out locally.
+            const errText = (err) => typeof err === 'object' && err !== null && 'message' in err && err.message
+                ? String(err.message)
+                : String(err);
             const wasmTable = globalThis.__NIMBUS_WASM || {};
             const mod = wasmTable['user.wasm'];
             if (!mod) {
@@ -390,7 +397,7 @@ export function makeWasmRunner(deps) {
                             mode: 'wasi',
                             error: `wasi-threads: could not reserve the shared memory the module declares `
                                 + `(${args.threads.memory.initial}–${args.threads.memory.maximum} pages, `
-                                + `${(args.threads.memory.maximum * 64) / 1024} MiB): ${e?.message || e}. `
+                                + `${(args.threads.memory.maximum * 64) / 1024} MiB): ${errText(e)}. `
                                 + 'A shared memory reserves its maximum immediately — lower --max-memory.',
                         };
                     }
@@ -414,11 +421,14 @@ export function makeWasmRunner(deps) {
                     return {
                         ok: false,
                         mode: 'wasi',
-                        error: `instantiate failed: ${e?.message || e}`,
+                        error: `instantiate failed: ${errText(e)}`,
                     };
                 }
-                if (!memRef.mem)
-                    memRef.mem = inst.exports.memory;
+                if (!memRef.mem) {
+                    const exported = inst.exports.memory;
+                    if (exported instanceof WebAssembly.Memory)
+                        memRef.mem = exported;
+                }
                 if (!memRef.mem) {
                     return {
                         ok: false,
@@ -464,7 +474,7 @@ export function makeWasmRunner(deps) {
                 return {
                     ok: false,
                     mode: 'direct',
-                    error: `instantiate failed: ${e?.message || e}`,
+                    error: `instantiate failed: ${errText(e)}`,
                 };
             }
             const exportNames = Object.keys(inst.exports);
@@ -487,7 +497,7 @@ export function makeWasmRunner(deps) {
                     ok: false,
                     mode: 'direct',
                     exports: exportNames,
-                    error: `${args.exportName}(${(args.intArgs || []).join(', ')}) threw: ${e?.message || e}`,
+                    error: `${args.exportName}(${(args.intArgs || []).join(', ')}) threw: ${errText(e)}`,
                 };
             }
             // BigInt (i64) → string; everything else → as-is.
@@ -585,7 +595,7 @@ export function makeWasmRunner(deps) {
             }));
         }
         catch (e) {
-            outcome = { ok: false, error: `dispatch failed: ${e?.message || e}` };
+            outcome = { ok: false, error: `dispatch failed: ${errorText(e)}` };
         }
         finally {
             facet?.dispose();
@@ -603,15 +613,13 @@ export function makeWasmRunner(deps) {
             // If runStart reported an `error` (wasm trapped, _start missing,
             // …), append it to stderr but still surface its exitCode (default
             // 1 from runStart on trap) so callers can distinguish.
-            const wasiOut = outcome;
-            // Either branch carries optional stdout/stderr/exitCode/error.
-            stdout = wasiOut.stdout || '';
-            stderr = wasiOut.stderr || '';
-            if (wasiOut.error) {
+            stdout = outcome.stdout || '';
+            stderr = outcome.stderr || '';
+            if (outcome.error) {
                 stderr = (stderr ? stderr : '') +
-                    `wasm-runner: wasi trap: ${wasiOut.error}\n`;
+                    `wasm-runner: wasi trap: ${outcome.error}\n`;
             }
-            exitCode = wasiOut.exitCode ?? (wasiOut.ok ? 0 : 1);
+            exitCode = outcome.exitCode ?? (outcome.ok ? 0 : 1);
         }
         else if (!outcome.ok) {
             // Direct-mode failure or pre-instantiate dispatch failure — shell

package/dist/shell/features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../src/shell/features.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../src/shell/features.ts"],"names":[],"mappings":"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"}

package/dist/shell/features.js

@@ -121,7 +121,7 @@ export class HeredocHandler {
                 }
                 return;
             }
-            return this._handleOriginalInput(data);
+            this._handleOriginalInput(data);
         };
         this.shell.executeLine = async (line) => {
             if (this.active) {
@@ -144,7 +144,7 @@ export class HeredocHandler {
                 this._accumulateLine('');
                 return;
             }
-            return this._printPrompt();
+            this._printPrompt();
         };
     }
     _printPrompt() {
@@ -353,7 +353,8 @@ export class LineEditorExtender {
             // shell-prompt input. Process-stdin input has its own model
             // (terminalStdin / stdinLineBuffer) handled by the shell.
             if (this.shell.running) {
-                return this.originalHandleInput(data);
+                this.originalHandleInput(data);
+                return;
             }
             // Reverse-i-search sub-mode owns ALL input until exited.
             if (this.rsearchActive) {
@@ -368,7 +369,7 @@ export class LineEditorExtender {
             // Try each binding. First-match wins; on no match fall through.
             if (this._handleBinding(data))
                 return;
-            return this.originalHandleInput(data);
+            this.originalHandleInput(data);
         };
     }
     /**