@fungi.computer/mycelium

Classes

MyceliumDefinitionError

A capability declaration could not form one coherent installed surface.

Extends

Error

Constructors

Constructor

new MyceliumDefinitionError(message): MyceliumDefinitionError

Parameters

message

string

Returns

MyceliumDefinitionError

Overrides

Error.constructor

Properties

code

readonly code: "invalid_definition" = invalidDefinitionCode

Stable machine-readable failure code.

MyceliumClosedError

An operation attempted to use a closed Mycelium runtime.

Extends

Error

Constructors

Constructor

new MyceliumClosedError(message?): MyceliumClosedError

Parameters

message?

string = "Mycelium runtime is closed"

Returns

MyceliumClosedError

Overrides

Error.constructor

Properties

code

readonly code: "runtime_closed" = runtimeClosedCode

Stable machine-readable failure code.

MyceliumSourceError

A capability source failed at its bounded host boundary.

Extends

Error

Constructors

Constructor

new MyceliumSourceError(sourceId, phase): MyceliumSourceError

Parameters

sourceId

string | undefined

Stable identity of the source, absent for whole-candidate failures.

phase

MyceliumSourcePhase

Lifecycle phase that could not settle.

Returns

MyceliumSourceError

Overrides

Error.constructor

Properties

code

readonly code: "source_failure" = sourceFailureCode

Stable machine-readable failure code.

sourceId

readonly sourceId: string | undefined

Stable identity of the source, absent for whole-candidate failures.

phase

readonly phase: MyceliumSourcePhase

Lifecycle phase that could not settle.

Type Aliases

CapabilitySession

CapabilitySession = Readonly<{ sessionId: string; }>

Session on whose behalf one runtime acquires its capability projections.

CapabilitySourceContext

CapabilitySourceContext = Readonly<{ session?: CapabilitySession; signal: AbortSignal; invalidate: () => void; }>

Context supplied while acquiring one current capability projection.

CapabilitySourceSnapshot

CapabilitySourceSnapshot = Readonly<{ version: string; modules: readonly ModuleRegistration[]; }>

Bounded current projection returned by one capability source.

CapabilitySourceAcquisition

CapabilitySourceAcquisition = Readonly<{ snapshot: CapabilitySourceSnapshot; release: () => Promise<void>>; }>

Acquired source projection and the cleanup that owns its live adapter.

CapabilitySource

CapabilitySource = Readonly<{ id: string; acquire: (context) => Promise<CapabilitySourceAcquisition>>; }>

Promise-shaped host boundary for one versioned capability projection.

MyceliumSourcePhase

MyceliumSourcePhase = "acquire" | "release" | "stale"

Lifecycle phase in which a capability source failed.

MyceliumError

MyceliumError = MyceliumClosedError | MyceliumDefinitionError | MyceliumSourceError | SandboxFailure

Closed failure vocabulary for the first Mycelium runtime slice.

ExecutionOptions

ExecutionOptions = Readonly<{ timeoutMs?: number; abortGraceMs?: number; }>

Host-selectable execution limits; neither budget can be disabled.

CollectedImage

CollectedImage = Readonly<{ data: string; mimeType: "image/jpeg" | "image/png" | "image/webp"; path: string; bytes: number; }>

A single image collected during an execute run.

ExecutionImages

ExecutionImages = Readonly<{ push: (image) => string; }>

The collector as one execution’s operations see it: push only.

InvocationContext

InvocationContext = Readonly<{ executionId: string; signal: AbortSignal; images?: ExecutionImages; }>

The only context an operation callback may observe.

MyceliumJsonValue

MyceliumJsonValue = output<ZodJSONSchema>>

JSON value allowed to cross the sandbox and capability boundary.

SandboxValue

SandboxValue = input<ZodUnknown>>

Untrusted value supplied by or returned from a host sandbox boundary.

SandboxBinding

SandboxBinding = (input) => Promise<MyceliumJsonValue>>

One invocation binding visible to the host-provided sandbox.

Parameters

input

SandboxValue

Returns

