@codemation/core 0.8.0 → 0.10.0

package/src/contracts/workflowTypes.ts

@@ -3,13 +3,18 @@ import type { ZodType } from "zod";
 import type { TypeToken } from "../di";
 import type { CredentialRequirement } from "./credentialTypes";
 import type { RetryPolicySpec } from "./retryPolicySpec.types";
+import type { InputPortKey, NodeConnectionName, NodeId, OutputPortKey, WorkflowId } from "./baseTypes";
+
+export type {
+  InputPortKey,
+  NodeConnectionName,
+  NodeId,
+  OutputPortKey,
+  PersistedTokenId,
+  WorkflowId,
+} from "./baseTypes";
 
-export type WorkflowId = string;
-export type NodeId = string;
 export type NodeIdRef<TJson = unknown> = NodeId & Readonly<{ __codemationNodeJson?: TJson }>;
-export type OutputPortKey = string;
-export type InputPortKey = string;
-export type PersistedTokenId = string;
 
 export type NodeKind = "trigger" | "node";
 export type JsonPrimitive = string | number | boolean | null;
@@ -26,8 +31,6 @@ export interface Edge {
   to: { nodeId: NodeId; input: InputPortKey };
 }
 
-export type NodeConnectionName = string;
-
 /**
  * Named connection from a parent node to child nodes that exist in {@link WorkflowDefinition.nodes}
  * but are not traversed by the main execution graph. Parents are commonly executable nodes, but may
@@ -91,6 +94,14 @@ export interface NodeConfigBase {
   readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
   readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
+  /**
+   * Marker: this node emits {@link import("./assertionTypes").AssertionResult}-shaped items on its
+   * `main` port. The TestSuiteOrchestrator (and host-side TestAssertionPersister) listen for
+   * `nodeCompleted` events from nodes with this flag set, and persist their output items as
+   * TestAssertion records (only when the run carries a `testContext`). Set on assertion node
+   * configs (e.g. `AssertionNodeConfig`, `StringEqualsAssertionNodeConfig`).
+   */
+  readonly emitsAssertions?: true;
 }
 
 export declare const runnableNodeInputType: unique symbol;
@@ -127,6 +138,12 @@ export interface TriggerNodeConfig<
   readonly kind: "trigger";
   readonly [triggerNodeOutputType]?: TOutputJson;
   readonly [triggerNodeSetupStateType]?: TSetupState;
+  /**
+   * Distinguishes triggers driven by the live activation policy (webhooks, cron, polling) from
+   * triggers driven only by the {@link TestSuiteOrchestrator}. `WorkflowActivation` skips
+   * `"test"` triggers; the orchestrator skips `"live"` triggers. Defaults to `"live"` when omitted.
+   */
+  readonly triggerKind?: "live" | "test";
 }
 
 export type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> =
@@ -194,6 +211,12 @@ export type NodeOutputs = Partial<Record<OutputPortKey, Items>>;
 
 export type RunId = string;
 export type NodeActivationId = string;
