@fungi.computer/mycelium 0.0.2 → 0.2.0

package/dist/internal/host-cores.node.d.ts

@@ -0,0 +1,2 @@
+/** Node's maintained, affinity-aware observation; captured by runtime policy. */
+export declare function availableHostCores(): number;

package/dist/internal/host-cores.node.js

@@ -0,0 +1,5 @@
+import { availableParallelism } from "node:os";
+/** Node's maintained, affinity-aware observation; captured by runtime policy. */
+export function availableHostCores() {
+    return availableParallelism();
+}

package/dist/mcp-catalog.d.ts

@@ -6,12 +6,6 @@ export type McpCatalogSnapshot = Readonly<{
     sources: readonly CapabilitySource[];
     /** Every permitted module is named; an omitted module is refused. */
     grants: Grants;
-    /**
-     * Granted modules whose writes a person already approved for this principal,
-     * such as an owner's stored approval of a key's App tools. Their writes run
-     * without a per-call elicitation; every other write still asks.
-     */
-    approvedWrites?: readonly string[];
 }>;
 /**
  * Adapt principal-scoped capability sources and a sandbox to the shared MCP server.

package/dist/mcp-catalog.js

@@ -41,7 +41,6 @@ export function createMcpCatalog(options) {
                         ...access,
                         defaultGrant: "none",
                         sessionGrants: () => snapshot?.grants ?? {},
-                        approvedWrites: () => snapshot?.approvedWrites ?? [],
                     },
                 });
                 try {

package/dist/mcp.d.ts

@@ -28,7 +28,6 @@ export type McpExecutionContext = Readonly<{
     }>) => Promise<void>;
     /** Apply to Mycelium access options for this call only; never persist callbacks. */
     access: Pick<AccessOptions, "confirm"> & Readonly<{
-        confirmWrites: true;
         /** Recheck the open connection and refresh authority before each operation. */
         beforeCall: (signal: AbortSignal) => Promise<void>;
     }>;

package/dist/mcp.js

