@decaf-ts/integrations 0.10.8 → 0.11.0

package/lib/types/graph/engine/execution/GraphExecutionEngine.d.mts

@@ -1,278 +0,0 @@
-/**
- * @module integrations/graph/execution/GraphExecutionEngine
- * @summary Reference graph execution engine (DECAF-50 §4.9).
- * @description Executes canonical {@link GraphWorkflowDocument}s. The public
- * `execute(document, inputs, options)` entrypoint performs resolution
- * internally: the document runs through the nine-stage §4.8 validation gate
- * (structured issue accumulation), is resolved against the trusted backend
- * catalogue into a {@link GraphResolvedWorkflow}, planned by the
- * {@link GraphExecutionPlanner} (resolved workflows only — never raw
- * definitions), and executed layer by layer. Node inputs are built from
- * routed edges, literal bindings, allowed expressions, manifest defaults,
- * and node parameters; configuration and input data are separated in the
- * {@link GraphNodeExecutionRequest}. Executor outputs are validated against
- * the effective output manifest. Disabled nodes follow the explicit
- * {@link GraphDisabledNodeBehavior} semantics. Events are emitted through
- * Decaf's Observable pipeline, including the DECAF-48 §4.4 visual-state
- * events and the `graph.run.log` run-log channel.
- */
-import type { Observable } from "@decaf-ts/core";
-import type { GraphWorkflowDocument } from "@decaf-ts/ui-decorators/graph";
-import type { GraphExecutionEvent } from "@decaf-ts/ui-decorators/graph";
-import type { GraphExecutionOptions, GraphExecutionResult, GraphExecutionValues, GraphPinNodeOptions, GraphUnpinNodeOptions } from "../types.d.mts";
-import type { GraphExecutionObserver } from "../events/GraphExecutionObserver.d.mts";
-import { GraphExecutionEventEmitter } from "../events/GraphExecutionEventEmitter.d.mts";
-import type { GraphNodeExecutorRegistry } from "../registry/GraphNodeExecutorRegistry.d.mts";
-import type { GraphNodeCatalogue } from "../catalog/GraphNodeCatalogue.d.mts";
-import { GraphExecutionPlanner } from "../planning/GraphExecutionPlanner.d.mts";
-import { GraphWorkflowDocumentValidator, type GraphWorkflowDocumentValidationLimits } from "../validation/GraphWorkflowDocumentValidator.d.mts";
-import type { GraphCredentialAuthorizer } from "../validation/GraphCredentialReferenceValidator.d.mts";
-import type { GraphValueStoreAdapter } from "../store/GraphValueStoreAdapter.d.mts";
-import type { CodeSandboxEvaluator } from "./CodeSandboxEvaluator.d.mts";
-/**
- * Configuration for the {@link GraphExecutionEngine}.
- */
-export interface GraphExecutionEngineConfig {
-    registry: GraphNodeExecutorRegistry;
-    /**
-     * Trusted backend kind catalogue. Defaults to the registry facade's
-     * catalogue; required for the nine-stage document validation gate.
-     */
-    catalogue?: GraphNodeCatalogue;
-    /** Optional pre-configured document validator (overrides catalogue/limits). */
-    documentValidator?: GraphWorkflowDocumentValidator;
-    /** Backend-enforced document resource limits (§4.8 stage 1). */
-    documentLimits?: GraphWorkflowDocumentValidationLimits;
-    /** Pluggable credential existence/authorization hook (§4.8 stage 8). */
-    credentialAuthorizer?: GraphCredentialAuthorizer;
-    planner?: GraphExecutionPlanner;
-    valueStoreAdapter?: GraphValueStoreAdapter;
-    eventEmitter?: GraphExecutionEventEmitter;
-    defaultOptions?: Partial<GraphExecutionOptions>;
-    /**
-     * Optional pluggable code sandbox evaluator for code-based conditions and
-     * expression bindings (DECAF-32 §22.4). When absent, code conditions and
-     * expression bindings throw `GRAPH_CODE_SANDBOX_NOT_CONFIGURED`.
-     * Downstream projects (e.g. ALFRED) supply the actual VM sandbox
-     * implementation.
-     */
-    codeSandboxEvaluator?: CodeSandboxEvaluator;
-    /**
-     * Optional callback invoked at the end of engine construction with the
-     * fully-initialised engine instance. Use this to register executors that
-     * need a back-reference to the engine (e.g. loop executors that execute
-     * sub-workflows through the same engine).
-     */
-    onEngineCreated?: (engine: GraphExecutionEngine) => void;
-}
-/**
- * Reference graph execution engine.
- *
- * Executes a canonical {@link GraphWorkflowDocument} by:
- * 1. Validating it through the nine-stage gate and resolving it against the
- *    backend catalogue (§4.8).
- * 2. Planning the resolved workflow into topological layers (§4.9).
- * 3. Seeding workflow inputs into the value store.
- * 4. Executing nodes layer-by-layer with configurable concurrency, honouring
- *    disabled-node semantics.
- * 5. Building node inputs from routed edges, literal bindings, allowed
- *    expressions, and manifest defaults; keeping configuration (parameters,
- *    credentials) separate from input data.
- * 6. Validating executor outputs against the effective output manifest.
- * 7. Routing values along data edges.
- * 8. Emitting structured events through Decaf's Observable pipeline.
- * 9. Returning a complete {@link GraphExecutionResult}.
- */
-export declare class GraphExecutionEngine implements Observable<[GraphExecutionObserver], [GraphExecutionEvent]> {
-    private readonly emitter;
-    private readonly planner;
-    private readonly valueStoreAdapter;
-    private readonly defaultOptions;
-    private readonly documentValidator;
-    /** Pluggable code sandbox evaluator (§22.4); may be undefined. */
-    readonly codeSandboxEvaluator?: CodeSandboxEvaluator;
-    constructor(config: GraphExecutionEngineConfig);
-    private readonly config;
-    /**
-     * Registers an observer on the engine's event pipeline.
-     *
-     * @param observer - The observer to register.
-     * @returns An unsubscribe function that removes the observer.
-     */
-    observe(observer: GraphExecutionObserver): () => void;
-    /**
-     * Unregisters an observer from the engine's event pipeline.
-     *
-     * @param observer - The observer to remove.
-     */
-    unObserve(observer: GraphExecutionObserver): void;
-    /**
-     * Dispatches an event to all registered observers.
-     *
-     * @param event - The event to distribute.
-     */
-    updateObservers(event: GraphExecutionEvent): Promise<void>;
-    /**
-     * Executes a canonical workflow document with the given inputs and options.
-     *
-     * Resolution happens internally (DECAF-50 §4.9): the document is validated
-     * through the nine-stage gate and resolved against the backend catalogue
-     * before planning. Decorated `GraphWorkflowDefinition` objects are NOT
-     * accepted — compile them with the §4.18 transition compiler first.
-     *
-     * @param document - The canonical workflow document to execute.
-     * @param inputs - Workflow input values keyed by input port id.
-     * @param options - Optional execution overrides (merged over the defaults).
-     * @returns The complete execution result, including a `runId`, per-node
-     *   results, and workflow outputs (or the failure payload).
-     * @throws {GraphDocumentValidationError} when the document fails the
-     *   nine-stage validation gate (carries every structured issue).
-     */
-    execute(document: GraphWorkflowDocument, inputs?: GraphExecutionValues, options?: GraphExecutionOptions): Promise<GraphExecutionResult>;
-    /**
-     * Pins a node and its upstream dependencies after a completed run.
-     *
-     * Delegates to {@link GraphPinningService}. The plan and result must come
-     * from a prior successful execution of the same workflow.
-     */
-    pinNode(options: GraphPinNodeOptions): Promise<void>;
-    /**
-     * Unpins a node by its fingerprint.
-     */
-    unpinNode(options: GraphUnpinNodeOptions): Promise<void>;
-    /**
-     * Creates a {@link GraphPinningService} backed by this engine's value store
-     * adapter.
-     */
-    private createPinningService;
-    /**
-     * Emits a pinning-related event to all observers.
-     */
-    private emitPinningEvent;
-    /**
-     * Fills unprovided workflow inputs with their declared port defaults.
-     */
-    private withWorkflowInputDefaults;
-    /**
-     * Executes a layer of nodes with the configured concurrency.
-     */
-    private executeLayer;
-    /**
-     * Executes a single node, honouring disabled-node semantics (§4.9).
-     */
-    private executeNode;
-    /**
-     * Resolves whether a plan node is activated for execution under the
-     * DECAF-50 §4.9 branch semantics. A node with no incoming data edges is
-     * a root/source node and always runs. A node fed by one or more data
-     * edges runs only when at least one of those edges was activated by a
-     * routed upstream output port — a branch the upstream switch (or any
-     * partial-output node) did not select leaves its downstream edges
-     * unactivated, so the branch is never executed. Workflow-boundary edges
-     * are active from the start because workflow inputs are seeded before
-     * execution begins.
-     */
-    private isNodeActivated;
-    /**
-     * Skips a node whose incoming data edges were all left unactivated by an
-     * upstream branch selection. The node is not executed and its outputs are
-     * never routed or collected into workflow outputs (DECAF-50 §4.9).
-     */
-    private skipInactiveNode;
-    /**
-     * Applies the explicit disabled-node semantics (§4.9):
-     * `skip`, `passThroughFirstInput`, or `emitDefaults`, resolved from the
-     * instance metadata, document settings, and the default.
-     */
-    private executeDisabledNode;
-    /**
-     * Invokes the node's catalogue-resolved executor (§4.9 request contract,
-     * post-cutover: every executor receives the full request with
-     * configuration and input data separated).
-     */
-    private invokeExecutor;
-    /**
-     * Validates executor outputs against the effective output manifest
-     * (§4.9): unknown outputs are rejected by default; missing required
-     * outputs fail the node. Lenient transition manifests (legacy
-     * executor-only registrations) are exempt until cutover.
-     */
-    private validateNodeOutputs;
-    /**
-     * Collects the resolved credential references for a node: credential-type
-     * parameter values plus the `credentials` record in instance metadata.
-     * Documents carry references only — secret material never enters requests.
-     */
-    private collectCredentials;
-    /**
-     * Resolves a node's input values from routed data edges, literal bindings,
-     * allowed expression bindings, and manifest port defaults (§4.9).
-     *
-     * When multiple edges target the same port, their values are spread into the
-     * top-level inputs keyed by each edge's `sourcePort`. This allows multiple
-     * workflow input badges to connect to a single port (e.g. the Code node's
-     * `data` port) and have all values accessible directly as
-     * `$input.{sourcePort}` (e.g. `$input.count`, `$input.text`).
-     */
-    private resolveNodeInputs;
-    /**
-     * Evaluates an expression binding with the EXISTING allowed-expression
-     * machinery only (the pluggable {@link CodeSandboxEvaluator}, DECAF-32
-     * §22.4) — no new evaluator. The expression sees the already-routed input
-     * values as `$input` and the run metadata as context.
-     */
-    private evaluateExpressionBinding;
-    /**
-     * Attempts to read a pinned value for the node. Returns the cached outputs
-     * when a valid pinned value exists, or `undefined` to proceed with normal
-     * execution.
-     */
-    private tryPinnedValue;
-    /**
-     * Recursively computes fingerprints for all upstream dependencies of a node
-     * using the results already accumulated in the frame.
-     */
-    private computeDependencyFingerprints;
-    /**
-     * Routes a node's outputs to downstream inputs and workflow outputs along
-     * data edges (connection edges are structural and never route values).
-     *
-     * An edge is traversed only when the source node actually emitted the
-     * edge's `sourcePort` (DECAF-50 §4.9 branch semantics). A node that
-     * emitted a subset of its declared outputs — e.g. a switch that selected
-     * one case — therefore activates only the downstream branch edges of the
-     * emitted ports; unselected branch edges are left unactivated, so their
-     * downstream nodes are skipped and never contribute to workflow outputs.
-     * Emitting an output port explicitly with `undefined` still counts as
-     * activated (the port was produced by the executor).
-     */
-    private routeOutgoingEdges;
-    /**
-     * Emits an event, records it in the frame, and dispatches to observers.
-     */
-    private emitEvent;
-    /**
-     * Emits a `NODE_STATE_CHANGED` event (DECAF-48 §4.4) carrying the given
-     * visual state for the node. Rides the existing Observable pipeline; no
-     * second out-of-band channel.
-     */
-    private emitNodeStateChanged;
-    /**
-     * Emits an `EDGE_STATE_CHANGED` event (DECAF-48 §4.4) carrying the given
-     * visual state for a routed edge.
-     */
-    private emitEdgeStateChanged;
-    /**
-     * Merges default options with the given options.
-     */
-    private mergeOptions;
-    private assertNotAborted;
-    /**
-     * Generates a unique run id.
-     */
-    private generateRunId;
-    /**
-     * Converts an error into a serialized payload.
-     */
-    private toErrorPayload;
-}

