@codemation/core 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @codemation/core
 
+## 0.3.0
+
+### Minor Changes
+
+- [#52](https://github.com/MadeRelevant/codemation/pull/52) [`bb2b3b8`](https://github.com/MadeRelevant/codemation/commit/bb2b3b89069697c6aa36aac1de7124c5eea65c3e) Thanks [@cblokland90](https://github.com/cblokland90)! - **Breaking change:** `defineNode(...)` now follows the per-item pipeline: implement **`executeOne(args, context)`** (optional **`inputSchema`**, **`mapInput`**, and **`TWireJson`** on the generated runnable config). Add **`defineBatchNode(...)`** with **`run(items, context)`** for plugin nodes that still require legacy batch **`Node.execute`** semantics.
+
+  Align documentation (site guides, repo **`AGENTS.md`**, **`strict-oop-di`** skill, **`packages/core/docs/item-node-execution.md`**) and the **plugin** starter **`AGENTS.md`** with **config** for static wiring (credentials, retry, presentation) vs **inputs** / wire JSON for per-item behavior.
+
+## 0.2.3
+
+### Patch Changes
+
+- [#50](https://github.com/MadeRelevant/codemation/pull/50) [`d3a4321`](https://github.com/MadeRelevant/codemation/commit/d3a4321dc178df51dfd61cc6eb872ccca36bbcdb) Thanks [@cblokland90](https://github.com/cblokland90)! - Release automation: GitHub Actions now dispatches `publish-npm.yml` after versioning so npm OIDC trusted publishing continues to match the publish workflow file (no `workflow_call` from the Changesets workflow).
+
+## 0.2.2
+
+### Patch Changes
+
+- [#47](https://github.com/MadeRelevant/codemation/pull/47) [`74dc571`](https://github.com/MadeRelevant/codemation/commit/74dc571afb592bd7c05297b25f9f1fb06a46815f) Thanks [@cblokland90](https://github.com/cblokland90)! - Item-node input mapping refinements, `RunQueuePlanner` multi-input merge routing, Split/Filter/Aggregate batch nodes, AIAgent `ItemNode` + optional `mapInput`/`inputSchema`, and documentation updates.
+
+- [#47](https://github.com/MadeRelevant/codemation/pull/47) [`74dc571`](https://github.com/MadeRelevant/codemation/commit/74dc571afb592bd7c05297b25f9f1fb06a46815f) Thanks [@cblokland90](https://github.com/cblokland90)! - Add `TWireJson` to `RunnableNodeConfig`, typed `ItemInputMapper<TWire, TIn>` (bivariant for storage), `RunnableNodeWireJson` helper, and align `ChainCursor` / workflow DSL with upstream wire typing. Introduce `ItemInputMapperContext` so `mapInput` receives typed `ctx.data` (`RunDataSnapshot`) for reading any completed upstream node’s outputs.
+
 ## 0.2.1
 
 ### Patch Changes

package/README.md

@@ -14,6 +14,8 @@ npm install @codemation/core@^0.0.0
 
 Use this package when you define workflows, implement **custom nodes** (config classes + `Node` implementations), or integrate with the engine in TypeScript. Consumer apps and node packages should depend on `@codemation/core`; they should not pull host or infrastructure code into engine-shaped modules.
 
+Plugin-style helpers: **`defineNode(...)`** generates an **`ItemNode`** — implement **`executeOne`**. Use **`defineBatchNode(...)`** for legacy batch **`run(items, ...)`**. See **`docs/item-node-execution.md`** in this package.
+
 ## Usage
 
 Main entry:

package/dist/{EngineRuntimeRegistration.types-0sgV2XL2.d.ts → EngineRuntimeRegistration.types-Bjeo7Sfq.d.ts}

@@ -1,4 +1,4 @@
-import { Ti as EngineExecutionLimitsPolicyConfig, ir as TriggerRuntimeDiagnostics, oi as DependencyContainer, xr as WebhookTriggerRoutingDiagnostics, yr as WebhookTriggerMatcher } from "./RunIntentService-BCvGdOSY.js";
+import { Dr as WebhookTriggerRoutingDiagnostics, Tr as WebhookTriggerMatcher, fi as DependencyContainer, ji as EngineExecutionLimitsPolicyConfig, ur as TriggerRuntimeDiagnostics } from "./RunIntentService-BAKikN8h.js";
 
 //#region src/bootstrap/runtime/EngineRuntimeRegistration.types.d.ts
 
@@ -39,4 +39,4 @@ interface EngineRuntimeRegistrationOptions {
 }
 //#endregion
 export { TriggerRuntimeDiagnosticsProvider as n, WebhookTriggerMatcherProvider as r, EngineRuntimeRegistrationOptions as t };
-//# sourceMappingURL=EngineRuntimeRegistration.types-0sgV2XL2.d.ts.map
+//# sourceMappingURL=EngineRuntimeRegistration.types-Bjeo7Sfq.d.ts.map

package/dist/{EngineWorkflowRunnerService-Dx7bJsJR.d.cts → EngineWorkflowRunnerService-Dd4yD31l.d.cts}

@@ -1,4 +1,4 @@
-import { $n as PersistedWorkflowSnapshotNode, Ct as WorkflowId, I as Items, Lr as EngineExecutionLimitsPolicyConfig, Nn as WebhookTriggerRoutingDiagnostics, Qn as PersistedWorkflowSnapshot, Sn as WorkflowRepository, U as NodeConfigBase, Y as NodeId, _t as WorkflowDefinition, cr as RunResult, er as PersistedWorkflowTokenRegistryLike, gn as TriggerRuntimeDiagnostics, jn as WebhookTriggerMatcher, r as Engine, rt as ParentExecutionRef, vr as DependencyContainer } from "./RunIntentService-CV8izV8t.cjs";
+import { Dt as WorkflowId, K as NodeConfigBase, Ln as WebhookTriggerMatcher, On as WorkflowRepository, Q as NodeId, Sn as TriggerRuntimeDiagnostics, Ur as EngineExecutionLimitsPolicyConfig, ar as PersistedWorkflowSnapshotNode, ir as PersistedWorkflowSnapshot, mr as RunResult, or as PersistedWorkflowTokenRegistryLike, ot as ParentExecutionRef, r as Engine, wr as DependencyContainer, xt as WorkflowDefinition, z as Items, zn as WebhookTriggerRoutingDiagnostics } from "./RunIntentService-Bkg4oYrM.cjs";
 
 //#region src/workflowSnapshots/WorkflowSnapshotCodec.d.ts
 declare class WorkflowSnapshotCodec {
@@ -70,4 +70,4 @@ declare class EngineWorkflowRunnerService {
 }
 //#endregion
 export { WorkflowSnapshotCodec as a, WebhookTriggerMatcherProvider as i, EngineRuntimeRegistrationOptions as n, TriggerRuntimeDiagnosticsProvider as r, EngineWorkflowRunnerService as t };
-//# sourceMappingURL=EngineWorkflowRunnerService-Dx7bJsJR.d.cts.map
+//# sourceMappingURL=EngineWorkflowRunnerService-Dd4yD31l.d.cts.map

package/dist/{InMemoryRunDataFactory-qIYQEar7.d.cts → InMemoryRunDataFactory-OUzDmAHt.d.cts}

@@ -1,4 +1,4 @@
-import { Bt as BinaryStorageStatResult, Ct as WorkflowId, H as NodeActivationId, Ht as BinaryStorageWriteResult, Jt as ExecutionContextFactory, Kt as ExecutionBinaryService, Lt as BinaryBody, Q as NodeOutputs, Rt as BinaryStorage, V as MutableRunData, Wr as RetryPolicySpec, Y as NodeId, b as CredentialSessionService, cn as NodeExecutionStatePublisher, ct as RunId, in as NodeExecutionContext, k as BinaryAttachment, ot as RunDataFactory, qt as ExecutionContext, rn as NodeBinaryAttachmentService, rt as ParentExecutionRef, st as RunDataSnapshot, zt as BinaryStorageReadResult } from "./RunIntentService-CV8izV8t.cjs";
+import { $t as ExecutionContextFactory, Dt as WorkflowId, G as NodeActivationId, Gt as BinaryStorageStatResult, Ht as BinaryBody, Q as NodeId, Qt as ExecutionContext, Ut as BinaryStorage, W as MutableRunData, Wt as BinaryStorageReadResult, Xr as RetryPolicySpec, Zt as ExecutionBinaryService, b as CredentialSessionService, dt as RunId, k as BinaryAttachment, ln as NodeBinaryAttachmentService, lt as RunDataFactory, mn as NodeExecutionStatePublisher, ot as ParentExecutionRef, qt as BinaryStorageWriteResult, tt as NodeOutputs, un as NodeExecutionContext, ut as RunDataSnapshot } from "./RunIntentService-Bkg4oYrM.cjs";
 
 //#region src/execution/CredentialResolverFactory.d.ts
 declare class CredentialResolverFactory {
@@ -91,4 +91,4 @@ declare class InMemoryRunDataFactory implements RunDataFactory {
 }
 //#endregion
 export { InProcessRetryRunner as a, AsyncSleeper as c, UnavailableBinaryStorage as i, CredentialResolverFactory as l, InMemoryBinaryStorage as n, DefaultExecutionContextFactory as o, DefaultExecutionBinaryService as r, DefaultAsyncSleeper as s, InMemoryRunDataFactory as t };
-//# sourceMappingURL=InMemoryRunDataFactory-qIYQEar7.d.cts.map
+//# sourceMappingURL=InMemoryRunDataFactory-OUzDmAHt.d.cts.map

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

@@ -1,9 +1,9 @@
 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 { 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).
@@ -684,6 +684,23 @@ interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
   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`.
+ */
+interface ItemNode<TConfig extends NodeConfigBase = NodeConfigBase, TInputJson$1 = unknown, TOutputJson$1 = unknown> {
+  readonly kind: "node";
+  readonly outputPorts: readonly ["main"];
+  /** 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;
+}
 interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
   kind: "node";
   outputPorts: ReadonlyArray<OutputPortKey>;
@@ -902,11 +919,61 @@ interface NodeConfigBase {
 }
 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;
-interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
+/**
+ * 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.
+ */
+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 {
   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.
+   * 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.
+   */
+  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
 }
 declare const triggerNodeSetupStateType: unique symbol;
 interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonValue | undefined = undefined> extends NodeConfigBase {
@@ -914,8 +981,9 @@ interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonV
   readonly [triggerNodeOutputType]?: TOutputJson$1;
   readonly [triggerNodeSetupStateType]?: TSetupState$1;
 }
-type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any> ? TInputJson : never;
-type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson> ? TOutputJson : never;
+type 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 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 {
@@ -1369,17 +1437,17 @@ declare class RunFinishedAtFactory {
 }
 //#endregion
 //#region src/workflow/dsl/workflowBuilderTypes.d.ts
-type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
+type AnyRunnableNodeConfig = RunnableNodeConfig<any, any, any>;
 type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
-type ValidStepSequence<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps extends readonly [] ? readonly [] : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>] : never : never : TSteps;
-type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? TSteps extends readonly [] ? TCurrentJson : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? StepSequenceOutput<TNextJson, TRest> : never : never : TCurrentJson : TCurrentJson;
+type 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 TypesMatch<TLeft, TRight> = [TLeft] extends [TRight] ? ([TRight] extends [TLeft] ? true : false) : false;
 type BranchOutputGuard<TCurrentJson, TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TypesMatch<StepSequenceOutput<TCurrentJson, TTrueSteps>, StepSequenceOutput<TCurrentJson, TFalseSteps>> extends true ? unknown : never;
 type BranchStepsArg<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps & ValidStepSequence<TCurrentJson, TSteps>;
-type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
+type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
 type BooleanWhenOverloads<TCurrentJson, TReturn> = {
   <TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, steps: BranchStepsArg<TCurrentJson, TSteps>): TReturn;
-  <TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
+  <TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
 };
 //#endregion
 //#region src/workflow/dsl/WhenBuilder.d.ts
@@ -1405,7 +1473,7 @@ declare class ChainCursor<TCurrentJson> {
   private readonly cursor;
   private readonly cursorOutput;
   constructor(wf: WorkflowBuilder, cursor: NodeRef, cursorOutput: OutputPortKey);
-  then<TConfig extends RunnableNodeConfig<TCurrentJson, any>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
+  then<TInputJson$1, TOutputJson$1, TConfig extends RunnableNodeConfig<TInputJson$1, TOutputJson$1, TCurrentJson>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
   readonly when: ChainCursorWhenOverloads<TCurrentJson>;
   build(): WorkflowDefinition;
 }
@@ -1769,5 +1837,5 @@ declare class RunIntentService {
   private createWebhookExecutionOptions;
 }
 //#endregion
-export { CredentialHealthTester as $, PersistedTriggerSetupState as $n, RunStopCondition as $r, RunnableNodeInputJson as $t, ExecutionInstanceDto as A, RetryPolicy as Ai, BinaryStorageWriteResult as An, NodeExecutionError as Ar, NodeActivationId as At, RunSlotProjectionState as B, NodeActivationContinuation as Bn, PersistedWorkflowSnapshot as Br, NodeOutputs as Bt, BranchOutputGuard as C, ENGINE_EXECUTION_LIMITS_DEFAULTS as Ci, triggerNodeSetupStateType as Cn, WorkflowActivationPolicy as Cr, ItemBinary as Ct, RunFinishedAtFactory as D, RunEventBus as Di, BinaryStorageReadResult as Dn, CurrentStateExecutionRequest as Dr, JsonPrimitive as Dt, ValidStepSequence as E, RunEvent as Ei, BinaryStorage as En, ConnectionInvocationRecord as Er, JsonObject as Et, PersistedExecutionInstanceRecord as F, RetryPolicySpec as Fi, ExecutionContext as Fn, PersistedMutableNodeState as Fr, NodeErrorHandlerArgs as Ft, WorkflowRunDetailDto as G, NodeBinaryAttachmentService as Gn, RunCurrentState as Gr, ParentExecutionRef as Gt, WorkItemId as H, NodeActivationRequest as Hn, PersistedWorkflowTokenRegistryLike as Hr, NodeSchedulerDecision as Ht, PersistedRunSlotProjectionRecord as I, ExecutionContextFactory as In, PersistedMutableRunState as Ir, NodeErrorHandlerSpec as It, CredentialBinding as J, NodeExecutionRequestHandler as Jn, RunPruneCandidate as Jr, RunDataFactory as Jt, AnyCredentialType as K, NodeExecutionContext as Kn, RunEventPublisherDeps as Kr, PersistedRunPolicySnapshot as Kt, PersistedRunWorkItemKind as L, LiveWorkflowRepository as Ln, PersistedRunControlState as Lr, NodeId as Lt, ExecutionPayloadPolicyFields as M, ExponentialRetryPolicySpec as Mi, EngineHost as Mn, NodeExecutionStatus as Mr, NodeConnectionName as Mt, PayloadStorageKind as N, FixedRetryPolicySpec as Ni, ExecutableTriggerNode as Nn, NodeInputsByPort as Nr, NodeDefinition as Nt, BatchId as O, RunEventSubscription as Oi, BinaryStorageStatResult as On, EngineRunCounters as Or, JsonValue as Ot, PersistedExecutionInstanceKind as P, NoneRetryPolicySpec as Pi, ExecutionBinaryService as Pn, PendingNodeExecution as Pr, NodeErrorHandler as Pt, CredentialHealthStatus as Q, NodeResolver as Qn, RunStatus as Qr, RunnableNodeConfig as Qt, PersistedRunWorkItemRecord as R, MultiInputNode as Rn, PersistedRunSchedulingState as Rr, NodeKind as Rt, BranchMoreArgs as S, CoreTokens as Si, triggerNodeOutputType as Sn, AllWorkflowsActiveWorkflowActivationPolicy as Sr, Item as St, StepSequenceOutput as T, EngineExecutionLimitsPolicyConfig as Ti, BinaryBody as Tn, ConnectionInvocationId as Tr, JsonArray as Tt, WorkItemStatus as U, NodeActivationRequestBase as Un, PinnedNodeOutputsByPort as Ur, OutputPortKey as Ut, SlotExecutionStateDto as V, NodeActivationReceipt as Vn, PersistedWorkflowSnapshotNode as Vr, NodeRef as Vt, WorkflowDetailSelectionState as W, NodeActivationScheduler as Wn, RunCompletionNotifier as Wr, PairedItemRef as Wt, CredentialFieldSchema as X, NodeExecutionStatePublisher as Xn, RunResult as Xr, RunId as Xt, CredentialBindingKey as Y, NodeExecutionScheduler as Yn, RunQueueEntry as Yr, RunDataSnapshot as Yt, CredentialHealth as Z, NodeExecutor as Zn, RunStateResetRequest as Zr, RunIdFactory as Zt, ChainCursor as _, instanceCachingFactory as _i, WorkflowStoragePolicyResolver as _n, WebhookControlSignal as _r, BinaryAttachment as _t, RunTerminalPersistenceCoordinator as a, Container as ai, WorkflowDefinition as an, TriggerSetupContext as ar, CredentialRequirement as at, AnyTriggerNodeConfig as b, registry as bi, runnableNodeInputType as bn, WebhookTriggerResolution as br, ExecutionMode as bt, EngineExecutionLimitsPolicyFactory as c, InjectionToken$1 as ci, WorkflowErrorHandlerSpec as cn, TriggerTestItemsContext as cr, CredentialSessionService as ct, DefaultWorkflowGraphFactory as d, TypeToken as di, WorkflowId as dn, WorkflowRunnerResolver as dr, CredentialTypeDefinition as dt, RunSummary as ei, RunnableNodeOutputJson as en, PreparedNodeActivationDispatch as er, CredentialInstanceId as et, WorkflowExecutableNodeClassifierFactory as f, container$1 as fi, WorkflowNodeConnection as fn, WorkflowRunnerService as fr, CredentialTypeId as ft, WorkflowBuilder as g, injectable as gi, WorkflowStoragePolicyMode as gn, TriggerInstanceId as gr, ActivationIdFactory as gt, ConnectionInvocationIdFactory as h, injectAll as hi, WorkflowStoragePolicyDecisionArgs as hn, HttpMethod as hr, OAuth2ProviderFromPublicConfig as ht, WorkflowPolicyErrorServices as i, WorkflowExecutionRepository as ii, UpstreamRefPlaceholder as in, TriggerRuntimeDiagnostics as ir, CredentialOAuth2AuthDefinition as it, ExecutionInstanceId as j, NoRetryPolicy as ji, EngineDeps as jn, NodeExecutionSnapshot as jr, NodeConfigBase as jt, ConnectionInvocationKind as k, ExpRetryPolicy as ki, BinaryStorageWriteRequest as kn, ExecutionFrontierPlan as kr, MutableRunData as kt, WorkflowSnapshotCodec as l, Lifecycle as li, WorkflowGraph as ln, WorkflowNodeInstanceFactory as lr, CredentialSetupStatus as lt, ConnectionNodeIdFactory as m, inject as mi, WorkflowPrunePolicySpec as mn, WorkflowSnapshotResolver as mr, CredentialUnboundError as mt, InMemoryLiveWorkflowRepository as n, WorkflowExecutionListingRepository as ni, TriggerNodeOutputJson as nn, TriggerCleanupHandle as nr, CredentialJsonRecord as nt, WorkflowStoragePolicyEvaluator as o, DependencyContainer$1 as oi, WorkflowErrorContext as on, TriggerSetupStateFor as or, CredentialSessionFactory as ot, WorkflowExecutableNodeClassifier as p, delay as pi, WorkflowPolicyRuntimeDefaults as pn, WorkflowSnapshotFactory as pr, CredentialTypeRegistry as pt, CredentialAuthDefinition as q, NodeExecutionRequest as qn, RunExecutionOptions as qr, PersistedTokenId as qt, EngineWorkflowRunnerService as r, WorkflowExecutionPruneRepository as ri, TriggerNodeSetupState as rn, TriggerNode as rr, CredentialMaterialSourceKind as rt, RunPolicySnapshotFactory as s, Disposable as si, WorkflowErrorHandler as sn, TriggerSetupStateRepository as sr, CredentialSessionFactoryArgs as st, RunIntentService as t, WebhookRunResult as ti, TriggerNodeConfig as tn, TestableTriggerNode as tr, CredentialInstanceRecord as tt, Engine as u, RegistrationOptions as ui, WorkflowGraphFactory as un, WorkflowRepository as ur, CredentialType as ut, WhenBuilder as v, instancePerContainerCachingFactory as vi, WorkflowStoragePolicySpec as vn, WebhookInvocationMatch as vr, BinaryPreviewKind as vt, BranchStepsArg as w, EngineExecutionLimitsPolicy as wi, BinaryAttachmentCreateRequest as wn, ConnectionInvocationAppendArgs as wr, Items as wt, BooleanWhenOverloads as x, singleton as xi, runnableNodeOutputType as xn, WebhookTriggerRoutingDiagnostics as xr, InputPortKey as xt, AnyRunnableNodeConfig as y, predicateAwareClassFactory as yi, branchRef as yn, WebhookTriggerMatcher as yr, Edge as yt, RunRevision as z, Node as zn, PersistedRunState as zr, NodeOffloadPolicy as zt };
-//# sourceMappingURL=RunIntentService-BCvGdOSY.d.ts.map
+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

package/dist/{RunIntentService-CV8izV8t.d.cts → RunIntentService-Bkg4oYrM.d.cts}

@@ -1,5 +1,6 @@
 import { ReadableStream } from "node:stream/web";
 import { DependencyContainer as Container, DependencyContainer as DependencyContainer$1, Disposable, InjectionToken as InjectionToken$1, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+import { ZodType } from "zod";
 
 //#region src/contracts/retryPolicySpec.types.d.ts
 
@@ -655,6 +656,23 @@ interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
   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`.
+ */
+interface ItemNode<TConfig extends NodeConfigBase = NodeConfigBase, TInputJson$1 = unknown, TOutputJson$1 = unknown> {
+  readonly kind: "node";
+  readonly outputPorts: readonly ["main"];
+  /** 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;
+}
 interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
   kind: "node";
   outputPorts: ReadonlyArray<OutputPortKey>;
@@ -873,11 +891,61 @@ interface NodeConfigBase {
 }
 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;
-interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
+/**
+ * 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.
+ */
+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 {
   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.
+   * 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.
+   */
+  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
 }
 declare const triggerNodeSetupStateType: unique symbol;
 interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonValue | undefined = undefined> extends NodeConfigBase {
@@ -885,8 +953,9 @@ interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonV
   readonly [triggerNodeOutputType]?: TOutputJson$1;
   readonly [triggerNodeSetupStateType]?: TSetupState$1;
 }
-type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any> ? TInputJson : never;
-type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson> ? TOutputJson : never;
+type 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 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 {
@@ -1375,5 +1444,5 @@ declare class RunIntentService {
   private createWebhookExecutionOptions;
 }
 //#endregion
-export { NodeRef as $, PersistedWorkflowSnapshotNode as $n, NodeActivationReceipt as $t, BinaryPreviewKind as A, WebhookInvocationMatch as An, instancePerContainerCachingFactory as Ar, WorkflowStoragePolicySpec as At, JsonValue as B, EngineRunCounters as Bn, RunEventSubscription as Br, BinaryStorageStatResult as Bt, CredentialTypeDefinition as C, WorkflowRunnerResolver as Cn, TypeToken as Cr, WorkflowId as Ct, OAuth2ProviderFromPublicConfig as D, HttpMethod as Dn, injectAll as Dr, WorkflowStoragePolicyDecisionArgs as Dt, CredentialUnboundError as E, WorkflowSnapshotResolver as En, inject as Er, WorkflowPrunePolicySpec as Et, ItemBinary as F, WorkflowActivationPolicy as Fn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Fr, triggerNodeSetupStateType as Ft, NodeDefinition as G, NodeInputsByPort as Gn, ExecutableTriggerNode as Gt, NodeActivationId as H, NodeExecutionError as Hn, FixedRetryPolicySpec as Hr, BinaryStorageWriteResult as Ht, Items as I, ConnectionInvocationAppendArgs as In, EngineExecutionLimitsPolicy as Ir, BinaryAttachmentCreateRequest as It, NodeErrorHandlerSpec as J, PersistedMutableRunState as Jn, ExecutionContextFactory as Jt, NodeErrorHandler as K, PendingNodeExecution as Kn, ExecutionBinaryService as Kt, JsonArray as L, ConnectionInvocationId as Ln, EngineExecutionLimitsPolicyConfig as Lr, BinaryBody as Lt, ExecutionMode as M, WebhookTriggerResolution as Mn, registry as Mr, runnableNodeInputType as Mt, InputPortKey as N, WebhookTriggerRoutingDiagnostics as Nn, singleton as Nr, runnableNodeOutputType as Nt, ActivationIdFactory as O, TriggerInstanceId as On, injectable as Or, WorkflowStoragePolicyMode as Ot, Item as P, AllWorkflowsActiveWorkflowActivationPolicy as Pn, CoreTokens as Pr, triggerNodeOutputType as Pt, NodeOutputs as Q, PersistedWorkflowSnapshot as Qn, NodeActivationContinuation as Qt, JsonObject as R, ConnectionInvocationRecord as Rn, RunEvent as Rr, BinaryStorage as Rt, CredentialType as S, WorkflowRepository as Sn, RegistrationOptions as Sr, WorkflowGraphFactory as St, CredentialTypeRegistry as T, WorkflowSnapshotFactory as Tn, delay as Tr, WorkflowPolicyRuntimeDefaults as Tt, NodeConfigBase as U, NodeExecutionSnapshot as Un, NoneRetryPolicySpec as Ur, EngineDeps as Ut, MutableRunData as V, ExecutionFrontierPlan as Vn, ExponentialRetryPolicySpec as Vr, BinaryStorageWriteRequest as Vt, NodeConnectionName as W, NodeExecutionStatus as Wn, RetryPolicySpec as Wr, EngineHost as Wt, NodeKind as X, PersistedRunSchedulingState as Xn, MultiInputNode as Xt, NodeId as Y, PersistedRunControlState as Yn, LiveWorkflowRepository as Yt, NodeOffloadPolicy as Z, PersistedRunState as Zn, Node as Zt, CredentialRequirement as _, TriggerSetupContext as _n, Container as _r, WorkflowDefinition as _t, CredentialAuthDefinition as a, NodeExecutionRequest as an, RunExecutionOptions as ar, PersistedTokenId as at, CredentialSessionService as b, TriggerTestItemsContext as bn, InjectionToken$1 as br, WorkflowErrorHandlerSpec as bt, CredentialFieldSchema as c, NodeExecutionStatePublisher as cn, RunResult as cr, RunId as ct, CredentialHealthTester as d, PersistedTriggerSetupState as dn, RunStopCondition as dr, RunnableNodeInputJson as dt, NodeActivationRequest as en, PersistedWorkflowTokenRegistryLike as er, NodeSchedulerDecision as et, CredentialInstanceId as f, PreparedNodeActivationDispatch as fn, RunSummary as fr, RunnableNodeOutputJson as ft, CredentialOAuth2AuthDefinition as g, TriggerRuntimeDiagnostics as gn, WorkflowExecutionRepository as gr, UpstreamRefPlaceholder as gt, CredentialMaterialSourceKind as h, TriggerNode as hn, WorkflowExecutionPruneRepository as hr, TriggerNodeSetupState as ht, AnyCredentialType as i, NodeExecutionContext as in, RunEventPublisherDeps as ir, PersistedRunPolicySnapshot as it, Edge as j, WebhookTriggerMatcher as jn, predicateAwareClassFactory as jr, branchRef as jt, BinaryAttachment as k, WebhookControlSignal as kn, instanceCachingFactory as kr, WorkflowStoragePolicyResolver as kt, CredentialHealth as l, NodeExecutor as ln, RunStateResetRequest as lr, RunIdFactory as lt, CredentialJsonRecord as m, TriggerCleanupHandle as mn, WorkflowExecutionListingRepository as mr, TriggerNodeOutputJson as mt, InMemoryLiveWorkflowRepository as n, NodeActivationScheduler as nn, RunCompletionNotifier as nr, PairedItemRef as nt, CredentialBinding as o, NodeExecutionRequestHandler as on, RunPruneCandidate as or, RunDataFactory as ot, CredentialInstanceRecord as p, TestableTriggerNode as pn, WebhookRunResult as pr, TriggerNodeConfig as pt, NodeErrorHandlerArgs as q, PersistedMutableNodeState as qn, ExecutionContext as qt, Engine as r, NodeBinaryAttachmentService as rn, RunCurrentState as rr, ParentExecutionRef as rt, CredentialBindingKey as s, NodeExecutionScheduler as sn, RunQueueEntry as sr, RunDataSnapshot as st, RunIntentService as t, NodeActivationRequestBase as tn, PinnedNodeOutputsByPort as tr, OutputPortKey as tt, CredentialHealthStatus as u, NodeResolver as un, RunStatus as ur, RunnableNodeConfig as ut, CredentialSessionFactory as v, TriggerSetupStateFor as vn, DependencyContainer$1 as vr, WorkflowErrorContext as vt, CredentialTypeId as w, WorkflowRunnerService as wn, container as wr, WorkflowNodeConnection as wt, CredentialSetupStatus as x, WorkflowNodeInstanceFactory as xn, Lifecycle as xr, WorkflowGraph as xt, CredentialSessionFactoryArgs as y, TriggerSetupStateRepository as yn, Disposable as yr, WorkflowErrorHandler as yt, JsonPrimitive as z, CurrentStateExecutionRequest as zn, RunEventBus as zr, BinaryStorageReadResult as zt };
-//# sourceMappingURL=RunIntentService-CV8izV8t.d.cts.map
+export { NodeKind as $, PersistedMutableNodeState as $n, ExecutionContextFactory as $t, BinaryPreviewKind as A, WorkflowRunnerService as An, container as Ar, WorkflowPrunePolicySpec as At, JsonArray as B, AllWorkflowsActiveWorkflowActivationPolicy as Bn, CoreTokens as Br, triggerNodeSetupStateType as Bt, CredentialTypeDefinition as C, TriggerSetupContext as Cn, Container as Cr, WorkflowErrorHandler as Ct, OAuth2ProviderFromPublicConfig as D, WorkflowNodeInstanceFactory as Dn, Lifecycle as Dr, WorkflowId as Dt, CredentialUnboundError as E, TriggerTestItemsContext as En, InjectionToken$1 as Er, WorkflowGraphFactory as Et, ItemBinary as F, WebhookControlSignal as Fn, instanceCachingFactory as Fr, branchRef as Ft, NodeActivationId as G, CurrentStateExecutionRequest as Gn, RunEventBus as Gr, BinaryStorageStatResult as Gt, JsonPrimitive as H, ConnectionInvocationAppendArgs as Hn, EngineExecutionLimitsPolicy as Hr, BinaryBody as Ht, ItemInputMapper as I, WebhookInvocationMatch as In, instancePerContainerCachingFactory as Ir, runnableNodeInputType as It, NodeDefinition as J, NodeExecutionError as Jn, FixedRetryPolicySpec as Jr, EngineDeps as Jt, NodeConfigBase as K, EngineRunCounters as Kn, RunEventSubscription as Kr, BinaryStorageWriteRequest as Kt, ItemInputMapperArgs as L, WebhookTriggerMatcher as Ln, predicateAwareClassFactory as Lr, runnableNodeOutputType as Lt, ExecutionMode as M, WorkflowSnapshotResolver as Mn, inject as Mr, WorkflowStoragePolicyMode as Mt, InputPortKey as N, HttpMethod as Nn, injectAll as Nr, WorkflowStoragePolicyResolver as Nt, ActivationIdFactory as O, WorkflowRepository as On, RegistrationOptions as Or, WorkflowNodeConnection as Ot, Item as P, TriggerInstanceId as Pn, injectable as Pr, WorkflowStoragePolicySpec as Pt, NodeId as Q, PendingNodeExecution as Qn, ExecutionContext as Qt, ItemInputMapperContext as R, WebhookTriggerResolution as Rn, registry as Rr, runnableNodeWireType as Rt, CredentialType as S, TriggerRuntimeDiagnostics as Sn, WorkflowExecutionRepository as Sr, WorkflowErrorContext as St, CredentialTypeRegistry as T, TriggerSetupStateRepository as Tn, Disposable as Tr, WorkflowGraph as Tt, JsonValue as U, ConnectionInvocationId as Un, EngineExecutionLimitsPolicyConfig as Ur, BinaryStorage as Ut, JsonObject as V, WorkflowActivationPolicy as Vn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Vr, BinaryAttachmentCreateRequest as Vt, MutableRunData as W, ConnectionInvocationRecord as Wn, RunEvent as Wr, BinaryStorageReadResult as Wt, NodeErrorHandlerArgs as X, NodeExecutionStatus as Xn, RetryPolicySpec as Xr, ExecutableTriggerNode as Xt, NodeErrorHandler as Y, NodeExecutionSnapshot as Yn, NoneRetryPolicySpec as Yr, EngineHost as Yt, NodeErrorHandlerSpec as Z, NodeInputsByPort as Zn, ExecutionBinaryService as Zt, CredentialRequirement as _, PersistedTriggerSetupState as _n, RunStopCondition as _r, TriggerNodeConfig as _t, CredentialAuthDefinition as a, NodeActivationReceipt as an, PersistedWorkflowSnapshotNode as ar, PairedItemRef as at, CredentialSessionService as b, TriggerCleanupHandle as bn, WorkflowExecutionListingRepository as br, UpstreamRefPlaceholder as bt, CredentialFieldSchema as c, NodeActivationScheduler as cn, RunCompletionNotifier as cr, PersistedTokenId as ct, CredentialHealthTester as d, NodeExecutionRequest as dn, RunExecutionOptions as dr, RunId as dt, ItemNode as en, PersistedMutableRunState as er, NodeOffloadPolicy as et, CredentialInstanceId as f, NodeExecutionRequestHandler as fn, RunPruneCandidate as fr, RunIdFactory as ft, CredentialOAuth2AuthDefinition as g, NodeResolver as gn, RunStatus as gr, RunnableNodeWireJson as gt, CredentialMaterialSourceKind as h, NodeExecutor as hn, RunStateResetRequest as hr, RunnableNodeOutputJson as ht, AnyCredentialType as i, NodeActivationContinuation as in, PersistedWorkflowSnapshot as ir, OutputPortKey as it, Edge as j, WorkflowSnapshotFactory as jn, delay as jr, WorkflowStoragePolicyDecisionArgs as jt, BinaryAttachment as k, WorkflowRunnerResolver as kn, TypeToken as kr, WorkflowPolicyRuntimeDefaults as kt, CredentialHealth as l, NodeBinaryAttachmentService as ln, RunCurrentState as lr, RunDataFactory as lt, CredentialJsonRecord as m, NodeExecutionStatePublisher as mn, RunResult as mr, RunnableNodeInputJson as mt, InMemoryLiveWorkflowRepository as n, MultiInputNode as nn, PersistedRunSchedulingState as nr, NodeRef as nt, CredentialBinding as o, NodeActivationRequest as on, PersistedWorkflowTokenRegistryLike as or, ParentExecutionRef as ot, CredentialInstanceRecord as p, NodeExecutionScheduler as pn, RunQueueEntry as pr, RunnableNodeConfig as pt, NodeConnectionName as q, ExecutionFrontierPlan as qn, ExponentialRetryPolicySpec as qr, BinaryStorageWriteResult as qt, Engine as r, Node as rn, PersistedRunState as rr, NodeSchedulerDecision as rt, CredentialBindingKey as s, NodeActivationRequestBase as sn, PinnedNodeOutputsByPort as sr, PersistedRunPolicySnapshot as st, RunIntentService as t, LiveWorkflowRepository as tn, PersistedRunControlState as tr, NodeOutputs as tt, CredentialHealthStatus as u, NodeExecutionContext as un, RunEventPublisherDeps as ur, RunDataSnapshot as ut, CredentialSessionFactory as v, PreparedNodeActivationDispatch as vn, RunSummary as vr, TriggerNodeOutputJson as vt, CredentialTypeId as w, TriggerSetupStateFor as wn, DependencyContainer$1 as wr, WorkflowErrorHandlerSpec as wt, CredentialSetupStatus as x, TriggerNode as xn, WorkflowExecutionPruneRepository as xr, WorkflowDefinition as xt, CredentialSessionFactoryArgs as y, TestableTriggerNode as yn, WebhookRunResult as yr, TriggerNodeSetupState as yt, Items as z, WebhookTriggerRoutingDiagnostics as zn, singleton as zr, triggerNodeOutputType as zt };
+//# sourceMappingURL=RunIntentService-Bkg4oYrM.d.cts.map

package/dist/bootstrap/index.cjs

@@ -1,36 +1,36 @@
-const require_RunIntentService = require('../RunIntentService-DcxXf_AM.cjs');
-const require_bootstrap = require('../bootstrap-DoQHAEQJ.cjs');
+const require_runtime = require('../runtime-ZJUpWmPH.cjs');
+const require_bootstrap = require('../bootstrap-DwS5S7s9.cjs');
 
-exports.ConfigDrivenOffloadPolicy = require_RunIntentService.ConfigDrivenOffloadPolicy;
-exports.CredentialResolverFactory = require_RunIntentService.CredentialResolverFactory;
-exports.DefaultAsyncSleeper = require_RunIntentService.DefaultAsyncSleeper;
-exports.DefaultDrivingScheduler = require_RunIntentService.DefaultDrivingScheduler;
-exports.DefaultExecutionBinaryService = require_RunIntentService.DefaultExecutionBinaryService;
-exports.DefaultExecutionContextFactory = require_RunIntentService.DefaultExecutionContextFactory;
-exports.ENGINE_EXECUTION_LIMITS_DEFAULTS = require_RunIntentService.ENGINE_EXECUTION_LIMITS_DEFAULTS;
-exports.Engine = require_bootstrap.Engine;
-exports.EngineExecutionLimitsPolicy = require_RunIntentService.EngineExecutionLimitsPolicy;
+exports.ConfigDrivenOffloadPolicy = require_runtime.ConfigDrivenOffloadPolicy;
+exports.CredentialResolverFactory = require_runtime.CredentialResolverFactory;
+exports.DefaultAsyncSleeper = require_runtime.DefaultAsyncSleeper;
+exports.DefaultDrivingScheduler = require_runtime.DefaultDrivingScheduler;
+exports.DefaultExecutionBinaryService = require_runtime.DefaultExecutionBinaryService;
+exports.DefaultExecutionContextFactory = require_runtime.DefaultExecutionContextFactory;
+exports.ENGINE_EXECUTION_LIMITS_DEFAULTS = require_runtime.ENGINE_EXECUTION_LIMITS_DEFAULTS;
+exports.Engine = require_runtime.Engine;
+exports.EngineExecutionLimitsPolicy = require_runtime.EngineExecutionLimitsPolicy;
 exports.EngineExecutionLimitsPolicyFactory = require_bootstrap.EngineExecutionLimitsPolicyFactory;
-exports.EngineFactory = require_bootstrap.EngineFactory;
+exports.EngineFactory = require_runtime.EngineFactory;
 exports.EngineRuntimeRegistrar = require_bootstrap.EngineRuntimeRegistrar;
-exports.EngineWorkflowRunnerService = require_bootstrap.EngineWorkflowRunnerService;
-exports.HintOnlyOffloadPolicy = require_RunIntentService.HintOnlyOffloadPolicy;
-exports.InMemoryBinaryStorage = require_RunIntentService.InMemoryBinaryStorage;
-exports.InMemoryLiveWorkflowRepository = require_RunIntentService.InMemoryLiveWorkflowRepository;
-exports.InMemoryRunDataFactory = require_RunIntentService.InMemoryRunDataFactory;
+exports.EngineWorkflowRunnerService = require_runtime.EngineWorkflowRunnerService;
+exports.HintOnlyOffloadPolicy = require_runtime.HintOnlyOffloadPolicy;
+exports.InMemoryBinaryStorage = require_runtime.InMemoryBinaryStorage;
+exports.InMemoryLiveWorkflowRepository = require_runtime.InMemoryLiveWorkflowRepository;
+exports.InMemoryRunDataFactory = require_runtime.InMemoryRunDataFactory;
 exports.InMemoryWorkflowExecutionRepository = require_bootstrap.InMemoryWorkflowExecutionRepository;
-exports.InProcessRetryRunner = require_RunIntentService.InProcessRetryRunner;
-exports.InlineDrivingScheduler = require_RunIntentService.InlineDrivingScheduler;
-exports.LocalOnlyScheduler = require_RunIntentService.LocalOnlyScheduler;
-exports.MissingRuntimeTriggerToken = require_RunIntentService.MissingRuntimeTriggerToken;
-exports.NodeExecutor = require_RunIntentService.NodeExecutor;
-exports.NodeInstanceFactory = require_RunIntentService.NodeInstanceFactory;
-exports.PersistedWorkflowTokenRegistry = require_RunIntentService.PersistedWorkflowTokenRegistry;
-exports.RunIntentService = require_RunIntentService.RunIntentService;
-exports.RunPolicySnapshotFactory = require_RunIntentService.RunPolicySnapshotFactory;
+exports.InProcessRetryRunner = require_runtime.InProcessRetryRunner;
+exports.InlineDrivingScheduler = require_runtime.InlineDrivingScheduler;
+exports.LocalOnlyScheduler = require_runtime.LocalOnlyScheduler;
+exports.MissingRuntimeTriggerToken = require_runtime.MissingRuntimeTriggerToken;
+exports.NodeExecutor = require_runtime.NodeExecutor;
+exports.NodeInstanceFactory = require_runtime.NodeInstanceFactory;
+exports.PersistedWorkflowTokenRegistry = require_runtime.PersistedWorkflowTokenRegistry;
+exports.RunIntentService = require_runtime.RunIntentService;
+exports.RunPolicySnapshotFactory = require_runtime.RunPolicySnapshotFactory;
 exports.RunSummaryMapper = require_bootstrap.RunSummaryMapper;
-exports.RunTerminalPersistenceCoordinator = require_bootstrap.RunTerminalPersistenceCoordinator;
-exports.UnavailableBinaryStorage = require_RunIntentService.UnavailableBinaryStorage;
-exports.WorkflowPolicyErrorServices = require_bootstrap.WorkflowPolicyErrorServices;
-exports.WorkflowRepositoryWebhookTriggerMatcher = require_bootstrap.WorkflowRepositoryWebhookTriggerMatcher;
-exports.WorkflowStoragePolicyEvaluator = require_bootstrap.WorkflowStoragePolicyEvaluator;
+exports.RunTerminalPersistenceCoordinator = require_runtime.RunTerminalPersistenceCoordinator;
+exports.UnavailableBinaryStorage = require_runtime.UnavailableBinaryStorage;
+exports.WorkflowPolicyErrorServices = require_runtime.WorkflowPolicyErrorServices;
+exports.WorkflowRepositoryWebhookTriggerMatcher = require_runtime.WorkflowRepositoryWebhookTriggerMatcher;
+exports.WorkflowStoragePolicyEvaluator = require_runtime.WorkflowStoragePolicyEvaluator;

package/dist/bootstrap/index.d.cts

@@ -1,6 +1,6 @@
-import { $n as PersistedWorkflowSnapshotNode, An as WebhookInvocationMatch, Bn as EngineRunCounters, Cr as TypeToken, Ct as WorkflowId, Dn as HttpMethod, Dt as WorkflowStoragePolicyDecisionArgs, Fn as WorkflowActivationPolicy, Fr as ENGINE_EXECUTION_LIMITS_DEFAULTS, G as NodeDefinition, Ir as EngineExecutionLimitsPolicy, J as NodeErrorHandlerSpec, K as NodeErrorHandler, Lr as EngineExecutionLimitsPolicyConfig, M as ExecutionMode, Nn as WebhookTriggerRoutingDiagnostics, Q as NodeOutputs, Qt as NodeActivationContinuation, Sn as WorkflowRepository, Tt as WorkflowPolicyRuntimeDefaults, U as NodeConfigBase, Ut as EngineDeps, Xn as PersistedRunSchedulingState, Y as NodeId, Z as NodeOffloadPolicy, Zn as PersistedRunState, _t as WorkflowDefinition, an as NodeExecutionRequest, at as PersistedTokenId, bt as WorkflowErrorHandlerSpec, ct as RunId, en as NodeActivationRequest, et as NodeSchedulerDecision, fn as PreparedNodeActivationDispatch, fr as RunSummary, gr as WorkflowExecutionRepository, hr as WorkflowExecutionPruneRepository, it as PersistedRunPolicySnapshot, jn as WebhookTriggerMatcher, mr as WorkflowExecutionListingRepository, n as InMemoryLiveWorkflowRepository, nn as NodeActivationScheduler, or as RunPruneCandidate, r as Engine, rt as ParentExecutionRef, sn as NodeExecutionScheduler, t as RunIntentService, un as NodeResolver, vr as DependencyContainer, xn as WorkflowNodeInstanceFactory, yt as WorkflowErrorHandler } from "../RunIntentService-CV8izV8t.cjs";
-import { a as WorkflowSnapshotCodec, i as WebhookTriggerMatcherProvider, n as EngineRuntimeRegistrationOptions, r as TriggerRuntimeDiagnosticsProvider, t as EngineWorkflowRunnerService } from "../EngineWorkflowRunnerService-Dx7bJsJR.cjs";
-import { a as InProcessRetryRunner, c as AsyncSleeper, i as UnavailableBinaryStorage, l as CredentialResolverFactory, n as InMemoryBinaryStorage, o as DefaultExecutionContextFactory, r as DefaultExecutionBinaryService, s as DefaultAsyncSleeper, t as InMemoryRunDataFactory } from "../InMemoryRunDataFactory-qIYQEar7.cjs";
+import { Ct as WorkflowErrorHandler, Dn as WorkflowNodeInstanceFactory, Dt as WorkflowId, Hr as EngineExecutionLimitsPolicy, In as WebhookInvocationMatch, J as NodeDefinition, Jt as EngineDeps, K as NodeConfigBase, Kn as EngineRunCounters, Ln as WebhookTriggerMatcher, M as ExecutionMode, Nn as HttpMethod, On as WorkflowRepository, Q as NodeId, Sr as WorkflowExecutionRepository, Ur as EngineExecutionLimitsPolicyConfig, Vn as WorkflowActivationPolicy, Vr as ENGINE_EXECUTION_LIMITS_DEFAULTS, Y as NodeErrorHandler, Z as NodeErrorHandlerSpec, ar as PersistedWorkflowSnapshotNode, br as WorkflowExecutionListingRepository, cn as NodeActivationScheduler, ct as PersistedTokenId, dn as NodeExecutionRequest, dt as RunId, et as NodeOffloadPolicy, fr as RunPruneCandidate, gn as NodeResolver, in as NodeActivationContinuation, jt as WorkflowStoragePolicyDecisionArgs, kr as TypeToken, kt as WorkflowPolicyRuntimeDefaults, n as InMemoryLiveWorkflowRepository, nr as PersistedRunSchedulingState, on as NodeActivationRequest, ot as ParentExecutionRef, pn as NodeExecutionScheduler, r as Engine, rr as PersistedRunState, rt as NodeSchedulerDecision, st as PersistedRunPolicySnapshot, t as RunIntentService, tt as NodeOutputs, vn as PreparedNodeActivationDispatch, vr as RunSummary, wr as DependencyContainer, wt as WorkflowErrorHandlerSpec, xr as WorkflowExecutionPruneRepository, xt as WorkflowDefinition, zn as WebhookTriggerRoutingDiagnostics } from "../RunIntentService-Bkg4oYrM.cjs";
+import { a as WorkflowSnapshotCodec, i as WebhookTriggerMatcherProvider, n as EngineRuntimeRegistrationOptions, r as TriggerRuntimeDiagnosticsProvider, t as EngineWorkflowRunnerService } from "../EngineWorkflowRunnerService-Dd4yD31l.cjs";
+import { a as InProcessRetryRunner, c as AsyncSleeper, i as UnavailableBinaryStorage, l as CredentialResolverFactory, n as InMemoryBinaryStorage, o as DefaultExecutionContextFactory, r as DefaultExecutionBinaryService, s as DefaultAsyncSleeper, t as InMemoryRunDataFactory } from "../InMemoryRunDataFactory-OUzDmAHt.cjs";
 
 //#region src/workflowSnapshots/MissingRuntimeFallbacksFactory.d.ts
 declare class MissingRuntimeFallbacks {
@@ -53,6 +53,8 @@ declare class NodeExecutor {
   execute(request: NodeActivationRequest): Promise<NodeOutputs>;
   private executeMultiInputNode;
   private executeSingleInputNode;
+  private hasExecuteOne;
+  private executeItemNode;
 }
 //#endregion
 //#region src/execution/NodeInstanceFactory.d.ts

package/dist/bootstrap/index.d.ts

@@ -1,6 +1,6 @@
-import { Ci as ENGINE_EXECUTION_LIMITS_DEFAULTS, Ti as EngineExecutionLimitsPolicyConfig, a as RunTerminalPersistenceCoordinator, an as WorkflowDefinition, c as EngineExecutionLimitsPolicyFactory, di as TypeToken, i as WorkflowPolicyErrorServices, n as InMemoryLiveWorkflowRepository, o as WorkflowStoragePolicyEvaluator, oi as DependencyContainer, qt as PersistedTokenId, r as EngineWorkflowRunnerService, s as RunPolicySnapshotFactory, t as RunIntentService, u as Engine, wi as EngineExecutionLimitsPolicy } from "../RunIntentService-BCvGdOSY.js";
-import { At as AsyncSleeper, Dt as InProcessRetryRunner, Et as NodeExecutor, Nt as EngineCompositionDeps, Ot as DefaultExecutionContextFactory, Pt as EngineFactory, Tt as NodeInstanceFactory, a as ConfigDrivenOffloadPolicy, c as InMemoryWorkflowExecutionRepository, d as DefaultExecutionBinaryService, f as UnavailableBinaryStorage, i as InlineDrivingScheduler, jt as CredentialResolverFactory, kt as DefaultAsyncSleeper, l as InMemoryRunDataFactory, n as HintOnlyOffloadPolicy, o as WorkflowRepositoryWebhookTriggerMatcher, r as DefaultDrivingScheduler, s as RunSummaryMapper, t as LocalOnlyScheduler, u as InMemoryBinaryStorage } from "../index-CueSzHsf.js";
-import { n as TriggerRuntimeDiagnosticsProvider, r as WebhookTriggerMatcherProvider, t as EngineRuntimeRegistrationOptions } from "../EngineRuntimeRegistration.types-0sgV2XL2.js";
+import { Ai as EngineExecutionLimitsPolicy, Xt as PersistedTokenId, _i as TypeToken, a as RunTerminalPersistenceCoordinator, c as EngineExecutionLimitsPolicyFactory, fi as DependencyContainer, i as WorkflowPolicyErrorServices, ji as EngineExecutionLimitsPolicyConfig, ki as ENGINE_EXECUTION_LIMITS_DEFAULTS, ln as WorkflowDefinition, n as InMemoryLiveWorkflowRepository, o as WorkflowStoragePolicyEvaluator, r as EngineWorkflowRunnerService, s as RunPolicySnapshotFactory, t as RunIntentService, u as Engine } from "../RunIntentService-BAKikN8h.js";
+import { At as InProcessRetryRunner, It as EngineCompositionDeps, Lt as EngineFactory, Mt as DefaultAsyncSleeper, Nt as AsyncSleeper, Ot as NodeInstanceFactory, Pt as CredentialResolverFactory, a as ConfigDrivenOffloadPolicy, c as InMemoryWorkflowExecutionRepository, d as DefaultExecutionBinaryService, f as UnavailableBinaryStorage, i as InlineDrivingScheduler, jt as DefaultExecutionContextFactory, kt as NodeExecutor, l as InMemoryRunDataFactory, n as HintOnlyOffloadPolicy, o as WorkflowRepositoryWebhookTriggerMatcher, r as DefaultDrivingScheduler, s as RunSummaryMapper, t as LocalOnlyScheduler, u as InMemoryBinaryStorage } from "../index-uCm9l0nw.js";
+import { n as TriggerRuntimeDiagnosticsProvider, r as WebhookTriggerMatcherProvider, t as EngineRuntimeRegistrationOptions } from "../EngineRuntimeRegistration.types-Bjeo7Sfq.js";
 
 //#region src/bootstrap/runtime/EngineRuntimeRegistrar.d.ts
 

package/dist/bootstrap/index.js

@@ -1,4 +1,4 @@
-import { A as NodeExecutor, D as MissingRuntimeTriggerToken, F as DefaultAsyncSleeper, I as CredentialResolverFactory, N as InProcessRetryRunner, P as DefaultExecutionContextFactory, R as DefaultExecutionBinaryService, S as NodeInstanceFactory, T as PersistedWorkflowTokenRegistry, a as InMemoryBinaryStorage, c as LocalOnlyScheduler, d as DefaultDrivingScheduler, f as ConfigDrivenOffloadPolicy, i as InMemoryRunDataFactory, l as InlineDrivingScheduler, m as RunPolicySnapshotFactory, n as InMemoryLiveWorkflowRepository, o as ENGINE_EXECUTION_LIMITS_DEFAULTS, s as EngineExecutionLimitsPolicy, t as RunIntentService, u as HintOnlyOffloadPolicy, z as UnavailableBinaryStorage } from "../RunIntentService-BFA48UpH.js";
-import { a as Engine, c as WorkflowStoragePolicyEvaluator, d as EngineExecutionLimitsPolicyFactory, i as EngineFactory, l as WorkflowPolicyErrorServices, n as WorkflowRepositoryWebhookTriggerMatcher, o as InMemoryWorkflowExecutionRepository, r as EngineWorkflowRunnerService, s as RunSummaryMapper, t as EngineRuntimeRegistrar, u as RunTerminalPersistenceCoordinator } from "../bootstrap-D67Sf2BF.js";
+import { A as NodeExecutor, C as RunPolicySnapshotFactory, D as PersistedWorkflowTokenRegistry, F as CredentialResolverFactory, I as DefaultExecutionBinaryService, L as UnavailableBinaryStorage, M as InProcessRetryRunner, N as DefaultExecutionContextFactory, O as MissingRuntimeTriggerToken, P as DefaultAsyncSleeper, S as ConfigDrivenOffloadPolicy, T as NodeInstanceFactory, _ as EngineExecutionLimitsPolicy, a as InMemoryLiveWorkflowRepository, b as HintOnlyOffloadPolicy, c as EngineFactory, d as InMemoryRunDataFactory, f as InMemoryBinaryStorage, g as ENGINE_EXECUTION_LIMITS_DEFAULTS, h as RunTerminalPersistenceCoordinator, i as RunIntentService, l as Engine, m as WorkflowPolicyErrorServices, n as WorkflowRepositoryWebhookTriggerMatcher, p as WorkflowStoragePolicyEvaluator, s as EngineWorkflowRunnerService, v as LocalOnlyScheduler, x as DefaultDrivingScheduler, y as InlineDrivingScheduler } from "../runtime-Cy-3FTI_.js";
+import { i as EngineExecutionLimitsPolicyFactory, n as InMemoryWorkflowExecutionRepository, r as RunSummaryMapper, t as EngineRuntimeRegistrar } from "../bootstrap-BD6CobHl.js";
 
 export { ConfigDrivenOffloadPolicy, CredentialResolverFactory, DefaultAsyncSleeper, DefaultDrivingScheduler, DefaultExecutionBinaryService, DefaultExecutionContextFactory, ENGINE_EXECUTION_LIMITS_DEFAULTS, Engine, EngineExecutionLimitsPolicy, EngineExecutionLimitsPolicyFactory, EngineFactory, EngineRuntimeRegistrar, EngineWorkflowRunnerService, HintOnlyOffloadPolicy, InMemoryBinaryStorage, InMemoryLiveWorkflowRepository, InMemoryRunDataFactory, InMemoryWorkflowExecutionRepository, InProcessRetryRunner, InlineDrivingScheduler, LocalOnlyScheduler, MissingRuntimeTriggerToken, NodeExecutor, NodeInstanceFactory, PersistedWorkflowTokenRegistry, RunIntentService, RunPolicySnapshotFactory, RunSummaryMapper, RunTerminalPersistenceCoordinator, UnavailableBinaryStorage, WorkflowPolicyErrorServices, WorkflowRepositoryWebhookTriggerMatcher, WorkflowStoragePolicyEvaluator };