@codemation/core 0.11.1 → 0.13.0

package/dist/{index-zWGtEhrf.d.ts → index-rllWL4r-.d.ts}

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 import { DependencyContainer as Container, DependencyContainer as DependencyContainer$1, Disposable, InjectionToken as InjectionToken$1, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container as container$1, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
-import { ZodType } from "zod";
+import { ZodType, z } from "zod";
 import { ReadableStream } from "node:stream/web";
 
 //#region src/contracts/baseTypes.d.ts
@@ -190,6 +190,19 @@ type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = Crede
   setupStatus: CredentialSetupStatus;
   createdAt: string;
   updatedAt: string;
+  /**
+   * Pointer to where the credential material bytes live. For OSS / standalone
+   * rows this is `{source: "local", ref: instanceId}` and the bytes co-locate
+   * with the row in the workspace DB. For managed-mode rows this is
+   * `{source: "control-plane", ref: <cp_id>}` and the bytes live at CP.
+   *
+   * The seam is read through `CredentialMaterialProvider`. See
+   * `docs/design/credentials-oauth-unification.md` ("Material provider seam").
+   */
+  material: Readonly<{
+    source: "local" | "control-plane";
+    ref: string;
+  }>;
 }>;
 /**
  * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
@@ -397,6 +410,16 @@ declare class CodemationTelemetryAttributeNames {
   static readonly mcpServerId = "mcp.server_id";
   /** MCP tool name on spans created for callTool invocations. */
   static readonly mcpToolName = "mcp.tool_name";
+  /** Terminal node-execution status (e.g. `"hitl-approved"`, `"hitl-rejected"`) on HITL outcome spans. */
+  static readonly nodeExecutionStatus = "codemation.node.execution_status";
+  /** Populated on run-halted spans; discriminates the halt reason (e.g. `"hitl-rejected"`). */
+  static readonly runHaltReason = "codemation.run.halt_reason";
+  /** Human task ID on `hitl.task.*` span events. */
+  static readonly hitlTaskId = "codemation.hitl.task_id";
+  /** HITL channel name (e.g. `"inbox"`, `"control-plane-inbox"`) on `hitl.task.*` span events. */
+  static readonly hitlChannel = "codemation.hitl.channel";
+  /** Decision outcome (e.g. `"approved"`, `"rejected"`) on `hitl.task.decided` span events. */
+  static readonly hitlDecisionStatus = "codemation.hitl.decision_status";
 }
 //#endregion
 //#region src/contracts/GenAiTelemetryAttributeNames.d.ts
@@ -573,6 +596,100 @@ interface WebhookTriggerMatcher {
 }
 //#endregion
 //#region src/contracts/runtimeTypes.d.ts