package/lib/types/graph/engine/execution/GraphExecutionFrame.d.cts

@@ -1,42 +0,0 @@
-/**
- * @module integrations/graph/execution/GraphExecutionFrame
- * @summary Per-run state container for graph execution.
- * @description Holds the run id, execution plan, value store, accumulated node results, events, and timing for a single workflow execution.
- */
-import type { GraphExecutionPlan } from "../planning/GraphExecutionPlan.d.cts";
-import type { GraphValueStore } from "../store/GraphValueStore.d.cts";
-import type { GraphExecutionEventFactory } from "../events/GraphExecutionEventFactory.d.cts";
-import type { GraphExecutionEvent } from "@decaf-ts/ui-decorators/graph";
-import type { GraphNodeExecutionResult, GraphRunId } from "../types.d.cts";
-/**
- * Mutable state for a single graph execution run.
- */
-export declare class GraphExecutionFrame {
-    readonly runId: GraphRunId;
-    readonly plan: GraphExecutionPlan;
-    readonly valueStore: GraphValueStore;
-    readonly eventFactory: GraphExecutionEventFactory;
-    readonly startedAt: Date;
-    readonly nodeResults: Map<string, GraphNodeExecutionResult>;
-    readonly events: GraphExecutionEvent[];
-    /**
-     * Ids of the data edges activated by a routed upstream output port
-     * (DECAF-50 §4.9 branch semantics). A data edge is activated only when
-     * its source node actually emitted the edge's source port; downstream
-     * nodes with no activated incoming data edge are skipped rather than run
-     * with undefined inputs.
-     */
-    private readonly activeDataEdges;
-    finishedAt?: Date;
-    constructor(runId: GraphRunId, plan: GraphExecutionPlan, valueStore: GraphValueStore, eventFactory: GraphExecutionEventFactory);
-    /** Records a node execution result. */
-    recordNodeResult(result: GraphNodeExecutionResult): void;
-    /** Marks a data edge as activated by its routed source output port. */
-    activateDataEdge(edgeId: string): void;
-    /** Returns whether a data edge has been activated during this run. */
-    isDataEdgeActive(edgeId: string): boolean;
-    /** Appends an event to the run's event log. */
-    appendEvent(event: GraphExecutionEvent): void;
-    /** Marks the run as finished. */
-    finish(): void;
-}