+/**
+ * One per-item iteration of a runnable node's execute loop. Refines `NodeActivationId` for
+ * per-item connection invocations and telemetry. Undefined when the executing node is a batch
+ * node or trigger that does not iterate items.
+ */
+export type NodeIterationId = string;
 
 export interface ParentExecutionRef {
   runId: RunId;
@@ -205,6 +228,12 @@ export interface ParentExecutionRef {
   engineMaxNodeActivations?: number;
   /** Effective max subworkflow depth from the parent run (propagated to child policy merge). */
   engineMaxSubworkflowDepth?: number;
+  /**
+   * Test-suite linkage inherited by the child subworkflow run. Set by whichever node
+   * spawns the subworkflow when its own `ctx.testContext` is present, so assertions
+   * emitted inside a subworkflow land under the correct parent test case.
+   */
+  testContext?: import("./runTypes").RunTestContext;
 }
 
 export interface RunDataSnapshot {

package/src/contracts.ts

@@ -0,0 +1,59 @@
+// Pure-type-only re-exports. Use this for type-only consumers that should not drag in runtime DSL or factory code.
+// This subpath prevents unnecessary compile-graph bloat for packages that only need types like NodeId, Items, etc.
+
+export type * from "./contracts/baseTypes";
+export type * from "./contracts/assertionTypes";
+// assertionTypes also exports a runtime helper for deriving pass/fail from a score+threshold.
+// We keep the type-only re-export above and surface the helper explicitly here so UI consumers
+// (next-host) don't need to re-implement the comparison.
+export { deriveAssertionPassed, DEFAULT_ASSERTION_PASS_THRESHOLD } from "./contracts/assertionTypes";
+export type * from "./contracts/params";
+export type * from "./contracts/retryPolicySpec.types";
+export type * from "./contracts/CostCatalogContract";
+export type * from "./contracts/executionPersistenceContracts";
+export type * from "./contracts/runtimeTypes";
+export type * from "./contracts/telemetryTypes";
+export type * from "./contracts/testTriggerTypes";
+export type * from "./contracts/runTypes";
+export type * from "./contracts/webhookTypes";
+export type * from "./contracts/workflowTypes";
+
+// credentialTypes mixes types (Credential* interfaces) with runtime (CredentialUnboundError class).
+// Export type-only subset for pure type consumers.
+export type {
+  CredentialTypeId,
+  CredentialInstanceId,
+  CredentialMaterialSourceKind,
+  CredentialSetupStatus,
+  CredentialHealthStatus,
+  CredentialFieldSchema,
+  CredentialRequirement,
+  CredentialBindingKey,
+  CredentialBinding,
+  CredentialHealth,
+  OAuth2ProviderFromPublicConfig,
+  CredentialOAuth2ScopesFromPublicConfig,
+  CredentialOAuth2AuthDefinition,
+  CredentialAuthDefinition,
+  CredentialAdvancedSectionPresentation,
+  CredentialTypeDefinition,
+  CredentialJsonRecord,
+  CredentialInstanceRecord,
+  CredentialSessionFactoryArgs,
+  CredentialSessionFactory,
+  CredentialHealthTester,
+  CredentialType,
+  AnyCredentialType,
+  CredentialSessionService,
+  CredentialTypeRegistry,
+} from "./contracts/credentialTypes";
+
+// CostTrackingTelemetryContract mixes types with const runtime values (metric/attribute names).
+// Export type-only subset for pure type consumers.
+export type {
+  CostTrackingComponent,
+  CostTrackingUsageRecord,
+  CostTrackingPriceQuote,
+  CostTrackingTelemetry,
+  CostTrackingTelemetryFactory,
+} from "./contracts/CostTrackingTelemetryContract";

package/src/events/ConnectionInvocationEventPublisher.ts

@@ -0,0 +1,46 @@
+import type { ConnectionInvocationRecord } from "../contracts/runTypes";
+import type { ParentExecutionRef } from "../types";
+import type { RunEventBus } from "./runEvents";
+
+/**
+ * Publishes per-invocation lifecycle records onto the run {@link RunEventBus}.
+ *
+ * Surgical, per-invocation events let the UI update the right-side inspector
+ * timeline as each LLM round / tool call transitions through `running` → `completed`
+ * (or `failed`) without depending on a coarse `runSaved` poll.
+ */
+export class ConnectionInvocationEventPublisher {
+  constructor(
+    private readonly eventBus: RunEventBus | undefined,
+    private readonly parent: ParentExecutionRef | undefined,
+  ) {}
+
+  async publish(record: ConnectionInvocationRecord): Promise<void> {
+    if (!this.eventBus) return;
+    const kind = this.kindFor(record);
+    if (!kind) return;
+    await this.eventBus.publish({
+      kind,
+      runId: record.runId,
+      workflowId: record.workflowId,
+      parent: this.parent,
+      at: record.updatedAt,
+      record,
+    });
+  }
+
+  private kindFor(
+    record: ConnectionInvocationRecord,
+  ): "connectionInvocationStarted" | "connectionInvocationCompleted" | "connectionInvocationFailed" | undefined {
+    if (record.status === "running" || record.status === "queued") {
+      return "connectionInvocationStarted";
+    }
+    if (record.status === "completed") {
+      return "connectionInvocationCompleted";
+    }
+    if (record.status === "failed") {
+      return "connectionInvocationFailed";
+    }
+    return undefined;
+  }
+}

package/src/events/index.ts

@@ -1,3 +1,4 @@
+export { ConnectionInvocationEventPublisher } from "./ConnectionInvocationEventPublisher";
 export { NodeEventPublisher } from "./NodeEventPublisher";
 export { InMemoryRunEventBus } from "./InMemoryRunEventBusRegistry";
 export { EventPublishingWorkflowExecutionRepository } from "./EventPublishingWorkflowExecutionRepository";

package/src/events/runEvents.ts

@@ -1,5 +1,18 @@
+import type { TestSuiteRunId } from "../contracts/testTriggerTypes";
+import type { ConnectionInvocationRecord } from "../contracts/runTypes";
 import type { NodeExecutionSnapshot, ParentExecutionRef, PersistedRunState, RunId, WorkflowId } from "../types";
 
+/**
+ * Outcome of a single test case (one workflow run dispatched by the test-suite orchestrator).
+ * - `running`: workflow still in flight
+ * - `succeeded`: workflow completed AND all assertions passed (or no assertions)
+ * - `failed`: workflow failed OR (workflow completed but ≥1 assertion failed)
+ * - `errored` / `cancelled`: workflow itself errored or was cancelled
+ */
+export type TestCaseRunStatus = "running" | "succeeded" | "failed" | "errored" | "cancelled";
+/** Aggregate outcome of a TestSuiteRun. */
+export type TestSuiteRunStatus = "succeeded" | "failed" | "partial" | "errored" | "cancelled";
+
 export type RunEvent =
   | Readonly<{ kind: "runCreated"; runId: RunId; workflowId: WorkflowId; parent?: ParentExecutionRef; at: string }>
   | Readonly<{
@@ -41,6 +54,67 @@ export type RunEvent =
       parent?: ParentExecutionRef;
       at: string;
       snapshot: NodeExecutionSnapshot;
+    }>
+  | Readonly<{
+      kind: "connectionInvocationStarted";
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      at: string;
+      record: ConnectionInvocationRecord;
+    }>
+  | Readonly<{
+      kind: "connectionInvocationCompleted";
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      at: string;
+      record: ConnectionInvocationRecord;
+    }>
+  | Readonly<{
+      kind: "connectionInvocationFailed";
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      at: string;
+      record: ConnectionInvocationRecord;
+    }>
+  | Readonly<{
+      kind: "testSuiteStarted";
+      testSuiteRunId: TestSuiteRunId;
+      workflowId: WorkflowId;
+      triggerNodeId: string;
+      triggerNodeName?: string;
+      concurrency: number;
+      at: string;
+    }>
+  | Readonly<{
+      kind: "testSuiteFinished";
+      testSuiteRunId: TestSuiteRunId;
+      workflowId: WorkflowId;
+      status: TestSuiteRunStatus;
+      totalCases: number;
+      passedCases: number;
+      failedCases: number;
+      at: string;
+    }>
+  | Readonly<{
+      kind: "testCaseStarted";
+      testSuiteRunId: TestSuiteRunId;
+      testCaseIndex: number;
+      runId: RunId;
+      workflowId: WorkflowId;
+      testCaseLabel?: string;
+      at: string;
+    }>
+  | Readonly<{
+      kind: "testCaseCompleted";
+      testSuiteRunId: TestSuiteRunId;
+      testCaseIndex: number;
+      runId: RunId;
+      workflowId: WorkflowId;
+      status: TestCaseRunStatus;
+      at: string;
     }>;
 
 export interface RunEventSubscription {

package/src/execution/ChildExecutionScopeFactory.ts

@@ -0,0 +1,55 @@
+import type {
+  ActivationIdFactory,
+  ConnectionInvocationId,
+  NodeExecutionContext,
+  NodeId,
+  RunnableNodeConfig,
+  TelemetrySpanScope,
+} from "../types";
+
+/**
+ * Builds a re-rooted child execution context for sub-agent (and other deeply-nested) invocations.
+ *
+ * At the orchestrator's `agent.tool.call` boundary the inner runtime needs a ctx whose:
+ * - `nodeId` is the tool's connection node id (so inner LLM/tool connection ids derive correctly),
+ * - `activationId` is fresh (so its connection-invocation rows are uniquely identifiable),
+ * - `telemetry` parents children under the tool-call span (not the orchestrator's node span),
+ * - `binary` is scoped to the new (nodeId, activationId),
+ * - `parentInvocationId` points back to the tool-call invocation for downstream lineage.
+ *
+ * Registered via factory in {@link EngineRuntimeRegistrar} so constructors stay free of parameter
+ * decorators (Next/SWC and coverage tooling cannot parse them on in-repo sources).
+ */
+export class ChildExecutionScopeFactory {
+  constructor(private readonly activationIdFactory: ActivationIdFactory) {}
+
+  forSubAgent<TConfig extends RunnableNodeConfig<any, any>>(
+    args: Readonly<{
+      parentCtx: NodeExecutionContext<TConfig>;
+      childNodeId: NodeId;
+      childConfig: TConfig;
+      parentInvocationId: ConnectionInvocationId;
+      parentSpan: TelemetrySpanScope;
+    }>,
+  ): NodeExecutionContext<TConfig> {
+    const childActivationId = this.activationIdFactory.makeActivationId();
+    const childTelemetry = args.parentSpan.asNodeTelemetry({
+      nodeId: args.childNodeId,
+      activationId: childActivationId,
+    });
+    const childBinary = args.parentCtx.binary.forNode({
+      nodeId: args.childNodeId,
+      activationId: childActivationId,
+    });
+    return {
+      ...args.parentCtx,
+      nodeId: args.childNodeId,
+      activationId: childActivationId,
+      config: args.childConfig,
+      telemetry: childTelemetry,
+      binary: childBinary,
+      parentInvocationId: args.parentInvocationId,
+      iterationId: undefined,
+    };
+  }
+}

package/src/execution/DefaultExecutionContextFactory.ts

@@ -1,5 +1,6 @@
 import type {
   BinaryStorage,
+  CollectionsContext,
   CostTrackingTelemetryFactory,
   ExecutionContext,
   ExecutionContextFactory,
@@ -8,6 +9,7 @@ import type {
   ParentExecutionRef,
   RunDataSnapshot,
   RunId,
+  RunTestContext,
   WorkflowId,
 } from "../types";
 import { NoOpCostTrackingTelemetryFactory, NoOpExecutionTelemetryFactory } from "../types";
@@ -26,6 +28,7 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
     private readonly telemetryFactory: ExecutionTelemetryFactory = new NoOpExecutionTelemetryFactory(),
     private readonly costTrackingFactory: CostTrackingTelemetryFactory = new NoOpCostTrackingTelemetryFactory(),
     private readonly currentDate: () => Date = () => new Date(),
+    private readonly collections?: CollectionsContext,
   ) {}
 
   create(args: {
@@ -40,6 +43,7 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
     nodeState?: NodeExecutionStatePublisher;
     telemetry?: ExecutionContext["telemetry"];
     getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+    testContext?: RunTestContext;
   }): ExecutionContext {
     const baseTelemetry =
       args.telemetry ??
@@ -66,6 +70,8 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
       telemetry,
       binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
       getCredential: args.getCredential,
+      testContext: args.testContext,
+      collections: this.collections,
     };
   }
 }

package/src/execution/ExecutionTelemetryCostTrackingDecoratorFactory.ts

@@ -62,6 +62,15 @@ export class ExecutionTelemetryCostTrackingDecoratorFactory {
           costTracking: args.costTracking.forScope(nodeTelemetry),
         });
       },