+/** Opaque unique identifier for a single HumanTask instance. */
+type HumanTaskId = string;
+/**
+ * Duration string — ISO 8601 duration ("PT24H") or shorthand ("24h").
+ * Parsed by the timeout job; stored as-is in the suspension record.
+ */
+type Duration = string;
+/**
+ * Minimal handle handed to the `deliver` callback so it can route to the correct
+ * inbox channel.
+ */
+interface HumanTaskHandle {
+  readonly taskId: HumanTaskId;
+  readonly runId: string;
+  readonly nodeId: string;
+  readonly expiresAt: Date;
+  /** TODO: real signed URL; placeholder empty string for now. */
+  readonly resumeUrl: string;
+  /**
+   * Arbitrary JSON metadata copied from `SuspensionRequest.request.metadata` at suspension time.
+   * Used by the agent runtime to round-trip the `agentCheckpoint` back to the
+   * resumed node via `ctx.resumeContext.task.metadata`.
+   */
+  readonly metadata?: Readonly<Record<string, JsonValue>>;
+}
+/** Human-readable description surface shown to the reviewer. */
+interface HumanTaskSubject {
+  readonly title: string;
+  readonly summary: string;
+  readonly attributes?: JsonValue;
+}
+/** Identity of the person who made a decision on the task. */
+interface HumanTaskActor {
+  readonly actorId: string;
+  readonly displayName?: string;
+}
+/**
+ * Resume context injected into `NodeExecutionContext` when the engine re-activates
+ * a previously suspended node. `defineHumanApprovalNode` wraps this with parsed
+ * `TDecision`; at the engine layer `decision.value` is `unknown`.
+ */
+interface ResumeContext {
+  readonly decision: Readonly<{
+    kind: "decided";
+    value: unknown;
+    actor: HumanTaskActor;
+    decidedAt: Date;
+  }> | Readonly<{
+    kind: "timed_out";
+    at: Date;
+  }> | Readonly<{
+    kind: "auto_accepted";
+    at: Date;
+  }>;
+  readonly delivery: JsonValue;
+  readonly task: HumanTaskHandle;
+}
+/**
+ * Thrown by a node's `execute()` to request durable suspension of the current item.
+ * The engine catches this, persists the suspension entry, calls `deliver`, and
+ * continues to the next item (per-item semantics).
+ *
+ * @example
+ * ```ts
+ * throw new SuspensionRequest({
+ *   decisionSchema: z.object({ approved: z.boolean() }),
+ *   timeout: "PT24H",
+ *   onTimeout: "halt",
+ *   subject: { title: "Approve invoice", summary: "Invoice #1234 needs approval" },
+ *   deliver: async (handle) => {
+ *     await notifySlack(handle);
+ *     return { channel: "slack", ts: "..." };
+ *   },
+ * });
+ * ```
+ */
+declare class SuspensionRequest<TDecision = unknown, TDelivery extends JsonValue = JsonValue> extends Error {
+  readonly request: Readonly<{
+    decisionSchema: ZodType<TDecision>;
+    timeout: Duration;
+    onTimeout: "halt" | "auto-accept";
+    subject: HumanTaskSubject;
+    metadata?: Readonly<Record<string, JsonValue>>;
+    deliver: (handle: HumanTaskHandle) => Promise<TDelivery>;
+  }>;
+  constructor(request: Readonly<{
+    decisionSchema: ZodType<TDecision>;
+    timeout: Duration;
+    onTimeout: "halt" | "auto-accept";
+    subject: HumanTaskSubject;
+    metadata?: Readonly<Record<string, JsonValue>>;
+    deliver: (handle: HumanTaskHandle) => Promise<TDelivery>;
+  }>);
+}
 interface WorkflowRunnerService {
   runById(args: {
     workflowId: WorkflowId;
@@ -668,12 +785,30 @@ interface NodeBinaryAttachmentService extends ExecutionBinaryService {
   attach(args: BinaryAttachmentCreateRequest): Promise<BinaryAttachment>;
   withAttachment<TJson>(item: Item<TJson>, name: string, attachment: BinaryAttachment): Item<TJson>;
 }
+/** Default maximum bytes read into memory by the bounded helpers (50 MiB). */
+declare const BINARY_DEFAULT_MAX_BYTES: number;
 interface ExecutionBinaryService {
   forNode(args: {
     nodeId: NodeId;
     activationId: NodeActivationId;
   }): NodeBinaryAttachmentService;
   openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
+  /**
+   * Reads all bytes from the attachment into a contiguous `Uint8Array`.
+   * Checks `attachment.size` against `maxBytes` *before* any allocation; throws a bounded-read
+   * error when exceeded (no OOM). Throws if the stream is unavailable or the byte count mismatches.
+   */
+  getBytes(attachment: BinaryAttachment, maxBytes?: number): Promise<Uint8Array>;
+  /**
+   * Reads the attachment and decodes the bytes as UTF-8 text.
+   * Subject to the same bounded-read safety as `getBytes`.
+   */
+  getText(attachment: BinaryAttachment, maxBytes?: number): Promise<string>;
+  /**
+   * Reads the attachment, decodes as UTF-8 text, and parses as JSON.
+   * Throws a clear error on invalid JSON. Subject to the same bounded-read safety.
+   */
+  getJson<T = unknown>(attachment: BinaryAttachment, maxBytes?: number): Promise<T>;
 }
 interface ExecutionContext {
   runId: RunId;
@@ -706,6 +841,14 @@ interface ExecutionContext {
    * Collections registered in the codemation config, keyed by collection name.
    */
   readonly collections?: CollectionsContext;
+  /**
+   * Resolve a DI token from the host container.
+   * Allows nodes to reach host-side services (e.g. `InboxChannelResolverToken`)
+   * without importing host code. Wired by `DefaultExecutionContextFactory`; throws
+   * a clear error when no resolver is configured (e.g. in unit tests that don't
+   * set up the full container).
+   */
+  resolve<T>(token: TypeToken<T>): T;
 }
 interface ExecutionContextFactory {
   create(args: {
@@ -729,6 +872,11 @@ interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase>
   config: TConfig;
   telemetry: NodeExecutionTelemetry;
   binary: NodeBinaryAttachmentService;
+  /**
+   * Present when this node activation is a HITL resume.
+   * The node checks `ctx.resumeContext !== undefined` and takes the resume branch.
+   */
+  resumeContext?: ResumeContext;
 }
 interface PollingTriggerHandle {
   /**
@@ -1635,7 +1783,7 @@ interface RunQueueEntry {
     received: Readonly<Record<InputPortKey, Items>>;
   }>;
 }
-type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
+type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped" | "hitl-approved" | "hitl-rejected" | "hitl-timeout" | "hitl-auto-accepted" | "hitl-cancelled";
 interface NodeExecutionError {
   message: string;
   name?: string;
@@ -1743,7 +1891,9 @@ interface ExecutionFrontierPlan {
   clearedNodeIds: ReadonlyArray<NodeId>;
   preservedPinnedNodeIds: ReadonlyArray<NodeId>;
 }
-type RunStatus = "running" | "pending" | "completed" | "failed";
+type RunStatus = "running" | "pending" | "completed" | "failed" | "suspended" | "halted";
+/** Reason a run transitioned to {@link RunStatus} `"halted"`. */
+type RunHaltReason = "hitl-rejected" | "hitl-timeout" | "hitl-cancelled";
 interface RunSummary {
   runId: RunId;
   workflowId: WorkflowId;
@@ -1777,6 +1927,35 @@ interface PersistedRunSchedulingState {
   pending?: PendingNodeExecution;
   queue: RunQueueEntry[];
 }
+/** One persisted suspension entry per suspended item. */
+interface PersistedSuspensionEntry {
+  /** Opaque task identifier (UUID v4). */
+  readonly taskId: string;
+  readonly nodeId: NodeId;
+  readonly activationId: NodeActivationId;
+  readonly itemIndex: number;
+  /** SHA-256 hex digest of the decision schema JSON (for schema-drift detection). */
+  readonly decisionSchemaHash: string;
+  /** Serialized return value from `SuspensionRequest.deliver` (stored on the HumanTask row). */
+  readonly deliveryRef: JsonValue;
+  /** ISO timestamp when the task expires. */
+  readonly timeoutAt: string;
+  readonly onTimeout: "halt" | "auto-accept";
+}
+/**
+ * When a node is re-activated after suspension, the engine writes the resume context here
+ * so `NodeExecutionRequestHandlerService` can splice `resumeContext` into ctx.
+ * Cleared once the re-activation is consumed.
+ */
+interface PendingResumeEntry {
+  readonly activationId: NodeActivationId;
+  readonly nodeId: NodeId;
+  /**
+   * Typed as `unknown` here to avoid a circular import between runTypes ↔ runtimeTypes.
+   * `NodeExecutionRequestHandlerService` casts this to `ResumeContext` from runtimeTypes.
+   */
+  readonly resumeContext: unknown;
+}
 interface PersistedRunState {
   runId: RunId;
   workflowId: WorkflowId;
@@ -1795,12 +1974,24 @@ interface PersistedRunState {
   /** Successful node completions so far (for activation budget). */
   engineCounters?: EngineRunCounters;
   status: RunStatus;
+  /** Populated when `status === "halted"` to discriminate why the run was halted. */
+  reason?: RunHaltReason;
   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>;
+  /**
+   * One entry per outstanding HITL suspension (per-item).
+   * Present and non-empty iff `status === "suspended"`.
+   */
+  suspension?: ReadonlyArray<PersistedSuspensionEntry>;
+  /**
+   * Written by `resumeRun()` so `NodeExecutionRequestHandlerService` can splice `resumeContext`
+   * into the ctx when re-executing the suspended node. Cleared once consumed.
+   */
+  pendingResume?: PendingResumeEntry;
 }
 interface WorkflowExecutionRepository {
   createRun(args: {
@@ -1860,6 +2051,12 @@ type RunResult = {
   error: {
     message: string;
   };
+} | {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "halted";
+  reason: RunHaltReason;
 };
 type WebhookRunResult = Readonly<{
   runId: RunId;
@@ -2367,6 +2564,244 @@ declare class RunFinishedAtFactory {
   static resolveIso(state: RunFinishedAtSource): string | undefined;
 }
 //#endregion
+//#region src/authoring/defineNode.types.d.ts
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+type ResolvableCredentialType = AnyCredentialType | CredentialTypeId;
+type SessionForCredentialType<TCredential extends ResolvableCredentialType> = TCredential extends AnyCredentialType ? Awaited<ReturnType<TCredential["createSession"]>> : unknown;
+type DefinedNodeCredentialBinding = ResolvableCredentialType | Readonly<{
+  readonly type: ResolvableCredentialType | ReadonlyArray<ResolvableCredentialType>;
+  readonly label?: string;
+  readonly optional?: true;
+  readonly helpText?: string;
+  readonly helpUrl?: string;
+}>;
+type DefinedNodeCredentialBindings = Readonly<Record<string, DefinedNodeCredentialBinding>>;
+type SessionForBinding<TBinding extends DefinedNodeCredentialBinding> = TBinding extends Readonly<{
+  type: infer TType;
+}> ? TType extends ReadonlyArray<infer TEntry> ? SessionForCredentialType<TEntry & ResolvableCredentialType> : SessionForCredentialType<TType & ResolvableCredentialType> : SessionForCredentialType<TBinding & ResolvableCredentialType>;
+type DefinedNodeCredentialAccessors<TBindings extends DefinedNodeCredentialBindings | undefined> = TBindings extends DefinedNodeCredentialBindings ? Readonly<{ [TKey in keyof TBindings]: () => Promise<SessionForBinding<TBindings[TKey]>> }> : Readonly<Record<string, never>>;
+interface DefinedNodeRunContext<TConfig extends CredentialJsonRecord, TBindings extends DefinedNodeCredentialBindings | undefined> {
+  readonly config: TConfig;
+  readonly credentials: DefinedNodeCredentialAccessors<TBindings>;
+  readonly execution: NodeExecutionContext<RunnableNodeConfig<TConfig, unknown>>;
+}
+/**
+ * Arguments for {@link defineNode} `execute` (engine `ctx` matches {@link RunnableNode.execute};
+ * the second callback parameter adds {@link DefinedNodeRunContext} for credential accessors).
+ */
+type DefineNodeExecuteArgs<TConfig extends CredentialJsonRecord, TInputJson$1> = Readonly<{
+  input: TInputJson$1;
+  item: Item;
+  itemIndex: number;
+  items: Items;
+  ctx: NodeExecutionContext<RunnableNodeConfig<TInputJson$1, unknown> & Readonly<{
+    config: TConfig;
+  }>>;
+}>;
+type DefinedNodeConfigInput<TConfigResolved extends CredentialJsonRecord, TItemJson> = ParamDeep<TConfigResolved, TItemJson>;
+interface DefinedNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, _TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  readonly kind: "defined-node";
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  create<TConfigItemJson = TInputJson$1>(config: DefinedNodeConfigInput<TConfig, TConfigItemJson>, name?: string, id?: string): RunnableNodeConfig<TInputJson$1, TOutputJson$1>;
+  register(context: {
+    registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
+  }): void;
+}
+/**
+ * Plugin / DSL-friendly node: per-item `execute` with optional {@link RunnableNodeConfig.inputSchema}.
+ */
+interface DefineNodeOptions<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  /**
+   * Canvas icon for this node (same contract as `NodeConfigBase.icon` on runnable configs).
+   * The Next host resolves Lucide (`lucide:…`), built-in SVGs (`builtin:…`), Simple Icons (`si:…`), and image URLs (`https:`, `data:`, `/…`).
+   */
+  readonly icon?: string;
+  /** Default values / form hints for **static** node configuration (credentials, retry, IDs), not per-item payload. */
+  readonly input?: Readonly<Record<keyof TConfig & string, unknown>>;
+  readonly configSchema?: z.ZodType<TConfig>;
+  readonly credentials?: TBindings;
+  /**
+   * Validates **`input`** (engine also accepts `inputSchema` on the node class).
+   */
+  readonly inputSchema?: ZodType<TInputJson$1>;
+  /** Preserve inbound `item.binary` when `execute` returns plain JSON or item-shaped results without `binary`. */
+  readonly keepBinaries?: boolean;
+  /**
+   * Static configuration summary surfaced in the workflow inspector — see
+   * {@link import("../contracts/workflowTypes").NodeConfigBase.inspectorSummary}.
+   *
+   * Receives the static config; returns 2–6 short label/value pairs (or `undefined` to skip).
+   */
+  readonly inspectorSummary?: (args: Readonly<{
+    config: TConfig;
+  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
+  execute(args: DefineNodeExecuteArgs<TConfig, TInputJson$1>, context: DefinedNodeRunContext<TConfig, TBindings>): MaybePromise<TOutputJson$1>;
+}
+/**
+ * Batch-oriented defined node: `run` receives all item JSON once (last item in activation); emits one output per input row.
+ */
+interface DefineBatchNodeOptions<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  readonly icon?: string;
+  readonly input?: Readonly<Record<keyof TConfig & string, unknown>>;
+  readonly configSchema?: z.ZodType<TConfig>;
+  readonly credentials?: TBindings;
+  readonly inspectorSummary?: (args: Readonly<{
+    config: TConfig;
+  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
+  run(items: ReadonlyArray<TInputJson$1>, context: DefinedNodeRunContext<TConfig, TBindings>): MaybePromise<ReadonlyArray<TOutputJson$1>>;
+}
+declare function defineNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineNodeOptions<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>): DefinedNode<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>;
+declare function defineBatchNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineBatchNodeOptions<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>): DefinedNode<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>;
+//#endregion
+//#region src/authoring/defineHumanApprovalNode.types.d.ts
+/**
+ * Decision shape merged into `item.json` after a HITL approval task resolves.
+ *
+ * - `"approved"` / `"rejected"` — from a human decision (uses `approvedPredicate`).
+ * - `"timed-out"` — timeout fired with `onTimeout: "halt"`.
+ * - `"auto-accepted"` — timeout fired with `onTimeout: "auto-accept"`.
+ */
+interface HumanApprovalDecisionResult {
+  readonly status: "approved" | "rejected" | "timed-out" | "auto-accepted";
+  /** Identity of the person who decided; absent for automated outcomes. */
+  readonly actor?: HumanTaskActor;
+  /** ISO 8601 timestamp of the decision. */
+  readonly decidedAt?: Date;
+  /** Optional free-text note from the reviewer. */
+  readonly note?: string;
+  /**
+   * Full raw decision payload (only present for `"approved"` / `"rejected"`).
+   * Shape is determined by the channel's `decisionSchema`.
+   */
+  readonly payload?: Record<string, unknown>;
+}
+/**
+ * Output item shape emitted by a `defineHumanApprovalNode`-based node.
+ * Original `item.json` fields are preserved and `decision` is merged in.
+ * If the input `item.json` already contained a `decision` key it is **overwritten**.
+ */
+type HumanApprovalOutputJson<TInputJson$1 extends Record<string, unknown>> = TInputJson$1 & {
+  readonly decision: HumanApprovalDecisionResult;
+};
+/**
+ * Extends {@link DefinedNode} with the `humanApprovalToolBehavior` metadata marker.
+ * Story 10 reads this field when attaching the node as an agent tool.
+ */
+interface DefinedHumanApprovalNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1 extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> extends DefinedNode<TKey$1, TConfig, TInputJson$1, HumanApprovalOutputJson<TInputJson$1>, TBindings> {
+  /**
+   * Behavior hint consumed by the agent runtime (story 10) when this node is attached as a tool.
+   * `"return"` (default) — return the rejection to the agent as a tool result.
+   * `"halt"` — halt the agent run on rejection.
+   *
+   * Standalone DSL usage ignores this field.
+   */
+  readonly humanApprovalToolBehavior: {
+    onRejected: "return" | "halt";
+  };
+}
+/**
+ * Returns `true` when `node` was created by {@link defineHumanApprovalNode}.
+ * Uses the `humanApprovalToolBehavior` typed field as the discriminant.
+ */
+declare function isHumanApprovalNode(node: unknown): node is DefinedHumanApprovalNode<string, Record<string, unknown>, Record<string, unknown>, undefined>;
+/**
+ * Authoring helper that compiles a HITL approval channel down to a regular
+ * {@link defineNode}-backed node with `SuspensionRequest` semantics.
+ *
+ * **Fast-forward decision semantics:**
+ * - On the first `execute` call (no `ctx.resumeContext`): throws a `SuspensionRequest`
+ *   that calls the author's `deliver`. The engine persists the suspension and continues.
+ * - On resume (`ctx.resumeContext` set): calls `onDecision`/`onTimeout` as appropriate,
+ *   merges a `decision` key into `item.json`, and returns an item with the original
+ *   `binary` map passed by reference (no copy).
+ *
+ * **Output shape per item:**
+ * ```ts
+ * // Input:  { json: { invoiceId: 42 }, binary?: {...} }
+ * // Output: { json: { invoiceId: 42, decision: { status: "approved", actor, decidedAt } }, binary: <unchanged> }
+ * ```
+ * If `item.json` already has a `decision` key it is **overwritten**. Namespace as
+ * needed if your schema reserves that key for another purpose.
+ *
+ * **Predicate persistence:**
+ * The `approvedPredicate` function is NOT serialized to the suspension record (except
+ * as an audit-only string via `toString()`). On resume, the workflow definition is
+ * reloaded from code at process start and the predicate closure is rebuilt naturally.
+ * If a deploy ships a changed predicate between suspend and resume, the *new* predicate
+ * runs — document this in your runbook when the predicate carries business logic that
+ * may change across deploys.
+ *
+ * @example
+ * ```ts
+ * export const slackApprovalNode = defineHumanApprovalNode({
+ *   key: "my-plugin.slackApproval",
+ *   title: "Slack Approval",
+ *   channel: "slack",
+ *   configSchema: z.object({ channel: z.string(), message: z.string() }),
+ *   decisionSchema: z.object({ approved: z.boolean(), note: z.string().optional() }),
+ *
+ *   async deliver({ task, config, item }, ctx) {
+ *     const ts = await postSlackMessage(config.channel, `Approve? <${task.resumeUrl}>`);
+ *     return { channel: config.channel, ts };
+ *   },
+ *
+ *   async onDecision({ decision, actor, delivery }, ctx) {
+ *     await updateSlackMessage(delivery.channel, delivery.ts, decision.approved ? "✅" : "❌");
+ *   },
+ * });
+ * ```
+ */
+declare function defineHumanApprovalNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1 extends Record<string, unknown>, TDecision extends Record<string, unknown>, TDelivery extends JsonValue, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(opts: {
+  key: TKey$1;
+  title: string;
+  description?: string;
+  icon?: string;
+  channel: string;
+  configSchema: ZodType<TConfig>;
+  inputSchema?: ZodType<TInputJson$1>;
+  decisionSchema: ZodType<TDecision>;
+  credentials?: TBindings;
+  /**
+   * Custom predicate that decides whether a decision counts as "approved".
+   * When omitted, the helper checks if `decisionSchema` is a Zod object with an
+   * `approved: boolean` field; if so it uses `decision.approved === true`.
+   * If neither holds, `defineHumanApprovalNode` throws at **definition time** (not runtime).
+   */
+  approvedPredicate?: (decision: TDecision) => boolean;
+  /** Default suspension timeout. Defaults to `"24h"`. */
+  defaultTimeout?: Duration;
+  /** What to do when the task times out. Defaults to `"halt"`. */
+  defaultOnTimeout?: "halt" | "auto-accept";
+  inspectorSummary?: (config: TConfig) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
+  deliver: (args: {
+    task: HumanTaskHandle;
+    config: TConfig;
+    input: TInputJson$1;
+    item: Item;
+  }, ctx: ExecutionContext) => Promise<TDelivery>;
+  onDecision?: (args: {
+    decision: TDecision;
+    actor: HumanTaskActor;
+    task: HumanTaskHandle;
+    delivery: TDelivery;
+    item: Item;
+  }, ctx: ExecutionContext) => Promise<void>;
+  onTimeout?: (args: {
+    task: HumanTaskHandle;
+    delivery: TDelivery;
+    item: Item;
+    policy: "halt" | "auto-accept";
+  }, ctx: ExecutionContext) => Promise<void>;
+}): DefinedHumanApprovalNode<TKey$1, TConfig, TInputJson$1, TBindings>;
+//#endregion
 //#region src/workflow/dsl/workflowBuilderTypes.d.ts
 type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
 type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
@@ -2412,6 +2847,25 @@ declare class ChainCursor<TCurrentJson> {
   thenIntoInputHints<TOutputJson$1, TConfig extends RunnableNodeConfig<any, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
   readonly when: ChainCursorWhenOverloads<TCurrentJson>;
   route<TNextJson$1>(branches: Readonly<Record<OutputPortKey, (branch: ChainCursor<TCurrentJson>) => ChainCursor<TNextJson$1> | undefined>>): ChainCursor<TNextJson$1>;
+  /**
+   * Chainable shorthand for `.then(node.create(config, metadata?.name, metadata?.nodeId))`.
+   *
+   * Signals to readers that this step suspends the run and waits for a human decision.
+   * Throws at workflow-build time if `node` was not created via `defineHumanApprovalNode`.
+   *
+   * @example
+   * ```ts
+   * workflow
+   *   .trigger(...)
+   *   .humanApproval(inboxApproval, { title: "Approve?", body: "...", priority: "normal" })
+   *   .then(nextStep.create(...))
+   *   .build();
+   * ```
+   */
+  humanApproval<TKey$1 extends string, TConfig extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(node: DefinedHumanApprovalNode<TKey$1, TConfig, TCurrentJson & Record<string, unknown>, TBindings>, config: TConfig, metadata?: {
+    name?: string;
+    nodeId?: string;
+  }): ChainCursor<HumanApprovalOutputJson<TCurrentJson & Record<string, unknown>>>;
   build(): WorkflowDefinition;
   private resolveSharedInputPortHint;
 }
@@ -2554,5 +3008,5 @@ declare class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
   create(def: WorkflowDefinition): WorkflowGraph;
 }
 //#endregion
-export { CostCatalogEntry as $, NodeId as $a, TelemetryChildSpanStart as $i, NodeInspectorSummaryRow as $n, ExecutionBinaryService as $r, WebhookRunResult as $t, isUnbrandedPortsEmissionShape as A, CredentialHealthTester as Aa, TriggerTestItemsContext as Ai, TestTriggerNodeConfig as An, WorkflowStoragePolicyMode as Ar, NodeInputsByPort as At, PersistedExecutionInstanceRecord as B, CredentialSessionService as Ba, WebhookInvocationMatch as Bi, JsonArray as Bn, FixedRetryPolicySpec as Br, PinnedNodeOutputsByPort as Bt, ExpRetryPolicy as C, CredentialAdvancedSectionPresentation as Ca, TestableTriggerNode as Ci, EngineExecutionLimitsPolicyConfig as Cn, WorkflowErrorHandlerSpec as Cr, ConnectionInvocationRecord as Ct, PortsEmission as D, CredentialFieldSchema as Da, TriggerSetupContext as Di, TestCaseRunStatus as Dn, WorkflowPolicyRuntimeDefaults as Dr, NodeExecutionError as Dt, getOriginIndexFromItem as E, CredentialBindingKey as Ea, TriggerRuntimeDiagnostics as Ei, RunEventSubscription as En, WorkflowNodeConnection as Er, ExecutionFrontierPlan as Et, ExecutionInstanceDto as F, CredentialOAuth2AuthDefinition as Fa, WorkflowSnapshotFactory as Fi, Edge as Fn, runnableNodeInputType as Fr, PersistedRunSchedulingState as Ft, RunRevision as G, CredentialTypeRegistry as Ga, WorkflowActivationPolicy as Gi, MutableRunData as Gn, BinaryStorage as Gr, RunPruneCandidate as Gt, PersistedRunWorkItemKind as H, CredentialType as Ha, WebhookTriggerResolution as Hi, JsonObject as Hn, RetryPolicySpec as Hr, RunCurrentState as Ht, ExecutionInstanceId as I, CredentialOAuth2ScopesFromPublicConfig as Ia, WorkflowSnapshotResolver as Ii, ExecutionMode as In, runnableNodeOutputType as Ir, PersistedRunState as It, WorkItemId as J, NoOpPollingTriggerLogger as Ja, NodeExecutionTelemetry as Ji, NodeDefinition as Jn, BinaryStorageWriteRequest as Jr, RunStateResetRequest as Jt, RunSlotProjectionState as K, CredentialUnboundError as Ka, ExecutionTelemetry as Ki, NodeActivationId as Kn, BinaryStorageReadResult as Kr, RunQueueEntry as Kt, ExecutionPayloadPolicyFields as L, CredentialRequirement as La, HttpMethod as Li, Item as Ln, triggerNodeOutputType as Lr, PersistedWorkflowSnapshot as Lt, McpServerTransport as M, CredentialInstanceRecord as Ma, WorkflowRepository as Mi, ActivationIdFactory as Mn, WorkflowStoragePolicySpec as Mr, PersistedMutableNodeState as Mt, BatchId as N, CredentialJsonRecord as Na, WorkflowRunnerResolver as Ni, BinaryAttachment as Nn, branchRef as Nr, PersistedMutableRunState as Nt, emitPorts as O, CredentialHealth as Oa, TriggerSetupStateFor as Oi, TestSuiteRunStatus as On, WorkflowPrunePolicySpec as Or, NodeExecutionSnapshot as Ot, ConnectionInvocationKind as P, CredentialMaterialSourceKind as Pa, WorkflowRunnerService as Pi, BinaryPreviewKind as Pn, nodeRef as Pr, PersistedRunControlState as Pt, CostCatalog as Q, NodeConnectionName as Qa, TelemetryAttributes as Qi, NodeIdRef as Qn, ExecutableTriggerNode as Qr, RunTestContext as Qt, PayloadStorageKind as R, CredentialSessionFactory as Ra, TriggerInstanceId as Ri, ItemBinary as Rn, triggerNodeSetupStateType as Rr, PersistedWorkflowSnapshotNode as Rt, NoOpCostTrackingTelemetry as S, AnyCredentialType as Sa, RunnableNodeExecuteArgs as Si, EngineExecutionLimitsPolicy as Sn, WorkflowErrorHandler as Sr, ConnectionInvocationId as St, NoRetryPolicy as T, CredentialBinding as Ta, TriggerNode as Ti, RunEventBus as Tn, WorkflowGraphFactory as Tr, EngineRunCounters as Tt, PersistedRunWorkItemRecord as U, CredentialTypeDefinition as Ua, WebhookTriggerRoutingDiagnostics as Ui, JsonPrimitive as Un, BinaryAttachmentCreateRequest as Ur, RunEventPublisherDeps as Ut, PersistedRunSlotProjectionRecord as V, CredentialSetupStatus as Va, WebhookTriggerMatcher as Vi, JsonNonArray as Vn, NoneRetryPolicySpec as Vr, RunCompletionNotifier as Vt, RunIterationDto as W, CredentialTypeId as Wa, AllWorkflowsActiveWorkflowActivationPolicy as Wi, JsonValue as Wn, BinaryBody as Wr, RunExecutionOptions as Wt, WorkflowDetailSelectionState as X, PollingTriggerDedupWindow as Xa, TelemetryArtifactReference as Xi, NodeErrorHandlerArgs as Xn, EngineDeps as Xr, RunStopCondition as Xt, WorkItemStatus as Y, PollingTriggerLogger as Ya, TelemetryArtifactAttachment as Yi, NodeErrorHandler as Yn, BinaryStorageWriteResult as Yr, RunStatus as Yt, WorkflowRunDetailDto as Z, InputPortKey as Za, TelemetryAttributePrimitive as Zi, NodeErrorHandlerSpec as Zn, EngineHost as Zr, RunSummary as Zt, BranchStepsArg as _, CostTrackingTelemetryFactory as _a, NodeResolver as _i, predicateAwareClassFactory as _n, TriggerNodeOutputJson as _r, AgentBindError as _t, ConnectionNodeIdFactory as a, CodemationTelemetryMetricNames as aa, NodeActivationContinuation as ai, Disposable as an, NodeSchedulerDecision as ar, ItemExprCallback as at, RunFinishedAtFactory as b, CollectionStore as ba, PreparedNodeActivationDispatch as bi, CoreTokens as bn, WorkflowDefinition as br, NeedsReconsentEvent as bt, WorkflowDefinitionError as c, NoOpExecutionTelemetryFactory as ca, NodeActivationRequestBase as ci, RegistrationOptions as cn, PersistedRunPolicySnapshot as cr, isItemExpr as ct, WhenBuilder as d, NoOpTelemetrySpanScope as da, NodeExecutionContext as di, delay as dn, RunId as dr, resolveItemExprsInUnknown as dt, TelemetryMetricRecord as ea, ExecutionContext as ei, WorkflowExecutionListingRepository as en, OutputPortKey as eo, NodeIterationId as er, Expr as et, AnyRunnableNodeConfig as f, NoOpTelemetryArtifactReference as fa, NodeExecutionRequest as fi, inject as fn, RunIdFactory as fr, AssertionResult as ft, BranchOutputGuard as g, CostTrackingTelemetryAttributeNames as ga, NodeExecutor as gi, instancePerContainerCachingFactory as gn, TriggerNodeConfig as gr, NoOpAgentMcpIntegration as gt, BranchMoreArgs as h, CostTrackingTelemetry as ha, NodeExecutionStatePublisher as hi, instanceCachingFactory as hn, RunnableNodeOutputJson as hr, deriveAssertionPassed as ht, NodeIterationIdFactory as i, TelemetrySpanScope as ia, MultiInputNode as ii, DependencyContainer$1 as in, NodeRef as ir, ItemExprArgs as it, McpServerDeclaration as j, CredentialInstanceId as ja, WorkflowNodeInstanceFactory as ji, TestTriggerSetupContext as jn, WorkflowStoragePolicyResolver as jr, PendingNodeExecution as jt, isPortsEmission as k, CredentialHealthStatus as ka, TriggerSetupStateRepository as ki, TestSuiteRunId as kn, WorkflowStoragePolicyDecisionArgs as kr, NodeExecutionStatus as kt, WorkflowBuilder as l, NoOpExecutionTelemetry as la, NodeActivationScheduler as li, TypeToken as ln, RunDataFactory as lr, itemExpr as lt, BooleanWhenOverloads as m, CostTrackingPriceQuote as ma, NodeExecutionScheduler as mi, injectable as mn, RunnableNodeInputJson as mr, DEFAULT_ASSERTION_PASS_THRESHOLD as mt, WorkflowExecutableNodeClassifierFactory as n, TelemetrySpanEnd as na, ItemNode as ni, WorkflowExecutionRepository as nn, WorkflowId as no, NodeOffloadPolicy as nr, ParamDeep as nt, ConnectionInvocationIdFactory as o, GenAiTelemetryAttributeNames as oa, NodeActivationReceipt as oi, InjectionToken$1 as on, PairedItemRef as or, ItemExprContext as ot, AnyTriggerNodeConfig as p, CostTrackingComponent as pa, NodeExecutionRequestHandler as pi, injectAll as pn, RunnableNodeConfig as pr, AssertionResultProvenance as pt, SlotExecutionStateDto as q, OAuth2ProviderFromPublicConfig as qa, ExecutionTelemetryFactory as qi, NodeConfigBase as qn, BinaryStorageStatResult as qr, RunResult as qt, WorkflowExecutableNodeClassifier as r, TelemetrySpanEventRecord as ra, LiveWorkflowRepository as ri, Container as rn, NodeOutputs as rr, ItemExpr as rt, NodeIdSlugifier as s, CodemationTelemetryAttributeNames as sa, NodeActivationRequest as si, Lifecycle as sn, ParentExecutionRef as sr, ItemExprResolvedContext as st, DefaultWorkflowGraphFactory as t, TelemetryScope as ta, ExecutionContextFactory as ti, WorkflowExecutionPruneRepository as tn, PersistedTokenId as to, NodeKind as tr, Param as tt, ChainCursor as u, NoOpNodeExecutionTelemetry as ua, NodeBinaryAttachmentService as ui, container$1 as un, RunDataSnapshot as ur, resolveItemExprsForExecution as ut, StepSequenceOutput as v, CostTrackingTelemetryMetricNames as va, PersistedTriggerSetupState as vi, registry as vn, TriggerNodeSetupState as vr, AgentMcpIntegration as vt, RetryPolicy as w, CredentialAuthDefinition as wa, TriggerCleanupHandle as wi, RunEvent as wn, WorkflowGraph as wr, CurrentStateExecutionRequest as wt, NoOpCostTrackingTelemetryFactory as x, CollectionsContext as xa, RunnableNode as xi, ENGINE_EXECUTION_LIMITS_DEFAULTS as xn, WorkflowErrorContext as xr, ConnectionInvocationAppendArgs as xt, ValidStepSequence as y, CostTrackingUsageRecord as ya, PollingTriggerHandle as yi, singleton as yn, UpstreamRefPlaceholder as yr, AgentMcpToolMap as yt, PersistedExecutionInstanceKind as z, CredentialSessionFactoryArgs as za, WebhookControlSignal as zi, Items as zn, ExponentialRetryPolicySpec as zr, PersistedWorkflowTokenRegistryLike as zt };
-//# sourceMappingURL=index-zWGtEhrf.d.ts.map
+export { ExecutionPayloadPolicyFields as $, CredentialBindingKey as $a, TriggerRuntimeDiagnostics as $i, BinaryPreviewKind as $n, nodeRef as $r, PersistedRunState as $t, DefinedNodeCredentialAccessors as A, TelemetrySpanEventRecord as Aa, NodeActivationContinuation as Ai, delay as An, RunId as Ar, DEFAULT_ASSERTION_PASS_THRESHOLD as At, RetryPolicy as B, CostTrackingComponent as Ba, NodeExecutionStatePublisher as Bi, ENGINE_EXECUTION_LIMITS_DEFAULTS as Bn, WorkflowErrorContext as Br, CurrentStateExecutionRequest as Bt, defineHumanApprovalNode as C, TelemetryArtifactReference as Ca, HumanTaskActor as Ci, DependencyContainer$1 as Cn, PollingTriggerDedupWindow as Co, NodeRef as Cr, ItemExprResolvedContext as Ct, DefineNodeOptions as D, TelemetryMetricRecord as Da, ItemNode as Di, RegistrationOptions as Dn, OutputPortKey as Do, PersistedRunPolicySnapshot as Dr, resolveItemExprsInUnknown as Dt, DefineNodeExecuteArgs as E, TelemetryChildSpanStart as Ea, HumanTaskSubject as Ei, Lifecycle as En, NodeId as Eo, ParentExecutionRef as Er, resolveItemExprsForExecution as Et, defineNode as F, NoOpExecutionTelemetryFactory as Fa, NodeBinaryAttachmentService as Fi, instancePerContainerCachingFactory as Fn, TriggerNodeConfig as Fr, AgentMcpToolMap as Ft, isPortsEmission as G, CostTrackingTelemetryMetricNames as Ga, PreparedNodeActivationDispatch as Gi, RunEventSubscription as Gn, WorkflowNodeConnection as Gr, NodeExecutionStatus as Gt, getOriginIndexFromItem as H, CostTrackingTelemetry as Ha, NodeResolver as Hi, EngineExecutionLimitsPolicyConfig as Hn, WorkflowErrorHandlerSpec as Hr, ExecutionFrontierPlan as Ht, RunFinishedAtFactory as I, NoOpExecutionTelemetry as Ia, NodeExecutionContext as Ii, predicateAwareClassFactory as In, TriggerNodeOutputJson as Ir, NeedsReconsentEvent as It, McpServerTransport as J, CollectionsContext as Ja, RunnableNodeExecuteArgs as Ji, TestSuiteRunId as Jn, WorkflowStoragePolicyDecisionArgs as Jr, PendingResumeEntry as Jt, isUnbrandedPortsEmissionShape as K, CostTrackingUsageRecord as Ka, ResumeContext as Ki, TestCaseRunStatus as Kn, WorkflowPolicyRuntimeDefaults as Kr, NodeInputsByPort as Kt, NoOpCostTrackingTelemetryFactory as L, NoOpNodeExecutionTelemetry as La, NodeExecutionRequest as Li, registry as Ln, TriggerNodeSetupState as Lr, ConnectionInvocationAppendArgs as Lt, DefinedNodeCredentialBindings as M, CodemationTelemetryMetricNames as Ma, NodeActivationRequest as Mi, injectAll as Mn, RunnableNodeConfig as Mr, NoOpAgentMcpIntegration as Mt, DefinedNodeRunContext as N, GenAiTelemetryAttributeNames as Na, NodeActivationRequestBase as Ni, injectable as Nn, RunnableNodeInputJson as Nr, AgentBindError as Nt, DefinedNode as O, TelemetryScope as Oa, LiveWorkflowRepository as Oi, TypeToken as On, PersistedTokenId as Oo, RunDataFactory as Or, AssertionResult as Ot, defineBatchNode as P, CodemationTelemetryAttributeNames as Pa, NodeActivationScheduler as Pi, instanceCachingFactory as Pn, RunnableNodeOutputJson as Pr, AgentMcpIntegration as Pt, ExecutionInstanceId as Q, CredentialBinding as Qa, TriggerNode as Qi, BinaryAttachment as Qn, branchRef as Qr, PersistedRunSchedulingState as Qt, NoOpCostTrackingTelemetry as R, NoOpTelemetrySpanScope as Ra, NodeExecutionRequestHandler as Ri, singleton as Rn, UpstreamRefPlaceholder as Rr, ConnectionInvocationId as Rt, HumanApprovalOutputJson as S, TelemetryArtifactAttachment as Sa, ExecutionContextFactory as Si, Container as Sn, PollingTriggerLogger as So, NodeOutputs as Sr, ItemExprContext as St, DefineBatchNodeOptions as T, TelemetryAttributes as Ta, HumanTaskId as Ti, InjectionToken$1 as Tn, NodeConnectionName as To, PairedItemRef as Tr, itemExpr as Tt, PortsEmission as U, CostTrackingTelemetryAttributeNames as Ua, PersistedTriggerSetupState as Ui, RunEvent as Un, WorkflowGraph as Ur, NodeExecutionError as Ut, NoRetryPolicy as V, CostTrackingPriceQuote as Va, NodeExecutor as Vi, EngineExecutionLimitsPolicy as Vn, WorkflowErrorHandler as Vr, EngineRunCounters as Vt, emitPorts as W, CostTrackingTelemetryFactory as Wa, PollingTriggerHandle as Wi, RunEventBus as Wn, WorkflowGraphFactory as Wr, NodeExecutionSnapshot as Wt, ConnectionInvocationKind as X, CredentialAdvancedSectionPresentation as Xa, TestableTriggerNode as Xi, TestTriggerSetupContext as Xn, WorkflowStoragePolicyResolver as Xr, PersistedMutableRunState as Xt, BatchId as Y, AnyCredentialType as Ya, SuspensionRequest as Yi, TestTriggerNodeConfig as Yn, WorkflowStoragePolicyMode as Yr, PersistedMutableNodeState as Yt, ExecutionInstanceDto as Z, CredentialAuthDefinition as Za, TriggerCleanupHandle as Zi, ActivationIdFactory as Zn, WorkflowStoragePolicySpec as Zr, PersistedRunControlState as Zt, BranchStepsArg as _, AllWorkflowsActiveWorkflowActivationPolicy as _a, EngineDeps as _i, RunTestContext as _n, CredentialTypeId as _o, NodeIdRef as _r, Param as _t, ConnectionNodeIdFactory as a, WorkflowRepository as aa, FixedRetryPolicySpec as ai, RunCompletionNotifier as an, CredentialInstanceRecord as ao, JsonArray as ar, PersistedRunWorkItemRecord as at, DefinedHumanApprovalNode as b, ExecutionTelemetryFactory as ba, ExecutionBinaryService as bi, WorkflowExecutionPruneRepository as bn, OAuth2ProviderFromPublicConfig as bo, NodeKind as br, ItemExprArgs as bt, WorkflowDefinitionError as c, WorkflowSnapshotFactory as ca, BINARY_DEFAULT_MAX_BYTES as ci, RunExecutionOptions as cn, CredentialOAuth2AuthDefinition as co, JsonPrimitive as cr, RunSlotProjectionState as ct, WhenBuilder as d, TriggerInstanceId as da, BinaryStorage as di, RunQueueEntry as dn, CredentialSessionFactory as do, NodeActivationId as dr, WorkItemStatus as dt, TriggerSetupContext as ea, runnableNodeInputType as ei, PersistedSuspensionEntry as en, CredentialFieldSchema as eo, Edge as er, PayloadStorageKind as et, AnyRunnableNodeConfig as f, WebhookControlSignal as fa, BinaryStorageReadResult as fi, RunResult as fn, CredentialSessionFactoryArgs as fo, NodeConfigBase as fr, WorkflowDetailSelectionState as ft, BranchOutputGuard as g, WebhookTriggerRoutingDiagnostics as ga, Duration as gi, RunSummary as gn, CredentialTypeDefinition as go, NodeErrorHandlerSpec as gr, Expr as gt, BranchMoreArgs as h, WebhookTriggerResolution as ha, BinaryStorageWriteResult as hi, RunStopCondition as hn, CredentialType as ho, NodeErrorHandlerArgs as hr, CostCatalogEntry as ht, NodeIterationIdFactory as i, WorkflowNodeInstanceFactory as ia, ExponentialRetryPolicySpec as ii, PinnedNodeOutputsByPort as in, CredentialInstanceId as io, Items as ir, PersistedRunWorkItemKind as it, DefinedNodeCredentialBinding as j, TelemetrySpanScope as ja, NodeActivationReceipt as ji, inject as jn, RunIdFactory as jr, deriveAssertionPassed as jt, DefinedNodeConfigInput as k, TelemetrySpanEnd as ka, MultiInputNode as ki, container$1 as kn, WorkflowId as ko, RunDataSnapshot as kr, AssertionResultProvenance as kt, WorkflowBuilder as l, WorkflowSnapshotResolver as la, BinaryAttachmentCreateRequest as li, RunHaltReason as ln, CredentialOAuth2ScopesFromPublicConfig as lo, JsonValue as lr, SlotExecutionStateDto as lt, BooleanWhenOverloads as m, WebhookTriggerMatcher as ma, BinaryStorageWriteRequest as mi, RunStatus as mn, CredentialSetupStatus as mo, NodeErrorHandler as mr, CostCatalog as mt, WorkflowExecutableNodeClassifierFactory as n, TriggerSetupStateRepository as na, triggerNodeOutputType as ni, PersistedWorkflowSnapshotNode as nn, CredentialHealthStatus as no, Item as nr, PersistedExecutionInstanceRecord as nt, ConnectionInvocationIdFactory as o, WorkflowRunnerResolver as oa, NoneRetryPolicySpec as oi, RunCurrentState as on, CredentialJsonRecord as oo, JsonNonArray as or, RunIterationDto as ot, AnyTriggerNodeConfig as p, WebhookInvocationMatch as pa, BinaryStorageStatResult as pi, RunStateResetRequest as pn, CredentialSessionService as po, NodeDefinition as pr, WorkflowRunDetailDto as pt, McpServerDeclaration as q, CollectionStore as qa, RunnableNode as qi, TestSuiteRunStatus as qn, WorkflowPrunePolicySpec as qr, PendingNodeExecution as qt, WorkflowExecutableNodeClassifier as r, TriggerTestItemsContext as ra, triggerNodeSetupStateType as ri, PersistedWorkflowTokenRegistryLike as rn, CredentialHealthTester as ro, ItemBinary as rr, PersistedRunSlotProjectionRecord as rt, NodeIdSlugifier as s, WorkflowRunnerService as sa, RetryPolicySpec as si, RunEventPublisherDeps as sn, CredentialMaterialSourceKind as so, JsonObject as sr, RunRevision as st, DefaultWorkflowGraphFactory as t, TriggerSetupStateFor as ta, runnableNodeOutputType as ti, PersistedWorkflowSnapshot as tn, CredentialHealth as to, ExecutionMode as tr, PersistedExecutionInstanceKind as tt, ChainCursor as u, HttpMethod as ua, BinaryBody as ui, RunPruneCandidate as un, CredentialRequirement as uo, MutableRunData as ur, WorkItemId as ut, StepSequenceOutput as v, WorkflowActivationPolicy as va, EngineHost as vi, WebhookRunResult as vn, CredentialTypeRegistry as vo, NodeInspectorSummaryRow as vr, ParamDeep as vt, isHumanApprovalNode as w, TelemetryAttributePrimitive as wa, HumanTaskHandle as wi, Disposable as wn, InputPortKey as wo, NodeSchedulerDecision as wr, isItemExpr as wt, HumanApprovalDecisionResult as x, NodeExecutionTelemetry as xa, ExecutionContext as xi, WorkflowExecutionRepository as xn, NoOpPollingTriggerLogger as xo, NodeOffloadPolicy as xr, ItemExprCallback as xt, ValidStepSequence as y, ExecutionTelemetry as ya, ExecutableTriggerNode as yi, WorkflowExecutionListingRepository as yn, CredentialUnboundError as yo, NodeIterationId as yr, ItemExpr as yt, ExpRetryPolicy as z, NoOpTelemetryArtifactReference as za, NodeExecutionScheduler as zi, CoreTokens as zn, WorkflowDefinition as zr, ConnectionInvocationRecord as zt };
+//# sourceMappingURL=index-rllWL4r-.d.ts.map