package/lib/types/graph/engine/execution/GraphExecutionFrame.d.mts

@@ -1,42 +0,0 @@
-/**
- * @module integrations/graph/execution/GraphExecutionFrame
- * @summary Per-run state container for graph execution.
- * @description Holds the run id, execution plan, value store, accumulated node results, events, and timing for a single workflow execution.
- */
-import type { GraphExecutionPlan } from "../planning/GraphExecutionPlan.d.mts";
-import type { GraphValueStore } from "../store/GraphValueStore.d.mts";
-import type { GraphExecutionEventFactory } from "../events/GraphExecutionEventFactory.d.mts";
-import type { GraphExecutionEvent } from "@decaf-ts/ui-decorators/graph";
-import type { GraphNodeExecutionResult, GraphRunId } from "../types.d.mts";
-/**
- * Mutable state for a single graph execution run.
- */
-export declare class GraphExecutionFrame {
-    readonly runId: GraphRunId;
-    readonly plan: GraphExecutionPlan;
-    readonly valueStore: GraphValueStore;
-    readonly eventFactory: GraphExecutionEventFactory;
-    readonly startedAt: Date;
-    readonly nodeResults: Map<string, GraphNodeExecutionResult>;
-    readonly events: GraphExecutionEvent[];
-    /**
-     * Ids of the data edges activated by a routed upstream output port
-     * (DECAF-50 §4.9 branch semantics). A data edge is activated only when
-     * its source node actually emitted the edge's source port; downstream
-     * nodes with no activated incoming data edge are skipped rather than run
-     * with undefined inputs.
-     */
-    private readonly activeDataEdges;
-    finishedAt?: Date;
-    constructor(runId: GraphRunId, plan: GraphExecutionPlan, valueStore: GraphValueStore, eventFactory: GraphExecutionEventFactory);
-    /** Records a node execution result. */
-    recordNodeResult(result: GraphNodeExecutionResult): void;
-    /** Marks a data edge as activated by its routed source output port. */
-    activateDataEdge(edgeId: string): void;
-    /** Returns whether a data edge has been activated during this run. */
-    isDataEdgeActive(edgeId: string): boolean;
-    /** Appends an event to the run's event log. */
-    appendEvent(event: GraphExecutionEvent): void;
-    /** Marks the run as finished. */
-    finish(): void;
-}

