@decaf-ts/integrations 0.3.1 → 0.3.2

package/lib/types/graph/errors/GraphInputError.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphInputError
+ * @summary Error thrown when workflow or node inputs are invalid.
+ * @description Raised by the value validator when required inputs are missing or fail schema validation.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.mts";
+/**
+ * Thrown when workflow or node inputs are invalid.
+ */
+export declare class GraphInputError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphLoopLimitError.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphLoopLimitError
+ * @summary Error thrown when a loop exceeds its maximum iterations.
+ * @description Raised by loop executors when the iteration count reaches the configured safety limit.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.cts";
+/**
+ * Thrown when a loop exceeds its maximum iterations.
+ */
+export declare class GraphLoopLimitError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphLoopLimitError.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphLoopLimitError
+ * @summary Error thrown when a loop exceeds its maximum iterations.
+ * @description Raised by loop executors when the iteration count reaches the configured safety limit.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.mts";
+/**
+ * Thrown when a loop exceeds its maximum iterations.
+ */
+export declare class GraphLoopLimitError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphPinningError.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphPinningError
+ * @summary Error thrown when a pinning operation fails.
+ * @description Raised when a node cannot be pinned, e.g. because an upstream dependency is not pinnable.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.cts";
+/**
+ * Thrown when a pinning operation fails.
+ */
+export declare class GraphPinningError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphPinningError.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphPinningError
+ * @summary Error thrown when a pinning operation fails.
+ * @description Raised when a node cannot be pinned, e.g. because an upstream dependency is not pinnable.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.mts";
+/**
+ * Thrown when a pinning operation fails.
+ */
+export declare class GraphPinningError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphPortError.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphPortError
+ * @summary Error thrown when a port reference is invalid.
+ * @description Raised by the relation resolver or validator when a referenced port is missing or unknown.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.cts";
+/**
+ * Thrown when a port reference is invalid.
+ */
+export declare class GraphPortError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphPortError.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphPortError
+ * @summary Error thrown when a port reference is invalid.
+ * @description Raised by the relation resolver or validator when a referenced port is missing or unknown.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.mts";
+/**
+ * Thrown when a port reference is invalid.
+ */
+export declare class GraphPortError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphStoreError.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphStoreError
+ * @summary Error thrown when a value store operation fails.
+ * @description Raised by the value store or adapter when reading, writing, or deleting cached values fails.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.cts";
+/**
+ * Thrown when a value store operation fails.
+ */
+export declare class GraphStoreError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphStoreError.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphStoreError
+ * @summary Error thrown when a value store operation fails.
+ * @description Raised by the value store or adapter when reading, writing, or deleting cached values fails.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.mts";
+/**
+ * Thrown when a value store operation fails.
+ */
+export declare class GraphStoreError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphTopologyError.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphTopologyError
+ * @summary Error thrown when workflow topology is invalid.
+ * @description Raised by the relation resolver or planner when an endpoint is unknown or ambiguous.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.cts";
+/**
+ * Thrown when workflow topology is invalid.
+ */
+export declare class GraphTopologyError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/GraphTopologyError.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @module integrations/graph/errors/GraphTopologyError
+ * @summary Error thrown when workflow topology is invalid.
+ * @description Raised by the relation resolver or planner when an endpoint is unknown or ambiguous.
+ */
+import { GraphExecutionError } from "./GraphExecutionError.d.mts";
+/**
+ * Thrown when workflow topology is invalid.
+ */
+export declare class GraphTopologyError extends GraphExecutionError {
+    constructor(message: string, details?: unknown);
+}

package/lib/types/graph/errors/index.d.cts

@@ -0,0 +1,13 @@
+/**
+ * @module integrations/graph/errors
+ * @summary Graph execution error classes.
+ * @description Re-exports all structured error types used by the graph execution engine.
+ */
+export * from "./GraphExecutionError.d.cts";
+export * from "./GraphCycleError.d.cts";
+export * from "./GraphInputError.d.cts";
+export * from "./GraphLoopLimitError.d.cts";
+export * from "./GraphPinningError.d.cts";
+export * from "./GraphPortError.d.cts";
+export * from "./GraphStoreError.d.cts";
+export * from "./GraphTopologyError.d.cts";