+      asNodeTelemetry: (
+        rescope: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>,
+      ): NodeExecutionTelemetry => {
+        const nodeTelemetry = args.telemetry.asNodeTelemetry(rescope);
+        return this.decorateNodeExecutionTelemetry({
+          telemetry: nodeTelemetry,
+          costTracking: args.costTracking.forScope(nodeTelemetry),
+        });
+      },
     };
   }
 
@@ -79,6 +88,15 @@ export class ExecutionTelemetryCostTrackingDecoratorFactory {
         artifact: TelemetryArtifactAttachment,
       ): Promise<TelemetryArtifactReference> | TelemetryArtifactReference => args.scope.attachArtifact(artifact),
       end: (endArgs?: TelemetrySpanEnd) => args.scope.end(endArgs),
+      asNodeTelemetry: (
+        rescope: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>,
+      ): NodeExecutionTelemetry => {
+        const nodeTelemetry = args.scope.asNodeTelemetry(rescope);
+        return this.decorateNodeExecutionTelemetry({
+          telemetry: nodeTelemetry,
+          costTracking: args.costTracking.forScope(nodeTelemetry),
+        });
+      },
     };
   }
 }

package/src/execution/NodeExecutor.ts

@@ -13,6 +13,7 @@ import type {
   TriggerNode,
   WorkflowNodeInstanceFactory,
 } from "../types";