package/lib/types/graph/engine/execution/GraphExecutionResult.d.cts

@@ -1,13 +0,0 @@
-/**
- * @module integrations/graph/execution/GraphExecutionResult
- * @summary Helper for building GraphExecutionResult objects.
- * @description Provides a builder function that assembles a result from a frame.
- */
-import type { GraphWorkflowDocument } from "@decaf-ts/ui-decorators/graph";
-import type { GraphExecutionFrame } from "./GraphExecutionFrame.d.cts";
-import type { GraphExecutionResult, GraphExecutionValues } from "../types.d.cts";
-import type { GraphExecutionStatus } from "@decaf-ts/ui-decorators/graph";
-/**
- * Builds a {@link GraphExecutionResult} from a completed frame.
- */
-export declare function buildGraphExecutionResult(frame: GraphExecutionFrame, document: GraphWorkflowDocument, inputs: GraphExecutionValues, status: GraphExecutionStatus, metadata?: Record<string, unknown>): GraphExecutionResult;

package/lib/types/graph/engine/execution/GraphExecutionResult.d.mts

@@ -1,13 +0,0 @@
-/**
- * @module integrations/graph/execution/GraphExecutionResult
- * @summary Helper for building GraphExecutionResult objects.
- * @description Provides a builder function that assembles a result from a frame.
- */
-import type { GraphWorkflowDocument } from "@decaf-ts/ui-decorators/graph";
-import type { GraphExecutionFrame } from "./GraphExecutionFrame.d.mts";
-import type { GraphExecutionResult, GraphExecutionValues } from "../types.d.mts";
-import type { GraphExecutionStatus } from "@decaf-ts/ui-decorators/graph";
-/**
- * Builds a {@link GraphExecutionResult} from a completed frame.
- */
-export declare function buildGraphExecutionResult(frame: GraphExecutionFrame, document: GraphWorkflowDocument, inputs: GraphExecutionValues, status: GraphExecutionStatus, metadata?: Record<string, unknown>): GraphExecutionResult;