package/lib/types/graph/errors/index.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @module integrations/graph/errors
+ * @summary Graph execution error classes.
+ * @description Re-exports all structured error types used by the graph execution engine.
+ */
+export * from "./GraphExecutionError.d.mts";
+export * from "./GraphCycleError.d.mts";
+export * from "./GraphInputError.d.mts";
+export * from "./GraphLoopLimitError.d.mts";
+export * from "./GraphPinningError.d.mts";
+export * from "./GraphPortError.d.mts";
+export * from "./GraphStoreError.d.mts";
+export * from "./GraphTopologyError.d.mts";

package/lib/types/graph/events/GraphExecutionEvent.d.cts

@@ -0,0 +1,6 @@
+/**
+ * @module integrations/graph/events/GraphExecutionEvent
+ * @summary Re-export of the GraphExecutionEvent type for the events subpath.
+ * @description The GraphExecutionEvent interface is defined in the shared types module and re-exported here for convenience.
+ */
+export type { GraphExecutionEvent } from "../types.d.cts";

package/lib/types/graph/events/GraphExecutionEvent.d.mts

@@ -0,0 +1,6 @@
+/**
+ * @module integrations/graph/events/GraphExecutionEvent
+ * @summary Re-export of the GraphExecutionEvent type for the events subpath.
+ * @description The GraphExecutionEvent interface is defined in the shared types module and re-exported here for convenience.
+ */
+export type { GraphExecutionEvent } from "../types.d.mts";

package/lib/types/graph/events/GraphExecutionEventEmitter.d.cts

@@ -0,0 +1,26 @@
+/**
+ * @module integrations/graph/events/GraphExecutionEventEmitter
+ * @summary Observable implementation for graph execution events.
+ * @description Implements Decaf's {@link Observable} interface so observers can subscribe to graph execution events. Observer failures are isolated and do not crash the workflow.
+ */
+import type { Observable } from "@decaf-ts/core";
+import type { GraphExecutionObserver } from "./GraphExecutionObserver.d.cts";
+import type { GraphExecutionEvent } from "../types.d.cts";
+/**
+ * Manages observer registration and event dispatch for the graph execution
+ * engine.
+ */
+export declare class GraphExecutionEventEmitter implements Observable<[GraphExecutionObserver], [GraphExecutionEvent]> {
+    private readonly observers;
+    /** Registers an observer and returns an unsubscribe function. */
+    observe(observer: GraphExecutionObserver): () => void;
+    /** Removes a previously-registered observer. */
+    unObserve(observer: GraphExecutionObserver): void;
+    /**
+     * Notifies all registered observers of a new event.
+     *
+     * Observer failures are caught and swallowed so that a misbehaving observer
+     * cannot crash the workflow execution.
+     */
+    updateObservers(event: GraphExecutionEvent): Promise<void>;
+}

package/lib/types/graph/events/GraphExecutionEventEmitter.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @module integrations/graph/events/GraphExecutionEventEmitter
+ * @summary Observable implementation for graph execution events.
+ * @description Implements Decaf's {@link Observable} interface so observers can subscribe to graph execution events. Observer failures are isolated and do not crash the workflow.
+ */
+import type { Observable } from "@decaf-ts/core";
+import type { GraphExecutionObserver } from "./GraphExecutionObserver.d.mts";
+import type { GraphExecutionEvent } from "../types.d.mts";
+/**
+ * Manages observer registration and event dispatch for the graph execution
+ * engine.
+ */
+export declare class GraphExecutionEventEmitter implements Observable<[GraphExecutionObserver], [GraphExecutionEvent]> {
+    private readonly observers;
+    /** Registers an observer and returns an unsubscribe function. */
+    observe(observer: GraphExecutionObserver): () => void;
+    /** Removes a previously-registered observer. */
+    unObserve(observer: GraphExecutionObserver): void;
+    /**
+     * Notifies all registered observers of a new event.
+     *
+     * Observer failures are caught and swallowed so that a misbehaving observer
+     * cannot crash the workflow execution.
+     */
+    updateObservers(event: GraphExecutionEvent): Promise<void>;
+}

package/lib/types/graph/events/GraphExecutionEventFactory.d.cts