+import { NodeIterationIdFactory } from "../workflow/definition/NodeIterationIdFactory";
 
 import { FanInMergeByOriginMerger } from "./FanInMergeByOriginMerger";
 import { ItemExprResolver } from "./ItemExprResolver";
@@ -158,13 +159,20 @@ export class NodeExecutor {
       const parsed = inputSchema.parse(item.json);
       const runnableCtx = request.ctx as NodeExecutionContext<RunnableNodeConfig>;
       const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
-      const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+      const baseCtx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+      // Mint a per-item iteration id and stamp it (with the item index) onto the ctx so connection
+      // invocations and telemetry written from inside `node.execute` carry the per-item identity.
+      const iterationCtx = {
+        ...baseCtx,
+        iterationId: NodeIterationIdFactory.create(),
+        itemIndex: i,
+      } as NodeExecutionContext<RunnableNodeConfig>;
       const args: RunnableNodeExecuteArgs = {
         input: parsed,
         item,
         itemIndex: i,
         items: inputBatch,
-        ctx,
+        ctx: iterationCtx,
       };
       const raw = await Promise.resolve(node.execute(args));
       const normalized = this.outputNormalizer.normalizeExecuteResult({

package/src/execution/NodeInstanceFactory.ts

@@ -4,6 +4,7 @@ import type { NodeId, NodeResolver, WorkflowDefinition, WorkflowNodeInstanceFact
 import { MissingRuntimeNode, MissingRuntimeTrigger } from "../workflowSnapshots";
 import { MissingRuntimeNodeToken } from "../workflowSnapshots/MissingRuntimeNodeToken";
 import { MissingRuntimeTriggerToken } from "../workflowSnapshots/MissingRuntimeTriggerToken";
+import { NodeInstantiationError } from "./NodeInstantiationError";
 
 export class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
   constructor(private readonly nodeResolver: NodeResolver) {}
@@ -11,7 +12,18 @@ export class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
   createNodes(workflow: WorkflowDefinition): Map<NodeId, unknown> {
     const nodeInstances = new Map<NodeId, unknown>();
     for (const definition of workflow.nodes) {
-      nodeInstances.set(definition.id, this.createNode(definition));
+      try {
+        nodeInstances.set(definition.id, this.createNode(definition));
+      } catch (err) {
+        if (err instanceof NodeInstantiationError) {
+          throw err;
+        }
+        throw new NodeInstantiationError(
+          definition.id,
+          typeof definition.type === "function" ? definition.type.name : String(definition.type),
+          err instanceof Error ? err : new Error(String(err)),
+        );
+      }
     }
     return nodeInstances;
   }

package/src/execution/NodeInstantiationError.ts

@@ -0,0 +1,16 @@
+import type { NodeId } from "../types";
+
+export class NodeInstantiationError extends Error {
+  readonly name = "NodeInstantiationError";
+  readonly originalError: Error;
+
+  constructor(
+    readonly nodeId: NodeId,
+    readonly nodeType: string,
+    originalError: Error,
+  ) {
+    super(`Failed to instantiate node "${nodeId}" (type ${nodeType}): ${originalError.message}`);
+    this.originalError = originalError;
+    this.stack = originalError.stack;
+  }
+}

package/src/execution/NodeRunStateWriter.ts

@@ -28,6 +28,7 @@ export class NodeRunStateWriter implements NodeExecutionStatePublisher {
       kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed",
       snapshot: NodeExecutionSnapshot,
     ) => Promise<void>,
+    private readonly publishConnectionInvocationEvent?: (record: ConnectionInvocationRecord) => Promise<void>,
   ) {}
 
   markQueued(args: {
@@ -148,11 +149,17 @@ export class NodeRunStateWriter implements NodeExecutionStatePublisher {
         startedAt: args.startedAt,
         finishedAt: args.finishedAt,
         updatedAt,
+        iterationId: args.iterationId,
+        itemIndex: args.itemIndex,
+        parentInvocationId: args.parentInvocationId,
       };
       await this.workflowExecutionRepository.save({
         ...state,
         connectionInvocations: [...(state.connectionInvocations ?? []), record],
       });
+      if (this.publishConnectionInvocationEvent) {
+        await this.publishConnectionInvocationEvent(record);
+      }
     });
   }
 

package/src/execution/NodeRunStateWriterFactory.ts

@@ -6,16 +6,20 @@ import type {
   WorkflowId,
 } from "../types";
 
+import { ConnectionInvocationEventPublisher } from "../events/ConnectionInvocationEventPublisher";
 import { NodeEventPublisher } from "../events/NodeEventPublisher";
+import type { RunEventBus } from "../events/runEvents";
 import { NodeRunStateWriter } from "./NodeRunStateWriter";
 
 export class NodeRunStateWriterFactory {
   constructor(
     private readonly workflowExecutionRepository: WorkflowExecutionRepository,
     private readonly nodeEventPublisher: NodeEventPublisher,
+    private readonly eventBus?: RunEventBus,
   ) {}
 
   create(runId: RunId, workflowId: WorkflowId, parent: ParentExecutionRef | undefined): NodeExecutionStatePublisher {
+    const connectionInvocationEventPublisher = new ConnectionInvocationEventPublisher(this.eventBus, parent);
     return new NodeRunStateWriter(
       this.workflowExecutionRepository,
       runId,
@@ -24,6 +28,9 @@ export class NodeRunStateWriterFactory {
       async (kind, snapshot) => {
         await this.nodeEventPublisher.publish(kind, snapshot);
       },
+      async (record) => {
+        await connectionInvocationEventPublisher.publish(record);
+      },
     );
   }
 }

package/src/execution/WorkflowRunExecutionContextFactory.ts

@@ -5,6 +5,7 @@ import type {
   ParentExecutionRef,
   RunDataFactory,
   RunId,
+  RunTestContext,
   WorkflowId,
 } from "../types";
 
@@ -30,6 +31,7 @@ export class WorkflowRunExecutionContextFactory {
     engineMaxSubworkflowDepth: number;
     data: ReturnType<RunDataFactory["create"]>;
     nodeState?: NodeExecutionStatePublisher;
+    testContext?: RunTestContext;
   }) {
     return this.executionContextFactory.create({
       runId: args.runId,
@@ -42,6 +44,7 @@ export class WorkflowRunExecutionContextFactory {
       data: args.data,
       nodeState: args.nodeState,
       getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId),
+      testContext: args.testContext,
     });
   }
 }

package/src/execution/index.ts

@@ -1,6 +1,8 @@
 export { ActivationEnqueueService } from "./ActivationEnqueueService";
+export { ChildExecutionScopeFactory } from "./ChildExecutionScopeFactory";
 export { NodeActivationRequestInputPreparer } from "./NodeActivationRequestInputPreparer";
 export { NodeInputContractError } from "./NodeInputContractError";
+export { NodeInstantiationError } from "./NodeInstantiationError";
 export { CredentialResolverFactory } from "./CredentialResolverFactory";
 export { DefaultAsyncSleeper } from "./DefaultAsyncSleeper";
 export { DefaultExecutionContextFactory } from "./DefaultExecutionContextFactory";

package/src/index.ts

@@ -14,6 +14,7 @@ export * from "./runtime-types/runtimeTypeDecorators.types";
 export * from "./serialization/ItemsInputNormalizer";
 export { DefaultExecutionBinaryService, UnavailableBinaryStorage } from "./binaries";
 export {
+  ChildExecutionScopeFactory,
   CredentialResolverFactory,
   DefaultAsyncSleeper,
   DefaultExecutionContextFactory,
@@ -26,3 +27,10 @@ export { EngineExecutionLimitsPolicy, type EngineExecutionLimitsPolicyConfig } f
 export { InMemoryBinaryStorage, InMemoryRunDataFactory } from "./runStorage";
 export { InMemoryLiveWorkflowRepository, RunIntentService } from "./runtime";
 export * from "./types";
+export { PollingTriggerRuntime, PollingTriggerDedupWindow, NoOpPollingTriggerLogger } from "./triggers/polling";
+export type {
+  PollingTriggerLogger,
+  PollingRunCycleArgs,
+  PollingRunCycleResult,
+  PollingTriggerStartArgs,
+} from "./triggers/polling";

package/src/orchestration/AbortControllerFactory.ts

@@ -0,0 +1,9 @@
+/**
+ * Mints fresh {@link AbortController}s. Injected (rather than direct `new`) to honor the
+ * codebase's no-direct-construction rule and to give tests a seam for substituting a fake.
+ */
+export class AbortControllerFactory {
+  create(): AbortController {
+    return new AbortController();
+  }
+}

package/src/orchestration/NodeExecutionRequestHandlerService.ts

@@ -77,6 +77,7 @@ export class NodeExecutionRequestHandlerService implements NodeExecutionRequestH
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent),
+      testContext: state.executionOptions?.testContext,
     });
 
     const inputsByPort = pendingExecution.inputsByPort;

package/src/orchestration/RunContinuationService.ts

@@ -141,6 +141,7 @@ export class RunContinuationService {
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent),
+      testContext: state.executionOptions?.testContext,
     });
 
     data.setOutputs(args.nodeId, args.outputs);
@@ -755,6 +756,7 @@ export class RunContinuationService {
       engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(args.state.runId, args.state.workflowId, args.state.parent),
+      testContext: args.state.executionOptions?.testContext,
     });
     const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
       next,
@@ -859,6 +861,7 @@ export class RunContinuationService {
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent),
+      testContext: state.executionOptions?.testContext,
     });
     const activationId = pendingExecution.activationId;
     return {