package/lib/types/graph/engine/execution/GraphNodeExecutor.d.cts

@@ -1,31 +0,0 @@
-/**
- * @module integrations/graph/execution/GraphNodeExecutor
- * @summary Node executor contract (DECAF-50 §4.9, post-cutover).
- * @description The single executor contract: executors receive a
- * {@link GraphNodeExecutionRequest} that separates configuration
- * (`parameters`, `credentials`, `metadata`) from input data (`inputs`).
- * The §4.18 transition artifacts (legacy input-only contract, the
- * compatibility adapter, and the request-executor marker) were removed at
- * the P7 cutover.
- */
-import type { GraphExecutionContext } from "./GraphExecutionContext.d.cts";
-import type { GraphExecutionValues, GraphNodeExecutionRequest } from "../types.d.cts";
-/**
- * Executor for a specific graph node kind (DECAF-50 §4.9 request contract).
- *
- * Implementations are registered in the {@link GraphNodeExecutorRegistry}
- * (a facade over the backend catalogue) and always receive the full
- * {@link GraphNodeExecutionRequest}; configuration and input data are
- * separated.
- */
-export interface GraphNodeExecutor<Output extends GraphExecutionValues = GraphExecutionValues> {
-    /**
-     * Executes the node logic with configuration and input data separated.
-     *
-     * @param request - The node execution request (inputs, parameters,
-     * credentials, metadata).
-     * @param context - Decaf context for emitting progress and events.
-     * @returns The node's output values keyed by port name.
-     */
-    execute(request: GraphNodeExecutionRequest, context: GraphExecutionContext): Promise<Output> | Output;
-}