@@ -0,0 +1,25 @@
+/**
+ * @module integrations/graph/events/GraphExecutionEventFactory
+ * @summary Factory for creating graph execution events with unique ids, sequence numbers, and timestamps.
+ * @description Provides a stateful factory that produces monotonically-sequenced events for a single execution run.
+ */
+import type { GraphExecutionEvent } from "../types.d.cts";
+/**
+ * Factory that enriches partial events with a unique id, an incrementing
+ * sequence number, and a timestamp.
+ */
+export declare class GraphExecutionEventFactory {
+    private sequence;
+    /**
+     * Creates a fully-populated event from the given base fields.
+     *
+     * @param base - All event fields except `id`, `sequence`, and `timestamp`.
+     * @returns A complete {@link GraphExecutionEvent}.
+     */
+    create(base: Omit<GraphExecutionEvent, "id" | "sequence" | "timestamp">): GraphExecutionEvent;
+    /**
+     * Generates a unique event id using `crypto.randomUUID` when available,
+     * falling back to a timestamp + random string.
+     */
+    private createEventId;
+}

package/lib/types/graph/events/GraphExecutionEventFactory.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @module integrations/graph/events/GraphExecutionEventFactory
+ * @summary Factory for creating graph execution events with unique ids, sequence numbers, and timestamps.
+ * @description Provides a stateful factory that produces monotonically-sequenced events for a single execution run.
+ */
+import type { GraphExecutionEvent } from "../types.d.mts";
+/**
+ * Factory that enriches partial events with a unique id, an incrementing
+ * sequence number, and a timestamp.
+ */
+export declare class GraphExecutionEventFactory {
+    private sequence;
+    /**
+     * Creates a fully-populated event from the given base fields.
+     *
+     * @param base - All event fields except `id`, `sequence`, and `timestamp`.
+     * @returns A complete {@link GraphExecutionEvent}.
+     */
+    create(base: Omit<GraphExecutionEvent, "id" | "sequence" | "timestamp">): GraphExecutionEvent;
+    /**
+     * Generates a unique event id using `crypto.randomUUID` when available,
+     * falling back to a timestamp + random string.
+     */
+    private createEventId;
+}

package/lib/types/graph/events/GraphExecutionObserver.d.cts

@@ -0,0 +1,17 @@
+/**
+ * @module integrations/graph/events/GraphExecutionObserver
+ * @summary Observer interface for graph execution events.
+ * @description Extends Decaf's {@link Observer} so graph events flow through the standard Observable/Observer pipeline.
+ */
+import type { Observer } from "@decaf-ts/core";
+import type { GraphExecutionEvent } from "../types.d.cts";
+/**
+ * Observer that receives {@link GraphExecutionEvent} instances from the
+ * graph execution engine.
+ */
+export interface GraphExecutionObserver extends Observer<[GraphExecutionEvent]> {
+    /**
+     * Called by the engine when a new graph execution event is emitted.
+     */
+    refresh(event: GraphExecutionEvent): Promise<void>;
+}

package/lib/types/graph/events/GraphExecutionObserver.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @module integrations/graph/events/GraphExecutionObserver
+ * @summary Observer interface for graph execution events.
+ * @description Extends Decaf's {@link Observer} so graph events flow through the standard Observable/Observer pipeline.
+ */
+import type { Observer } from "@decaf-ts/core";
+import type { GraphExecutionEvent } from "../types.d.mts";
+/**
+ * Observer that receives {@link GraphExecutionEvent} instances from the
+ * graph execution engine.
+ */
+export interface GraphExecutionObserver extends Observer<[GraphExecutionEvent]> {
+    /**
+     * Called by the engine when a new graph execution event is emitted.
+     */
+    refresh(event: GraphExecutionEvent): Promise<void>;
+}

package/lib/types/graph/events/index.d.cts

@@ -0,0 +1,9 @@
+/**
+ * @module integrations/graph/events
+ * @summary Graph execution event pipeline.
+ * @description Re-exports the observer interface, event emitter, and event factory.
+ */
+export * from "./GraphExecutionEvent.d.cts";
+export * from "./GraphExecutionObserver.d.cts";
+export * from "./GraphExecutionEventEmitter.d.cts";
+export * from "./GraphExecutionEventFactory.d.cts";

package/lib/types/graph/events/index.d.mts

@@ -0,0 +1,9 @@
+/**
+ * @module integrations/graph/events
+ * @summary Graph execution event pipeline.
+ * @description Re-exports the observer interface, event emitter, and event factory.
+ */
+export * from "./GraphExecutionEvent.d.mts";
+export * from "./GraphExecutionObserver.d.mts";
+export * from "./GraphExecutionEventEmitter.d.mts";
+export * from "./GraphExecutionEventFactory.d.mts";

package/lib/types/graph/execution/GraphExecutionContext.d.cts