Promise<MyceliumJsonValue>

SandboxRequest

SandboxRequest = Readonly<{ executionId: string; code: string; timeoutMs: number; bindings: Readonly<Record<string, Readonly<Record<string, SandboxBinding>>>>>>>>; modules?: Readonly<Record<string, string>>>>; sessionId?: string | null; }>

Request crossing the root Promise-shaped sandbox seam.

Sandbox

Sandbox = Readonly<{ adapter?: string; buildSha?: string; execute: (request, signal) => Promise<SandboxValue>>; }>

Promise-shaped sandbox interface implemented by a host or stranger.

MyceliumOptions

MyceliumOptions = Readonly<{ modules?: readonly ModuleRegistration[]; sources?: readonly CapabilitySource[]; session?: CapabilitySession; execution?: ExecutionOptions; sandbox: Sandbox; onSandboxFailure?: (event) => Promise<void>>; }>

Inputs used to construct the Promise-facing runtime.

AcquireOptions

AcquireOptions = Readonly<{ signal?: AbortSignal; }>

Cancellation options for one Promise-facing lease acquisition.

Lease

Lease = Readonly<{ revision: string; catalog: ForageCatalog; executeTool: MuleTool; release: () => Promise<void>>; }>

One immutable Promise-facing capability revision.

Runtime

Runtime = Readonly<{ acquire: (options?) => Promise<Lease>>; close: () => Promise<void>>; }>

Warm Promise-facing lifecycle for acquiring immutable run leases.

OperationDefinition

OperationDefinition<I, O> > = Readonly<{ replay?: "safe" | "unsafe"; description?: string; input: ZodType<I>>; output?: ZodType<O>>; execute: (input, context) => Promise<O>>; }>

Zod-first declaration for one operation behind the execute door.

Type Parameters

I

I extends MyceliumJsonValue

O

O extends MyceliumJsonValue

ModuleDefinition

ModuleDefinition = Readonly<{ id: string; name?: string; description?: string; operations: Readonly<Record<string, OperationRegistration>>>>; }>

Declaration for one stable module and its related operations.

MyceliumApi

MyceliumApi = Readonly<{ module: (definition) => ModuleRegistration; operation: <I, O>>(definition) => OperationRegistration<I, O>>; make: (options) => Promise<Runtime>>; gate: (module, gate) => ModuleRegistration; }>

Public convenience namespace contract.

OperationRegistration

OperationRegistration<I, O> > = Readonly<{ [operationBrand]: true; [operationTypes]?: Readonly<{ input: I; output: O; }>; }>

Opaque handle for one Zod-authored operation.

Type Parameters

I

I = unknown

O

O = unknown

ModuleRegistration

ModuleRegistration = Readonly<{ [moduleBrand]: true; }>

Opaque handle for one namespaced capability module.

GateDecision

GateDecision = Readonly<{ kind: "allow"; }> | Readonly<{ kind: "refuse"; value: MyceliumJsonValue; }>

A gate’s verdict for one call: run the operation, or return value instead.

OperationGate

OperationGate = (call) => GateDecision | Promise<GateDecision>>

Asked before every call of a gated module’s operations.

Parameters

call

Readonly<{ operation: string; context: InvocationContext; }>

Returns

GateDecision | Promise<GateDecision>

SandboxFailureEvent

SandboxFailureEvent = typeof SandboxFailureEventSchema.Type

Full operator diagnostics, excluded from model conversation and default reads.

Variables

MAX_EXECUTION_IMAGES

const MAX_EXECUTION_IMAGES: 8 = 8

Maximum number of out-of-band images retained for one execution.

Mycelium

const Mycelium: MyceliumApi

Zod-first authoring and Promise-facing runtime construction.

SandboxFailureEventSchema

const SandboxFailureEventSchema: Struct<{ kind: Literal<"sandbox_failure">>; ref: String; executionId: String; adapter: String; buildSha: NullOr<String>>; tag: Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>; fields: $Record<String, Codec<JSONType, JSONType, never, never>>>>; healthAlert: Boolean; }>