package/lib/types/graph/engine/execution/GraphNodeExecutor.d.mts

@@ -1,31 +0,0 @@
-/**
- * @module integrations/graph/execution/GraphNodeExecutor
- * @summary Node executor contract (DECAF-50 §4.9, post-cutover).
- * @description The single executor contract: executors receive a
- * {@link GraphNodeExecutionRequest} that separates configuration
- * (`parameters`, `credentials`, `metadata`) from input data (`inputs`).
- * The §4.18 transition artifacts (legacy input-only contract, the
- * compatibility adapter, and the request-executor marker) were removed at
- * the P7 cutover.
- */
-import type { GraphExecutionContext } from "./GraphExecutionContext.d.mts";
-import type { GraphExecutionValues, GraphNodeExecutionRequest } from "../types.d.mts";
-/**
- * Executor for a specific graph node kind (DECAF-50 §4.9 request contract).
- *
- * Implementations are registered in the {@link GraphNodeExecutorRegistry}
- * (a facade over the backend catalogue) and always receive the full
- * {@link GraphNodeExecutionRequest}; configuration and input data are
- * separated.
- */
-export interface GraphNodeExecutor<Output extends GraphExecutionValues = GraphExecutionValues> {
-    /**
-     * Executes the node logic with configuration and input data separated.
-     *
-     * @param request - The node execution request (inputs, parameters,
-     * credentials, metadata).
-     * @param context - Decaf context for emitting progress and events.
-     * @returns The node's output values keyed by port name.
-     */
-    execute(request: GraphNodeExecutionRequest, context: GraphExecutionContext): Promise<Output> | Output;
-}

package/lib/types/graph/engine/execution/IsolatedVmCodeSandboxEvaluator.d.cts