@@ -0,0 +1,50 @@
+/**
+ * @module integrations/graph/execution/GraphExecutionContext
+ * @summary Decaf Context for graph node execution.
+ * @description Extends Decaf's {@link Context} so node executors receive the same contextual plumbing as task handlers. Executors use the context to emit progress, log messages, and report state through the engine's observer pipeline.
+ */
+import { Context } from "@decaf-ts/core";
+import type { GraphNodeDefinition, GraphWorkflowDefinition } from "@decaf-ts/ui-decorators/graph";
+import type { GraphExecutionEvent, GraphRunId } from "../types.d.cts";
+/**
+ * Context passed to every graph node executor.
+ *
+ * Mirrors the `TaskEngine` / `TaskContext` pattern: the engine creates a
+ * `GraphExecutionContext` per node execution and passes it to
+ * `executor.execute(inputs, context)`. The executor uses `context.progress(...)`
+ * and `context.log(...)` to report intermediate state.
+ */
+export declare class GraphExecutionContext extends Context {
+    readonly runId: GraphRunId;
+    readonly parentRunId: GraphRunId | undefined;
+    readonly workflow: GraphWorkflowDefinition;
+    readonly node: GraphNodeDefinition;
+    readonly path: string[];
+    private readonly emitFn;
+    readonly metadata: Record<string, unknown>;
+    /**
+     * @param runId - Unique identifier for the current execution run.
+     * @param parentRunId - Run id of the parent execution (for nested loop bodies).
+     * @param workflow - The workflow definition being executed.
+     * @param node - The node definition being executed.
+     * @param path - Dotted path from the workflow root to this node.
+     * @param emitFn - Callback invoked when an event is emitted from this context.
+     * @param metadata - Free-form metadata attached to this context.
+     */
+    constructor(runId: GraphRunId, parentRunId: GraphRunId | undefined, workflow: GraphWorkflowDefinition, node: GraphNodeDefinition, path: string[], emitFn: (event: Partial<GraphExecutionEvent>) => Promise<void>, metadata?: Record<string, unknown>);
+    /**
+     * Emits a partial graph execution event. The engine fills in runId,
+     * parentRunId, workflowId, nodeId, and path automatically.
+     */
+    emit(event: Partial<GraphExecutionEvent>): Promise<void>;
+    /**
+     * Emits a `NODE_OUTPUT` event with the given payload, useful for reporting
+     * intermediate progress from within a node executor.
+     */
+    progress(payload: unknown): Promise<void>;
+    /**
+     * Emits a `NODE_OUTPUT` event with a structured `{ message, payload }` shape
+     * so executors can log human-readable messages.
+     */
+    log(message: string, payload?: unknown): Promise<void>;
+}

package/lib/types/graph/execution/GraphExecutionContext.d.mts

@@ -0,0 +1,50 @@
+/**
+ * @module integrations/graph/execution/GraphExecutionContext
+ * @summary Decaf Context for graph node execution.
+ * @description Extends Decaf's {@link Context} so node executors receive the same contextual plumbing as task handlers. Executors use the context to emit progress, log messages, and report state through the engine's observer pipeline.
+ */
+import { Context } from "@decaf-ts/core";
+import type { GraphNodeDefinition, GraphWorkflowDefinition } from "@decaf-ts/ui-decorators/graph";
+import type { GraphExecutionEvent, GraphRunId } from "../types.d.mts";
+/**
+ * Context passed to every graph node executor.
+ *
+ * Mirrors the `TaskEngine` / `TaskContext` pattern: the engine creates a
+ * `GraphExecutionContext` per node execution and passes it to
+ * `executor.execute(inputs, context)`. The executor uses `context.progress(...)`
+ * and `context.log(...)` to report intermediate state.
+ */
+export declare class GraphExecutionContext extends Context {
+    readonly runId: GraphRunId;
+    readonly parentRunId: GraphRunId | undefined;
+    readonly workflow: GraphWorkflowDefinition;
+    readonly node: GraphNodeDefinition;
+    readonly path: string[];
+    private readonly emitFn;
+    readonly metadata: Record<string, unknown>;
+    /**
+     * @param runId - Unique identifier for the current execution run.
+     * @param parentRunId - Run id of the parent execution (for nested loop bodies).
+     * @param workflow - The workflow definition being executed.
+     * @param node - The node definition being executed.
+     * @param path - Dotted path from the workflow root to this node.
+     * @param emitFn - Callback invoked when an event is emitted from this context.
+     * @param metadata - Free-form metadata attached to this context.
+     */
+    constructor(runId: GraphRunId, parentRunId: GraphRunId | undefined, workflow: GraphWorkflowDefinition, node: GraphNodeDefinition, path: string[], emitFn: (event: Partial<GraphExecutionEvent>) => Promise<void>, metadata?: Record<string, unknown>);
+    /**
+     * Emits a partial graph execution event. The engine fills in runId,
+     * parentRunId, workflowId, nodeId, and path automatically.
+     */
+    emit(event: Partial<GraphExecutionEvent>): Promise<void>;
+    /**
+     * Emits a `NODE_OUTPUT` event with the given payload, useful for reporting
+     * intermediate progress from within a node executor.
+     */
+    progress(payload: unknown): Promise<void>;
+    /**
+     * Emits a `NODE_OUTPUT` event with a structured `{ message, payload }` shape
+     * so executors can log human-readable messages.
+     */
+    log(message: string, payload?: unknown): Promise<void>;
+}