@@ -73,7 +73,6 @@ export function createMcp(options) {
                     }
                     : undefined;
                 const access = {
-                    confirmWrites: true,
                     confirm,
                     beforeCall: async (signal) => {
                         signal.throwIfAborted();

package/dist/output-collector.d.ts

@@ -0,0 +1,46 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+/** Complete decoded text, in completion order across stdout/stderr, not byte order. */
+export declare class OutputCollector {
+    #private;
+    private readonly wake;
+    private constructor();
+    static make(): Effect.Effect<OutputCollector, never, never>;
+    /** Never waits for a reader. An incomplete scalar stays with its producer. */
+    write(stream: "stdout" | "stderr", bytes: Uint8Array): void;
+    snapshot(): {
+        tail: string;
+        droppedBytes: number;
+        totalBytes: number;
+    };
+    /** EOF flush order is stdout then stderr; the final update precedes terminal. */
+    finish(): {
+        type: "update";
+        result: {
+            isError: false;
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            data: {
+                droppedBytes: number;
+                totalBytes: number;
+            };
+        };
+    } | undefined;
+    get updates(): Stream.Stream<{
+        type: "update";
+        result: {
+            isError: false;
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            data: {
+                droppedBytes: number;
+                totalBytes: number;
+            };
+        };
+    }, never, never>;
+    dispose(): void;
+}

package/dist/output-collector.js

@@ -0,0 +1,145 @@
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+const capacity = 8192;
+const encoder = new TextEncoder();
+// fatal: false is the existing default; Cloudflare's type requires the field.
+const decoder = () => new TextDecoder("utf-8", { ignoreBOM: true, fatal: false });
+/** Complete decoded text, in completion order across stdout/stderr, not byte order. */
+export class OutputCollector {
+    wake;
+    #producers = {
+        stdout: { decoder: decoder(), pendingBytes: 0 },
+        stderr: { decoder: decoder(), pendingBytes: 0 },
+    };
+    #probe = decoder();
+    // One bounded ring of complete decoder emissions. No UTF-8 slicing/parser.
+    #parts = Array.from({ length: capacity }, () => undefined);
+    #head = 0;
+    #size = 0;
+    #textBytes = 0;
+    #newlines = 0;
+    #droppedBytes = 0;
+    #totalBytes = 0;
+    #dirty = false;
+    #closed = false;
+    constructor(wake) {
+        this.wake = wake;
+    }
+    static make() {
+        return Queue.make({ capacity: 1, strategy: "dropping" }).pipe(Effect.map((wake) => new OutputCollector(wake)));
+    }
+    /** Never waits for a reader. An incomplete scalar stays with its producer. */
+    write(stream, bytes) {
+        if (this.#closed || bytes.length === 0)
+            return;
+        const producer = this.#producers[stream];
+        this.#totalBytes += bytes.length;
+        // Byte-sized decoder inputs let each retained emission carry its exact raw
+        // cost, even when malformed input expands to replacement characters.
+        for (let i = 0; i < bytes.length; i++) {
+            const byte = bytes.subarray(i, i + 1);
+            producer.pendingBytes++;
+            const text = producer.decoder.decode(byte, { stream: true });
+            if (text.length === 0)
+                continue;
+            // A decoder may emit a replacement for a prior incomplete sequence while
+            // buffering the current byte as the start of the next scalar. Ask the
+            // maintained decoder, rather than duplicating UTF-8 byte grammar.
+            const pending = producer.pendingBytes > 1 &&
+                this.#probe.decode(byte, { stream: true }).length === 0
+                ? 1
+                : 0;
+            this.#probe.decode();
+            this.#append(text, producer.pendingBytes - pending);
+            producer.pendingBytes = pending;
+        }
+        this.#dirty = true;
+        Queue.offerUnsafe(this.wake, undefined);
+    }
+    #evict() {
+        const part = this.#parts[this.#head];
+        if (part === undefined)
+            throw new Error("Missing output ring entry");
+        this.#parts[this.#head] = undefined;
+        this.#head = (this.#head + 1) % capacity;
+        this.#size--;
+        this.#textBytes -= part.textBytes;
+        this.#newlines -= part.newlines;
+        this.#droppedBytes += part.rawBytes;
+    }
+    #append(text, rawBytes) {
+        if (text.length === 0)
+            return;
+        const part = {
+            text,
+            rawBytes,
+            textBytes: encoder.encode(text).length,
+            newlines: text.split("\n").length - 1,
+        };
+        if (this.#size === capacity)
+            this.#evict();
+        this.#parts[(this.#head + this.#size) % capacity] = part;
+        this.#size++;
+        this.#textBytes += part.textBytes;
+        this.#newlines += part.newlines;
+        while (this.#textBytes > capacity || this.#newlines >= 200)
+            this.#evict();
+    }
+    snapshot() {
+        let tail = "";
+        for (let i = 0; i < this.#size; i++) {
+            const part = this.#parts[(this.#head + i) % capacity];
+            if (part === undefined)
+                throw new Error("Missing output ring entry");
+            tail += part.text;
+        }
+        return {
+            tail,
+            droppedBytes: this.#droppedBytes,
+            totalBytes: this.#totalBytes,
+        };
+    }
+    #update() {
+        if (!this.#dirty)
+            return undefined;
+        this.#dirty = false;
+        const { tail, ...data } = this.snapshot();
+        return {
+            type: "update",
+            result: {
+                isError: false,
+                content: [{ type: "text", text: tail }],
+                data,
+            },
+        };
+    }
+    /** EOF flush order is stdout then stderr; the final update precedes terminal. */
+    finish() {
+        if (this.#closed)
+            return undefined;
+        this.#closed = true;
+        for (const producer of [this.#producers.stdout, this.#producers.stderr]) {
+            const text = producer.decoder.decode();
+            this.#append(text, producer.pendingBytes);
+            producer.pendingBytes = 0;
+            if (text.length > 0)
+                this.#dirty = true;
+        }
+        return this.#update();
+    }
+    get updates() {
+        return Stream.fromQueue(this.wake).pipe(Stream.mapEffect(() => Effect.sleep("100 millis").pipe(Effect.map(() => (this.#closed ? undefined : this.#update())))), Stream.filter((part) => part !== undefined));
+    }
+    dispose() {
+        this.#closed = true;
+        this.#parts.fill(undefined);
+        this.#head = this.#size = this.#textBytes = this.#newlines = 0;
+        this.#totalBytes = this.#droppedBytes = 0;
+        this.#dirty = false;
+        for (const producer of [this.#producers.stdout, this.#producers.stderr]) {
+            producer.decoder.decode();
+            producer.pendingBytes = 0;
+        }
+    }
+}

package/dist/runtime.js

@@ -36,13 +36,13 @@ function settleClosePlans(plans, liveRevisions) {
 export function openCoreRuntime(options) {
     return Effect.gen(function* () {
         const gate = yield* Semaphore.make(1);
-        const backingWork = createBackingWorkTracker();
         const execution = yield* Effect.try({
             try: () => normalizeExecutionPolicy(options.execution),
             catch: (cause) => cause instanceof MyceliumDefinitionError
                 ? cause
                 : new MyceliumDefinitionError("Execution policy is invalid"),
         });
+        const backingWork = yield* createBackingWorkTracker(execution.capacity);
         const sandbox = Object.freeze({
             execute: options.sandbox.execute,
             adapter: options.sandbox.adapter,

package/dist/sandbox-admission.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const sandboxAdmissionOptionsSchema: z.ZodObject<{
+    sandboxCapacity: z.ZodOptional<z.ZodInt>;
+    admissionWaitMs: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+/** Host-owned admission inputs; never part of guest execute arguments. */
+export type SandboxAdmissionOptions = Readonly<{
+    /** Positive host-selected capacity; omission derives the host default. */
+    sandboxCapacity?: number | undefined;
+    /** Maximum admission wait in milliseconds, from 1 through 900,000. */
+    admissionWaitMs?: number | undefined;
+}>;
+/** Captured once per runtime and shared across backing-work groups. */
+export type SandboxAdmissionPolicy = Readonly<{
+    capacity: number;
+    waitMs: number;
+}>;
+/** Validate host policy and resolve defaults from a platform-owned core observation. */
+export declare function normalizeSandboxAdmissionPolicy(options: SandboxAdmissionOptions | undefined, availableCores?: number): SandboxAdmissionPolicy;

package/dist/sandbox-admission.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { MyceliumDefinitionError } from "./errors.js";
+export const sandboxAdmissionOptionsSchema = z.strictObject({
+    sandboxCapacity: z.int().positive().optional(),
+    admissionWaitMs: z.int().min(1).max(900_000).optional(),
+});
+/** Validate host policy and resolve defaults from a platform-owned core observation. */
+export function normalizeSandboxAdmissionPolicy(options, availableCores) {
+    const parsed = sandboxAdmissionOptionsSchema.safeParse(options ?? {});
+    const cores = z
+        .int()
+        .positive()
+        .safeParse(availableCores ?? 2);
+    if (!parsed.success || !cores.success) {
+        throw new MyceliumDefinitionError("Sandbox admission policy is invalid");
+    }
+    return Object.freeze({
+        capacity: parsed.data.sandboxCapacity ?? Math.min(32, Math.max(2, cores.data)),
+        waitMs: parsed.data.admissionWaitMs ?? 5_000,
+    });
+}

package/dist/sandbox-boundary.js

@@ -4,11 +4,12 @@ import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import { z } from "zod";
 import { InvalidOperationInput } from "./errors.js";
-import { SourceInvalid, GuestThrew, DeadlineExceeded, Cancelled, DispatchLost, SandboxCrashed, BadResponse, ResultTooLarge, ResultNotJson, CapabilityFailed, Unknown, referenceSandboxFailure, sandboxFailureMessage, } from "./sandbox-failure.js";
-const ownedFailureSchema = z.union([
+import { SourceInvalid, GuestThrew, DeadlineExceeded, SandboxBusy, Cancelled, DispatchLost, SandboxCrashed, BadResponse, ResultTooLarge, ResultNotJson, CapabilityFailed, Unknown, referenceSandboxFailure, sandboxFailureMessage, } from "./sandbox-failure.js";
+const ownedFailureSchema = z.lazy(() => z.union([
     z.instanceof(SourceInvalid),
     z.instanceof(GuestThrew),
     z.instanceof(DeadlineExceeded),
+    z.instanceof(SandboxBusy),
     z.instanceof(Cancelled),
     z.instanceof(DispatchLost),
     z.instanceof(SandboxCrashed),
@@ -17,9 +18,9 @@ const ownedFailureSchema = z.union([
     z.instanceof(ResultNotJson),
     z.instanceof(CapabilityFailed),
     z.instanceof(Unknown),
-]);
+]));
 /** The one interpretation boundary for foreign in-process values and rejections. */
-const foreignValueSchema = z
+const foreignValueSchema = z.lazy(() => z
     .unknown()
     .pipe(z.union([
     z
@@ -32,7 +33,12 @@ const foreignValueSchema = z
     z.string().transform((value) => ({ kind: "string", value })),
     z.boolean().transform((value) => ({ kind: "boolean", value })),
     z
-        .union([z.number(), z.nan(), z.literal(Infinity), z.literal(-Infinity)])
+        .union([
+        z.number(),
+        z.nan(),
+        z.literal(Infinity),
+        z.literal(-Infinity),
+    ])
         .transform((value) => ({ kind: "number", value })),
     z.bigint().transform((value) => ({ kind: "bigint", value })),
     z.symbol().transform((value) => ({ kind: "symbol", value })),
@@ -46,7 +52,7 @@ const foreignValueSchema = z
         .union([z.instanceof(Object), z.record(z.string(), z.unknown())])
         .transform((value) => ({ kind: "object", value })),
     z.unknown().transform(() => ({ kind: "opaque" })),
-]));
+])));
 /** Admit only errors constructed by the sandbox owner, using the maintained decoder. */
 export function isSandboxFailure(cause) {
     return ownedFailureSchema.safeParse(cause).success;
@@ -68,7 +74,7 @@ export function sandboxValueKind(value) {
             return decoded.kind;
     }
 }
-const bindingInputSchema = z.json().optional();
+const bindingInputSchema = z.lazy(() => z.json().optional());
 /** Decode the RPC argument before any capability callback observes it. */
 export function sandboxBindingInput(value) {
     return bindingInputSchema.parse(value);
@@ -132,7 +138,7 @@ function operatorValue(cause, seen) {
         }
     }
 }
-const missingVariable = z
+const missingVariable = z.lazy(() => z
     .object({
     name: z.literal("ReferenceError"),
     message: z
@@ -142,10 +148,13 @@ const missingVariable = z
     .transform((value) => ({
     ...value,
     missingVariable: value.message.slice(0, -" is not defined".length),
-}));
-const guestDiagnosticSchema = z
-    .union([missingVariable, z.object({ name: z.string(), message: z.string() })])
-    .and(z.object({ transportMessage: z.string().max(512).optional() }));
+})));
+const guestDiagnosticSchema = z.lazy(() => z
+    .union([
+    missingVariable,
+    z.object({ name: z.string(), message: z.string() }),
+])
+    .and(z.object({ transportMessage: z.string().max(512).optional() })));
 /** Decode the engine's guest-owned diagnostic once; renderers receive typed fields. */
 export function sandboxGuestFailure(cause, bindings = {}) {
     const diagnostic = guestDiagnosticSchema.parse(cause);
@@ -160,13 +169,14 @@ export function sandboxGuestFailure(cause, bindings = {}) {
     }
     return new GuestThrew(diagnostic);
 }
-const transportEnvelopeSchema = z.strictObject({
+const transportEnvelopeSchema = z.lazy(() => z.strictObject({
     v: z.literal(1),
     kind: z.literal("sandbox_failure"),
     tag: z.enum([
         "SourceInvalid",
         "GuestThrew",
         "DeadlineExceeded",
+        "SandboxBusy",
         "Cancelled",
         "DispatchLost",
         "SandboxCrashed",
@@ -178,9 +188,9 @@ const transportEnvelopeSchema = z.strictObject({
     ]),
     ref: z.string().min(1).max(32),
     message: z.string().max(160),
-});
+}));
 const decodeJsonText = Schema.decodeUnknownResult(Schema.fromJsonString(Schema.Unknown));
-const jsonTextSchema = z.string().transform((text, context) => {
+const jsonTextSchema = z.lazy(() => z.string().transform((text, context) => {
     const decoded = decodeJsonText(text);
     if (Result.isFailure(decoded)) {
         context.addIssue({
@@ -190,7 +200,7 @@ const jsonTextSchema = z.string().transform((text, context) => {
         return z.NEVER;
     }
     return decoded.success;
-});
+}));
 const transportMessageSchema = jsonTextSchema.pipe(transportEnvelopeSchema);
 const returnedOperationFailure = z.strictObject({
     error: transportMessageSchema,
@@ -218,16 +228,15 @@ export function recoverSandboxFailure(failure, failures) {
     const original = failures.get(decoded.data.ref);
     return original?._tag === decoded.data.tag ? original : failure;
 }
-const executorFailureSchema = z
-    .unknown()
-    .pipe(z.union([
+const executorFailureSchema = z.lazy(() => z.unknown().pipe(z.union([
     z
         .literal("Execution timed out")
         .transform(() => ({ kind: "deadline" })),
-    z
-        .unknown()
-        .transform((rawCause) => ({ kind: "bad_response", rawCause })),
-]));
+    z.unknown().transform((rawCause) => ({
+        kind: "bad_response",
+        rawCause,
+    })),
+])));
 /** Decode Codemode's documented error carrier before adapters choose a failure. */
 export function sandboxExecutorFailure(cause, limitMs, elapsedMs) {
     const decoded = executorFailureSchema.parse(cause);

package/dist/sandbox-failure-event.d.ts

@@ -7,7 +7,7 @@ export declare const SandboxFailureEventSchema: Schema.Struct<{
     readonly executionId: Schema.String;
     readonly adapter: Schema.String;
     readonly buildSha: Schema.NullOr<Schema.String>;
-    readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
+    readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "SandboxBusy", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
     readonly fields: Schema.$Record<Schema.String, Schema.Codec<z.core.util.JSONType, z.core.util.JSONType, never, never>>;
     readonly healthAlert: Schema.Boolean;
 }>;

package/dist/sandbox-failure-event.js

@@ -20,6 +20,7 @@ export const SandboxFailureEventSchema = Schema.Struct({
         "SourceInvalid",
         "GuestThrew",
         "DeadlineExceeded",
+        "SandboxBusy",
         "Cancelled",
         "DispatchLost",
         "SandboxCrashed",

package/dist/sandbox-failure.d.ts

@@ -34,6 +34,17 @@ export declare class DeadlineExceeded extends DeadlineExceeded_base<SandboxFailu
     readonly acknowledged?: boolean | undefined;
 }> {
 }
+declare const SandboxBusy_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SandboxBusy";
+} & Readonly<A>;
+/** Admission expired before any sandbox work started. */
+export declare class SandboxBusy extends SandboxBusy_base<SandboxFailureReference & {
+    readonly capacity: number;
+    readonly waitedMs: number;
+}> {
+    /** Stable contention code, not a sandbox health failure. */
+    readonly code = "sandbox-busy";
+}
 declare const Cancelled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Cancelled";
 } & Readonly<A>;
@@ -120,7 +131,7 @@ export declare class Unknown extends Unknown_base<SandboxFailureReference & {
 }> {
 }
 /** Closed error channel shared by sandbox adapters and the invocation owner. */
-export type SandboxFailure = SourceInvalid | GuestThrew | DeadlineExceeded | Cancelled | DispatchLost | SandboxCrashed | BadResponse | ResultTooLarge | ResultNotJson | CapabilityFailed | Unknown;
+export type SandboxFailure = SourceInvalid | GuestThrew | DeadlineExceeded | SandboxBusy | Cancelled | DispatchLost | SandboxCrashed | BadResponse | ResultTooLarge | ResultNotJson | CapabilityFailed | Unknown;
 /** Copy the failure to correlate one execution without mutating shared host errors. */
 export declare function referenceSandboxFailure(failure: SandboxFailure, ref: string): SandboxFailure;
 /** The sole model projection. Transport, parser and raw cause fields stay private. */

package/dist/sandbox-failure.js

@@ -8,6 +8,11 @@ export class GuestThrew extends Data.TaggedError("GuestThrew") {
 /** The invocation owner decided its execution budget was spent. */
 export class DeadlineExceeded extends Data.TaggedError("DeadlineExceeded") {
 }
+/** Admission expired before any sandbox work started. */
+export class SandboxBusy extends Data.TaggedError("SandboxBusy") {
+    /** Stable contention code, not a sandbox health failure. */
+    code = "sandbox-busy";
+}
 /** The invocation owner accepted cancellation. */
 export class Cancelled extends Data.TaggedError("Cancelled") {
 }
@@ -62,6 +67,12 @@ export function referenceSandboxFailure(failure, ref) {
                 acknowledged: failure.acknowledged,
                 ref,
             });
+        case "SandboxBusy":
+            return new SandboxBusy({
+                capacity: failure.capacity,
+                waitedMs: failure.waitedMs,
+                ref,
+            });
         case "Cancelled":
             return new Cancelled({
                 by: failure.by,
@@ -126,6 +137,9 @@ export function sandboxFailureMessage(failure, includeReference = true) {
         case "DeadlineExceeded":
             text = `execute hit its ${String(failure.limitMs)} ms deadline after ${String(failure.elapsedMs)} ms; split the work or persist progress${failure.acknowledged === false ? "; sandbox did not acknowledge cancellation" : ""}`;
             break;
+        case "SandboxBusy":
+            text = `sandbox-busy: all ${String(failure.capacity)} sandbox slots remained occupied after waiting ${String(failure.waitedMs)} ms. Nothing ran; retry this call after capacity becomes available.`;
+            break;
         case "Cancelled":
             text =
                 failure.acknowledged === false

package/dist/sandbox-guest.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 /** Closed guest envelope: guest exceptions cannot masquerade as host failures. */
-export declare const sandboxGuestResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const sandboxGuestResultSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     ok: z.ZodLiteral<true>;
     value: z.ZodUnknown;
 }, z.core.$strict>, z.ZodObject<{
@@ -11,7 +11,7 @@ export declare const sandboxGuestResultSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         message: z.ZodString;
         transportMessage: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
-}, z.core.$strict>], "ok">;
+}, z.core.$strict>], "ok">>;
 /** Locate syntax in the submitted code, accounting for Codemode's normalization. */
 export declare function submittedSourceLocation(normalized: string, submitted: string): Readonly<{
     line: number;
@@ -19,13 +19,13 @@ export declare function submittedSourceLocation(normalized: string, submitted: s
     excerpt: string;
 }> | null;
 /** Parsed guest namespace segments; callbacks never cross this wire. */
-export declare const sandboxNamespaceSegmentSchema: z.ZodString;
+export declare const sandboxNamespaceSegmentSchema: z.ZodLazy<z.ZodString>;
 /** A transport alias is interpolated as a strict JavaScript binding identifier. */
-export declare const sandboxTransportAliasSchema: z.ZodString;
+export declare const sandboxTransportAliasSchema: z.ZodLazy<z.ZodString>;
 /** Transport aliases mapped to their logical namespace paths. */
-export declare const sandboxNamespacePathsSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+export declare const sandboxNamespacePathsSchema: z.ZodLazy<z.ZodRecord<z.ZodLazy<z.ZodString>, z.ZodArray<z.ZodLazy<z.ZodString>>>>;
 /** Serializable flat transport table; operation keys may have any namespace depth. */
-export declare const sandboxBindingNamesSchema: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+export declare const sandboxBindingNamesSchema: z.ZodLazy<z.ZodRecord<z.ZodLazy<z.ZodString>, z.ZodArray<z.ZodString>>>;
 /** Serializable operation names; callbacks stay in the host's existing binding table. */
 export declare function sandboxBindingNames<A>(bindings: Readonly<Record<string, Readonly<Record<string, A>>>>): Readonly<Record<string, readonly string[]>>;
 /** Injective provider identifier: Codemode sanitizes dotted function names. */

package/dist/sandbox-guest.js

@@ -2,7 +2,7 @@ import { parse } from "acorn";
 import { z } from "zod";
 import { sandboxSourceError } from "./sandbox-boundary.js";
 /** Closed guest envelope: guest exceptions cannot masquerade as host failures. */
-export const sandboxGuestResultSchema = z.discriminatedUnion("ok", [
+export const sandboxGuestResultSchema = z.lazy(() => z.discriminatedUnion("ok", [
     z.strictObject({ ok: z.literal(true), value: z.unknown() }),
     z.strictObject({
         ok: z.literal(false),
@@ -13,7 +13,7 @@ export const sandboxGuestResultSchema = z.discriminatedUnion("ok", [
             transportMessage: z.string().max(512).optional(),
         }),
     }),
-]);
+]));
 /** Locate syntax in the submitted code, accounting for Codemode's normalization. */
 export function submittedSourceLocation(normalized, submitted) {
     try {
@@ -45,9 +45,7 @@ export function submittedSourceLocation(normalized, submitted) {
     }
 }
 /** Parsed guest namespace segments; callbacks never cross this wire. */
-export const sandboxNamespaceSegmentSchema = z
-    .string()
-    .regex(/^[A-Za-z][A-Za-z0-9_]*$/u);
+export const sandboxNamespaceSegmentSchema = z.lazy(() => z.string().regex(/^[A-Za-z][A-Za-z0-9_]*$/u));
 /** A transport alias is interpolated as a strict JavaScript binding identifier. */
 export const sandboxTransportAliasSchema = sandboxNamespaceSegmentSchema.refine((alias) => {
     if (alias === "env")
@@ -63,9 +61,9 @@ export const sandboxTransportAliasSchema = sandboxNamespaceSegmentSchema.refine(
     }
 }, "Invalid sandbox transport alias");
 /** Transport aliases mapped to their logical namespace paths. */
-export const sandboxNamespacePathsSchema = z.record(sandboxTransportAliasSchema, z.array(sandboxNamespaceSegmentSchema).min(1));
+export const sandboxNamespacePathsSchema = z.lazy(() => z.record(sandboxTransportAliasSchema, z.array(sandboxNamespaceSegmentSchema).min(1)));
 /** Serializable flat transport table; operation keys may have any namespace depth. */
-export const sandboxBindingNamesSchema = z.record(sandboxTransportAliasSchema, z.array(z.string().regex(/^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)*$/u)));
+export const sandboxBindingNamesSchema = z.lazy(() => z.record(sandboxTransportAliasSchema, z.array(z.string().regex(/^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)*$/u))));
 /** Serializable operation names; callbacks stay in the host's existing binding table. */
 export function sandboxBindingNames(bindings) {
     return Object.fromEntries(Object.entries(bindings).map(([namespace, operations]) => [

package/dist/sandbox-wire.d.ts

@@ -20,6 +20,11 @@ export declare const sandboxWireSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"deadline_exceeded">;
         limitMs: z.ZodNumber;
         elapsedMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"sandbox_busy">;
+        code: z.ZodLiteral<"sandbox-busy">;
+        capacity: z.ZodInt;
+        waitedMs: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"result_not_json">;
         valueKind: z.ZodString;