@codemation/core 0.0.5 → 0.0.7

package/dist/InMemoryLiveWorkflowRepository-DxoualoC.d.ts

@@ -0,0 +1,1344 @@
+import "reflect-metadata";
+import { DependencyContainer, DependencyContainer as Container, Disposable, InjectionToken, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+import { ReadableStream } from "node:stream/web";
+
+//#region src/contracts/retryPolicySpec.types.d.ts
+
+/**
+ * In-process retry policy for runnable nodes. Serialized configs use the same
+ * `kind` discriminator (`JSON.stringify` / persisted workflows).
+ *
+ * `maxAttempts` is the total number of tries including the first (e.g. 3 means up to 2 delays after failures).
+ */
+type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
+interface NoneRetryPolicySpec {
+  readonly kind: "none";
+}
+interface FixedRetryPolicySpec {
+  readonly kind: "fixed";
+  /** Total attempts including the first execution. Must be >= 1. */
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+}
+interface ExponentialRetryPolicySpec {
+  readonly kind: "exponential";
+  /** Total attempts including the first execution. Must be >= 1. */
+  readonly maxAttempts: number;
+  readonly initialDelayMs: number;
+  readonly multiplier: number;
+  readonly maxDelayMs?: number;
+  /** When true, each delay is multiplied by a random factor in [1, 1.2). */
+  readonly jitter?: boolean;
+}
+//#endregion
+//#region src/contracts/NoRetryPolicy.d.ts
+declare class NoRetryPolicy implements NoneRetryPolicySpec {
+  readonly kind: "none";
+}
+//#endregion
+//#region src/contracts/RetryPolicy.d.ts
+declare class RetryPolicy implements FixedRetryPolicySpec {
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly kind: "fixed";
+  constructor(maxAttempts: number, delayMs: number);
+  /** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
+  static readonly defaultForHttp: FixedRetryPolicySpec;
+  /** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
+  static readonly defaultForAiAgent: FixedRetryPolicySpec;
+}
+//#endregion
+//#region src/contracts/ExpRetryPolicy.d.ts
+declare class ExpRetryPolicy implements ExponentialRetryPolicySpec {
+  readonly maxAttempts: number;
+  readonly initialDelayMs: number;
+  readonly multiplier: number;
+  readonly maxDelayMs?: number | undefined;
+  readonly jitter?: boolean | undefined;
+  readonly kind: "exponential";
+  constructor(maxAttempts: number, initialDelayMs: number, multiplier: number, maxDelayMs?: number | undefined, jitter?: boolean | undefined);
+}
+//#endregion
+//#region src/events/runEvents.d.ts
+type RunEvent = Readonly<{
+  kind: "runCreated";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+}> | Readonly<{
+  kind: "runSaved";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  state: PersistedRunState;
+}> | Readonly<{
+  kind: "nodeQueued";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeStarted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeCompleted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeFailed";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}>;
+interface RunEventSubscription {
+  close(): Promise<void>;
+}
+interface RunEventBus {
+  publish(event: RunEvent): Promise<void>;
+  subscribe(onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+  subscribeToWorkflow(workflowId: WorkflowId, onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+}
+//#endregion
+//#region src/policies/executionLimits/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#endregion
+//#region src/di/CoreTokens.d.ts
+declare const CoreTokens: {
+  readonly PersistedWorkflowTokenRegistry: TypeToken<PersistedWorkflowTokenRegistryLike>;
+  readonly CredentialSessionService: TypeToken<CredentialSessionService>;
+  readonly CredentialTypeRegistry: TypeToken<CredentialTypeRegistry>;
+  readonly WorkflowRunnerService: TypeToken<WorkflowRunnerService>;
+  readonly LiveWorkflowRepository: TypeToken<LiveWorkflowRepository>;
+  readonly WorkflowRepository: TypeToken<WorkflowRepository>;
+  readonly NodeResolver: TypeToken<NodeResolver>;
+  readonly WorkflowNodeInstanceFactory: TypeToken<WorkflowNodeInstanceFactory>;
+  readonly RunIdFactory: TypeToken<RunIdFactory>;
+  readonly ActivationIdFactory: TypeToken<ActivationIdFactory>;
+  readonly WorkflowExecutionRepository: TypeToken<WorkflowExecutionRepository>;
+  readonly TriggerSetupStateRepository: TypeToken<TriggerSetupStateRepository>;
+  readonly NodeActivationScheduler: TypeToken<NodeActivationScheduler>;
+  readonly RunDataFactory: TypeToken<RunDataFactory>;
+  readonly ExecutionContextFactory: TypeToken<ExecutionContextFactory>;
+  readonly RunEventBus: TypeToken<RunEventBus>;
+  readonly BinaryStorage: TypeToken<BinaryStorage>;
+  readonly WebhookBasePath: TypeToken<string>;
+  /** Engine execution limits (defaults + optional host overrides). Consumers may bind a custom instance to override. */
+  readonly EngineExecutionLimitsPolicy: TypeToken<EngineExecutionLimitsPolicy>;
+  readonly WorkflowActivationPolicy: TypeToken<WorkflowActivationPolicy>;
+};
+//#endregion
+//#region src/contracts/runTypes.d.ts
+interface RunExecutionOptions {
+  /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
+  localOnly?: boolean;
+  /** Marks runs started from webhook handling so orchestration can apply webhook-specific continuation rules. */
+  webhook?: boolean;
+  mode?: "manual" | "debug";
+  sourceWorkflowId?: WorkflowId;
+  sourceRunId?: RunId;
+  derivedFromRunId?: RunId;
+  isMutable?: boolean;
+  /** Set by the engine for this run: 0 = root, 1 = first child subworkflow, … */
+  subworkflowDepth?: number;
+  /** Effective cap after engine policy merge (successful node completions per run). */
+  maxNodeActivations?: number;
+  /** Effective cap after engine policy merge (subworkflow nesting). */
+  maxSubworkflowDepth?: number;
+}
+/** Engine-owned counters persisted with the run (worker-safe). */
+interface EngineRunCounters {
+  completedNodeActivations: number;
+}
+type RunStopCondition = Readonly<{
+  kind: "workflowCompleted";
+}> | Readonly<{
+  kind: "nodeCompleted";
+  nodeId: NodeId;
+}>;
+interface RunStateResetRequest {
+  clearFromNodeId: NodeId;
+}
+interface PersistedRunControlState {
+  stopCondition?: RunStopCondition;
+}
+interface PersistedWorkflowSnapshotNode {
+  id: NodeId;
+  kind: NodeKind;
+  name?: string;
+  nodeTokenId: PersistedTokenId;
+  configTokenId: PersistedTokenId;
+  tokenName?: string;
+  configTokenName?: string;
+  config: unknown;
+}
+interface PersistedWorkflowSnapshot {
+  id: WorkflowId;
+  name: string;
+  nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
+  edges: ReadonlyArray<Edge>;
+  /** When the snapshot was built from a live workflow definition that configured a workflow error handler. */
+  workflowErrorHandlerConfigured?: boolean;
+  /** Connection metadata for child nodes not in the execution graph (e.g. AI agent attachments). */
+  connections?: ReadonlyArray<WorkflowNodeConnection>;
+}
+type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
+interface PersistedMutableNodeState {
+  pinnedOutputsByPort?: PinnedNodeOutputsByPort;
+  lastDebugInput?: Items;
+}
+interface PersistedMutableRunState {
+  nodesById: Readonly<Record<NodeId, PersistedMutableNodeState>>;
+}
+type NodeInputsByPort = Readonly<Record<InputPortKey, Items>>;
+interface RunQueueEntry {
+  nodeId: NodeId;
+  input: Items;
+  toInput?: InputPortKey;
+  batchId?: string;
+  from?: Readonly<{
+    nodeId: NodeId;
+    output: OutputPortKey;
+  }>;
+  collect?: Readonly<{
+    expectedInputs: ReadonlyArray<InputPortKey>;
+    received: Readonly<Record<InputPortKey, Items>>;
+  }>;
+}
+type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
+interface NodeExecutionError {
+  message: string;
+  name?: string;
+  stack?: string;
+}
+interface NodeExecutionSnapshot {
+  runId: RunId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  activationId?: NodeActivationId;
+  parent?: ParentExecutionRef;
+  status: NodeExecutionStatus;
+  usedPinnedOutput?: boolean;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  updatedAt: string;
+  inputsByPort?: NodeInputsByPort;
+  outputs?: NodeOutputs;
+  error?: NodeExecutionError;
+}
+/** Stable id for a single connection invocation row in {@link ConnectionInvocationRecord}. */
+type ConnectionInvocationId = string;
+/**
+ * One logical LLM or tool call under an owning workflow node (e.g. AI agent).
+ * The owning node defines what {@link managedInput} and {@link managedOutput} contain.
+ */
+interface ConnectionInvocationRecord {
+  readonly invocationId: ConnectionInvocationId;
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly connectionNodeId: NodeId;
+  readonly parentAgentNodeId: NodeId;
+  readonly parentAgentActivationId: NodeActivationId;
+  readonly status: NodeExecutionStatus;
+  readonly managedInput?: JsonValue;
+  readonly managedOutput?: JsonValue;
+  readonly error?: NodeExecutionError;
+  readonly queuedAt?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly updatedAt: string;
+}
+/** Arguments for appending a {@link ConnectionInvocationRecord} (engine fills run/workflow ids and timestamps). */
+type ConnectionInvocationAppendArgs = Readonly<{
+  invocationId: ConnectionInvocationId;
+  connectionNodeId: NodeId;
+  parentAgentNodeId: NodeId;
+  parentAgentActivationId: NodeActivationId;
+  status: NodeExecutionStatus;
+  managedInput?: JsonValue;
+  managedOutput?: JsonValue;
+  error?: NodeExecutionError;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+}>;
+interface RunCurrentState {
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
+  /** Append-only history of connection-scoped invocations (LLM/tool) for inspector and canvas. */
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+  mutableState?: PersistedMutableRunState;
+}
+interface CurrentStateExecutionRequest {
+  workflow: WorkflowDefinition;
+  items?: Items;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  currentState?: RunCurrentState;
+  stopCondition?: RunStopCondition;
+  reset?: RunStateResetRequest;
+}
+interface ExecutionFrontierPlan {
+  rootNodeId?: NodeId;
+  rootNodeInput?: Items;
+  queue: RunQueueEntry[];
+  currentState: RunCurrentState;
+  stopCondition: RunStopCondition;
+  satisfiedNodeIds: ReadonlyArray<NodeId>;
+  skippedNodeIds: ReadonlyArray<NodeId>;
+  clearedNodeIds: ReadonlyArray<NodeId>;
+  preservedPinnedNodeIds: ReadonlyArray<NodeId>;
+}
+type RunStatus = "running" | "pending" | "completed" | "failed";
+interface RunSummary {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: RunStatus;
+  /** ISO timestamp when the run finished (derived from node snapshots or store `updatedAt`); omit while running/pending. */
+  finishedAt?: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+}
+interface PendingNodeExecution {
+  runId: RunId;
+  activationId: NodeActivationId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  itemsIn: number;
+  inputsByPort: NodeInputsByPort;
+  receiptId: string;
+  queue?: string;
+  batchId?: string;
+  enqueuedAt: string;
+}
+interface PersistedRunState {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  control?: PersistedRunControlState;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  /** Frozen at createRun from workflow + runtime defaults for prune/storage decisions. */
+  policySnapshot?: PersistedRunPolicySnapshot;
+  /** Successful node completions so far (for activation budget). */
+  engineCounters?: EngineRunCounters;
+  status: RunStatus;
+  pending?: PendingNodeExecution;
+  queue: RunQueueEntry[];
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
+  /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+}
+interface WorkflowExecutionRepository {
+  createRun(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: RunExecutionOptions;
+    control?: PersistedRunControlState;
+    workflowSnapshot?: PersistedWorkflowSnapshot;
+    mutableState?: PersistedMutableRunState;
+    policySnapshot?: PersistedRunPolicySnapshot;
+    engineCounters?: EngineRunCounters;
+  }): Promise<void>;
+  load(runId: RunId): Promise<PersistedRunState | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  deleteRun?(runId: RunId): Promise<void>;
+}
+interface WorkflowExecutionListingRepository {
+  listRuns(args?: Readonly<{
+    workflowId?: WorkflowId;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+}
+/** Runs eligible for retention-based pruning (completed or failed, older than cutoff). */
+interface RunPruneCandidate {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly startedAt: string;
+  readonly finishedAt: string;
+}
+interface WorkflowExecutionPruneRepository {
+  listRunsOlderThan(args: Readonly<{
+    beforeIso: string;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+type RunResult = {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "completed";
+  outputs: Items;
+} | {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "pending";
+  pending: PendingNodeExecution;
+} | {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "failed";
+  error: {
+    message: string;
+  };
+};
+type WebhookRunResult = Readonly<{
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  runStatus: "pending" | "completed";
+  response: Items;
+}>;
+interface PersistedWorkflowTokenRegistryLike {
+  register(type: TypeToken<unknown>, packageId: string, persistedNameOverride?: string): string;
+  getTokenId(type: TypeToken<unknown>): string | undefined;
+  resolve(tokenId: string): TypeToken<unknown> | undefined;
+  registerFromWorkflows?(workflows: ReadonlyArray<WorkflowDefinition>): void;
+}
+interface RunCompletionNotifier {
+  resolveRunCompletion(result: RunResult): void;
+  resolveWebhookResponse(result: WebhookRunResult): void;
+}
+interface RunEventPublisherDeps {
+  eventBus?: RunEventBus;
+}
+//#endregion
+//#region src/contracts/workflowActivationPolicy.d.ts
+/**
+ * Host-controlled policy: when false, trigger {@link TriggerNode} setup is skipped and webhook routes
+ * for that workflow are not registered (see engine trigger runtime + webhook matcher).
+ */
+interface WorkflowActivationPolicy {
+  isActive(workflowId: WorkflowId): boolean;
+}
+/** Default for tests and harnesses: every workflow is treated as active (legacy behavior). */
+declare class AllWorkflowsActiveWorkflowActivationPolicy implements WorkflowActivationPolicy {
+  isActive(_workflowId: WorkflowId): boolean;
+}
+//#endregion
+//#region src/contracts/webhookTypes.d.ts
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface WebhookControlSignal {
+  readonly __webhookControl: true;
+  readonly kind: "respondNow" | "respondNowAndContinue";
+  readonly responseItems: Items;
+  readonly continueItems?: Items;
+}
+interface WebhookTriggerRoutingDiagnostics {
+  warn(message: string): void;
+  /** Inactive workflows omitted from the webhook route index (optional; host should wire for clarity at boot/reload). */
+  info?(message: string): void;
+}
+interface TriggerInstanceId {
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+}
+/** Match for an incoming HTTP request: user-defined URL segment + workflow trigger node. */
+interface WebhookInvocationMatch {
+  /** Same value as the webhook trigger's configured endpoint key (URL segment under the webhook base path). */
+  endpointPath: string;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  methods: ReadonlyArray<HttpMethod>;
+  parseJsonBody?: (body: unknown) => unknown;
+}
+/** Result of resolving an HTTP method + endpoint path against the catalog webhook index (404 vs 405 vs match). */
+type WebhookTriggerResolution = {
+  status: "notFound";
+} | {
+  status: "methodNotAllowed";
+  match: WebhookInvocationMatch;
+} | {
+  status: "ok";
+  match: WebhookInvocationMatch;
+};
+/**
+ * Resolves webhook routes from workflow definitions (catalog-backed index, no registration at trigger setup).
+ */
+interface WebhookTriggerMatcher {
+  match(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookInvocationMatch | undefined;
+  lookup(endpointPath: string): WebhookInvocationMatch | undefined;
+  onEngineWorkflowsLoaded?(): void;
+  onEngineStopped?(): void;
+  /** Rebuild route index after activation changes without stopping the engine. */
+  reloadWebhookRoutes?(): void;
+}
+//#endregion
+//#region src/contracts/runtimeTypes.d.ts
+interface WorkflowRunnerService {
+  runById(args: {
+    workflowId: WorkflowId;
+    startAt?: NodeId;
+    items: Items;
+    parent?: ParentExecutionRef;
+  }): Promise<RunResult>;
+}
+interface WorkflowRunnerResolver {
+  resolve(): WorkflowRunnerService | undefined;
+}
+interface WorkflowRepository {
+  list(): ReadonlyArray<WorkflowDefinition>;
+  get(workflowId: WorkflowId): WorkflowDefinition | undefined;
+}
+interface LiveWorkflowRepository extends WorkflowRepository {
+  setWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+}
+interface NodeResolver {
+  resolve<T>(token: TypeToken<T>): T;
+}
+interface NodeExecutionStatePublisher {
+  markQueued(args: {
+    nodeId: NodeId;
+    activationId?: NodeActivationId;
+    inputsByPort?: NodeInputsByPort;
+  }): Promise<void>;
+  markRunning(args: {
+    nodeId: NodeId;
+    activationId?: NodeActivationId;
+    inputsByPort?: NodeInputsByPort;
+  }): Promise<void>;
+  markCompleted(args: {
+    nodeId: NodeId;
+    activationId?: NodeActivationId;
+    inputsByPort?: NodeInputsByPort;
+    outputs?: NodeOutputs;
+  }): Promise<void>;
+  markFailed(args: {
+    nodeId: NodeId;
+    activationId?: NodeActivationId;
+    inputsByPort?: NodeInputsByPort;
+    error: Error;
+  }): Promise<void>;
+  appendConnectionInvocation(args: ConnectionInvocationAppendArgs): Promise<void>;
+}
+type BinaryBody = ReadableStream<Uint8Array> | AsyncIterable<Uint8Array> | Uint8Array | ArrayBuffer;
+interface BinaryStorageWriteRequest {
+  storageKey: string;
+  body: BinaryBody;
+}
+interface BinaryStorageWriteResult {
+  storageKey: string;
+  size: number;
+  sha256?: string;
+}
+interface BinaryStorageReadResult {
+  body: ReadableStream<Uint8Array>;
+  size?: number;
+}
+interface BinaryStorageStatResult {
+  exists: boolean;
+  size?: number;
+}
+interface BinaryStorage {
+  readonly driverName: string;
+  write(args: BinaryStorageWriteRequest): Promise<BinaryStorageWriteResult>;
+  openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
+  stat(storageKey: string): Promise<BinaryStorageStatResult>;
+  delete(storageKey: string): Promise<void>;
+}
+interface BinaryAttachmentCreateRequest {
+  name: string;
+  body: BinaryBody;
+  mimeType: string;
+  filename?: string;
+  previewKind?: BinaryAttachment["previewKind"];
+}
+interface NodeBinaryAttachmentService extends ExecutionBinaryService {
+  attach(args: BinaryAttachmentCreateRequest): Promise<BinaryAttachment>;
+  withAttachment<TJson>(item: Item<TJson>, name: string, attachment: BinaryAttachment): Item<TJson>;
+}
+interface ExecutionBinaryService {
+  forNode(args: {
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+  }): NodeBinaryAttachmentService;
+  openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
+}
+interface ExecutionContext {
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  /** This run's subworkflow depth (0 = root). */
+  subworkflowDepth: number;
+  /** Effective activation budget cap for this run (after policy merge). */
+  engineMaxNodeActivations: number;
+  /** Effective subworkflow nesting cap for this run (after policy merge). */
+  engineMaxSubworkflowDepth: number;
+  now: () => Date;
+  data: RunDataSnapshot;
+  nodeState?: NodeExecutionStatePublisher;
+  binary: ExecutionBinaryService;
+  getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+}
+interface ExecutionContextFactory {
+  create(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    parent?: ParentExecutionRef;
+    subworkflowDepth: number;
+    engineMaxNodeActivations: number;
+    engineMaxSubworkflowDepth: number;
+    data: RunDataSnapshot;
+    nodeState?: NodeExecutionStatePublisher;
+    getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+  }): ExecutionContext;
+}
+interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase> extends ExecutionContext {
+  nodeId: NodeId;
+  activationId: NodeActivationId;
+  config: TConfig;
+  binary: NodeBinaryAttachmentService;
+}
+interface TriggerSetupContext<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>, TSetupState$1 extends JsonValue | undefined = TriggerNodeSetupState<TConfig>> extends ExecutionContext {
+  trigger: TriggerInstanceId;
+  config: TConfig;
+  previousState: TSetupState$1;
+  registerCleanup(cleanup: TriggerCleanupHandle): void;
+  emit(items: Items): Promise<void>;
+}
+interface TriggerTestItemsContext<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>, TSetupState$1 extends JsonValue | undefined = TriggerNodeSetupState<TConfig>> extends ExecutionContext {
+  trigger: TriggerInstanceId;
+  nodeId: NodeId;
+  config: TConfig;
+  previousState: TSetupState$1;
+}
+/**
+ * Trigger setup state is intentionally engine-owned so future ownership and
+ * leader-election metadata can be coordinated centrally rather than pushed into
+ * package-level setup code.
+ */
+interface PersistedTriggerSetupState<TState extends JsonValue | undefined = JsonValue | undefined> {
+  trigger: TriggerInstanceId;
+  updatedAt: string;
+  state: TState;
+}
+interface TriggerSetupStateRepository {
+  load(trigger: TriggerInstanceId): Promise<PersistedTriggerSetupState | undefined>;
+  save(state: PersistedTriggerSetupState): Promise<void>;
+  delete(trigger: TriggerInstanceId): Promise<void>;
+}
+interface TriggerCleanupHandle {
+  stop(): Promise<void> | void;
+}
+interface EngineHost {
+  credentialSessions: CredentialSessionService;
+  workflows?: WorkflowRunnerService;
+}
+interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
+  kind: "node";
+  outputPorts: ReadonlyArray<OutputPortKey>;
+  execute(items: Items, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
+}
+interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
+  kind: "node";
+  outputPorts: ReadonlyArray<OutputPortKey>;
+  executeMulti(inputsByPort: NodeInputsByPort, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
+}
+type TriggerSetupStateFor<TConfig extends TriggerNodeConfig<any, any>> = TriggerNodeSetupState<TConfig>;
+interface TriggerNode<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>> {
+  kind: "trigger";
+  outputPorts: readonly ["main"];
+  setup(ctx: TriggerSetupContext<TConfig>): Promise<TriggerSetupStateFor<TConfig>>;
+  execute(items: Items, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
+}
+interface TestableTriggerNode<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>> extends TriggerNode<TConfig> {
+  getTestItems(ctx: TriggerTestItemsContext<TConfig>): Promise<Items>;
+}
+type ExecutableTriggerNode<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>> = TriggerNode<TConfig>;
+interface NodeExecutionRequest {
+  runId: RunId;
+  activationId: NodeActivationId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  input: Items;
+  parent?: ParentExecutionRef;
+  queue?: string;
+  executionOptions?: RunExecutionOptions;
+}
+interface NodeExecutionScheduler {
+  enqueue(request: NodeExecutionRequest): Promise<{
+    receiptId: string;
+  }>;
+  cancel?(receiptId: string): Promise<void>;
+}
+interface NodeExecutionRequestHandler {
+  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
+}
+type NodeActivationRequestBase = Readonly<{
+  runId: RunId;
+  activationId: NodeActivationId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  batchId?: string;
+  ctx: NodeExecutionContext;
+}>;
+type NodeActivationRequest = (NodeActivationRequestBase & Readonly<{
+  kind: "single";
+  input: Items;
+}>) | (NodeActivationRequestBase & Readonly<{
+  kind: "multi";
+  inputsByPort: NodeInputsByPort;
+}>);
+interface NodeActivationReceipt {
+  receiptId: string;
+  mode?: "local" | "worker";
+  queue?: string;
+}
+interface NodeActivationContinuation {
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+}
+interface NodeActivationScheduler {
+  setContinuation?(continuation: NodeActivationContinuation): void;
+  enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt>;
+  notifyPendingStatePersisted?(runId: RunId): void;
+  cancel?(receiptId: string): Promise<void>;
+}
+interface WorkflowNodeInstanceFactory {
+  createNodes(workflow: WorkflowDefinition): ReadonlyMap<NodeId, unknown>;
+  createByType(type: TypeToken<unknown>): unknown;
+}
+interface NodeExecutor {
+  execute(request: NodeActivationRequest): Promise<NodeOutputs>;
+}
+interface WorkflowSnapshotFactory {
+  create(workflow: WorkflowDefinition): PersistedWorkflowSnapshot;
+}
+interface WorkflowSnapshotResolver {
+  resolve(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: PersistedWorkflowSnapshot;
+  }): WorkflowDefinition | undefined;
+}
+/** Optional host wiring for trigger lifecycle logs (boot skip + activation sync). */
+interface TriggerRuntimeDiagnostics {
+  info(message: string): void;
+  warn(message: string): void;
+}
+interface EngineDeps {
+  credentialSessions: CredentialSessionService;
+  liveWorkflowRepository: LiveWorkflowRepository;
+  workflowRepository: WorkflowRepository;
+  /** When {@link AllWorkflowsActiveWorkflowActivationPolicy}, all workflows behave as active (tests). */
+  workflowActivationPolicy: WorkflowActivationPolicy;
+  nodeResolver: NodeResolver;
+  triggerSetupStateRepository: TriggerSetupStateRepository;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  runIdFactory: RunIdFactory;
+  activationIdFactory: ActivationIdFactory;
+  workflowExecutionRepository: WorkflowExecutionRepository;
+  activationScheduler: NodeActivationScheduler;
+  runDataFactory: RunDataFactory;
+  executionContextFactory: ExecutionContextFactory;
+  nodeExecutor: NodeExecutor;
+  eventBus?: RunEventBus;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  workflowNodeInstanceFactory: WorkflowNodeInstanceFactory;
+  /** Defaults for prune/storage snapshot when workflow omits explicit policy fields. */
+  workflowPolicyRuntimeDefaults?: WorkflowPolicyRuntimeDefaults;
+  /** When set, logs inactive-workflow skips at boot and trigger start/stop on activation changes. */
+  triggerRuntimeDiagnostics?: TriggerRuntimeDiagnostics;
+}
+//#endregion
+//#region src/contracts/workflowTypes.d.ts
+type WorkflowId = string;
+type NodeId = string;
+type OutputPortKey = string;
+type InputPortKey = string;
+type PersistedTokenId = string;
+type NodeKind = "trigger" | "node";
+type JsonPrimitive = string | number | boolean | null;
+interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type JsonArray = ReadonlyArray<JsonValue>;
+interface Edge {
+  from: {
+    nodeId: NodeId;
+    output: OutputPortKey;
+  };
+  to: {
+    nodeId: NodeId;
+    input: InputPortKey;
+  };
+}
+type NodeConnectionName = string;
+/**
+ * Named connection from an executable parent node to child nodes that exist in {@link WorkflowDefinition.nodes}
+ * but are not traversed by the main execution graph.
+ */
+interface WorkflowNodeConnection {
+  readonly parentNodeId: NodeId;
+  readonly connectionName: NodeConnectionName;
+  readonly childNodeIds: ReadonlyArray<NodeId>;
+}
+interface WorkflowDefinition {
+  id: WorkflowId;
+  name: string;
+  nodes: NodeDefinition[];
+  edges: Edge[];
+  /**
+   * Optional metadata: which nodes are connection-owned children (e.g. AI agent `llm` / `tools` slots).
+   * When omitted, all nodes in {@link nodes} are treated as executable for topology.
+   */
+  readonly connections?: ReadonlyArray<WorkflowNodeConnection>;
+  /** Directory + file-stem path under a workflow discovery root (for UI grouping only). */
+  discoveryPathSegments?: readonly string[];
+  /** Retention for run JSON and binaries (seconds). Host/env may supply defaults when omitted. */
+  readonly prunePolicy?: WorkflowPrunePolicySpec;
+  /** Whether to keep run data after completion. Host/env may supply defaults when omitted. */
+  readonly storagePolicy?: WorkflowStoragePolicySpec;
+  /** Invoked after a node fails permanently (retries exhausted) and node error handler did not recover. */
+  readonly workflowErrorHandler?: WorkflowErrorHandlerSpec;
+}
+interface WorkflowGraph {
+  next(nodeId: NodeId, output: OutputPortKey): ReadonlyArray<Readonly<{
+    nodeId: NodeId;
+    input: InputPortKey;
+  }>>;
+}
+interface WorkflowGraphFactory {
+  create(def: WorkflowDefinition): WorkflowGraph;
+}
+interface NodeConfigBase {
+  readonly kind: NodeKind;
+  readonly type: TypeToken<unknown>;
+  readonly name?: string;
+  readonly id?: NodeId;
+  readonly icon?: string;
+  readonly execution?: Readonly<{
+    hint?: "local" | "worker";
+    queue?: string;
+  }>;
+  /** In-process execute retries (runnable nodes). Triggers typically omit this. */
+  readonly retryPolicy?: RetryPolicySpec;
+  /** Recover from execute failures; return outputs to continue, or rethrow to fail the node. */
+  readonly nodeErrorHandler?: NodeErrorHandlerSpec;
+  /**
+   * When true, edges carrying zero items on an output port still schedule single-input downstream nodes.
+   * Decided from the **source** node that produced the (empty) output. Default (false/undefined): empty
+   * main batches skip downstream execution and propagate the empty path.
+   */
+  readonly continueWhenEmptyOutput?: boolean;
+  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
+}
+declare const runnableNodeInputType: unique symbol;
+declare const runnableNodeOutputType: unique symbol;
+declare const triggerNodeOutputType: unique symbol;
+interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
+  readonly kind: "node";
+  readonly [runnableNodeInputType]?: TInputJson$1;
+  readonly [runnableNodeOutputType]?: TOutputJson$1;
+}
+declare const triggerNodeSetupStateType: unique symbol;
+interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonValue | undefined = undefined> extends NodeConfigBase {
+  readonly kind: "trigger";
+  readonly [triggerNodeOutputType]?: TOutputJson$1;
+  readonly [triggerNodeSetupStateType]?: TSetupState$1;
+}
+type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any> ? TInputJson : never;
+type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson> ? TOutputJson : never;
+type TriggerNodeOutputJson<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<infer TOutputJson, any> ? TOutputJson : never;
+type TriggerNodeSetupState<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<any, infer TSetupState> ? TSetupState : never;
+interface NodeDefinition {
+  id: NodeId;
+  kind: NodeKind;
+  type: TypeToken<unknown>;
+  name?: string;
+  config: NodeConfigBase;
+}
+interface NodeRef {
+  id: NodeId;
+  kind: NodeKind;
+  name?: string;
+}
+type PairedItemRef = Readonly<{
+  nodeId: NodeId;
+  output: OutputPortKey;
+  itemIndex: number;
+}>;
+type BinaryPreviewKind = "image" | "audio" | "video" | "download";
+type BinaryAttachment = Readonly<{
+  id: string;
+  storageKey: string;
+  mimeType: string;
+  size: number;
+  storageDriver: string;
+  previewKind: BinaryPreviewKind;
+  createdAt: string;
+  runId: RunId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  activationId: NodeActivationId;
+  filename?: string;
+  sha256?: string;
+}>;
+type ItemBinary = Readonly<Record<string, BinaryAttachment>>;
+type Item<TJson = unknown> = Readonly<{
+  json: TJson;
+  binary?: ItemBinary;
+  meta?: Readonly<Record<string, unknown>>;
+  paired?: ReadonlyArray<PairedItemRef>;
+}>;
+type Items<TJson = unknown> = ReadonlyArray<Item<TJson>>;
+type NodeOutputs = Partial<Record<OutputPortKey, Items>>;
+type RunId = string;
+type NodeActivationId = string;
+interface ParentExecutionRef {
+  runId: RunId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  /** Subworkflow depth of the **spawning** run (0 = root). Passed when starting a child run. */
+  subworkflowDepth?: number;
+  /** Effective max node activations from the parent run (propagated to child policy merge). */
+  engineMaxNodeActivations?: number;
+  /** Effective max subworkflow depth from the parent run (propagated to child policy merge). */
+  engineMaxSubworkflowDepth?: number;
+}
+interface RunDataSnapshot {
+  getOutputs(nodeId: NodeId): NodeOutputs | undefined;
+  getOutputItems(nodeId: NodeId, output?: OutputPortKey): Items;
+  getOutputItem(nodeId: NodeId, itemIndex: number, output?: OutputPortKey): Item | undefined;
+}
+interface MutableRunData extends RunDataSnapshot {
+  setOutputs(nodeId: NodeId, outputs: NodeOutputs): void;
+  dump(): Record<NodeId, NodeOutputs>;
+}
+interface RunDataFactory {
+  create(initial?: Record<NodeId, NodeOutputs>): MutableRunData;
+}
+interface RunIdFactory {
+  makeRunId(): RunId;
+}
+interface ActivationIdFactory {
+  makeActivationId(): NodeActivationId;
+}
+type UpstreamRefPlaceholder = `$${number}`;
+declare const branchRef: (index: number) => UpstreamRefPlaceholder;
+type ExecutionMode = "local" | "worker";
+interface NodeSchedulerDecision {
+  mode: ExecutionMode;
+  queue?: string;
+}
+interface NodeOffloadPolicy {
+  decide(args: {
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    config: NodeConfigBase;
+  }): NodeSchedulerDecision;
+}
+/** Whether to persist run execution data after the workflow finishes. */
+type WorkflowStoragePolicyMode = "ALL" | "SUCCESS" | "ERROR" | "NEVER";
+type WorkflowStoragePolicySpec = WorkflowStoragePolicyMode | TypeToken<WorkflowStoragePolicyResolver>;
+interface WorkflowStoragePolicyResolver {
+  shouldPersist(args: WorkflowStoragePolicyDecisionArgs): boolean | Promise<boolean>;
+}
+interface WorkflowStoragePolicyDecisionArgs {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly workflow: WorkflowDefinition;
+  readonly finalStatus: "completed" | "failed";
+  readonly startedAt: string;
+  readonly finishedAt: string;
+}
+interface WorkflowPrunePolicySpec {
+  readonly runDataRetentionSeconds?: number;
+  readonly binaryRetentionSeconds?: number;
+}
+interface PersistedRunPolicySnapshot {
+  readonly retentionSeconds?: number;
+  readonly binaryRetentionSeconds?: number;
+  readonly storagePolicy: WorkflowStoragePolicyMode;
+}
+interface WorkflowErrorHandler {
+  onError(ctx: WorkflowErrorContext): void | Promise<void>;
+}
+interface WorkflowErrorContext {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly workflow: WorkflowDefinition;
+  readonly failedNodeId: NodeId;
+  readonly error: Error;
+  readonly startedAt: string;
+  readonly finishedAt: string;
+}
+type WorkflowErrorHandlerSpec = TypeToken<WorkflowErrorHandler> | WorkflowErrorHandler;
+interface NodeErrorHandlerArgs<TConfig extends NodeConfigBase = NodeConfigBase> {
+  readonly kind: "single" | "multi";
+  readonly items: Items;
+  readonly inputsByPort: Readonly<Record<InputPortKey, Items>> | undefined;
+  readonly ctx: NodeExecutionContext<TConfig>;
+  readonly error: Error;
+}
+interface NodeErrorHandler {
+  handle<TConfig extends NodeConfigBase>(args: NodeErrorHandlerArgs<TConfig>): Promise<NodeOutputs>;
+}
+type NodeErrorHandlerSpec = TypeToken<NodeErrorHandler> | NodeErrorHandler;
+/** Runtime defaults when workflow omits prune/storage fields (typically from host env). */
+interface WorkflowPolicyRuntimeDefaults {
+  readonly retentionSeconds?: number;
+  readonly binaryRetentionSeconds?: number;
+  readonly storagePolicy?: WorkflowStoragePolicyMode;
+}
+//#endregion
+//#region src/contracts/credentialTypes.d.ts
+type CredentialTypeId = string;
+type CredentialInstanceId = string;
+type CredentialMaterialSourceKind = "db" | "env" | "code";
+type CredentialSetupStatus = "draft" | "ready";
+type CredentialHealthStatus = "unknown" | "healthy" | "failing";
+type CredentialFieldSchema = Readonly<{
+  key: string;
+  label: string;
+  type: "string" | "password" | "textarea" | "json" | "boolean";
+  required?: true;
+  order?: number;
+  placeholder?: string;
+  helpText?: string;
+  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
+  envVarName?: string;
+  /**
+   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
+   * pattern or documentation URL). Do not use for secret values.
+   */
+  copyValue?: string;
+  /** Accessible label for the copy control (default: Copy). */
+  copyButtonLabel?: string;
+}>;
+type CredentialRequirement = Readonly<{
+  slotKey: string;
+  label: string;
+  acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  optional?: true;
+  helpText?: string;
+  helpUrl?: string;
+}>;
+type CredentialBindingKey = Readonly<{
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  slotKey: string;
+}>;
+type CredentialBinding = Readonly<{
+  key: CredentialBindingKey;
+  instanceId: CredentialInstanceId;
+  updatedAt: string;
+}>;
+type CredentialHealth = Readonly<{
+  status: CredentialHealthStatus;
+  message?: string;
+  testedAt?: string;
+  expiresAt?: string;
+  details?: Readonly<Record<string, unknown>>;
+}>;
+type OAuth2ProviderFromPublicConfig = Readonly<{
+  authorizeUrlFieldKey: string;
+  tokenUrlFieldKey: string;
+  userInfoUrlFieldKey?: string;
+}>;
+type CredentialOAuth2AuthDefinition = Readonly<{
+  kind: "oauth2";
+  providerId: string;
+  scopes: ReadonlyArray<string>;
+  clientIdFieldKey?: string;
+  clientSecretFieldKey?: string;
+} | {
+  kind: "oauth2";
+  providerFromPublicConfig: OAuth2ProviderFromPublicConfig;
+  scopes: ReadonlyArray<string>;
+  clientIdFieldKey?: string;
+  clientSecretFieldKey?: string;
+}>;
+type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
+type CredentialTypeDefinition = Readonly<{
+  typeId: CredentialTypeId;
+  displayName: string;
+  description?: string;
+  publicFields?: ReadonlyArray<CredentialFieldSchema>;
+  secretFields?: ReadonlyArray<CredentialFieldSchema>;
+  supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
+  auth?: CredentialAuthDefinition;
+}>;
+/**
+ * JSON-shaped credential field bag (public config, resolved secret material, etc.).
+ */
+type CredentialJsonRecord = Readonly<Record<string, unknown>>;
+/**
+ * Persisted credential instance with typed `publicConfig`.
+ * Hosts may specialize `secretRef` with a stricter union while remaining
+ * assignable here for session/test callbacks.
+ */
+type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  instanceId: CredentialInstanceId;
+  typeId: CredentialTypeId;
+  displayName: string;
+  sourceKind: CredentialMaterialSourceKind;
+  publicConfig: TPublicConfig;
+  secretRef: CredentialJsonRecord;
+  tags: ReadonlyArray<string>;
+  setupStatus: CredentialSetupStatus;
+  createdAt: string;
+  updatedAt: string;
+}>;
+/**
+ * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
+ * Declare `TPublicConfig` / `TMaterial` on `CredentialType` so implementations are checked
+ * against your credential shapes (similar to `NodeExecutionContext.config` for nodes).
+ */
+type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  instance: CredentialInstanceRecord<TPublicConfig>;
+  material: TMaterial;
+  publicConfig: TPublicConfig;
+}>;
+type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
+type CredentialHealthTester<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<CredentialHealth>;
+/**
+ * Full credential type implementation: `definition` (UI/schema), `createSession`, and `test`.
+ * Use this at registration and config boundaries; `CredentialTypeDefinition` is only the schema slice.
+ */
+type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = Readonly<{
+  definition: CredentialTypeDefinition;
+  createSession: CredentialSessionFactory<TPublicConfig, TMaterial, TSession>;
+  test: CredentialHealthTester<TPublicConfig, TMaterial>;
+}>;
+/**
+ * Credential type with unspecified generics — used for `CodemationConfig.credentialTypes`, the host registry,
+ * and anywhere a concrete `CredentialType<YourPublic, YourMaterial, YourSession>` is placed in a heterogeneous list.
+ * Using `any` here avoids unsafe `as` casts while keeping typed `satisfies CredentialType<…>` definitions.
+ */
+type AnyCredentialType = CredentialType<any, any, unknown>;
+interface CredentialSessionService {
+  getSession<TSession = unknown>(args: Readonly<{
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    slotKey: string;
+  }>): Promise<TSession>;
+}
+interface CredentialTypeRegistry {
+  listTypes(): ReadonlyArray<CredentialTypeDefinition>;
+  getType(typeId: CredentialTypeId): CredentialTypeDefinition | undefined;
+}
+declare class CredentialUnboundError extends Error {
+  readonly bindingKey: CredentialBindingKey;
+  readonly acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  constructor(bindingKey: CredentialBindingKey, acceptedTypes?: ReadonlyArray<CredentialTypeId>);
+  private static createMessage;
+}
+//#endregion
+//#region src/contracts/runFinishedAtFactory.d.ts
+type RunFinishedAtSource = Pick<PersistedRunState, "status" | "nodeSnapshotsByNodeId">;
+/** Derives workflow end time from node snapshots for run listings. */
+declare class RunFinishedAtFactory {
+  static resolveIso(state: RunFinishedAtSource): string | undefined;
+}
+//#endregion
+//#region src/workflow/dsl/workflowBuilderTypes.d.ts
+type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
+type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
+type ValidStepSequence<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps extends readonly [] ? readonly [] : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>] : never : never : TSteps;
+type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? TSteps extends readonly [] ? TCurrentJson : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? StepSequenceOutput<TNextJson, TRest> : never : never : TCurrentJson : TCurrentJson;
+type TypesMatch<TLeft, TRight> = [TLeft] extends [TRight] ? ([TRight] extends [TLeft] ? true : false) : false;
+type BranchOutputGuard<TCurrentJson, TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TypesMatch<StepSequenceOutput<TCurrentJson, TTrueSteps>, StepSequenceOutput<TCurrentJson, TFalseSteps>> extends true ? unknown : never;
+type BranchStepsArg<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps & ValidStepSequence<TCurrentJson, TSteps>;
+type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
+type BooleanWhenOverloads<TCurrentJson, TReturn> = {
+  <TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, steps: BranchStepsArg<TCurrentJson, TSteps>): TReturn;
+  <TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
+};
+//#endregion
+//#region src/workflow/dsl/WhenBuilder.d.ts
+declare class WhenBuilder<TCurrentJson> {
+  private readonly wf;
+  private readonly from;
+  private readonly branchPort;
+  constructor(wf: WorkflowBuilder, from: NodeRef, branchPort: OutputPortKey);
+  addBranch<TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(steps: TSteps & ValidStepSequence<TCurrentJson, TSteps>): this;
+  readonly when: BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>>;
+  build(): WorkflowDefinition;
+}
+//#endregion
+//#region src/workflow/dsl/ChainCursorResolver.d.ts
+type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>> & {
+  <TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined>(branches: Readonly<{
+    true?: TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? BranchStepsArg<TCurrentJson, TTrueSteps> : never;
+    false?: TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? BranchStepsArg<TCurrentJson, TFalseSteps> : never;
+  }> & BranchOutputGuard<TCurrentJson, TTrueSteps, TFalseSteps>): ChainCursor<StepSequenceOutput<TCurrentJson, TTrueSteps>>;
+};
+declare class ChainCursor<TCurrentJson> {
+  private readonly wf;
+  private readonly cursor;
+  private readonly cursorOutput;
+  constructor(wf: WorkflowBuilder, cursor: NodeRef, cursorOutput: OutputPortKey);
+  then<TConfig extends RunnableNodeConfig<TCurrentJson, any>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
+  readonly when: ChainCursorWhenOverloads<TCurrentJson>;
+  build(): WorkflowDefinition;
+}
+//#endregion
+//#region src/workflow/dsl/WorkflowBuilder.d.ts
+declare class WorkflowBuilder {
+  private readonly meta;
+  private readonly options?;
+  private readonly nodes;
+  private readonly edges;
+  private seq;
+  constructor(meta: {
+    id: WorkflowId;
+    name: string;
+  }, options?: Readonly<{
+    makeMergeNode?: (name: string) => AnyRunnableNodeConfig;
+  }> | undefined);
+  private add;
+  private connect;
+  trigger<TConfig extends AnyTriggerNodeConfig>(config: TConfig): ChainCursor<TriggerNodeOutputJson<TConfig>>;
+  start<TConfig extends AnyRunnableNodeConfig>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
+  build(): WorkflowDefinition;
+}
+//#endregion
+//#region src/workflow/definition/ConnectionInvocationIdFactory.d.ts
+/**
+ * Unique ids for persisted connection invocation history rows (LLM/tool calls under an owning node).
+ */
+declare class ConnectionInvocationIdFactory {
+  static create(): string;
+  /** Deterministic id for tests when a stable sequence is needed. */
+  static createForTest(runId: string, connectionNodeId: NodeId, sequence: number): string;
+}
+//#endregion
+//#region src/workflow/definition/ConnectionNodeIdFactory.d.ts
+/**
+ * Deterministic ids for workflow connection-owned child nodes (LLM slot, tools, etc.).
+ * These are stable across loads.
+ */
+declare class ConnectionNodeIdFactory {
+  static readonly connectionSegment: "__conn__";
+  static languageModelConnectionNodeId(parentNodeId: NodeId): NodeId;
+  static toolConnectionNodeId(parentNodeId: NodeId, toolName: string): NodeId;
+  static isLanguageModelConnectionNodeId(nodeId: NodeId): boolean;
+  static isToolConnectionNodeId(nodeId: NodeId): boolean;
+  /** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
+  static isConnectionOwnedDescendantOf(parentNodeId: NodeId, nodeId: NodeId): boolean;
+  /** Normalizes a tool display name to a stable id segment. */
+  static normalizeToolName(toolName: string): string;
+}
+//#endregion
+//#region src/workflow/definition/WorkflowExecutableNodeClassifier.d.ts
+/**
+ * Derives which workflow nodes participate in the main execution graph vs connection-only children.
+ */
+declare class WorkflowExecutableNodeClassifier {
+  private readonly connectionOwnedIds;
+  constructor(workflow: WorkflowDefinition);
+  isConnectionOwnedNodeId(nodeId: NodeId): boolean;
+  isExecutableNodeId(nodeId: NodeId): boolean;
+  filterExecutableNodeDefinitions(nodes: ReadonlyArray<NodeDefinition>): ReadonlyArray<NodeDefinition>;
+  private collectConnectionOwnedIds;
+  /**
+   * Resolves the default start node: first trigger, else first executable node with no incoming edges from executable nodes.
+   */
+  findDefaultExecutableStartNodeId(workflow: WorkflowDefinition): NodeId;
+  firstExecutableNodeIdInDefinitionOrder(workflow: WorkflowDefinition): NodeId | undefined;
+  lastExecutableNodeIdInDefinitionOrder(workflow: WorkflowDefinition): NodeId;
+}
+//#endregion
+//#region src/workflow/definition/WorkflowExecutableNodeClassifierFactory.d.ts
+declare class WorkflowExecutableNodeClassifierFactory {
+  static create(workflow: WorkflowDefinition): WorkflowExecutableNodeClassifier;
+}
+//#endregion
+//#region src/workflow/graph/DefaultWorkflowGraphFactory.d.ts
+declare class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
+  create(def: WorkflowDefinition): WorkflowGraph;
+}
+//#endregion
+//#region src/workflowSnapshots/WorkflowSnapshotCodec.d.ts
+declare class WorkflowSnapshotCodec {
+  private readonly tokenRegistry;
+  constructor(tokenRegistry: PersistedWorkflowTokenRegistryLike);
+  create(workflow: WorkflowDefinition): PersistedWorkflowSnapshot;
+  hydrate(snapshotNode: PersistedWorkflowSnapshotNode, liveConfig: NodeConfigBase): NodeConfigBase;
+  private serializeConfig;
+  private injectTokenIds;
+  private mergeValue;
+  private mergeNestedValue;
+  private restoreNonSerializableProperties;
+  private restoreTypeProperty;
+  private resolveTokenId;
+  private resolveTokenName;
+  private asTypeToken;
+  private asRecord;
+}
+//#endregion
+//#region src/runtime/InMemoryLiveWorkflowRepository.d.ts
+declare class InMemoryLiveWorkflowRepository implements LiveWorkflowRepository {
+  private readonly workflowsById;
+  setWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  list(): ReadonlyArray<WorkflowDefinition>;
+  get(workflowId: WorkflowId): WorkflowDefinition | undefined;
+}
+//#endregion
+export { JsonArray as $, ConnectionInvocationRecord as $n, RunEventBus as $r, BinaryBody as $t, CredentialJsonRecord as A, TriggerNode as An, WorkflowExecutionRepository as Ar, TriggerNodeOutputJson as At, CredentialTypeId as B, WorkflowSnapshotFactory as Bn, inject as Br, WorkflowNodeConnection as Bt, CredentialBindingKey as C, NodeExecutionScheduler as Cn, RunStateResetRequest as Cr, RunDataSnapshot as Ct, CredentialHealthTester as D, PersistedTriggerSetupState as Dn, WebhookRunResult as Dr, RunnableNodeInputJson as Dt, CredentialHealthStatus as E, NodeResolver as En, RunSummary as Er, RunnableNodeConfig as Et, CredentialSessionFactoryArgs as F, TriggerTestItemsContext as Fn, Lifecycle as Fr, WorkflowErrorHandler as Ft, BinaryAttachment as G, WebhookInvocationMatch as Gn, predicateAwareClassFactory as Gr, WorkflowStoragePolicyResolver as Gt, CredentialUnboundError as H, HttpMethod as Hn, injectable as Hr, WorkflowPrunePolicySpec as Ht, CredentialSessionService as I, WorkflowNodeInstanceFactory as In, RegistrationOptions as Ir, WorkflowErrorHandlerSpec as It, ExecutionMode as J, WebhookTriggerRoutingDiagnostics as Jn, CoreTokens as Jr, runnableNodeInputType as Jt, BinaryPreviewKind as K, WebhookTriggerMatcher as Kn, registry as Kr, WorkflowStoragePolicySpec as Kt, CredentialSetupStatus as L, WorkflowRepository as Ln, TypeToken as Lr, WorkflowGraph as Lt, CredentialOAuth2AuthDefinition as M, TriggerSetupContext as Mn, DependencyContainer as Mr, UpstreamRefPlaceholder as Mt, CredentialRequirement as N, TriggerSetupStateFor as Nn, Disposable as Nr, WorkflowDefinition as Nt, CredentialInstanceId as O, TestableTriggerNode as On, WorkflowExecutionListingRepository as Or, RunnableNodeOutputJson as Ot, CredentialSessionFactory as P, TriggerSetupStateRepository as Pn, InjectionToken as Pr, WorkflowErrorContext as Pt, Items as Q, ConnectionInvocationId as Qn, RunEvent as Qr, BinaryAttachmentCreateRequest as Qt, CredentialType as R, WorkflowRunnerResolver as Rn, container as Rr, WorkflowGraphFactory as Rt, CredentialBinding as S, NodeExecutionRequestHandler as Sn, RunResult as Sr, RunDataFactory as St, CredentialHealth as T, NodeExecutor as Tn, RunStopCondition as Tr, RunIdFactory as Tt, OAuth2ProviderFromPublicConfig as U, TriggerInstanceId as Un, instanceCachingFactory as Ur, WorkflowStoragePolicyDecisionArgs as Ut, CredentialTypeRegistry as V, WorkflowSnapshotResolver as Vn, injectAll as Vr, WorkflowPolicyRuntimeDefaults as Vt, ActivationIdFactory as W, WebhookControlSignal as Wn, instancePerContainerCachingFactory as Wr, WorkflowStoragePolicyMode as Wt, Item as X, WorkflowActivationPolicy as Xn, EngineExecutionLimitsPolicy as Xr, triggerNodeOutputType as Xt, InputPortKey as Y, AllWorkflowsActiveWorkflowActivationPolicy as Yn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Yr, runnableNodeOutputType as Yt, ItemBinary as Z, ConnectionInvocationAppendArgs as Zn, EngineExecutionLimitsPolicyConfig as Zr, triggerNodeSetupStateType as Zt, StepSequenceOutput as _, NodeActivationRequestBase as _n, RunCurrentState as _r, OutputPortKey as _t, WorkflowExecutableNodeClassifier as a, FixedRetryPolicySpec as ai, EngineDeps as an, NodeExecutionStatus as ar, NodeConfigBase as at, AnyCredentialType as b, NodeExecutionContext as bn, RunPruneCandidate as br, PersistedRunPolicySnapshot as bt, WorkflowBuilder as c, ExecutionBinaryService as cn, PersistedMutableNodeState as cr, NodeErrorHandler as ct, AnyRunnableNodeConfig as d, LiveWorkflowRepository as dn, PersistedRunState as dr, NodeId as dt, RunEventSubscription as ei, BinaryStorage as en, CurrentStateExecutionRequest as er, JsonObject as et, AnyTriggerNodeConfig as f, MultiInputNode as fn, PersistedWorkflowSnapshot as fr, NodeKind as ft, BranchStepsArg as g, NodeActivationRequest as gn, RunCompletionNotifier as gr, NodeSchedulerDecision as gt, BranchOutputGuard as h, NodeActivationReceipt as hn, PinnedNodeOutputsByPort as hr, NodeRef as ht, WorkflowExecutableNodeClassifierFactory as i, ExponentialRetryPolicySpec as ii, BinaryStorageWriteResult as in, NodeExecutionSnapshot as ir, NodeActivationId as it, CredentialMaterialSourceKind as j, TriggerRuntimeDiagnostics as jn, Container as jr, TriggerNodeSetupState as jt, CredentialInstanceRecord as k, TriggerCleanupHandle as kn, WorkflowExecutionPruneRepository as kr, TriggerNodeConfig as kt, ChainCursor as l, ExecutionContext as ln, PersistedMutableRunState as lr, NodeErrorHandlerArgs as lt, BranchMoreArgs as m, NodeActivationContinuation as mn, PersistedWorkflowTokenRegistryLike as mr, NodeOutputs as mt, WorkflowSnapshotCodec as n, RetryPolicy as ni, BinaryStorageStatResult as nn, ExecutionFrontierPlan as nr, JsonValue as nt, ConnectionNodeIdFactory as o, NoneRetryPolicySpec as oi, EngineHost as on, NodeInputsByPort as or, NodeConnectionName as ot, BooleanWhenOverloads as p, Node as pn, PersistedWorkflowSnapshotNode as pr, NodeOffloadPolicy as pt, Edge as q, WebhookTriggerResolution as qn, singleton as qr, branchRef as qt, DefaultWorkflowGraphFactory as r, NoRetryPolicy as ri, BinaryStorageWriteRequest as rn, NodeExecutionError as rr, MutableRunData as rt, ConnectionInvocationIdFactory as s, RetryPolicySpec as si, ExecutableTriggerNode as sn, PendingNodeExecution as sr, NodeDefinition as st, InMemoryLiveWorkflowRepository as t, ExpRetryPolicy as ti, BinaryStorageReadResult as tn, EngineRunCounters as tr, JsonPrimitive as tt, WhenBuilder as u, ExecutionContextFactory as un, PersistedRunControlState as ur, NodeErrorHandlerSpec as ut, ValidStepSequence as v, NodeActivationScheduler as vn, RunEventPublisherDeps as vr, PairedItemRef as vt, CredentialFieldSchema as w, NodeExecutionStatePublisher as wn, RunStatus as wr, RunId as wt, CredentialAuthDefinition as x, NodeExecutionRequest as xn, RunQueueEntry as xr, PersistedTokenId as xt, RunFinishedAtFactory as y, NodeBinaryAttachmentService as yn, RunExecutionOptions as yr, ParentExecutionRef as yt, CredentialTypeDefinition as z, WorkflowRunnerService as zn, delay as zr, WorkflowId as zt };
+//# sourceMappingURL=InMemoryLiveWorkflowRepository-DxoualoC.d.ts.map