@codemation/core 0.3.0 → 0.5.0

package/dist/{RunIntentService-BAKikN8h.d.ts → RunIntentService-Dkr4YwN8.d.ts}

@@ -3,62 +3,6 @@ import { DependencyContainer as Container, DependencyContainer as DependencyCont
 import { ZodType } from "zod";
 import { ReadableStream } from "node:stream/web";
 
-//#region src/contracts/retryPolicySpec.types.d.ts
-/**
- * In-process retry policy for runnable nodes. Serialized configs use the same
- * `kind` discriminator (`JSON.stringify` / persisted workflows).
- *
- * `maxAttempts` is the total number of tries including the first (e.g. 3 means up to 2 delays after failures).
- */
-type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
-interface NoneRetryPolicySpec {
-  readonly kind: "none";
-}
-interface FixedRetryPolicySpec {
-  readonly kind: "fixed";
-  /** Total attempts including the first execution. Must be >= 1. */
-  readonly maxAttempts: number;
-  readonly delayMs: number;
-}
-interface ExponentialRetryPolicySpec {
-  readonly kind: "exponential";
-  /** Total attempts including the first execution. Must be >= 1. */
-  readonly maxAttempts: number;
-  readonly initialDelayMs: number;
-  readonly multiplier: number;
-  readonly maxDelayMs?: number;
-  /** When true, each delay is multiplied by a random factor in [1, 1.2). */
-  readonly jitter?: boolean;
-}
-//#endregion
-//#region src/contracts/NoRetryPolicy.d.ts
-declare class NoRetryPolicy implements NoneRetryPolicySpec {
-  readonly kind: "none";
-}
-//#endregion
-//#region src/contracts/RetryPolicy.d.ts
-declare class RetryPolicy implements FixedRetryPolicySpec {
-  readonly maxAttempts: number;
-  readonly delayMs: number;
-  readonly kind: "fixed";
-  constructor(maxAttempts: number, delayMs: number);
-  /** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
-  static readonly defaultForHttp: FixedRetryPolicySpec;
-  /** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
-  static readonly defaultForAiAgent: FixedRetryPolicySpec;
-}
-//#endregion
-//#region src/contracts/ExpRetryPolicy.d.ts
-declare class ExpRetryPolicy implements ExponentialRetryPolicySpec {
-  readonly maxAttempts: number;
-  readonly initialDelayMs: number;
-  readonly multiplier: number;
-  readonly maxDelayMs?: number | undefined;
-  readonly jitter?: boolean | undefined;
-  readonly kind: "exponential";
-  constructor(maxAttempts: number, initialDelayMs: number, multiplier: number, maxDelayMs?: number | undefined, jitter?: boolean | undefined);
-}
-//#endregion
 //#region src/events/runEvents.d.ts
 type RunEvent = Readonly<{
   kind: "runCreated";
@@ -160,6 +104,157 @@ declare const CoreTokens: {
   readonly WorkflowActivationPolicy: TypeToken<WorkflowActivationPolicy>;
 };
 //#endregion
+//#region src/contracts/credentialTypes.d.ts
+type CredentialTypeId = string;
+type CredentialInstanceId = string;
+type CredentialMaterialSourceKind = "db" | "env" | "code";
+type CredentialSetupStatus = "draft" | "ready";
+type CredentialHealthStatus = "unknown" | "healthy" | "failing";
+type CredentialFieldSchema = Readonly<{
+  key: string;
+  label: string;
+  type: "string" | "password" | "textarea" | "json" | "boolean";
+  required?: true;
+  order?: number;
+  placeholder?: string;
+  helpText?: string;
+  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
+  envVarName?: string;
+  /**
+   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
+   * pattern or documentation URL). Do not use for secret values.
+   */
+  copyValue?: string;
+  /** Accessible label for the copy control (default: Copy). */
+  copyButtonLabel?: string;
+}>;
+type CredentialRequirement = Readonly<{
+  slotKey: string;
+  label: string;
+  acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  optional?: true;
+  helpText?: string;
+  helpUrl?: string;
+}>;
+type CredentialBindingKey = Readonly<{
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  slotKey: string;
+}>;
+type CredentialBinding = Readonly<{
+  key: CredentialBindingKey;
+  instanceId: CredentialInstanceId;
+  updatedAt: string;
+}>;
+type CredentialHealth = Readonly<{
+  status: CredentialHealthStatus;
+  message?: string;
+  testedAt?: string;
+  expiresAt?: string;
+  details?: Readonly<Record<string, unknown>>;
+}>;
+type OAuth2ProviderFromPublicConfig = Readonly<{
+  authorizeUrlFieldKey: string;
+  tokenUrlFieldKey: string;
+  userInfoUrlFieldKey?: string;
+}>;
+type CredentialOAuth2ScopesFromPublicConfig = Readonly<{
+  presetFieldKey: string;
+  presetScopes: Readonly<Record<string, ReadonlyArray<string>>>;
+  customPresetKey?: string;
+  customScopesFieldKey?: string;
+}>;
+type CredentialOAuth2AuthDefinition = Readonly<{
+  kind: "oauth2";
+  providerId: string;
+  scopes: ReadonlyArray<string>;
+  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
+  clientIdFieldKey?: string;
+  clientSecretFieldKey?: string;
+} | {
+  kind: "oauth2";
+  providerFromPublicConfig: OAuth2ProviderFromPublicConfig;
+  scopes: ReadonlyArray<string>;
+  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
+  clientIdFieldKey?: string;
+  clientSecretFieldKey?: string;
+}>;
+type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
+type CredentialTypeDefinition = Readonly<{
+  typeId: CredentialTypeId;
+  displayName: string;
+  description?: string;
+  publicFields?: ReadonlyArray<CredentialFieldSchema>;
+  secretFields?: ReadonlyArray<CredentialFieldSchema>;
+  supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
+  auth?: CredentialAuthDefinition;
+}>;
+/**
+ * JSON-shaped credential field bag (public config, resolved secret material, etc.).
+ */
+type CredentialJsonRecord = Readonly<Record<string, unknown>>;
+/**
+ * Persisted credential instance with typed `publicConfig`.
+ * Hosts may specialize `secretRef` with a stricter union while remaining
+ * assignable here for session/test callbacks.
+ */
+type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  instanceId: CredentialInstanceId;
+  typeId: CredentialTypeId;
+  displayName: string;
+  sourceKind: CredentialMaterialSourceKind;
+  publicConfig: TPublicConfig;
+  secretRef: CredentialJsonRecord;
+  tags: ReadonlyArray<string>;
+  setupStatus: CredentialSetupStatus;
+  createdAt: string;
+  updatedAt: string;
+}>;
+/**
+ * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
+ * Declare `TPublicConfig` / `TMaterial` on `CredentialType` so implementations are checked
+ * against your credential shapes (similar to `NodeExecutionContext.config` for nodes).
+ */
+type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  instance: CredentialInstanceRecord<TPublicConfig>;
+  material: TMaterial;
+  publicConfig: TPublicConfig;
+}>;
+type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
+type CredentialHealthTester<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<CredentialHealth>;
+/**
+ * Full credential type implementation: `definition` (UI/schema), `createSession`, and `test`.
+ * Use this at registration and config boundaries; `CredentialTypeDefinition` is only the schema slice.
+ */
+type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = Readonly<{
+  definition: CredentialTypeDefinition;
+  createSession: CredentialSessionFactory<TPublicConfig, TMaterial, TSession>;
+  test: CredentialHealthTester<TPublicConfig, TMaterial>;
+}>;
+/**
+ * Credential type with unspecified generics — used for `CodemationConfig.credentialTypes`, the host registry,
+ * and anywhere a concrete `CredentialType<YourPublic, YourMaterial, YourSession>` is placed in a heterogeneous list.
+ * Using `any` here avoids unsafe `as` casts while keeping typed `satisfies CredentialType<…>` definitions.
+ */
+type AnyCredentialType = CredentialType<any, any, unknown>;
+interface CredentialSessionService {
+  getSession<TSession = unknown>(args: Readonly<{
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    slotKey: string;
+  }>): Promise<TSession>;
+}
+interface CredentialTypeRegistry {
+  listTypes(): ReadonlyArray<CredentialTypeDefinition>;
+  getType(typeId: CredentialTypeId): CredentialTypeDefinition | undefined;
+}
+declare class CredentialUnboundError extends Error {
+  readonly bindingKey: CredentialBindingKey;
+  readonly acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  constructor(bindingKey: CredentialBindingKey, acceptedTypes?: ReadonlyArray<CredentialTypeId>);
+  private static createMessage;
+}
+//#endregion
 //#region src/contracts/runTypes.d.ts
 interface RunExecutionOptions {
   /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
@@ -679,31 +774,41 @@ interface EngineHost {
   credentialSessions: CredentialSessionService;
   workflows?: WorkflowRunnerService;
 }
-interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
-  kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
-  execute(items: Items, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
-}
 /**
- * Single-input runnable node with per-item execution on `main` only (1→1 default).
- * Engine applies {@link RunnableNodeConfig.mapInput} (if any) + `inputSchema.parse` before `executeOne`.
+ * Per-item runnable node: return JSON, an array to fan-out on `main`, or {@link emitPorts} for multi-port emission.
+ * Engine applies `inputSchema.parse(item.json)` and passes the result as `args.input` (wire `item.json` is unchanged).
  */
-interface ItemNode<TConfig extends NodeConfigBase = NodeConfigBase, TInputJson$1 = unknown, TOutputJson$1 = unknown> {
+interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown> {
+  readonly input: TInputJson$1;
+  readonly item: Item;
+  readonly itemIndex: number;
+  readonly items: Items;
+  readonly ctx: NodeExecutionContext<TConfig>;
+}
+interface RunnableNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, _TOutputJson = unknown> {
   readonly kind: "node";
-  readonly outputPorts: readonly ["main"];
+  /**
+   * Declared output ports (e.g. `["main"]`).
+   *
+   * Prefer describing dynamic router ports (Switch) and fixed multi-ports (If true/false)
+   * via {@link NodeConfigBase.declaredOutputPorts}. Engine defaults to `["main"]` when omitted.
+   */
+  readonly outputPorts?: ReadonlyArray<OutputPortKey>;
   /** When omitted, engine uses {@link RunnableNodeConfig.inputSchema} or `z.unknown()`. */
   readonly inputSchema?: ZodType<TInputJson$1>;
-  executeOne(args: Readonly<{
-    input: TInputJson$1;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<TConfig>;
-  }>): Promise<TOutputJson$1> | TOutputJson$1;
+  execute(args: RunnableNodeExecuteArgs<TConfig, TInputJson$1>): Promise<unknown> | unknown;
 }
+/** @deprecated Use {@link RunnableNode} */
+type ItemNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, TOutputJson$1 = unknown> = RunnableNode<TConfig, TInputJson$1, TOutputJson$1>;
 interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
   kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
+  /**
+   * Declared output ports (typically `["main"]`).
+   *
+   * Prefer describing ports for authoring/canvas via {@link NodeConfigBase.declaredOutputPorts}.
+   * Engine defaults to `["main"]` when omitted.
+   */
+  outputPorts?: ReadonlyArray<OutputPortKey>;
   executeMulti(inputsByPort: NodeInputsByPort, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
 }
 type TriggerSetupStateFor<TConfig extends TriggerNodeConfig<any, any>> = TriggerNodeSetupState<TConfig>;
@@ -833,6 +938,34 @@ interface EngineDeps {
   triggerRuntimeDiagnostics?: TriggerRuntimeDiagnostics;
 }
 //#endregion
+//#region src/contracts/retryPolicySpec.types.d.ts
+/**
+ * In-process retry policy for runnable nodes. Serialized configs use the same
+ * `kind` discriminator (`JSON.stringify` / persisted workflows).
+ *
+ * `maxAttempts` is the total number of tries including the first (e.g. 3 means up to 2 delays after failures).
+ */
+type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
+interface NoneRetryPolicySpec {
+  readonly kind: "none";
+}
+interface FixedRetryPolicySpec {
+  readonly kind: "fixed";
+  /** Total attempts including the first execution. Must be >= 1. */
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+}
+interface ExponentialRetryPolicySpec {
+  readonly kind: "exponential";
+  /** Total attempts including the first execution. Must be >= 1. */
+  readonly maxAttempts: number;
+  readonly initialDelayMs: number;
+  readonly multiplier: number;
+  readonly maxDelayMs?: number;
+  /** When true, each delay is multiplied by a random factor in [1, 1.2). */
+  readonly jitter?: boolean;
+}
+//#endregion
 //#region src/contracts/workflowTypes.d.ts
 type WorkflowId = string;
 type NodeId = string;
@@ -846,6 +979,8 @@ interface JsonObject {
 }
 type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 type JsonArray = ReadonlyArray<JsonValue>;
+/** JSON value that is not a top-level array (nested arrays inside objects are allowed). */
+type JsonNonArray = JsonPrimitive | JsonObject;
 interface Edge {
   from: {
     nodeId: NodeId;
@@ -915,65 +1050,42 @@ interface NodeConfigBase {
    * main batches skip downstream execution and propagate the empty path.
    */
   readonly continueWhenEmptyOutput?: boolean;
+  /**
+   * Declared I/O port names for canvas authoring (unioned with ports inferred from edges).
+   * Use for dynamic routers (Switch) and future error ports.
+   */
+  readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
+  readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
 }
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
-/** Phantom: JSON shape on the wire from upstream before {@link RunnableNodeConfig.mapInput}. */
-declare const runnableNodeWireType: unique symbol;
 declare const triggerNodeOutputType: unique symbol;
+type LineageCarryPolicy = "emitOnly" | "carryThrough";
 /**
- * Read-only execution slice passed to {@link RunnableNodeConfig.mapInput} (aligned with the engine’s
- * node execution context for `runId`, `data`, etc.). Use **`ctx.data`** to read **any completed** upstream
- * node’s outputs in this run (e.g. `ctx.data.getOutputItems(nodeIdA, "main")` while mapping at D), not only
- * the immediate predecessor’s {@link ItemInputMapperArgs.item}.
- */
-interface ItemInputMapperContext {
-  readonly runId: RunId;
-  readonly workflowId: WorkflowId;
-  /** Node whose activation is being prepared (the consumer of `mapInput`). */
-  readonly nodeId: NodeId;
-  readonly activationId: NodeActivationId;
-  readonly parent?: ParentExecutionRef;
-  readonly data: RunDataSnapshot;
-}
-/**
- * Arguments for optional per-item input mapping applied by the engine before Zod validation.
+ * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
+ * **`TOutputJson`** is emitted `item.json` on outputs.
  */
-interface ItemInputMapperArgs<TWireJson$1 = unknown> {
-  readonly item: Item<TWireJson$1>;
-  readonly itemIndex: number;
-  readonly items: Items<TWireJson$1>;
-  readonly ctx: ItemInputMapperContext;
-}
-/**
- * Per-item mapper before Zod validation. Uses a **bivariant** method signature so concrete
- * `ItemInputMapper<SpecificWire, TIn>` remains assignable to `RunnableNodeConfig` fields typed as
- * `ItemInputMapper<unknown, unknown>` (same pattern as React-style callbacks).
- */
-type ItemInputMapper<TWireJson$1 = unknown, TInputJson$1 = unknown> = {
-  bivarianceHack(args: ItemInputMapperArgs<TWireJson$1>): TInputJson$1 | Promise<TInputJson$1>;
-}["bivarianceHack"];
-/**
- * Runnable node: **`TInputJson`** is the payload after `mapInput` (if any) + Zod validation — what {@link ItemNode}
- * `executeOne` receives. **`TOutputJson`** is emitted `item.json` on outputs. **`TWireJson`** is `item.json` from
- * upstream **before** `mapInput`; it defaults to **`TInputJson`** when there is no mapper or wire differs from execute input.
- */
-interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson$1 = TInputJson$1> extends NodeConfigBase {
+interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
   readonly kind: "node";
   readonly [runnableNodeInputType]?: TInputJson$1;
   readonly [runnableNodeOutputType]?: TOutputJson$1;
-  readonly [runnableNodeWireType]?: TWireJson$1;
   /**
-   * Optional Zod input contract for {@link ItemNode} when not set on the node class.
+   * Optional Zod input contract for {@link RunnableNode} when not set on the node class.
    * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
    */
   readonly inputSchema?: ZodType<TInputJson$1>;
   /**
-   * Optional per-item mapper: engine applies it before validating against the node’s `inputSchema`.
-   * When omitted, the engine validates `item.json` directly.
+   * Overrides default lineage propagation for `execute` outputs (binary/meta/paired).
+   * Routers with multiple {@link RunnableNode#outputPorts} default to **`carryThrough`**; others default to **`emitOnly`**.
    */
-  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
+  readonly lineageCarry?: LineageCarryPolicy;
+  /**
+   * When an activation receives **zero** input items, the engine normally runs `execute` zero times.
+   * Set to **`runOnce`** to run `execute` once with an empty `items` batch (and a synthetic wire item for schema parsing).
+   * Used by batch-style callback nodes (built-in `Callback`) so `callback([], ctx)` still runs.
+   */
+  readonly emptyBatchExecution?: "skip" | "runOnce";
 }
 declare const triggerNodeSetupStateType: unique symbol;
 interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonValue | undefined = undefined> extends NodeConfigBase {
@@ -981,9 +1093,8 @@ interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonV
   readonly [triggerNodeOutputType]?: TOutputJson$1;
   readonly [triggerNodeSetupStateType]?: TSetupState$1;
 }
-type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any, any> ? TInputJson : never;
-type RunnableNodeWireJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<any, any, infer TWireJson> ? TWireJson : never;
-type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson, any> ? TOutputJson : never;
+type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any> ? TInputJson : never;
+type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson> ? TOutputJson : never;
 type TriggerNodeOutputJson<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<infer TOutputJson, any> ? TOutputJson : never;
 type TriggerNodeSetupState<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<any, infer TSetupState> ? TSetupState : never;
 interface NodeDefinition {
@@ -1127,147 +1238,85 @@ interface WorkflowPolicyRuntimeDefaults {
   readonly storagePolicy?: WorkflowStoragePolicyMode;
 }
 //#endregion
-//#region src/contracts/credentialTypes.d.ts
-type CredentialTypeId = string;
-type CredentialInstanceId = string;
-type CredentialMaterialSourceKind = "db" | "env" | "code";
-type CredentialSetupStatus = "draft" | "ready";
-type CredentialHealthStatus = "unknown" | "healthy" | "failing";
-type CredentialFieldSchema = Readonly<{
-  key: string;
-  label: string;
-  type: "string" | "password" | "textarea" | "json" | "boolean";
-  required?: true;
-  order?: number;
-  placeholder?: string;
-  helpText?: string;
-  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
-  envVarName?: string;
-  /**
-   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
-   * pattern or documentation URL). Do not use for secret values.
-   */
-  copyValue?: string;
-  /** Accessible label for the copy control (default: Copy). */
-  copyButtonLabel?: string;
+//#region src/contracts/emitPorts.d.ts
+declare const EMIT_PORTS_BRAND: unique symbol;
+type PortsEmission = Readonly<{
+  readonly [EMIT_PORTS_BRAND]: true;
+  readonly ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>;
 }>;
-type CredentialRequirement = Readonly<{
-  slotKey: string;
-  label: string;
-  acceptedTypes: ReadonlyArray<CredentialTypeId>;
-  optional?: true;
-  helpText?: string;
-  helpUrl?: string;
+declare function emitPorts(ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>): PortsEmission;
+declare function isPortsEmission(value: unknown): value is PortsEmission;
+declare function isUnbrandedPortsEmissionShape(value: unknown): value is Readonly<{
+  ports: unknown;
 }>;
-type CredentialBindingKey = Readonly<{
+//#endregion
+//#region src/contracts/itemMeta.d.ts
+/**
+ * Reads `meta._cm.originIndex` when present (used for fan-in merge-by-origin and Merge routing).
+ */
+declare function getOriginIndexFromItem(item: Item): number | undefined;
+//#endregion
+//#region src/contracts/itemValue.d.ts
+declare const ITEM_VALUE_BRAND: unique symbol;
+type ItemValueResolvedContext = Readonly<{
+  runId: RunId;
   workflowId: WorkflowId;
   nodeId: NodeId;
-  slotKey: string;
-}>;
-type CredentialBinding = Readonly<{
-  key: CredentialBindingKey;
-  instanceId: CredentialInstanceId;
-  updatedAt: string;
-}>;
-type CredentialHealth = Readonly<{
-  status: CredentialHealthStatus;
-  message?: string;
-  testedAt?: string;
-  expiresAt?: string;
-  details?: Readonly<Record<string, unknown>>;
-}>;
-type OAuth2ProviderFromPublicConfig = Readonly<{
-  authorizeUrlFieldKey: string;
-  tokenUrlFieldKey: string;
-  userInfoUrlFieldKey?: string;
-}>;
-type CredentialOAuth2AuthDefinition = Readonly<{
-  kind: "oauth2";
-  providerId: string;
-  scopes: ReadonlyArray<string>;
-  clientIdFieldKey?: string;
-  clientSecretFieldKey?: string;
-} | {
-  kind: "oauth2";
-  providerFromPublicConfig: OAuth2ProviderFromPublicConfig;
-  scopes: ReadonlyArray<string>;
-  clientIdFieldKey?: string;
-  clientSecretFieldKey?: string;
-}>;
-type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
-type CredentialTypeDefinition = Readonly<{
-  typeId: CredentialTypeId;
-  displayName: string;
-  description?: string;
-  publicFields?: ReadonlyArray<CredentialFieldSchema>;
-  secretFields?: ReadonlyArray<CredentialFieldSchema>;
-  supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
-  auth?: CredentialAuthDefinition;
+  activationId: NodeActivationId;
+  data: RunDataSnapshot;
 }>;
 /**
- * JSON-shaped credential field bag (public config, resolved secret material, etc.).
- */
-type CredentialJsonRecord = Readonly<Record<string, unknown>>;
-/**
- * Persisted credential instance with typed `publicConfig`.
- * Hosts may specialize `secretRef` with a stricter union while remaining
- * assignable here for session/test callbacks.
+ * Context aligned with former {@link ItemInputMapperContext} — use **`data`** to read any completed upstream node.
  */
-type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
-  instanceId: CredentialInstanceId;
-  typeId: CredentialTypeId;
-  displayName: string;
-  sourceKind: CredentialMaterialSourceKind;
-  publicConfig: TPublicConfig;
-  secretRef: CredentialJsonRecord;
-  tags: ReadonlyArray<string>;
-  setupStatus: CredentialSetupStatus;
-  createdAt: string;
-  updatedAt: string;
+type ItemValueContext = ItemValueResolvedContext;
+type ItemValueArgs<TItemJson = unknown> = Readonly<{
+  item: Item<TItemJson>;
+  itemIndex: number;
+  items: Items<TItemJson>;
+  ctx: ItemValueContext;
 }>;
-/**
- * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
- * Declare `TPublicConfig` / `TMaterial` on `CredentialType` so implementations are checked
- * against your credential shapes (similar to `NodeExecutionContext.config` for nodes).
- */
-type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
-  instance: CredentialInstanceRecord<TPublicConfig>;
-  material: TMaterial;
-  publicConfig: TPublicConfig;
+type ItemValueCallback<T, TItemJson = unknown> = (args: ItemValueArgs<TItemJson>) => T | Promise<T>;
+type ItemValue<T, TItemJson = unknown> = Readonly<{
+  readonly [ITEM_VALUE_BRAND]: true;
+  readonly fn: ItemValueCallback<T, TItemJson>;
 }>;
-type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
-type CredentialHealthTester<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<CredentialHealth>;
+declare function itemValue<T, TItemJson = unknown>(fn: ItemValueCallback<T, TItemJson>): ItemValue<T, TItemJson>;
+declare function isItemValue<T, TItemJson = unknown>(value: unknown): value is ItemValue<T, TItemJson>;
 /**
- * Full credential type implementation: `definition` (UI/schema), `createSession`, and `test`.
- * Use this at registration and config boundaries; `CredentialTypeDefinition` is only the schema slice.
+ * Deep-resolves {@link itemValue} leaves. Returns a new graph (does not mutate the original config object).
  */
-type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = Readonly<{
-  definition: CredentialTypeDefinition;
-  createSession: CredentialSessionFactory<TPublicConfig, TMaterial, TSession>;
-  test: CredentialHealthTester<TPublicConfig, TMaterial>;
-}>;
+declare function resolveItemValuesInUnknown(value: unknown, args: ItemValueArgs, seen?: WeakSet<object>): Promise<unknown>;
 /**
- * Credential type with unspecified generics — used for `CodemationConfig.credentialTypes`, the host registry,
- * and anywhere a concrete `CredentialType<YourPublic, YourMaterial, YourSession>` is placed in a heterogeneous list.
- * Using `any` here avoids unsafe `as` casts while keeping typed `satisfies CredentialType<…>` definitions.
+ * Clones runnable config (best-effort) so per-item {@link itemValue} resolution never mutates shared instances.
  */
-type AnyCredentialType = CredentialType<any, any, unknown>;
-interface CredentialSessionService {
-  getSession<TSession = unknown>(args: Readonly<{
-    workflowId: WorkflowId;
-    nodeId: NodeId;
-    slotKey: string;
-  }>): Promise<TSession>;
+declare function resolveItemValuesForExecution(config: unknown, nodeCtx: NodeExecutionContext, item: Item, itemIndex: number, items: Items): Promise<unknown | undefined>;
+//#endregion
+//#region src/contracts/NoRetryPolicy.d.ts
+declare class NoRetryPolicy implements NoneRetryPolicySpec {
+  readonly kind: "none";
 }
-interface CredentialTypeRegistry {
-  listTypes(): ReadonlyArray<CredentialTypeDefinition>;
-  getType(typeId: CredentialTypeId): CredentialTypeDefinition | undefined;
+//#endregion
+//#region src/contracts/RetryPolicy.d.ts
+declare class RetryPolicy implements FixedRetryPolicySpec {
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly kind: "fixed";
+  constructor(maxAttempts: number, delayMs: number);
+  /** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
+  static readonly defaultForHttp: FixedRetryPolicySpec;
+  /** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
+  static readonly defaultForAiAgent: FixedRetryPolicySpec;
 }
-declare class CredentialUnboundError extends Error {
-  readonly bindingKey: CredentialBindingKey;
-  readonly acceptedTypes: ReadonlyArray<CredentialTypeId>;
-  constructor(bindingKey: CredentialBindingKey, acceptedTypes?: ReadonlyArray<CredentialTypeId>);
-  private static createMessage;
+//#endregion
+//#region src/contracts/ExpRetryPolicy.d.ts
+declare class ExpRetryPolicy implements ExponentialRetryPolicySpec {
+  readonly maxAttempts: number;
+  readonly initialDelayMs: number;
+  readonly multiplier: number;
+  readonly maxDelayMs?: number | undefined;
+  readonly jitter?: boolean | undefined;
+  readonly kind: "exponential";
+  constructor(maxAttempts: number, initialDelayMs: number, multiplier: number, maxDelayMs?: number | undefined, jitter?: boolean | undefined);
 }
 //#endregion
 //#region src/contracts/executionPersistenceContracts.d.ts
@@ -1437,17 +1486,17 @@ declare class RunFinishedAtFactory {
 }
 //#endregion
 //#region src/workflow/dsl/workflowBuilderTypes.d.ts
-type AnyRunnableNodeConfig = RunnableNodeConfig<any, any, any>;
+type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
 type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
-type ValidStepSequence<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps extends readonly [] ? readonly [] : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>] : never : never : TSteps;
-type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? TSteps extends readonly [] ? TCurrentJson : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? StepSequenceOutput<TNextJson, TRest> : never : never : TCurrentJson : TCurrentJson;
+type ValidStepSequence<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps extends readonly [] ? readonly [] : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>] : never : never : TSteps;
+type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? TSteps extends readonly [] ? TCurrentJson : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? StepSequenceOutput<TNextJson, TRest> : never : never : TCurrentJson : TCurrentJson;
 type TypesMatch<TLeft, TRight> = [TLeft] extends [TRight] ? ([TRight] extends [TLeft] ? true : false) : false;
 type BranchOutputGuard<TCurrentJson, TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TypesMatch<StepSequenceOutput<TCurrentJson, TTrueSteps>, StepSequenceOutput<TCurrentJson, TFalseSteps>> extends true ? unknown : never;
 type BranchStepsArg<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps & ValidStepSequence<TCurrentJson, TSteps>;
-type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
+type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
 type BooleanWhenOverloads<TCurrentJson, TReturn> = {
   <TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, steps: BranchStepsArg<TCurrentJson, TSteps>): TReturn;
-  <TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
+  <TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
 };
 //#endregion
 //#region src/workflow/dsl/WhenBuilder.d.ts
@@ -1462,6 +1511,11 @@ declare class WhenBuilder<TCurrentJson> {
 }
 //#endregion
 //#region src/workflow/dsl/ChainCursorResolver.d.ts
+type ChainCursorEndpoint = Readonly<{
+  node: NodeRef;
+  output: OutputPortKey;
+  inputPortHint?: InputPortKey;
+}>;
 type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>> & {
   <TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined>(branches: Readonly<{
     true?: TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? BranchStepsArg<TCurrentJson, TTrueSteps> : never;
@@ -1470,12 +1524,14 @@ type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson,
 };
 declare class ChainCursor<TCurrentJson> {
   private readonly wf;
-  private readonly cursor;
-  private readonly cursorOutput;
-  constructor(wf: WorkflowBuilder, cursor: NodeRef, cursorOutput: OutputPortKey);
-  then<TInputJson$1, TOutputJson$1, TConfig extends RunnableNodeConfig<TInputJson$1, TOutputJson$1, TCurrentJson>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
+  private readonly endpoints;
+  constructor(wf: WorkflowBuilder, endpoints: ReadonlyArray<ChainCursorEndpoint>);
+  then<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
+  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>;
   build(): WorkflowDefinition;
+  private resolveSharedInputPortHint;
 }
 //#endregion
 //#region src/workflow/dsl/WorkflowBuilder.d.ts
@@ -1488,9 +1544,7 @@ declare class WorkflowBuilder {
   constructor(meta: {
     id: WorkflowId;
     name: string;
-  }, options?: Readonly<{
-    makeMergeNode?: (name: string) => AnyRunnableNodeConfig;
-  }> | undefined);
+  }, options?: Readonly<Record<string, never>> | undefined);
   private add;
   private connect;
   trigger<TConfig extends AnyTriggerNodeConfig>(config: TConfig): ChainCursor<TriggerNodeOutputJson<TConfig>>;
@@ -1837,5 +1891,5 @@ declare class RunIntentService {
   private createWebhookExecutionOptions;
 }
 //#endregion
-export { CredentialHealthTester as $, NodeExecutionRequest as $n, RunExecutionOptions as $r, RunId as $t, ExecutionInstanceDto as A, EngineExecutionLimitsPolicy as Ai, BinaryBody as An, ConnectionInvocationAppendArgs as Ar, JsonPrimitive as At, RunSlotProjectionState as B, NoneRetryPolicySpec as Bi, ExecutionContext as Bn, PendingNodeExecution as Br, NodeId as Bt, BranchOutputGuard as C, instanceCachingFactory as Ci, branchRef as Cn, WebhookControlSignal as Cr, ItemBinary as Ct, RunFinishedAtFactory as D, singleton as Di, triggerNodeOutputType as Dn, WebhookTriggerRoutingDiagnostics as Dr, Items as Dt, ValidStepSequence as E, registry as Ei, runnableNodeWireType as En, WebhookTriggerResolution as Er, ItemInputMapperContext as Et, PersistedExecutionInstanceRecord as F, ExpRetryPolicy as Fi, BinaryStorageWriteResult as Fn, ExecutionFrontierPlan as Fr, NodeConnectionName as Ft, WorkflowRunDetailDto as G, Node as Gn, PersistedRunState as Gr, NodeSchedulerDecision as Gt, WorkItemId as H, ItemNode as Hn, PersistedMutableRunState as Hr, NodeOffloadPolicy as Ht, PersistedRunSlotProjectionRecord as I, RetryPolicy as Ii, EngineDeps as In, NodeExecutionError as Ir, NodeDefinition as It, CredentialBinding as J, NodeActivationRequest as Jn, PersistedWorkflowTokenRegistryLike as Jr, ParentExecutionRef as Jt, AnyCredentialType as K, NodeActivationContinuation as Kn, PersistedWorkflowSnapshot as Kr, OutputPortKey as Kt, PersistedRunWorkItemKind as L, NoRetryPolicy as Li, EngineHost as Ln, NodeExecutionSnapshot as Lr, NodeErrorHandler as Lt, ExecutionPayloadPolicyFields as M, RunEvent as Mi, BinaryStorageReadResult as Mn, ConnectionInvocationRecord as Mr, MutableRunData as Mt, PayloadStorageKind as N, RunEventBus as Ni, BinaryStorageStatResult as Nn, CurrentStateExecutionRequest as Nr, NodeActivationId as Nt, BatchId as O, CoreTokens as Oi, triggerNodeSetupStateType as On, AllWorkflowsActiveWorkflowActivationPolicy as Or, JsonArray as Ot, PersistedExecutionInstanceKind as P, RunEventSubscription as Pi, BinaryStorageWriteRequest as Pn, EngineRunCounters as Pr, NodeConfigBase as Pt, CredentialHealthStatus as Q, NodeExecutionContext as Qn, RunEventPublisherDeps as Qr, RunDataSnapshot as Qt, PersistedRunWorkItemRecord as R, ExponentialRetryPolicySpec as Ri, ExecutableTriggerNode as Rn, NodeExecutionStatus as Rr, NodeErrorHandlerArgs as Rt, BranchMoreArgs as S, injectable as Si, WorkflowStoragePolicySpec as Sn, TriggerInstanceId as Sr, Item as St, StepSequenceOutput as T, predicateAwareClassFactory as Ti, runnableNodeOutputType as Tn, WebhookTriggerMatcher as Tr, ItemInputMapperArgs as Tt, WorkItemStatus as U, LiveWorkflowRepository as Un, PersistedRunControlState as Ur, NodeOutputs as Ut, SlotExecutionStateDto as V, RetryPolicySpec as Vi, ExecutionContextFactory as Vn, PersistedMutableNodeState as Vr, NodeKind as Vt, WorkflowDetailSelectionState as W, MultiInputNode as Wn, PersistedRunSchedulingState as Wr, NodeRef as Wt, CredentialFieldSchema as X, NodeActivationScheduler as Xn, RunCompletionNotifier as Xr, PersistedTokenId as Xt, CredentialBindingKey as Y, NodeActivationRequestBase as Yn, PinnedNodeOutputsByPort as Yr, PersistedRunPolicySnapshot as Yt, CredentialHealth as Z, NodeBinaryAttachmentService as Zn, RunCurrentState as Zr, RunDataFactory as Zt, ChainCursor as _, TypeToken as _i, WorkflowPolicyRuntimeDefaults as _n, WorkflowRunnerResolver as _r, BinaryAttachment as _t, RunTerminalPersistenceCoordinator as a, RunStopCondition as ai, TriggerNodeConfig as an, PersistedTriggerSetupState as ar, CredentialRequirement as at, AnyTriggerNodeConfig as b, inject as bi, WorkflowStoragePolicyMode as bn, WorkflowSnapshotResolver as br, ExecutionMode as bt, EngineExecutionLimitsPolicyFactory as c, WorkflowExecutionListingRepository as ci, UpstreamRefPlaceholder as cn, TriggerCleanupHandle as cr, CredentialSessionService as ct, DefaultWorkflowGraphFactory as d, Container as di, WorkflowErrorHandler as dn, TriggerSetupContext as dr, CredentialTypeDefinition as dt, RunPruneCandidate as ei, RunIdFactory as en, NodeExecutionRequestHandler as er, CredentialInstanceId as et, WorkflowExecutableNodeClassifierFactory as f, DependencyContainer$1 as fi, WorkflowErrorHandlerSpec as fn, TriggerSetupStateFor as fr, CredentialTypeId as ft, WorkflowBuilder as g, RegistrationOptions as gi, WorkflowNodeConnection as gn, WorkflowRepository as gr, ActivationIdFactory as gt, ConnectionInvocationIdFactory as h, Lifecycle as hi, WorkflowId as hn, WorkflowNodeInstanceFactory as hr, OAuth2ProviderFromPublicConfig as ht, WorkflowPolicyErrorServices as i, RunStatus as ii, RunnableNodeWireJson as in, NodeResolver as ir, CredentialOAuth2AuthDefinition as it, ExecutionInstanceId as j, EngineExecutionLimitsPolicyConfig as ji, BinaryStorage as jn, ConnectionInvocationId as jr, JsonValue as jt, ConnectionInvocationKind as k, ENGINE_EXECUTION_LIMITS_DEFAULTS as ki, BinaryAttachmentCreateRequest as kn, WorkflowActivationPolicy as kr, JsonObject as kt, WorkflowSnapshotCodec as l, WorkflowExecutionPruneRepository as li, WorkflowDefinition as ln, TriggerNode as lr, CredentialSetupStatus as lt, ConnectionNodeIdFactory as m, InjectionToken$1 as mi, WorkflowGraphFactory as mn, TriggerTestItemsContext as mr, CredentialUnboundError as mt, InMemoryLiveWorkflowRepository as n, RunResult as ni, RunnableNodeInputJson as nn, NodeExecutionStatePublisher as nr, CredentialJsonRecord as nt, WorkflowStoragePolicyEvaluator as o, RunSummary as oi, TriggerNodeOutputJson as on, PreparedNodeActivationDispatch as or, CredentialSessionFactory as ot, WorkflowExecutableNodeClassifier as p, Disposable as pi, WorkflowGraph as pn, TriggerSetupStateRepository as pr, CredentialTypeRegistry as pt, CredentialAuthDefinition as q, NodeActivationReceipt as qn, PersistedWorkflowSnapshotNode as qr, PairedItemRef as qt, EngineWorkflowRunnerService as r, RunStateResetRequest as ri, RunnableNodeOutputJson as rn, NodeExecutor as rr, CredentialMaterialSourceKind as rt, RunPolicySnapshotFactory as s, WebhookRunResult as si, TriggerNodeSetupState as sn, TestableTriggerNode as sr, CredentialSessionFactoryArgs as st, RunIntentService as t, RunQueueEntry as ti, RunnableNodeConfig as tn, NodeExecutionScheduler as tr, CredentialInstanceRecord as tt, Engine as u, WorkflowExecutionRepository as ui, WorkflowErrorContext as un, TriggerRuntimeDiagnostics as ur, CredentialType as ut, WhenBuilder as v, container$1 as vi, WorkflowPrunePolicySpec as vn, WorkflowRunnerService as vr, BinaryPreviewKind as vt, BranchStepsArg as w, instancePerContainerCachingFactory as wi, runnableNodeInputType as wn, WebhookInvocationMatch as wr, ItemInputMapper as wt, BooleanWhenOverloads as x, injectAll as xi, WorkflowStoragePolicyResolver as xn, HttpMethod as xr, InputPortKey as xt, AnyRunnableNodeConfig as y, delay as yi, WorkflowStoragePolicyDecisionArgs as yn, WorkflowSnapshotFactory as yr, Edge as yt, RunRevision as z, FixedRetryPolicySpec as zi, ExecutionBinaryService as zn, NodeInputsByPort as zr, NodeErrorHandlerSpec as zt };
-//# sourceMappingURL=RunIntentService-BAKikN8h.d.ts.map
+export { ItemValueResolvedContext as $, RunEventBus as $i, PreparedNodeActivationDispatch as $n, RunStatus as $r, UpstreamRefPlaceholder as $t, ExecutionInstanceDto as A, OAuth2ProviderFromPublicConfig as Ai, EngineDeps as An, ExecutionFrontierPlan as Ar, NodeErrorHandlerArgs as At, RunSlotProjectionState as B, inject as Bi, NodeActivationReceipt as Bn, PersistedRunState as Br, ParentExecutionRef as Bt, BranchOutputGuard as C, CredentialSessionService as Ci, BinaryAttachmentCreateRequest as Cn, AllWorkflowsActiveWorkflowActivationPolicy as Cr, LineageCarryPolicy as Ct, RunFinishedAtFactory as D, CredentialTypeId as Di, BinaryStorageStatResult as Dn, ConnectionInvocationRecord as Dr, NodeConnectionName as Dt, ValidStepSequence as E, CredentialTypeDefinition as Ei, BinaryStorageReadResult as En, ConnectionInvocationId as Er, NodeConfigBase as Et, PersistedExecutionInstanceRecord as F, Lifecycle as Fi, ExecutionContextFactory as Fn, PendingNodeExecution as Fr, NodeOutputs as Ft, WorkflowRunDetailDto as G, predicateAwareClassFactory as Gi, NodeExecutionContext as Gn, RunCompletionNotifier as Gr, RunId as Gt, WorkItemId as H, injectable as Hi, NodeActivationRequestBase as Hn, PersistedWorkflowSnapshotNode as Hr, PersistedTokenId as Ht, PersistedRunSlotProjectionRecord as I, RegistrationOptions as Ii, ItemNode as In, PersistedMutableNodeState as Ir, NodeRef as It, NoRetryPolicy as J, CoreTokens as Ji, NodeExecutionScheduler as Jn, RunExecutionOptions as Jr, RunnableNodeInputJson as Jt, ExpRetryPolicy as K, registry as Ki, NodeExecutionRequest as Kn, RunCurrentState as Kr, RunIdFactory as Kt, PersistedRunWorkItemKind as L, TypeToken as Li, LiveWorkflowRepository as Ln, PersistedMutableRunState as Lr, NodeSchedulerDecision as Lt, ExecutionPayloadPolicyFields as M, DependencyContainer$1 as Mi, ExecutableTriggerNode as Mn, NodeExecutionSnapshot as Mr, NodeId as Mt, PayloadStorageKind as N, Disposable as Ni, ExecutionBinaryService as Nn, NodeExecutionStatus as Nr, NodeKind as Nt, BatchId as O, CredentialTypeRegistry as Oi, BinaryStorageWriteRequest as On, CurrentStateExecutionRequest as Or, NodeDefinition as Ot, PersistedExecutionInstanceKind as P, InjectionToken$1 as Pi, ExecutionContext as Pn, NodeInputsByPort as Pr, NodeOffloadPolicy as Pt, ItemValueContext as Q, RunEvent as Qi, PersistedTriggerSetupState as Qn, RunStateResetRequest as Qr, TriggerNodeSetupState as Qt, PersistedRunWorkItemRecord as R, container$1 as Ri, MultiInputNode as Rn, PersistedRunControlState as Rr, OutputPortKey as Rt, BranchMoreArgs as S, CredentialSessionFactoryArgs as Si, RetryPolicySpec as Sn, WebhookTriggerRoutingDiagnostics as Sr, JsonValue as St, StepSequenceOutput as T, CredentialType as Ti, BinaryStorage as Tn, ConnectionInvocationAppendArgs as Tr, NodeActivationId as Tt, WorkItemStatus as U, instanceCachingFactory as Ui, NodeActivationScheduler as Un, PersistedWorkflowTokenRegistryLike as Ur, RunDataFactory as Ut, SlotExecutionStateDto as V, injectAll as Vi, NodeActivationRequest as Vn, PersistedWorkflowSnapshot as Vr, PersistedRunPolicySnapshot as Vt, WorkflowDetailSelectionState as W, instancePerContainerCachingFactory as Wi, NodeBinaryAttachmentService as Wn, PinnedNodeOutputsByPort as Wr, RunDataSnapshot as Wt, ItemValueArgs as X, EngineExecutionLimitsPolicy as Xi, NodeExecutor as Xn, RunQueueEntry as Xr, TriggerNodeConfig as Xt, ItemValue as Y, ENGINE_EXECUTION_LIMITS_DEFAULTS as Yi, NodeExecutionStatePublisher as Yn, RunPruneCandidate as Yr, RunnableNodeOutputJson as Yt, ItemValueCallback as Z, EngineExecutionLimitsPolicyConfig as Zi, NodeResolver as Zn, RunResult as Zr, TriggerNodeOutputJson as Zt, ChainCursor as _, CredentialMaterialSourceKind as _i, triggerNodeOutputType as _n, TriggerInstanceId as _r, Items as _t, RunTerminalPersistenceCoordinator as a, WorkflowExecutionRepository as ai, WorkflowGraphFactory as an, TriggerRuntimeDiagnostics as ar, PortsEmission as at, AnyTriggerNodeConfig as b, CredentialRequirement as bi, FixedRetryPolicySpec as bn, WebhookTriggerMatcher as br, JsonObject as bt, EngineExecutionLimitsPolicyFactory as c, CredentialBinding as ci, WorkflowPolicyRuntimeDefaults as cn, TriggerSetupStateRepository as cr, isUnbrandedPortsEmissionShape as ct, DefaultWorkflowGraphFactory as d, CredentialHealth as di, WorkflowStoragePolicyMode as dn, WorkflowRepository as dr, BinaryPreviewKind as dt, RunEventSubscription as ea, RunStopCondition as ei, WorkflowDefinition as en, RunnableNode as er, isItemValue as et, WorkflowExecutableNodeClassifierFactory as f, CredentialHealthStatus as fi, WorkflowStoragePolicyResolver as fn, WorkflowRunnerResolver as fr, Edge as ft, WorkflowBuilder as g, CredentialJsonRecord as gi, runnableNodeOutputType as gn, HttpMethod as gr, ItemBinary as gt, ConnectionInvocationIdFactory as h, CredentialInstanceRecord as hi, runnableNodeInputType as hn, WorkflowSnapshotResolver as hr, Item as ht, WorkflowPolicyErrorServices as i, WorkflowExecutionPruneRepository as ii, WorkflowGraph as in, TriggerNode as ir, getOriginIndexFromItem as it, ExecutionInstanceId as j, Container as ji, EngineHost as jn, NodeExecutionError as jr, NodeErrorHandlerSpec as jt, ConnectionInvocationKind as k, CredentialUnboundError as ki, BinaryStorageWriteResult as kn, EngineRunCounters as kr, NodeErrorHandler as kt, WorkflowSnapshotCodec as l, CredentialBindingKey as li, WorkflowPrunePolicySpec as ln, TriggerTestItemsContext as lr, ActivationIdFactory as lt, ConnectionNodeIdFactory as m, CredentialInstanceId as mi, branchRef as mn, WorkflowSnapshotFactory as mr, InputPortKey as mt, InMemoryLiveWorkflowRepository as n, WebhookRunResult as ni, WorkflowErrorHandler as nn, TestableTriggerNode as nr, resolveItemValuesForExecution as nt, WorkflowStoragePolicyEvaluator as o, AnyCredentialType as oi, WorkflowId as on, TriggerSetupContext as or, emitPorts as ot, WorkflowExecutableNodeClassifier as p, CredentialHealthTester as pi, WorkflowStoragePolicySpec as pn, WorkflowRunnerService as pr, ExecutionMode as pt, RetryPolicy as q, singleton as qi, NodeExecutionRequestHandler as qn, RunEventPublisherDeps as qr, RunnableNodeConfig as qt, EngineWorkflowRunnerService as r, WorkflowExecutionListingRepository as ri, WorkflowErrorHandlerSpec as rn, TriggerCleanupHandle as rr, resolveItemValuesInUnknown as rt, RunPolicySnapshotFactory as s, CredentialAuthDefinition as si, WorkflowNodeConnection as sn, TriggerSetupStateFor as sr, isPortsEmission as st, RunIntentService as t, RunSummary as ti, WorkflowErrorContext as tn, RunnableNodeExecuteArgs as tr, itemValue as tt, Engine as u, CredentialFieldSchema as ui, WorkflowStoragePolicyDecisionArgs as un, WorkflowNodeInstanceFactory as ur, BinaryAttachment as ut, WhenBuilder as v, CredentialOAuth2AuthDefinition as vi, triggerNodeSetupStateType as vn, WebhookControlSignal as vr, JsonArray as vt, BranchStepsArg as w, CredentialSetupStatus as wi, BinaryBody as wn, WorkflowActivationPolicy as wr, MutableRunData as wt, BooleanWhenOverloads as x, CredentialSessionFactory as xi, NoneRetryPolicySpec as xn, WebhookTriggerResolution as xr, JsonPrimitive as xt, AnyRunnableNodeConfig as y, CredentialOAuth2ScopesFromPublicConfig as yi, ExponentialRetryPolicySpec as yn, WebhookInvocationMatch as yr, JsonNonArray as yt, RunRevision as z, delay as zi, NodeActivationContinuation as zn, PersistedRunSchedulingState as zr, PairedItemRef as zt };
+//# sourceMappingURL=RunIntentService-Dkr4YwN8.d.ts.map