package/lib/types/graph/execution/GraphExecutionEngine.d.cts

@@ -0,0 +1,112 @@
+/**
+ * @module integrations/graph/execution/GraphExecutionEngine
+ * @summary Reference graph execution engine.
+ * @description Executes graph workflows declared with `@decaf-ts/ui-decorators/graph`, emits events through Decaf's Observable pipeline, supports parallel node execution within topological layers, and returns a complete execution result.
+ */
+import type { Observable } from "@decaf-ts/core";
+import type { GraphWorkflowDefinition } from "@decaf-ts/ui-decorators/graph";
+import type { GraphExecutionEvent, GraphExecutionOptions, GraphExecutionResult, GraphExecutionValues, GraphPinNodeOptions, GraphUnpinNodeOptions } from "../types.d.cts";
+import type { GraphExecutionObserver } from "../events/GraphExecutionObserver.d.cts";
+import { GraphExecutionEventEmitter } from "../events/GraphExecutionEventEmitter.d.cts";
+import type { GraphNodeExecutorRegistry } from "../registry/GraphNodeExecutorRegistry.d.cts";
+import { GraphExecutionPlanner } from "../planning/GraphExecutionPlanner.d.cts";
+import type { GraphValueStoreAdapter } from "../store/GraphValueStoreAdapter.d.cts";
+/**
+ * Configuration for the {@link GraphExecutionEngine}.
+ */
+export interface GraphExecutionEngineConfig {
+    registry: GraphNodeExecutorRegistry;
+    planner?: GraphExecutionPlanner;
+    valueStoreAdapter?: GraphValueStoreAdapter;
+    eventEmitter?: GraphExecutionEventEmitter;
+    defaultOptions?: Partial<GraphExecutionOptions>;
+}
+/**
+ * Reference graph execution engine.
+ *
+ * Executes a {@link GraphWorkflowDefinition} by:
+ * 1. Planning the workflow into topological layers.
+ * 2. Seeding workflow inputs into the value store.
+ * 3. Executing nodes layer-by-layer with configurable concurrency.
+ * 4. Routing values along edges.
+ * 5. Emitting structured events through Decaf's Observable pipeline.
+ * 6. 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;
+    constructor(config: GraphExecutionEngineConfig);
+    private readonly config;
+    observe(observer: GraphExecutionObserver): () => void;
+    unObserve(observer: GraphExecutionObserver): void;
+    updateObservers(event: GraphExecutionEvent): Promise<void>;
+    /**
+     * Executes a workflow with the given inputs and options.
+     */
+    execute(workflow: GraphWorkflowDefinition, 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;
+    /**
+     * Executes a layer of nodes with the configured concurrency.
+     */
+    private executeLayer;
+    /**
+     * Executes a single node.
+     */
+    private executeNode;
+    /**
+     * Resolves a node's input values from incoming edges.
+     */
+    private resolveNodeInputs;
+    /**
+     * 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.
+     */
+    private routeOutgoingEdges;
+    /**
+     * Emits an event, records it in the frame, and dispatches to observers.
+     */
+    private emitEvent;
+    /**
+     * Merges default options with the given options.
+     */
+    private mergeOptions;
+    /**
+     * Generates a unique run id.
+     */
+    private generateRunId;
+    /**
+     * Converts an error into a serialized payload.
+     */
+    private toErrorPayload;
+}