@codemation/core 0.11.0 → 0.12.0

package/dist/{RunIntentService-BrEq6Jm6.d.ts → index-CSKKuK60.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;
@@ -706,6 +823,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 +854,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 +1765,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 +1873,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 +1909,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 +1956,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 +2033,12 @@ type RunResult = {
   error: {
     message: string;
   };
+} | {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "halted";
+  reason: RunHaltReason;
 };
 type WebhookRunResult = Readonly<{
   runId: RunId;
@@ -2367,6 +2546,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 +2829,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,286 +2990,5 @@ declare class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
   create(def: WorkflowDefinition): WorkflowGraph;
 }
 //#endregion
-//#region src/orchestration/Engine.d.ts
-interface EngineTriggerRuntime {
-  startTriggers(): Promise<void>;
-  stop(): Promise<void>;
-  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
-  createTriggerTestItems(args: {
-    workflow: WorkflowDefinition;
-    nodeId: NodeId;
-  }): Promise<Items | undefined>;
-}
-interface EngineRunStartService {
-  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
-    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
-    mutableState?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"];
-  }>): Promise<RunResult>;
-  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
-}
-interface EngineRunContinuationService {
-  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>;
-  resumeFromStepResult(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    outputs: NodeOutputs;
-  }): Promise<RunResult>;
-  resumeFromStepError(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    error: Error;
-  }): Promise<RunResult>;
-  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
-    status: "completed" | "failed";
-  }>>;
-  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
-}
-interface EngineNodeExecutionRequestHandler {
-  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
-}
-interface EngineFacadeDeps {
-  liveWorkflowRepository: LiveWorkflowRepository;
-  tokenRegistry: PersistedWorkflowTokenRegistryLike;
-  webhookTriggerMatcher: WebhookTriggerMatcher;
-  workflowSnapshotResolver: WorkflowSnapshotResolver;
-  triggerRuntime: EngineTriggerRuntime;
-  runStartService: EngineRunStartService;
-  runContinuationService: EngineRunContinuationService;
-  nodeExecutionRequestHandler: EngineNodeExecutionRequestHandler;
-}
-/**
- * Runtime facade for orchestration, continuation, triggers, and webhook routing.
- * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
- * The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
- */
-declare class Engine implements NodeActivationContinuation, NodeExecutionRequestHandler {
-  private readonly deps;
-  constructor(deps: EngineFacadeDeps);
-  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
-  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
-  resolveWorkflowSnapshot(args: {
-    workflowId: WorkflowId;
-    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
-  }): WorkflowDefinition | undefined;
-  startTriggers(): Promise<void>;
-  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
-  start(workflows: WorkflowDefinition[]): Promise<void>;
-  stop(): Promise<void>;
-  resolveWebhookTrigger(args: {
-    endpointPath: string;
-    method: HttpMethod;
-  }): WebhookTriggerResolution;
-  createTriggerTestItems(args: {
-    workflow: WorkflowDefinition;
-    nodeId: NodeId;
-  }): Promise<Items | undefined>;
-  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
-    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
-    mutableState?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"];
-  }>): Promise<RunResult>;
-  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
-  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>;
-  resumeFromStepResult(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    outputs: NodeOutputs;
-  }): Promise<RunResult>;
-  resumeFromStepError(args: {
-    runId: RunId;
-    activationId: NodeActivationId;
-    nodeId: NodeId;
-    error: Error;
-  }): Promise<RunResult>;
-  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
-    status: "completed" | "failed";
-  }>>;
-  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
-  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
-}
-//#endregion
-//#region src/policies/storage/WorkflowStoragePolicyEvaluator.d.ts
-declare class WorkflowStoragePolicyEvaluator {
-  private readonly nodeResolver;
-  constructor(nodeResolver: NodeResolver);
-  shouldPersist(workflow: WorkflowDefinition, snapshot: PersistedRunPolicySnapshot | undefined, args: WorkflowStoragePolicyDecisionArgs): Promise<boolean>;
-  private modeMatches;
-}
-//#endregion
-//#region src/policies/storage/RunTerminalPersistenceCoordinator.d.ts
-declare class RunTerminalPersistenceCoordinator {
-  private readonly runRepository;
-  private readonly storageEvaluator;
-  constructor(runRepository: WorkflowExecutionRepository, storageEvaluator: WorkflowStoragePolicyEvaluator);
-  maybeDeleteAfterTerminalState(args: {
-    workflow: WorkflowDefinition;
-    state: PersistedRunState;
-    finalStatus: "completed" | "failed";
-    finishedAt: string;
-  }): Promise<void>;
-}
-//#endregion
-//#region src/policies/WorkflowPolicyErrorServices.d.ts
-declare class WorkflowPolicyErrorServices {
-  private readonly nodeResolver;
-  constructor(nodeResolver: NodeResolver);
-  resolveNodeErrorHandler(spec: NodeErrorHandlerSpec | undefined): NodeErrorHandler | undefined;
-  resolveWorkflowErrorHandler(spec: WorkflowErrorHandlerSpec | undefined): WorkflowErrorHandler | undefined;
-}
-//#endregion
-//#region src/policies/executionLimits/EngineExecutionLimitsPolicyFactory.d.ts
-/**
- * Builds {@link EngineExecutionLimitsPolicy} by merging {@link ENGINE_EXECUTION_LIMITS_DEFAULTS} with optional `overrides` (e.g. host `runtime.engineExecutionLimits`).
- */
-declare class EngineExecutionLimitsPolicyFactory {
-  create(overrides?: Partial<EngineExecutionLimitsPolicyConfig>): EngineExecutionLimitsPolicy;
-}
-//#endregion
-//#region src/policies/storage/RunPolicySnapshotFactory.d.ts
-declare class RunPolicySnapshotFactory {
-  static create(workflow: WorkflowDefinition, defaults?: WorkflowPolicyRuntimeDefaults): PersistedRunPolicySnapshot;
-}
-//#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;
-  /**
-   * Safely call `config.inspectorSummary()` and return a plain JSON-safe array, or undefined.
-   * Returns undefined if the method is absent, throws, or produces no valid rows.
-   */
-  private safeInspectorSummary;
-  private injectTokenIds;
-  private mergeValue;
-  private mergeNestedValue;
-  private restoreNonSerializableProperties;
-  private restoreTypeProperty;
-  private resolveTokenId;
-  private resolveTokenName;
-  private asTypeToken;
-  private asRecord;
-}
-//#endregion
-//#region src/runtime/EngineWorkflowRunnerService.d.ts
-declare class EngineWorkflowRunnerService {
-  private readonly engine;
-  private readonly workflowRepository;
-  constructor(engine: Engine, workflowRepository: WorkflowRepository);
-  runById(args: {
-    workflowId: WorkflowId;
-    startAt?: NodeId;
-    items: Items;
-    parent?: ParentExecutionRef;
-  }): Promise<RunResult>;
-  private findDefaultStartNodeId;
-}
-//#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
-//#region src/runtime/RunIntentService.d.ts
-type StartWorkflowIntent = {
-  workflow: WorkflowDefinition;
-  startAt?: string;
-  items: Items;
-  synthesizeTriggerItems?: boolean;
-  parent?: CurrentStateExecutionRequest["parent"];
-  executionOptions?: RunExecutionOptions;
-  workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
-  mutableState?: CurrentStateExecutionRequest["mutableState"];
-  currentState?: RunCurrentState;
-  stopCondition?: RunStopCondition;
-  reset?: CurrentStateExecutionRequest["reset"];
-};
-type RerunFromNodeIntent = {
-  workflow: WorkflowDefinition;
-  nodeId: NodeId;
-  currentState: RunCurrentState;
-  items?: Items;
-  synthesizeTriggerItems?: boolean;
-  parent?: CurrentStateExecutionRequest["parent"];
-  executionOptions?: RunExecutionOptions;
-  workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
-  mutableState?: CurrentStateExecutionRequest["mutableState"];
-};
-type MatchedWebhookRunIntent = {
-  endpointPath: string;
-  method: HttpMethod;
-  requestItem: Items[number];
-};
-type WebhookMatchRunIntent = {
-  match: WebhookInvocationMatch;
-  requestItem: Items[number];
-};
-declare class RunIntentService {
-  private readonly engine;
-  private readonly workflowRepository;
-  constructor(engine: Engine, workflowRepository: WorkflowRepository);
-  startWorkflow(args: StartWorkflowIntent): Promise<RunResult>;
-  rerunFromNode(args: RerunFromNodeIntent): Promise<RunResult>;
-  private resolveStartWorkflowItems;
-  private resolveRerunItems;
-  private resolveStartWorkflowTriggerNodeId;
-  private resolveRerunTriggerNodeId;
-  private firstTriggerNodeId;
-  private isTriggerNode;
-  private hasNonEmptyItems;
-  resolveWebhookTrigger(args: {
-    endpointPath: string;
-    method: HttpMethod;
-  }): WebhookTriggerResolution;
-  runMatchedWebhook(args: MatchedWebhookRunIntent): Promise<WebhookRunResult>;
-  runWebhookMatch(args: WebhookMatchRunIntent): Promise<WebhookRunResult>;
-  /**
-   * Webhook-triggered runs always force inline execution first.
-   * This is the highest-precedence scheduler override: it wins over node hints and container defaults.
-   */
-  private createWebhookExecutionOptions;
-}
-//#endregion
-export { PersistedRunWorkItemRecord as $, CredentialTypeDefinition as $a, WebhookTriggerRoutingDiagnostics as $i, JsonPrimitive as $n, BinaryAttachmentCreateRequest as $r, RunEventPublisherDeps as $t, RunFinishedAtFactory as A, CollectionStore as Aa, PreparedNodeActivationDispatch as Ai, CoreTokens as An, WorkflowDefinition as Ar, NeedsReconsentEvent as At, isUnbrandedPortsEmissionShape as B, CredentialHealthTester as Ba, TriggerTestItemsContext as Bi, TestTriggerNodeConfig as Bn, WorkflowStoragePolicyMode as Br, NodeInputsByPort as Bt, AnyTriggerNodeConfig as C, CostTrackingComponent as Ca, NodeExecutionRequestHandler as Ci, injectAll as Cn, RunnableNodeConfig as Cr, AssertionResultProvenance as Ct, BranchStepsArg as D, CostTrackingTelemetryFactory as Da, NodeResolver as Di, predicateAwareClassFactory as Dn, TriggerNodeOutputJson as Dr, AgentBindError as Dt, BranchOutputGuard as E, CostTrackingTelemetryAttributeNames as Ea, NodeExecutor as Ei, instancePerContainerCachingFactory as En, TriggerNodeConfig as Er, NoOpAgentMcpIntegration as Et, NoRetryPolicy as F, CredentialBinding as Fa, TriggerNode as Fi, RunEventBus as Fn, WorkflowGraphFactory as Fr, EngineRunCounters as Ft, ExecutionInstanceDto as G, CredentialOAuth2AuthDefinition as Ga, WorkflowSnapshotFactory as Gi, Edge as Gn, runnableNodeInputType as Gr, PersistedRunSchedulingState as Gt, McpServerTransport as H, CredentialInstanceRecord as Ha, WorkflowRepository as Hi, ActivationIdFactory as Hn, WorkflowStoragePolicySpec as Hr, PersistedMutableNodeState as Ht, getOriginIndexFromItem as I, CredentialBindingKey as Ia, TriggerRuntimeDiagnostics as Ii, RunEventSubscription as In, WorkflowNodeConnection as Ir, ExecutionFrontierPlan as It, PayloadStorageKind as J, CredentialSessionFactory as Ja, TriggerInstanceId as Ji, ItemBinary as Jn, triggerNodeSetupStateType as Jr, PersistedWorkflowSnapshotNode as Jt, ExecutionInstanceId as K, CredentialOAuth2ScopesFromPublicConfig as Ka, WorkflowSnapshotResolver as Ki, ExecutionMode as Kn, runnableNodeOutputType as Kr, PersistedRunState as Kt, PortsEmission as L, CredentialFieldSchema as La, TriggerSetupContext as Li, TestCaseRunStatus as Ln, WorkflowPolicyRuntimeDefaults as Lr, NodeExecutionError as Lt, NoOpCostTrackingTelemetry as M, AnyCredentialType as Ma, RunnableNodeExecuteArgs as Mi, EngineExecutionLimitsPolicy as Mn, WorkflowErrorHandler as Mr, ConnectionInvocationId as Mt, ExpRetryPolicy as N, CredentialAdvancedSectionPresentation as Na, TestableTriggerNode as Ni, EngineExecutionLimitsPolicyConfig as Nn, WorkflowErrorHandlerSpec as Nr, ConnectionInvocationRecord as Nt, StepSequenceOutput as O, CostTrackingTelemetryMetricNames as Oa, PersistedTriggerSetupState as Oi, registry as On, TriggerNodeSetupState as Or, AgentMcpIntegration as Ot, RetryPolicy as P, CredentialAuthDefinition as Pa, TriggerCleanupHandle as Pi, RunEvent as Pn, WorkflowGraph as Pr, CurrentStateExecutionRequest as Pt, PersistedRunWorkItemKind as Q, CredentialType as Qa, WebhookTriggerResolution as Qi, JsonObject as Qn, RetryPolicySpec as Qr, RunCurrentState as Qt, emitPorts as R, CredentialHealth as Ra, TriggerSetupStateFor as Ri, TestSuiteRunStatus as Rn, WorkflowPrunePolicySpec as Rr, NodeExecutionSnapshot as Rt, AnyRunnableNodeConfig as S, NoOpTelemetryArtifactReference as Sa, NodeExecutionRequest as Si, inject as Sn, RunIdFactory as Sr, AssertionResult as St, BranchMoreArgs as T, CostTrackingTelemetry as Ta, NodeExecutionStatePublisher as Ti, instanceCachingFactory as Tn, RunnableNodeOutputJson as Tr, deriveAssertionPassed as Tt, BatchId as U, CredentialJsonRecord as Ua, WorkflowRunnerResolver as Ui, BinaryAttachment as Un, branchRef as Ur, PersistedMutableRunState as Ut, McpServerDeclaration as V, CredentialInstanceId as Va, WorkflowNodeInstanceFactory as Vi, TestTriggerSetupContext as Vn, WorkflowStoragePolicyResolver as Vr, PendingNodeExecution as Vt, ConnectionInvocationKind as W, CredentialMaterialSourceKind as Wa, WorkflowRunnerService as Wi, BinaryPreviewKind as Wn, nodeRef as Wr, PersistedRunControlState as Wt, PersistedExecutionInstanceRecord as X, CredentialSessionService as Xa, WebhookInvocationMatch as Xi, JsonArray as Xn, FixedRetryPolicySpec as Xr, PinnedNodeOutputsByPort as Xt, PersistedExecutionInstanceKind as Y, CredentialSessionFactoryArgs as Ya, WebhookControlSignal as Yi, Items as Yn, ExponentialRetryPolicySpec as Yr, PersistedWorkflowTokenRegistryLike as Yt, PersistedRunSlotProjectionRecord as Z, CredentialSetupStatus as Za, WebhookTriggerMatcher as Zi, JsonNonArray as Zn, NoneRetryPolicySpec as Zr, RunCompletionNotifier as Zt, NodeIdSlugifier as _, CodemationTelemetryAttributeNames as _a, NodeActivationRequest as _i, Lifecycle as _n, ParentExecutionRef as _r, ItemExprResolvedContext as _t, RunPolicySnapshotFactory as a, TelemetryArtifactAttachment as aa, BinaryStorageWriteResult as ai, RunStatus as an, PollingTriggerLogger as ao, NodeErrorHandler as ar, WorkItemStatus as at, ChainCursor as b, NoOpNodeExecutionTelemetry as ba, NodeBinaryAttachmentService as bi, container$1 as bn, RunDataSnapshot as br, resolveItemExprsForExecution as bt, RunTerminalPersistenceCoordinator as c, TelemetryAttributes as ca, ExecutableTriggerNode as ci, RunTestContext as cn, NodeConnectionName as co, NodeIdRef as cr, CostCatalog as ct, DefaultWorkflowGraphFactory as d, TelemetryScope as da, ExecutionContextFactory as di, WorkflowExecutionPruneRepository as dn, PersistedTokenId as do, NodeKind as dr, Param as dt, AllWorkflowsActiveWorkflowActivationPolicy as ea, BinaryBody as ei, RunExecutionOptions as en, CredentialTypeId as eo, JsonValue as er, RunIterationDto as et, WorkflowExecutableNodeClassifierFactory as f, TelemetrySpanEnd as fa, ItemNode as fi, WorkflowExecutionRepository as fn, WorkflowId as fo, NodeOffloadPolicy as fr, ParamDeep as ft, ConnectionInvocationIdFactory as g, GenAiTelemetryAttributeNames as ga, NodeActivationReceipt as gi, InjectionToken$1 as gn, PairedItemRef as gr, ItemExprContext as gt, ConnectionNodeIdFactory as h, CodemationTelemetryMetricNames as ha, NodeActivationContinuation as hi, Disposable as hn, NodeSchedulerDecision as hr, ItemExprCallback as ht, WorkflowSnapshotCodec as i, NodeExecutionTelemetry as ia, BinaryStorageWriteRequest as ii, RunStateResetRequest as in, NoOpPollingTriggerLogger as io, NodeDefinition as ir, WorkItemId as it, NoOpCostTrackingTelemetryFactory as j, CollectionsContext as ja, RunnableNode as ji, ENGINE_EXECUTION_LIMITS_DEFAULTS as jn, WorkflowErrorContext as jr, ConnectionInvocationAppendArgs as jt, ValidStepSequence as k, CostTrackingUsageRecord as ka, PollingTriggerHandle as ki, singleton as kn, UpstreamRefPlaceholder as kr, AgentMcpToolMap as kt, WorkflowStoragePolicyEvaluator as l, TelemetryChildSpanStart as la, ExecutionBinaryService as li, WebhookRunResult as ln, NodeId as lo, NodeInspectorSummaryRow as lr, CostCatalogEntry as lt, NodeIterationIdFactory as m, TelemetrySpanScope as ma, MultiInputNode as mi, DependencyContainer$1 as mn, NodeRef as mr, ItemExprArgs as mt, InMemoryLiveWorkflowRepository as n, ExecutionTelemetry as na, BinaryStorageReadResult as ni, RunQueueEntry as nn, CredentialUnboundError as no, NodeActivationId as nr, RunSlotProjectionState as nt, EngineExecutionLimitsPolicyFactory as o, TelemetryArtifactReference as oa, EngineDeps as oi, RunStopCondition as on, PollingTriggerDedupWindow as oo, NodeErrorHandlerArgs as or, WorkflowDetailSelectionState as ot, WorkflowExecutableNodeClassifier as p, TelemetrySpanEventRecord as pa, LiveWorkflowRepository as pi, Container as pn, NodeOutputs as pr, ItemExpr as pt, ExecutionPayloadPolicyFields as q, CredentialRequirement as qa, HttpMethod as qi, Item as qn, triggerNodeOutputType as qr, PersistedWorkflowSnapshot as qt, EngineWorkflowRunnerService as r, ExecutionTelemetryFactory as ra, BinaryStorageStatResult as ri, RunResult as rn, OAuth2ProviderFromPublicConfig as ro, NodeConfigBase as rr, SlotExecutionStateDto as rt, WorkflowPolicyErrorServices as s, TelemetryAttributePrimitive as sa, EngineHost as si, RunSummary as sn, InputPortKey as so, NodeErrorHandlerSpec as sr, WorkflowRunDetailDto as st, RunIntentService as t, WorkflowActivationPolicy as ta, BinaryStorage as ti, RunPruneCandidate as tn, CredentialTypeRegistry as to, MutableRunData as tr, RunRevision as tt, Engine as u, TelemetryMetricRecord as ua, ExecutionContext as ui, WorkflowExecutionListingRepository as un, OutputPortKey as uo, NodeIterationId as ur, Expr as ut, WorkflowDefinitionError as v, NoOpExecutionTelemetryFactory as va, NodeActivationRequestBase as vi, RegistrationOptions as vn, PersistedRunPolicySnapshot as vr, isItemExpr as vt, BooleanWhenOverloads as w, CostTrackingPriceQuote as wa, NodeExecutionScheduler as wi, injectable as wn, RunnableNodeInputJson as wr, DEFAULT_ASSERTION_PASS_THRESHOLD as wt, WhenBuilder as x, NoOpTelemetrySpanScope as xa, NodeExecutionContext as xi, delay as xn, RunId as xr, resolveItemExprsInUnknown as xt, WorkflowBuilder as y, NoOpExecutionTelemetry as ya, NodeActivationScheduler as yi, TypeToken as yn, RunDataFactory as yr, itemExpr as yt, isPortsEmission as z, CredentialHealthStatus as za, TriggerSetupStateRepository as zi, TestSuiteRunId as zn, WorkflowStoragePolicyDecisionArgs as zr, NodeExecutionStatus as zt };
-//# sourceMappingURL=RunIntentService-BrEq6Jm6.d.ts.map
+export { ExecutionPayloadPolicyFields as $, CredentialFieldSchema as $a, TriggerSetupContext as $i, BinaryPreviewKind as $n, nodeRef as $r, PersistedRunState as $t, DefinedNodeCredentialAccessors as A, TelemetrySpanScope as Aa, NodeActivationReceipt as Ai, delay as An, RunId as Ar, DEFAULT_ASSERTION_PASS_THRESHOLD as At, RetryPolicy as B, CostTrackingPriceQuote as Ba, NodeExecutor as Bi, ENGINE_EXECUTION_LIMITS_DEFAULTS as Bn, WorkflowErrorContext as Br, CurrentStateExecutionRequest as Bt, defineHumanApprovalNode as C, TelemetryAttributePrimitive as Ca, HumanTaskHandle as Ci, DependencyContainer$1 as Cn, InputPortKey as Co, NodeRef as Cr, ItemExprResolvedContext as Ct, DefineNodeOptions as D, TelemetryScope as Da, LiveWorkflowRepository as Di, RegistrationOptions as Dn, PersistedTokenId as Do, PersistedRunPolicySnapshot as Dr, resolveItemExprsInUnknown as Dt, DefineNodeExecuteArgs as E, TelemetryMetricRecord as Ea, ItemNode as Ei, Lifecycle as En, OutputPortKey as Eo, ParentExecutionRef as Er, resolveItemExprsForExecution as Et, defineNode as F, NoOpExecutionTelemetry as Fa, NodeExecutionContext as Fi, instancePerContainerCachingFactory as Fn, TriggerNodeConfig as Fr, AgentMcpToolMap as Ft, isPortsEmission as G, CostTrackingUsageRecord as Ga, ResumeContext as Gi, RunEventSubscription as Gn, WorkflowNodeConnection as Gr, NodeExecutionStatus as Gt, getOriginIndexFromItem as H, CostTrackingTelemetryAttributeNames as Ha, PersistedTriggerSetupState as Hi, EngineExecutionLimitsPolicyConfig as Hn, WorkflowErrorHandlerSpec as Hr, ExecutionFrontierPlan as Ht, RunFinishedAtFactory as I, NoOpNodeExecutionTelemetry as Ia, NodeExecutionRequest as Ii, predicateAwareClassFactory as In, TriggerNodeOutputJson as Ir, NeedsReconsentEvent as It, McpServerTransport as J, AnyCredentialType as Ja, SuspensionRequest as Ji, TestSuiteRunId as Jn, WorkflowStoragePolicyDecisionArgs as Jr, PendingResumeEntry as Jt, isUnbrandedPortsEmissionShape as K, CollectionStore as Ka, RunnableNode as Ki, TestCaseRunStatus as Kn, WorkflowPolicyRuntimeDefaults as Kr, NodeInputsByPort as Kt, NoOpCostTrackingTelemetryFactory as L, NoOpTelemetrySpanScope as La, NodeExecutionRequestHandler as Li, registry as Ln, TriggerNodeSetupState as Lr, ConnectionInvocationAppendArgs as Lt, DefinedNodeCredentialBindings as M, GenAiTelemetryAttributeNames as Ma, NodeActivationRequestBase as Mi, injectAll as Mn, RunnableNodeConfig as Mr, NoOpAgentMcpIntegration as Mt, DefinedNodeRunContext as N, CodemationTelemetryAttributeNames as Na, NodeActivationScheduler as Ni, injectable as Nn, RunnableNodeInputJson as Nr, AgentBindError as Nt, DefinedNode as O, TelemetrySpanEnd as Oa, MultiInputNode as Oi, TypeToken as On, WorkflowId as Oo, RunDataFactory as Or, AssertionResult as Ot, defineBatchNode as P, NoOpExecutionTelemetryFactory as Pa, NodeBinaryAttachmentService as Pi, instanceCachingFactory as Pn, RunnableNodeOutputJson as Pr, AgentMcpIntegration as Pt, ExecutionInstanceId as Q, CredentialBindingKey as Qa, TriggerRuntimeDiagnostics as Qi, BinaryAttachment as Qn, branchRef as Qr, PersistedRunSchedulingState as Qt, NoOpCostTrackingTelemetry as R, NoOpTelemetryArtifactReference as Ra, NodeExecutionScheduler as Ri, singleton as Rn, UpstreamRefPlaceholder as Rr, ConnectionInvocationId as Rt, HumanApprovalOutputJson as S, TelemetryArtifactReference as Sa, HumanTaskActor as Si, Container as Sn, PollingTriggerDedupWindow as So, NodeOutputs as Sr, ItemExprContext as St, DefineBatchNodeOptions as T, TelemetryChildSpanStart as Ta, HumanTaskSubject as Ti, InjectionToken$1 as Tn, NodeId as To, PairedItemRef as Tr, itemExpr as Tt, PortsEmission as U, CostTrackingTelemetryFactory as Ua, PollingTriggerHandle as Ui, RunEvent as Un, WorkflowGraph as Ur, NodeExecutionError as Ut, NoRetryPolicy as V, CostTrackingTelemetry as Va, NodeResolver as Vi, EngineExecutionLimitsPolicy as Vn, WorkflowErrorHandler as Vr, EngineRunCounters as Vt, emitPorts as W, CostTrackingTelemetryMetricNames as Wa, PreparedNodeActivationDispatch as Wi, RunEventBus as Wn, WorkflowGraphFactory as Wr, NodeExecutionSnapshot as Wt, ConnectionInvocationKind as X, CredentialAuthDefinition as Xa, TriggerCleanupHandle as Xi, TestTriggerSetupContext as Xn, WorkflowStoragePolicyResolver as Xr, PersistedMutableRunState as Xt, BatchId as Y, CredentialAdvancedSectionPresentation as Ya, TestableTriggerNode as Yi, TestTriggerNodeConfig as Yn, WorkflowStoragePolicyMode as Yr, PersistedMutableNodeState as Yt, ExecutionInstanceDto as Z, CredentialBinding as Za, TriggerNode as Zi, ActivationIdFactory as Zn, WorkflowStoragePolicySpec as Zr, PersistedRunControlState as Zt, BranchStepsArg as _, WorkflowActivationPolicy as _a, EngineHost as _i, RunTestContext as _n, CredentialTypeRegistry as _o, NodeIdRef as _r, Param as _t, ConnectionNodeIdFactory as a, WorkflowRunnerResolver as aa, FixedRetryPolicySpec as ai, RunCompletionNotifier as an, CredentialJsonRecord as ao, JsonArray as ar, PersistedRunWorkItemRecord as at, DefinedHumanApprovalNode as b, NodeExecutionTelemetry as ba, ExecutionContext as bi, WorkflowExecutionPruneRepository as bn, NoOpPollingTriggerLogger as bo, NodeKind as br, ItemExprArgs as bt, WorkflowDefinitionError as c, WorkflowSnapshotResolver as ca, BinaryAttachmentCreateRequest as ci, RunExecutionOptions as cn, CredentialOAuth2ScopesFromPublicConfig as co, JsonPrimitive as cr, RunSlotProjectionState as ct, WhenBuilder as d, WebhookControlSignal as da, BinaryStorageReadResult as di, RunQueueEntry as dn, CredentialSessionFactoryArgs as do, NodeActivationId as dr, WorkItemStatus as dt, TriggerSetupStateFor as ea, runnableNodeInputType as ei, PersistedSuspensionEntry as en, CredentialHealth as eo, Edge as er, PayloadStorageKind as et, AnyRunnableNodeConfig as f, WebhookInvocationMatch as fa, BinaryStorageStatResult as fi, RunResult as fn, CredentialSessionService as fo, NodeConfigBase as fr, WorkflowDetailSelectionState as ft, BranchOutputGuard as g, AllWorkflowsActiveWorkflowActivationPolicy as ga, EngineDeps as gi, RunSummary as gn, CredentialTypeId as go, NodeErrorHandlerSpec as gr, Expr as gt, BranchMoreArgs as h, WebhookTriggerRoutingDiagnostics as ha, Duration as hi, RunStopCondition as hn, CredentialTypeDefinition as ho, NodeErrorHandlerArgs as hr, CostCatalogEntry as ht, NodeIterationIdFactory as i, WorkflowRepository as ia, ExponentialRetryPolicySpec as ii, PinnedNodeOutputsByPort as in, CredentialInstanceRecord as io, Items as ir, PersistedRunWorkItemKind as it, DefinedNodeCredentialBinding as j, CodemationTelemetryMetricNames as ja, NodeActivationRequest as ji, inject as jn, RunIdFactory as jr, deriveAssertionPassed as jt, DefinedNodeConfigInput as k, TelemetrySpanEventRecord as ka, NodeActivationContinuation as ki, container$1 as kn, RunDataSnapshot as kr, AssertionResultProvenance as kt, WorkflowBuilder as l, HttpMethod as la, BinaryBody as li, RunHaltReason as ln, CredentialRequirement as lo, JsonValue as lr, SlotExecutionStateDto as lt, BooleanWhenOverloads as m, WebhookTriggerResolution as ma, BinaryStorageWriteResult as mi, RunStatus as mn, CredentialType as mo, NodeErrorHandler as mr, CostCatalog as mt, WorkflowExecutableNodeClassifierFactory as n, TriggerTestItemsContext as na, triggerNodeOutputType as ni, PersistedWorkflowSnapshotNode as nn, CredentialHealthTester as no, Item as nr, PersistedExecutionInstanceRecord as nt, ConnectionInvocationIdFactory as o, WorkflowRunnerService as oa, NoneRetryPolicySpec as oi, RunCurrentState as on, CredentialMaterialSourceKind as oo, JsonNonArray as or, RunIterationDto as ot, AnyTriggerNodeConfig as p, WebhookTriggerMatcher as pa, BinaryStorageWriteRequest as pi, RunStateResetRequest as pn, CredentialSetupStatus as po, NodeDefinition as pr, WorkflowRunDetailDto as pt, McpServerDeclaration as q, CollectionsContext as qa, RunnableNodeExecuteArgs as qi, TestSuiteRunStatus as qn, WorkflowPrunePolicySpec as qr, PendingNodeExecution as qt, WorkflowExecutableNodeClassifier as r, WorkflowNodeInstanceFactory as ra, triggerNodeSetupStateType as ri, PersistedWorkflowTokenRegistryLike as rn, CredentialInstanceId as ro, ItemBinary as rr, PersistedRunSlotProjectionRecord as rt, NodeIdSlugifier as s, WorkflowSnapshotFactory as sa, RetryPolicySpec as si, RunEventPublisherDeps as sn, CredentialOAuth2AuthDefinition as so, JsonObject as sr, RunRevision as st, DefaultWorkflowGraphFactory as t, TriggerSetupStateRepository as ta, runnableNodeOutputType as ti, PersistedWorkflowSnapshot as tn, CredentialHealthStatus as to, ExecutionMode as tr, PersistedExecutionInstanceKind as tt, ChainCursor as u, TriggerInstanceId as ua, BinaryStorage as ui, RunPruneCandidate as un, CredentialSessionFactory as uo, MutableRunData as ur, WorkItemId as ut, StepSequenceOutput as v, ExecutionTelemetry as va, ExecutableTriggerNode as vi, WebhookRunResult as vn, CredentialUnboundError as vo, NodeInspectorSummaryRow as vr, ParamDeep as vt, isHumanApprovalNode as w, TelemetryAttributes as wa, HumanTaskId as wi, Disposable as wn, NodeConnectionName as wo, NodeSchedulerDecision as wr, isItemExpr as wt, HumanApprovalDecisionResult as x, TelemetryArtifactAttachment as xa, ExecutionContextFactory as xi, WorkflowExecutionRepository as xn, PollingTriggerLogger as xo, NodeOffloadPolicy as xr, ItemExprCallback as xt, ValidStepSequence as y, ExecutionTelemetryFactory as ya, ExecutionBinaryService as yi, WorkflowExecutionListingRepository as yn, OAuth2ProviderFromPublicConfig as yo, NodeIterationId as yr, ItemExpr as yt, ExpRetryPolicy as z, CostTrackingComponent as za, NodeExecutionStatePublisher as zi, CoreTokens as zn, WorkflowDefinition as zr, ConnectionInvocationRecord as zt };
+//# sourceMappingURL=index-CSKKuK60.d.ts.map