@@ -1,63 +0,0 @@
-import type { CodeSandboxEvaluator, CodeSandboxContext } from "./CodeSandboxEvaluator.d.cts";
-/**
- * `isolated-vm`-backed {@link CodeSandboxEvaluator} (ALFRED-5 §7.18).
- *
- * This evaluator provides a truly isolated V8 sandbox — the code runs in a
- * separate isolate with its own heap, separate from the host process. The
- * sandbox context exposes only the data variables (`$input`, `$vars`, `$item`,
- * `$index`, `$node`, `$output`); no host globals are available.
- *
- * Execution pipeline:
- * 1. **Transpile** — TypeScript code is transpiled to JavaScript via
- *    `typescript.transpileModule` (ALFRED-5 §7.4).
- * 2. **Validate** — the JavaScript code is parsed with `acorn` and walked with
- *    `acorn-walk` to reject imports, exports, blocked identifiers, `eval()`,
- *    and `new Function()` (ALFRED-5 §7.11).
- * 3. **Isolate** — a new `isolated-vm` `Isolate` is created with a memory
- *    limit. A context is created and the data variables are copied into the
- *    isolate's heap via `ExternalCopy`.
- * 4. **Compile & run** — the wrapped code is compiled and executed with a
- *    timeout. The result is copied back to the host heap.
- * 5. **Dispose** — the isolate is always disposed in a `finally` block.
- *
- * The user code is wrapped in a strict-mode async function:
- *
- * ```js
- * "use strict";
- * async function __userFunction($input, $vars, $item, $index, $node, $output) {
- *   <user code>
- * }
- * __userFunction($input, $vars, $item, $index, $node, $output);
- * ```
- *
- * When the code has no `return` statement it is treated as a single expression
- * and wrapped in `return (...)`.
- */
-export declare class IsolatedVmCodeSandboxEvaluator implements CodeSandboxEvaluator {
-    private readonly defaultTimeoutMs;
-    private readonly defaultMemoryMb;
-    /**
-     * @param defaultTimeoutMs - Default execution timeout in milliseconds.
-     * @param defaultMemoryMb - Default isolate memory limit in MB.
-     */
-    constructor(defaultTimeoutMs?: number, defaultMemoryMb?: number);
-    evaluate(ctx: CodeSandboxContext): Promise<unknown>;
-    /**
-     * Injects a `console` object into the isolate whose methods forward to the
-     * Context logger (bound to `runId`).
-     *
-     * Every standard `console.*` method is supported:
-     * `log`, `info`, `warn`, `error`, `debug`, `trace`, `dir`, `dirxml`,
-     * `table`, `group`, `groupCollapsed`, `groupEnd`, `time`, `timeEnd`,
-     * `timeLog`, `assert`, `count`, `countReset`, `clear`.
-     *
-     * Arguments are serialised inside the isolate (via `JSON.stringify` with a
-     * safe fallback) before being passed across the isolate boundary, because
-     * `isolated-vm` cannot copy arbitrary host objects.
-     *
-     * @param jail - The isolate's global object.
-     * @param logger - The Context logger that receives the forwarded calls.
-     * @param context - The isolate context (for running the init script).
-     */
-    private injectConsole;
-}

package/lib/types/graph/engine/execution/IsolatedVmCodeSandboxEvaluator.d.mts

