@makaio/framework 1.0.0-dev-1787670071418 → 1.0.0-dev-1787670559522

package/dist/index-Cny5RvjO.d.mts

@@ -1,800 +0,0 @@
-import { l as JsonValue$1 } from "./json-value-DPqb-SJ8.mjs";
-import { o as ICapabilityProvider$1 } from "./index-DQ8o3JGi.mjs";
-import * as _$zod from "zod";
-import { z } from "zod";
-import * as _$_makaio_core0 from "@makaio/framework/core";
-import { MakaioBusLike } from "@makaio/framework/core";
-import * as _$_makaio_contracts0 from "@makaio/framework/contracts";
-import * as _$zod_v4_core0 from "zod/v4/core";
-
-//#region core/contracts/src/code-execution/types.d.ts
-/** Capability identifier used for CodeExecution providers. */
-declare const CODE_EXECUTION_CAPABILITY_ID$1: "code-execution";
-/**
- * Ordered constant array of every trust level a CodeExecution provider may
- * declare.
- *
- * Source of truth for the {@link CodeExecutionTrustLevel} union, and the enum
- * the requirements schema is built from — `CodeExecutionRequirementsSchema`
- * spells its `trust` field as `z.enum(CODE_EXECUTION_TRUST_LEVELS)`, so adding
- * a level here widens the schema with it.
- */
-declare const CODE_EXECUTION_TRUST_LEVELS$1: readonly ["trusted-code-only", "isolated"];
-/**
- * Trust level a CodeExecution provider declares for the code it runs.
- *
- * - `trusted-code-only`: the provider executes code with the privileges of
- *   its host process. Only code the host already trusts may be submitted.
- * - `isolated`: the provider executes code inside an isolation boundary of
- *   its own (e.g. a container or microVM).
- *
- * Requirements may demand a trust level, but demanding one never grants it:
- * whether a provider is available and what it is trusted with is decided by
- * local runtime composition, not by the request.
- */
-type CodeExecutionTrustLevel$1 = (typeof CODE_EXECUTION_TRUST_LEVELS$1)[number];
-/**
- * Prepared, JSON-safe TypeScript/ESM module set to execute.
- *
- * This is a module-materialization contract: the provider materializes the
- * virtual module set into an ESM program root and imports the entry module
- * from it. The path rules keep that materialization well-defined across
- * provider hosts; they do not create runtime filesystem isolation.
- *
- * Virtual paths use canonical POSIX separators independent of the provider
- * host. Every key of {@link files} — and {@link entryFile} — must be a
- * non-empty, relative, normalized path without `.`/`..` segments,
- * backslashes, empty segments, or NUL bytes.
- */
-interface CodeExecutionProgram {
-  /** Virtual module set, keyed by canonical relative POSIX path. */
-  readonly files: Readonly<Record<string, string>>;
-  /** Virtual path of the entry module. Must name one of {@link files}. */
-  readonly entryFile: string;
-  /**
-   * Name of the export invoked on the entry module (e.g. `'default'`).
-   *
-   * Bounded in length by the program schema, like every identity string a
-   * request carries: no provider budget measures it, and a provider copies it
-   * per invocation into whatever runs the program.
-   */
-  readonly exportName: string;
-}
-/**
- * Optional constraints a request places on provider selection.
- *
- * Every field is an exact-match constraint; omitted fields impose no
- * constraint. Requirements only narrow the set of locally registered
- * providers — they never grant trust and never enable a provider that the
- * host did not compose.
- *
- * Each pin is bounded in length by the requirements schema: a pin longer than
- * any value it could ever match narrows nothing, and is only a larger request
- * to retain.
- */
-interface CodeExecutionRequirements$1 {
-  /** Exact provider identifier to pin (matches {@link ICapabilityProvider.id}). */
-  readonly providerId?: string;
-  /** Required exact runtime tag (matches {@link ICodeExecutionProvider.runtime}). */
-  readonly runtime?: string;
-  /** Required exact language tag (matches {@link ICodeExecutionProvider.language}). */
-  readonly language?: string;
-  /** Required exact module format (matches {@link ICodeExecutionProvider.moduleFormat}). */
-  readonly moduleFormat?: string;
-  /** Required exact trust level (matches {@link ICodeExecutionProvider.trust}). */
-  readonly trust?: CodeExecutionTrustLevel$1;
-}
-/**
- * One prepared, JSON-safe invocation routed to one CodeExecution provider.
- */
-interface CodeExecutionRequest$1 {
-  /**
-   * Caller-supplied identifier correlating this invocation across logs and
-   * telemetry. Bounded in length by the request schema.
-   */
-  readonly invocationId: string;
-  /** Prepared virtual TypeScript/ESM module set to execute. */
-  readonly program: CodeExecutionProgram;
-  /** JSON-safe value passed to the invoked export as its single argument. */
-  readonly arguments: JsonValue$1;
-  /** Optional exact-match constraints on provider selection. */
-  readonly requirements?: CodeExecutionRequirements$1;
-  /** Wall-clock budget for the execution, in milliseconds. */
-  readonly timeoutMs: number;
-}
-/**
- * Ordered constant array of every terminal outcome status.
- *
- * Neither the {@link CodeExecutionOutcome} union nor
- * `CodeExecutionOutcomeSchema` is derived from this array: the union names its
- * variant interfaces and the schema spells each discriminant as a `z.literal`,
- * because a discriminated union needs literal discriminants a generated enum
- * cannot supply. What keeps the three in step is a type-level assertion in the
- * contract tests, which requires this array's members to equal
- * `CodeExecutionOutcome['status']` exactly. Adding a status therefore fails
- * that assertion until the union, the schema, and this array all name it.
- */
-declare const CODE_EXECUTION_OUTCOME_STATUSES: readonly ["completed", "failed", "timed_out", "cancelled"];
-/**
- * Ordered constant array of every failure code valid on a `failed` outcome.
- *
- * These are the codes with no dedicated outcome status of their own: the
- * timeout and cancellation codes are excluded because they are pinned to the
- * `timed_out` and `cancelled` variants. Source of truth for the
- * `CodeExecutionFailedOutcomeCodeSchema` and the
- * {@link CodeExecutionFailedOutcomeCode} union.
- */
-declare const CODE_EXECUTION_FAILED_OUTCOME_CODES$1: readonly ["provider_unavailable", "invalid_provider", "invalid_program", "unsupported_import", "compilation_failed", "entrypoint_not_found", "handler_failed", "invalid_result", "provider_failed"];
-/**
- * Ordered constant array of every stable failure code.
- *
- * Composed from {@link CODE_EXECUTION_FAILED_OUTCOME_CODES} plus the two
- * codes pinned to their own outcome variants. Source of truth for the
- * `CodeExecutionFailureCodeSchema` and the {@link CodeExecutionFailureCode}
- * union.
- */
-declare const CODE_EXECUTION_FAILURE_CODES: readonly ["provider_unavailable", "invalid_provider", "invalid_program", "unsupported_import", "compilation_failed", "entrypoint_not_found", "handler_failed", "invalid_result", "provider_failed", "execution_timeout", "cancelled"];
-/**
- * Failure classification valid on a `failed` outcome.
- *
- * Excludes `execution_timeout` and `cancelled`, which are pinned to the
- * `timed_out` and `cancelled` outcome variants respectively.
- */
-type CodeExecutionFailedOutcomeCode$1 = (typeof CODE_EXECUTION_FAILED_OUTCOME_CODES$1)[number];
-/**
- * Stable, machine-readable classification of a non-completed outcome.
- *
- * - `provider_unavailable`: no registered provider satisfies the request, or
- *   the admitted provider is not accepting work (disposed, draining, or at
- *   capacity).
- * - `invalid_provider`: a registered or selected provider violated the provider
- *   contract — a malformed registration as much as a non-conforming outcome.
- * - `invalid_program`: the prepared program failed contract validation.
- * - `unsupported_import`: the program imported something the provider does not resolve.
- * - `compilation_failed`: the program could not be compiled, loaded, or
- *   evaluated into runnable code.
- * - `entrypoint_not_found`: the entry module's `exportName` is absent or not callable.
- * - `handler_failed`: the invoked export threw or rejected.
- * - `invalid_result`: the invoked export returned a non-JSON-safe value.
- * - `provider_failed`: the provider itself failed outside the handler.
- * - `execution_timeout`: the execution exceeded `timeoutMs` (only on `timed_out`).
- * - `cancelled`: the execution was cancelled before it completed (only on `cancelled`).
- */
-type CodeExecutionFailureCode = (typeof CODE_EXECUTION_FAILURE_CODES)[number];
-/**
- * Bounded, JSON-safe description of a non-completed outcome.
- *
- * The strict shape carries a stable code and a short summary — nothing else.
- * Failures must not carry stack traces, absolute temporary paths, environment
- * values, or provider-internal error objects over the bus; producers that
- * hold such data must reduce it to a bounded summary before it can cross
- * this boundary.
- * @typeParam TCode - Failure codes valid for the outcome variant carrying
- * this failure; defaults to the full {@link CodeExecutionFailureCode} union.
- */
-interface CodeExecutionFailure<TCode extends CodeExecutionFailureCode = CodeExecutionFailureCode> {
-  /** Stable failure classification. */
-  readonly code: TCode;
-  /**
-   * Short, human-readable, non-secret summary of what went wrong.
-   *
-   * Free text is not content-validated by the schema, so this bound is
-   * behavioral: producers must not embed stack traces, absolute filesystem
-   * paths, environment values, or provider-internal error serializations.
-   * Detailed causes belong in local diagnostic logging only.
-   */
-  readonly message: string;
-}
-/** Terminal outcome of an execution whose invoked export returned a JSON-safe value. */
-interface CodeExecutionCompletedOutcome {
-  /** Discriminant for a completed execution. */
-  readonly status: 'completed';
-  /** JSON-safe value returned by the invoked export. */
-  readonly value: JsonValue$1;
-}
-/** Terminal outcome of an execution that failed before producing a value. */
-interface CodeExecutionFailedOutcome {
-  /** Discriminant for a failed execution. */
-  readonly status: 'failed';
-  /** Bounded failure with a code from {@link CODE_EXECUTION_FAILED_OUTCOME_CODES}. */
-  readonly error: CodeExecutionFailure<CodeExecutionFailedOutcomeCode$1>;
-}
-/** Terminal outcome of an execution that exceeded its wall-clock budget. */
-interface CodeExecutionTimedOutOutcome {
-  /** Discriminant for a timed-out execution. */
-  readonly status: 'timed_out';
-  /** Bounded failure describing the exceeded budget; always coded `execution_timeout`. */
-  readonly error: CodeExecutionFailure<'execution_timeout'>;
-}
-/** Terminal outcome of an execution that was cancelled before completion. */
-interface CodeExecutionCancelledOutcome {
-  /** Discriminant for a cancelled execution. */
-  readonly status: 'cancelled';
-  /** Bounded failure describing the cancellation; always coded `cancelled`. */
-  readonly error: CodeExecutionFailure<'cancelled'>;
-}
-/**
- * Discriminated, JSON-safe union of every terminal execution outcome.
- *
- * Exactly one outcome is produced per invocation. Non-completed variants
- * carry a bounded {@link CodeExecutionFailure} instead of a thrown error so
- * that outcomes stay serializable and secret-free on the bus. Each variant
- * constrains its failure code: `timed_out` is always `execution_timeout`,
- * `cancelled` is always `cancelled`, and `failed` carries one of the
- * remaining codes — contradictory status/code pairings do not exist.
- */
-type CodeExecutionOutcome$1 = CodeExecutionCompletedOutcome | CodeExecutionFailedOutcome | CodeExecutionTimedOutOutcome | CodeExecutionCancelledOutcome;
-/**
- * Ordered constant array of every reason an execution's effective signal
- * aborts.
- *
- * Source of truth for the {@link CodeExecutionAbortReason} union and for the
- * literal values a routing service places on
- * {@link CodeExecutionProviderContext.signal}'s `reason`.
- */
-declare const CODE_EXECUTION_ABORT_REASONS: readonly ["timeout", "cancellation"];
-/**
- * Reason an execution's effective signal aborted.
- *
- * - `timeout`: the effective deadline elapsed before the execution completed.
- * - `cancellation`: the invocation's caller went away.
- *
- * The distinction decides which terminal outcome the invocation settles as —
- * `timed_out` versus `cancelled` — and only the signal's owner knows it. It
- * is carried on the signal precisely so that no observer has to re-derive it
- * by comparing a wall clock to {@link CodeExecutionProviderContext.deadlineEpochMs},
- * a comparison that races the settlement it is trying to classify.
- */
-type CodeExecutionAbortReason$1 = (typeof CODE_EXECUTION_ABORT_REASONS)[number];
-/**
- * Execution context handed to a provider alongside the request.
- *
- * Carries the effective cancellation and deadline signals the router derived
- * from the request's `timeoutMs`, so providers observe one authoritative
- * budget instead of re-deriving their own.
- */
-interface CodeExecutionProviderContext$1 {
-  /**
-   * Effective cancellation signal for this execution.
-   *
-   * Aborts when the execution budget is exhausted or the invocation is
-   * cancelled. Providers stop work cooperatively when it fires.
-   *
-   * When the routing service settles this signal, `signal.reason` is a
-   * {@link CodeExecutionAbortReason}, and that value is authoritative:
-   * providers classify a timeout against a cancellation from it rather than
-   * from their own clock. A provider handed a foreign signal — one it did not
-   * receive from the routing service — may fall back to comparing the current
-   * time against {@link CodeExecutionProviderContext.deadlineEpochMs}.
-   */
-  readonly signal: AbortSignal;
-  /**
-   * Effective execution deadline as a Unix epoch timestamp in milliseconds.
-   *
-   * The earlier of the request's `timeoutMs` budget and an inherited bus
-   * deadline at dispatch time. Providers that schedule internal work use this
-   * absolute instant rather than re-anchoring the relative budget.
-   */
-  readonly deadlineEpochMs: number;
-}
-/**
- * Capability provider that executes one prepared program invocation and
- * returns one normalized terminal outcome.
- *
- * Providers are locally registered runtime objects; they are handed over the
- * capability registry as live references and are never serialized. A provider
- * resolves every invocation to a {@link CodeExecutionOutcome} — including
- * timeouts and cancellations — and rejects only on contract-level misuse.
- */
-interface ICodeExecutionProvider$1 extends ICapabilityProvider$1 {
-  /** Request-addressable provider identifier within the public identifier length limit. */
-  readonly id: string;
-  /** Selection priority among matching providers; higher wins. */
-  readonly priority: number;
-  /** Request-addressable runtime tag within the public identifier length limit (e.g. `'node'`). */
-  readonly runtime: string;
-  /** Request-addressable source language within the public identifier length limit (e.g. `'typescript'`). */
-  readonly language: string;
-  /** Request-addressable module format within the public identifier length limit (e.g. `'esm'`). */
-  readonly moduleFormat: string;
-  /** Trust level this provider executes submitted code under. */
-  readonly trust: CodeExecutionTrustLevel$1;
-  /**
-   * Execute one prepared invocation to a terminal outcome.
-   * @param request - Prepared, JSON-safe invocation to execute.
-   * @param context - Effective cancellation signal and deadline for the execution.
-   * @returns Exactly one normalized terminal outcome for the invocation.
-   */
-  execute(request: CodeExecutionRequest$1, context: CodeExecutionProviderContext$1): Promise<CodeExecutionOutcome$1>;
-}
-//#endregion
-//#region core/contracts/src/code-execution/outcomes.d.ts
-/**
- * Clamp a failure summary to {@link CODE_EXECUTION_FAILURE_MESSAGE_MAX_LENGTH}.
- *
- * Summaries interpolate host-controlled identifiers and provider diagnostics of
- * unbounded length, so the bound is enforced where the failure is built rather
- * than trusted to the length of its inputs. Truncation is marked with an
- * ellipsis so a reader can tell a clipped summary from a complete one, and the
- * result always satisfies the failure schema.
- * @param message - Summary to place on a failure.
- * @returns The summary, truncated to the contract bound when needed.
- */
-declare function boundCodeExecutionFailureMessage$1(message: string): string;
-/**
- * Build the terminal outcome for an abort reason owned by the caller.
- *
- * This is deliberately separate from {@link codeExecutionAbortOutcome}: a
- * router which owns an effective signal retains its reason privately, while a
- * provider can only observe the signal it was handed. The owning router must
- * not let a provider's mutable view of that signal revise the classification
- * it already recorded.
- * @param reason - Authoritative abort reason recorded by the signal owner.
- * @returns The terminal timeout or cancellation outcome for that reason.
- */
-declare function codeExecutionAbortOutcomeForReason$1(reason: CodeExecutionAbortReason$1): CodeExecutionTimedOutOutcome | CodeExecutionCancelledOutcome;
-/**
- * Classify a settled execution abort as a timeout or a cancellation.
- *
- * This is the algorithm {@link CodeExecutionProviderContext.signal} documents
- * for a provider's observed or otherwise foreign signal. A routing service
- * which owns the abort reason privately uses
- * {@link codeExecutionAbortOutcomeForReason} instead.
- *
- * The signal's typed reason is authoritative, because only the party that owns
- * the signal knows why it settled. Comparing a wall clock against the deadline
- * instead would misreport a cancellation that happens to be processed after the
- * deadline, and would depend on the host clock not having moved. The deadline
- * comparison survives only as the documented fallback for a foreign signal —
- * one aborted by someone other than the routing service, which therefore
- * carries no `CodeExecutionAbortReason`.
- *
- * Each returned variant carries the failure code the outcome union pins to it,
- * so the mapping is total and cannot produce a contradictory status/code pair.
- * @param context - Effective cancellation signal and deadline for the execution.
- * @returns The `timed_out` or `cancelled` terminal outcome for that abort.
- */
-declare function codeExecutionAbortOutcome$1(context: CodeExecutionProviderContext$1): CodeExecutionTimedOutOutcome | CodeExecutionCancelledOutcome;
-//#endregion
-//#region core/contracts/src/code-execution/schemas.d.ts
-/**
- * Maximum length of a {@link CodeExecutionFailure} message.
- *
- * Failures travel over the bus and into logs, so their size is bounded at
- * the contract boundary rather than by convention. Producers holding larger
- * diagnostics must reduce them to a summary within this bound.
- */
-declare const CODE_EXECUTION_FAILURE_MESSAGE_MAX_LENGTH$1 = 512;
-/**
- * Maximum UTF-8 byte length of one segment in a
- * {@link CodeExecutionVirtualPathSchema | virtual path}.
- *
- * 255 bytes is the name-component limit on every filesystem the framework
- * targets (ext4, APFS, NTFS). The filesystem measures bytes, not characters:
- * a segment that is fewer than 255 characters but encodes to more than 255
- * UTF-8 bytes must also be rejected — otherwise the same program is valid on
- * the caller's host and unwritable on the runner's.
- */
-declare const VIRTUAL_PATH_SEGMENT_MAX_BYTES = 255;
-/**
- * Maximum UTF-8 byte length of a complete
- * {@link CodeExecutionVirtualPathSchema | virtual path}.
- *
- * Measured in bytes for the same reason as
- * {@link VIRTUAL_PATH_SEGMENT_MAX_BYTES}: filesystems bound pathnames in bytes,
- * so a path of fewer than 1024 UTF-16 code units can still encode to more than
- * 1024 UTF-8 bytes and be unwritable on the host that runs it.
- *
- * This bounds the *portable relative* path, and nothing more. The length that
- * finally reaches the filesystem also carries the materialization root the
- * runner prepends, which is a property of that host and unknowable at the
- * contract boundary. So this ceiling does not stand in for the resolved length,
- * and does not promise it: a path near the ceiling still fails under a long
- * enough root, and one at the ceiling fails under every root, because no root is
- * empty. The provider that owns the root is what admits or refuses the resolved
- * pathname, and it reports that refusal as an invalid program rather than as a
- * filesystem error. What this figure is for is judging the program itself,
- * wherever it is submitted and whichever host would run it.
- */
-declare const VIRTUAL_PATH_MAX_BYTES = 1024;
-/**
- * Maximum length of the identity strings a request carries, in UTF-16 code units.
- *
- * These are the free-text fields that name something rather than carry payload:
- * the invocation's correlation id, the invoked export, and each selection pin in
- * {@link CodeExecutionRequirementsSchema}. None of them is measured by any other
- * budget — a provider bounds the program's sources and the invocation's
- * arguments, and nothing bounds these — while every one of them is retained for
- * as long as the request is, and the export name is copied again into whatever a
- * provider hands its execution host. A schema-valid request carrying a
- * multi-megabyte export name would therefore cost a queued invocation that much
- * memory apiece, so the ceiling belongs at the contract boundary where the field
- * is defined rather than at each provider that happens to retain it.
- *
- * 256 is generous for every one of them: a named export is an ECMAScript
- * identifier, and the runtime, language, module-format, and provider pins are
- * short tags a host chose. The figure is a ceiling on abuse, not a style rule.
- */
-declare const CODE_EXECUTION_IDENTIFIER_MAX_LENGTH$1 = 256;
-/**
- * Zod schema for a canonical virtual program path.
- *
- * Virtual paths are portable, host-independent input: the same program must be
- * valid or invalid everywhere, never valid on the host that submitted it and
- * unwritable on the host that runs it. So the rules are the intersection of what
- * every supported filesystem can represent, not what the current one accepts:
- *
- * - non-empty, and free of NUL bytes
- * - well-formed Unicode, so no unpaired surrogate code points
- * - POSIX separators only, so no backslashes
- * - relative, so no leading `/` and no drive-letter prefix
- * - normalized, so no empty, `.`, or `..` segments
- * - no segment containing `< > : " | ? *` or a control character
- * - no segment ending in a `.` or a space, which Windows trims away
- * - no segment naming a Windows device (`CON`, `PRN`, `AUX`, `NUL`,
- *   `COM0`-`COM9`, `LPT0`-`LPT9`, and the superscript spellings `COM¹`-`COM³`
- *   and `LPT¹`-`LPT³`, which name the same devices), with or without an
- *   extension
- * - no segment exceeding {@link VIRTUAL_PATH_SEGMENT_MAX_BYTES} UTF-8 bytes —
- *   the name-component limit on every supported filesystem
- * - total path at most {@link VIRTUAL_PATH_MAX_BYTES} UTF-8 bytes — a
- *   conservative ceiling on the *relative* path, which is the only part of the
- *   pathname a portable program can be judged on
- *
- * These rules exist because a host would otherwise reject or silently rewrite
- * the file: Windows refuses or trims certain names, and every filesystem
- * enforces per-component and total absolute-path length limits that vary by
- * platform. A contract-valid program must never degrade into a provider-side
- * write failure on one host while succeeding on another.
- *
- * The well-formedness rule guards the one shape that fails without a write
- * failure at all. An unpaired surrogate has no UTF-8 encoding, so every encoder
- * between a program and the disk substitutes U+FFFD for it: `"\uD800.ts"` and
- * `"\uD801.ts"` are two distinct strings that reach the filesystem as one and
- * the same name, on every platform. A module set carrying both would be accepted
- * as two files and materialize as one, with whichever write landed last silently
- * winning — so the paths are rejected here, where they are still distinguishable,
- * rather than downstream where they no longer are.
- *
- * The total-path rule is the one bound that cannot be completed here. The
- * pathname a host actually writes is its materialization root plus this
- * relative path, and the root belongs to the runner. So the contract bounds
- * what it owns, and the provider bounds the resolved pathname against its own
- * root before creating anything — the two together are what keep an accepted
- * program from degrading into a raw filesystem error.
- *
- * These rules keep module materialization well-defined; they do not create
- * runtime filesystem isolation.
- */
-declare const CodeExecutionVirtualPathSchema$1: z.ZodString;
-/**
- * Zod schema for the prepared, JSON-safe TypeScript/ESM module set.
- *
- * Every `files` key and the `entryFile` are validated as canonical virtual
- * paths, and the cross-field check requires `entryFile` to name one of
- * `files` — a program whose entry module is absent is invalid at the
- * contract boundary, not at the provider.
- */
-declare const CodeExecutionProgramSchema$1: z.ZodObject<{
-  files: z.ZodType<Record<string, string>, Record<string, string>, z.core.$ZodTypeInternals<Record<string, string>, Record<string, string>>>;
-  entryFile: z.ZodString;
-  exportName: z.ZodString;
-}, z.core.$strict>;
-/**
- * Zod schema for optional exact-match provider selection constraints.
- *
- * Omitted fields impose no constraint. Requirements never grant trust and
- * never enable a provider the host did not compose.
- *
- * Every pin is a tag a host chose for itself, so each is bounded by
- * {@link CODE_EXECUTION_IDENTIFIER_MAX_LENGTH} — a pin longer than any value it
- * could ever match is not a narrower constraint, only a larger retained request.
- */
-declare const CodeExecutionRequirementsSchema: z.ZodObject<{
-  providerId: z.ZodOptional<z.ZodString>;
-  runtime: z.ZodOptional<z.ZodString>;
-  language: z.ZodOptional<z.ZodString>;
-  moduleFormat: z.ZodOptional<z.ZodString>;
-  trust: z.ZodOptional<z.ZodEnum<{
-    "trusted-code-only": "trusted-code-only";
-    isolated: "isolated";
-  }>>;
-}, z.core.$strict>;
-/**
- * Zod schema for one prepared, JSON-safe invocation.
- *
- * Like every schema that backs a bus subject payload, this one infers its own
- * type instead of being annotated `z.ZodType<CodeExecutionRequest>`: subject
- * payloads must be index-signature-compatible object types, which a named
- * interface is not. The `satisfies` clause keeps the published
- * {@link CodeExecutionRequest} interface authoritative over the schema output.
- *
- * The subject's caller-facing payload type is this schema's input. Fidelity
- * checks inspect the raw runtime value without widening JSON-bearing fields to
- * `unknown`.
- */
-declare const CodeExecutionRequestSchema$1: z.ZodObject<{
-  invocationId: z.ZodString;
-  program: z.ZodObject<{
-    files: z.ZodType<Record<string, string>, Record<string, string>, z.core.$ZodTypeInternals<Record<string, string>, Record<string, string>>>;
-    entryFile: z.ZodString;
-    exportName: z.ZodString;
-  }, z.core.$strict>;
-  arguments: z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-  requirements: z.ZodOptional<z.ZodObject<{
-    providerId: z.ZodOptional<z.ZodString>;
-    runtime: z.ZodOptional<z.ZodString>;
-    language: z.ZodOptional<z.ZodString>;
-    moduleFormat: z.ZodOptional<z.ZodString>;
-    trust: z.ZodOptional<z.ZodEnum<{
-      "trusted-code-only": "trusted-code-only";
-      isolated: "isolated";
-    }>>;
-  }, z.core.$strict>>;
-  timeoutMs: z.ZodNumber;
-}, z.core.$strict>;
-/**
- * Zod schema for the stable failure classification codes.
- */
-declare const CodeExecutionFailureCodeSchema: z.ZodEnum<{
-  cancelled: "cancelled";
-  provider_unavailable: "provider_unavailable";
-  invalid_provider: "invalid_provider";
-  invalid_program: "invalid_program";
-  unsupported_import: "unsupported_import";
-  compilation_failed: "compilation_failed";
-  entrypoint_not_found: "entrypoint_not_found";
-  handler_failed: "handler_failed";
-  invalid_result: "invalid_result";
-  provider_failed: "provider_failed";
-  execution_timeout: "execution_timeout";
-}>;
-/**
- * Zod schema for the failure codes valid on a `failed` outcome.
- *
- * Excludes `execution_timeout` and `cancelled`, which are pinned to the
- * `timed_out` and `cancelled` outcome variants respectively.
- */
-declare const CodeExecutionFailedOutcomeCodeSchema: z.ZodEnum<{
-  provider_unavailable: "provider_unavailable";
-  invalid_provider: "invalid_provider";
-  invalid_program: "invalid_program";
-  unsupported_import: "unsupported_import";
-  compilation_failed: "compilation_failed";
-  entrypoint_not_found: "entrypoint_not_found";
-  handler_failed: "handler_failed";
-  invalid_result: "invalid_result";
-  provider_failed: "provider_failed";
-}>;
-/**
- * Zod schema for the discriminated, JSON-safe union of terminal outcomes.
- *
- * `completed` carries the JSON-safe value returned by the invoked export;
- * every other status carries a bounded failure instead of a thrown error.
- * Each variant constrains its failure code: `timed_out` is always
- * `execution_timeout`, `cancelled` is always `cancelled`, and `failed`
- * admits only the codes without a dedicated variant.
- *
- * Inferred rather than annotated, for the same reason as
- * {@link CodeExecutionRequestSchema}: this schema is the response half of a
- * bus subject payload.
- */
-declare const CodeExecutionOutcomeSchema$1: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  status: z.ZodLiteral<"completed">;
-  value: z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-}, z.core.$strict>, z.ZodObject<{
-  status: z.ZodLiteral<"failed">;
-  error: z.ZodObject<{
-    code: z.ZodType<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown, z.core.$ZodTypeInternals<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown>>;
-    message: z.ZodString;
-  }, z.core.$strict>;
-}, z.core.$strict>, z.ZodObject<{
-  status: z.ZodLiteral<"timed_out">;
-  error: z.ZodObject<{
-    code: z.ZodType<"execution_timeout", unknown, z.core.$ZodTypeInternals<"execution_timeout", unknown>>;
-    message: z.ZodString;
-  }, z.core.$strict>;
-}, z.core.$strict>, z.ZodObject<{
-  status: z.ZodLiteral<"cancelled">;
-  error: z.ZodObject<{
-    code: z.ZodType<"cancelled", unknown, z.core.$ZodTypeInternals<"cancelled", unknown>>;
-    message: z.ZodString;
-  }, z.core.$strict>;
-}, z.core.$strict>], "status">;
-/**
- * CodeExecution domain schemas.
- *
- * Each key becomes a subject identifier as: `code-execution.{key}`.
- */
-declare const CodeExecutionSchemas: {
-  /**
-   * Execute one prepared program invocation.
-   *
-   * Subject: `code-execution.execute`
-   * Type: Request (RPC)
-   * Purpose: Routes one prepared, JSON-safe invocation to one locally
-   * registered provider and returns one normalized terminal outcome.
-   *
-   * Providers themselves are registered locally through the capability
-   * registry (`CapabilitySubjects.register`) as live runtime objects; a
-   * provider object is never part of this subject's payload.
-   */
-  execute: {
-    request: z.ZodObject<{
-      invocationId: z.ZodString;
-      program: z.ZodObject<{
-        files: z.ZodType<Record<string, string>, Record<string, string>, z.core.$ZodTypeInternals<Record<string, string>, Record<string, string>>>;
-        entryFile: z.ZodString;
-        exportName: z.ZodString;
-      }, z.core.$strict>;
-      arguments: z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-      requirements: z.ZodOptional<z.ZodObject<{
-        providerId: z.ZodOptional<z.ZodString>;
-        runtime: z.ZodOptional<z.ZodString>;
-        language: z.ZodOptional<z.ZodString>;
-        moduleFormat: z.ZodOptional<z.ZodString>;
-        trust: z.ZodOptional<z.ZodEnum<{
-          "trusted-code-only": "trusted-code-only";
-          isolated: "isolated";
-        }>>;
-      }, z.core.$strict>>;
-      timeoutMs: z.ZodNumber;
-    }, z.core.$strict>;
-    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
-      status: z.ZodLiteral<"completed">;
-      value: z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-    }, z.core.$strict>, z.ZodObject<{
-      status: z.ZodLiteral<"failed">;
-      error: z.ZodObject<{
-        code: z.ZodType<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown, z.core.$ZodTypeInternals<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown>>;
-        message: z.ZodString;
-      }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-      status: z.ZodLiteral<"timed_out">;
-      error: z.ZodObject<{
-        code: z.ZodType<"execution_timeout", unknown, z.core.$ZodTypeInternals<"execution_timeout", unknown>>;
-        message: z.ZodString;
-      }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-      status: z.ZodLiteral<"cancelled">;
-      error: z.ZodObject<{
-        code: z.ZodType<"cancelled", unknown, z.core.$ZodTypeInternals<"cancelled", unknown>>;
-        message: z.ZodString;
-      }, z.core.$strict>;
-    }, z.core.$strict>], "status">;
-  };
-};
-//#endregion
-//#region core/contracts/src/code-execution/namespace.d.ts
-/**
- * CodeExecution bus namespace.
- *
- * Registers the `code-execution` namespace with the framework's execution
- * routing subject. Part of `FrameworkContractNamespaces`, so hosts can
- * validate and route the subject even when they compose no handler.
- * Use {@link CodeExecutionSubjects} to access typed bus subject descriptors.
- */
-declare const CodeExecutionNamespace: _$_makaio_core0.BusNamespaceDefinition<"code-execution", {
-  execute: {
-    request: _$zod.ZodObject<{
-      invocationId: _$zod.ZodString;
-      program: _$zod.ZodObject<{
-        files: _$zod.ZodType<Record<string, string>, Record<string, string>, _$zod_v4_core0.$ZodTypeInternals<Record<string, string>, Record<string, string>>>;
-        entryFile: _$zod.ZodString;
-        exportName: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-      arguments: _$zod.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, _$zod_v4_core0.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-      requirements: _$zod.ZodOptional<_$zod.ZodObject<{
-        providerId: _$zod.ZodOptional<_$zod.ZodString>;
-        runtime: _$zod.ZodOptional<_$zod.ZodString>;
-        language: _$zod.ZodOptional<_$zod.ZodString>;
-        moduleFormat: _$zod.ZodOptional<_$zod.ZodString>;
-        trust: _$zod.ZodOptional<_$zod.ZodEnum<{
-          "trusted-code-only": "trusted-code-only";
-          isolated: "isolated";
-        }>>;
-      }, _$zod_v4_core0.$strict>>;
-      timeoutMs: _$zod.ZodNumber;
-    }, _$zod_v4_core0.$strict>;
-    response: _$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"completed">;
-      value: _$zod.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, _$zod_v4_core0.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"failed">;
-      error: _$zod.ZodObject<{
-        code: _$zod.ZodType<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown, _$zod_v4_core0.$ZodTypeInternals<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown>>;
-        message: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"timed_out">;
-      error: _$zod.ZodObject<{
-        code: _$zod.ZodType<"execution_timeout", unknown, _$zod_v4_core0.$ZodTypeInternals<"execution_timeout", unknown>>;
-        message: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"cancelled">;
-      error: _$zod.ZodObject<{
-        code: _$zod.ZodType<"cancelled", unknown, _$zod_v4_core0.$ZodTypeInternals<"cancelled", unknown>>;
-        message: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-    }, _$zod_v4_core0.$strict>], "status">;
-  };
-}>;
-/**
- * Typed subjects for CodeExecution bus communication.
- *
- * Available subjects:
- * - `CodeExecutionSubjects.execute` — execute one prepared invocation (RPC)
- */
-declare const CodeExecutionSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"code-execution", {
-  execute: {
-    request: _$zod.ZodObject<{
-      invocationId: _$zod.ZodString;
-      program: _$zod.ZodObject<{
-        files: _$zod.ZodType<Record<string, string>, Record<string, string>, _$zod_v4_core0.$ZodTypeInternals<Record<string, string>, Record<string, string>>>;
-        entryFile: _$zod.ZodString;
-        exportName: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-      arguments: _$zod.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, _$zod_v4_core0.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-      requirements: _$zod.ZodOptional<_$zod.ZodObject<{
-        providerId: _$zod.ZodOptional<_$zod.ZodString>;
-        runtime: _$zod.ZodOptional<_$zod.ZodString>;
-        language: _$zod.ZodOptional<_$zod.ZodString>;
-        moduleFormat: _$zod.ZodOptional<_$zod.ZodString>;
-        trust: _$zod.ZodOptional<_$zod.ZodEnum<{
-          "trusted-code-only": "trusted-code-only";
-          isolated: "isolated";
-        }>>;
-      }, _$zod_v4_core0.$strict>>;
-      timeoutMs: _$zod.ZodNumber;
-    }, _$zod_v4_core0.$strict>;
-    response: _$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"completed">;
-      value: _$zod.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, _$zod_v4_core0.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>;
-    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"failed">;
-      error: _$zod.ZodObject<{
-        code: _$zod.ZodType<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown, _$zod_v4_core0.$ZodTypeInternals<"provider_unavailable" | "invalid_provider" | "invalid_program" | "unsupported_import" | "compilation_failed" | "entrypoint_not_found" | "handler_failed" | "invalid_result" | "provider_failed", unknown>>;
-        message: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"timed_out">;
-      error: _$zod.ZodObject<{
-        code: _$zod.ZodType<"execution_timeout", unknown, _$zod_v4_core0.$ZodTypeInternals<"execution_timeout", unknown>>;
-        message: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-    }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-      status: _$zod.ZodLiteral<"cancelled">;
-      error: _$zod.ZodObject<{
-        code: _$zod.ZodType<"cancelled", unknown, _$zod_v4_core0.$ZodTypeInternals<"cancelled", unknown>>;
-        message: _$zod.ZodString;
-      }, _$zod_v4_core0.$strict>;
-    }, _$zod_v4_core0.$strict>], "status">;
-  };
-}>, "code-execution">;
-//#endregion
-//#region core/contracts/src/code-execution/register.d.ts
-/**
- * Register a CodeExecution provider with the capability registry.
- *
- * Registration is local runtime composition: the provider is handed to the
- * registry as a live object reference, is never serialized, and — see
- * {@link LOCAL_COMPOSITION_ONLY} — never reaches a transport.
- * @param bus - Makaio bus instance.
- * @param provider - Provider instance to register.
- * @returns Promise that resolves after registration handlers have completed.
- */
-declare function registerCodeExecutionProvider(bus: MakaioBusLike, provider: ICodeExecutionProvider$1): Promise<void>;
-/**
- * Unregister a CodeExecution provider from the capability registry.
- *
- * Routed local-only for the same reason the registration is: the bucket this
- * removes from only ever held a locally composed provider, so a peer has
- * nothing to remove and the two emissions must not disagree about scope.
- * @param bus - Makaio bus instance.
- * @param providerId - Provider identifier to remove.
- * @returns Promise that resolves after unregistration handlers have completed.
- */
-declare function unregisterCodeExecutionProvider(bus: MakaioBusLike, providerId: string): Promise<void>;
-//#endregion
-export { CodeExecutionFailedOutcomeCode$1 as A, ICodeExecutionProvider$1 as B, CODE_EXECUTION_FAILURE_CODES as C, CodeExecutionCancelledOutcome as D, CodeExecutionAbortReason$1 as E, CodeExecutionProviderContext$1 as F, CodeExecutionRequest$1 as I, CodeExecutionRequirements$1 as L, CodeExecutionFailureCode as M, CodeExecutionOutcome$1 as N, CodeExecutionCompletedOutcome as O, CodeExecutionProgram as P, CodeExecutionTimedOutOutcome as R, CODE_EXECUTION_FAILED_OUTCOME_CODES$1 as S, CODE_EXECUTION_TRUST_LEVELS$1 as T, boundCodeExecutionFailureMessage$1 as _, CODE_EXECUTION_FAILURE_MESSAGE_MAX_LENGTH$1 as a, CODE_EXECUTION_ABORT_REASONS as b, CodeExecutionFailureCodeSchema as c, CodeExecutionRequestSchema$1 as d, CodeExecutionRequirementsSchema as f, VIRTUAL_PATH_SEGMENT_MAX_BYTES as g, VIRTUAL_PATH_MAX_BYTES as h, CodeExecutionSubjects$1 as i, CodeExecutionFailure as j, CodeExecutionFailedOutcome as k, CodeExecutionOutcomeSchema$1 as l, CodeExecutionVirtualPathSchema$1 as m, unregisterCodeExecutionProvider as n, CODE_EXECUTION_IDENTIFIER_MAX_LENGTH$1 as o, CodeExecutionSchemas as p, CodeExecutionNamespace as r, CodeExecutionFailedOutcomeCodeSchema as s, registerCodeExecutionProvider as t, CodeExecutionProgramSchema$1 as u, codeExecutionAbortOutcome$1 as v, CODE_EXECUTION_OUTCOME_STATUSES as w, CODE_EXECUTION_CAPABILITY_ID$1 as x, codeExecutionAbortOutcomeForReason$1 as y, CodeExecutionTrustLevel$1 as z };