@fungi.computer/mycelium 0.0.1 → 0.1.0

package/dist/internal/execution-lifecycle.js

@@ -10,20 +10,15 @@ import * as Fiber from "effect/Fiber";
 import { z } from "zod";
 import { InvalidOperationInput, MyceliumDefinitionError, } from "../errors.js";
 const jsonValueSchema = z.json();
-const jsonScalarSchema = z.union([
-    z.null(),
-    z.string(),
-    z.boolean(),
-    z.number(),
-]);
-const jsonRecordSchema = z.record(z.string(), z.unknown());
-const executionOptionsSchema = z
+const jsonScalarSchema = z.lazy(() => z.union([z.null(), z.string(), z.boolean(), z.number()]));
+const jsonRecordSchema = z.lazy(() => z.record(z.string(), z.unknown()));
+const executionOptionsSchema = z.lazy(() => z
     .object({
     timeoutMs: z.number().int().min(1).max(900_000).optional(),
     abortGraceMs: z.number().int().min(1).max(30_000).optional(),
 })
     .strict()
-    .optional();
+    .optional());
 const maximumJsonDepth = 64;
 const maximumSerializedJsonBytes = 256 * 1024;
 const maximumBackingExecutions = 8;

package/dist/sandbox-boundary.js

@@ -5,7 +5,7 @@ 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([
+const ownedFailureSchema = z.lazy(() => z.union([
     z.instanceof(SourceInvalid),
     z.instanceof(GuestThrew),
     z.instanceof(DeadlineExceeded),
@@ -17,9 +17,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 +32,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 +51,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 +73,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 +137,7 @@ function operatorValue(cause, seen) {
         }
     }
 }
-const missingVariable = z
+const missingVariable = z.lazy(() => z
     .object({
     name: z.literal("ReferenceError"),
     message: z
@@ -142,10 +147,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,7 +168,7 @@ 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([
@@ -178,9 +186,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 +198,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 +226,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-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/source-runtime.js

@@ -9,11 +9,11 @@ function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
 const maximumCapabilitySources = 128;
-const sourceIdSchema = z.string().min(1).max(160);
-const sourceSnapshotSchema = z.object({
+const sourceIdSchema = z.lazy(() => z.string().min(1).max(160));
+const sourceSnapshotSchema = z.lazy(() => z.object({
     version: z.string().min(1).max(160),
     modules: z.array(z.unknown()),
-});
+}));
 const maximumCandidateModules = 1_000;
 function validateSources(input) {
     if (input.length > maximumCapabilitySources) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/mycelium",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Effect-native scoped capability lifecycle with a Zod-authored execute door",
   "type": "module",
@@ -75,9 +75,9 @@
   ],
   "dependencies": {
     "@fungi.computer/cairn": "0.0.1",
-    "@fungi.computer/forage": "0.0.1",
-    "@fungi.computer/mule": "0.0.1",
-    "@fungi.computer/puffball": "0.0.1",
+    "@fungi.computer/forage": "0.1.0",
+    "@fungi.computer/mule": "0.0.2",
+    "@fungi.computer/puffball": "0.1.0",
     "effect": "4.0.2",
     "zod": "4.4.3",
     "acorn": "8.18.0",