@@ -1,63 +0,0 @@
-import type { CodeSandboxEvaluator, CodeSandboxContext } from "./CodeSandboxEvaluator.d.mts";
-/**
- * `isolated-vm`-backed {@link CodeSandboxEvaluator} (ALFRED-5 §7.18).
- *
- * This evaluator provides a truly isolated V8 sandbox — the code runs in a
- * separate isolate with its own heap, separate from the host process. The
- * sandbox context exposes only the data variables (`$input`, `$vars`, `$item`,
- * `$index`, `$node`, `$output`); no host globals are available.
- *
- * Execution pipeline:
- * 1. **Transpile** — TypeScript code is transpiled to JavaScript via
- *    `typescript.transpileModule` (ALFRED-5 §7.4).
- * 2. **Validate** — the JavaScript code is parsed with `acorn` and walked with
- *    `acorn-walk` to reject imports, exports, blocked identifiers, `eval()`,
- *    and `new Function()` (ALFRED-5 §7.11).
- * 3. **Isolate** — a new `isolated-vm` `Isolate` is created with a memory
- *    limit. A context is created and the data variables are copied into the
- *    isolate's heap via `ExternalCopy`.
- * 4. **Compile & run** — the wrapped code is compiled and executed with a
- *    timeout. The result is copied back to the host heap.
- * 5. **Dispose** — the isolate is always disposed in a `finally` block.
- *
- * The user code is wrapped in a strict-mode async function:
- *
- * ```js
- * "use strict";
- * async function __userFunction($input, $vars, $item, $index, $node, $output) {
- *   <user code>
- * }
- * __userFunction($input, $vars, $item, $index, $node, $output);
- * ```
- *
- * When the code has no `return` statement it is treated as a single expression
- * and wrapped in `return (...)`.
- */
-export declare class IsolatedVmCodeSandboxEvaluator implements CodeSandboxEvaluator {
-    private readonly defaultTimeoutMs;
-    private readonly defaultMemoryMb;
-    /**
-     * @param defaultTimeoutMs - Default execution timeout in milliseconds.
-     * @param defaultMemoryMb - Default isolate memory limit in MB.
-     */
-    constructor(defaultTimeoutMs?: number, defaultMemoryMb?: number);
-    evaluate(ctx: CodeSandboxContext): Promise<unknown>;
-    /**
-     * Injects a `console` object into the isolate whose methods forward to the
-     * Context logger (bound to `runId`).
-     *
-     * Every standard `console.*` method is supported:
-     * `log`, `info`, `warn`, `error`, `debug`, `trace`, `dir`, `dirxml`,
-     * `table`, `group`, `groupCollapsed`, `groupEnd`, `time`, `timeEnd`,
-     * `timeLog`, `assert`, `count`, `countReset`, `clear`.
-     *
-     * Arguments are serialised inside the isolate (via `JSON.stringify` with a
-     * safe fallback) before being passed across the isolate boundary, because
-     * `isolated-vm` cannot copy arbitrary host objects.
-     *
-     * @param jail - The isolate's global object.
-     * @param logger - The Context logger that receives the forwarded calls.
-     * @param context - The isolate context (for running the init script).
-     */
-    private injectConsole;
-}

package/lib/types/graph/engine/execution/index.d.cts

@@ -1,12 +0,0 @@
-/**
- * @module integrations/graph/execution
- * @summary Graph execution context and executor interface.
- * @description Re-exports the graph execution context and node executor interface.
- */
-export * from "./GraphExecutionContext.d.cts";
-export * from "./GraphNodeExecutor.d.cts";
-export * from "./GraphExecutionResult.d.cts";
-export * from "./GraphExecutionFrame.d.cts";
-export * from "./GraphExecutionEngine.d.cts";
-export * from "./CodeSandboxEvaluator.d.cts";
-export * from "./IsolatedVmCodeSandboxEvaluator.d.cts";

package/lib/types/graph/engine/execution/index.d.mts

@@ -1,12 +0,0 @@
-/**
- * @module integrations/graph/execution
- * @summary Graph execution context and executor interface.
- * @description Re-exports the graph execution context and node executor interface.
- */
-export * from "./GraphExecutionContext.d.mts";
-export * from "./GraphNodeExecutor.d.mts";
-export * from "./GraphExecutionResult.d.mts";
-export * from "./GraphExecutionFrame.d.mts";
-export * from "./GraphExecutionEngine.d.mts";
-export * from "./CodeSandboxEvaluator.d.mts";
-export * from "./IsolatedVmCodeSandboxEvaluator.d.mts";