@codemation/core 0.8.1 → 0.10.0

package/dist/{RunIntentService-BqhmdoA1.d.ts → RunIntentService-BE9CAkbf.d.ts}

@@ -3,7 +3,91 @@ import { DependencyContainer as Container, DependencyContainer as DependencyCont
 import { ZodType } from "zod";
 import { ReadableStream } from "node:stream/web";
 
+//#region src/contracts/baseTypes.d.ts
+/**
+ * Minimal base types that have no dependencies on other contracts.
+ * Used by credentialTypes, workflowTypes, and other contract layers
+ * to avoid circular dependencies.
+ */
+type WorkflowId = string;
+type NodeId = string;
+type OutputPortKey = string;
+type InputPortKey = string;
+type PersistedTokenId = string;
+type NodeConnectionName = string;
+//#endregion
+//#region src/contracts/testTriggerTypes.d.ts
+/**
+ * Identifier minted by the host (or in-memory test runner) for one execution of a test suite.
+ * One TestSuiteRun produces N child workflow runs, one per item yielded by `generateItems`.
+ */
+type TestSuiteRunId = string;
+/**
+ * Setup context passed to a {@link TestTriggerNodeConfig.generateItems} callback. Distinct from
+ * {@link import("./runtimeTypes").TriggerSetupContext} on purpose: test triggers are not
+ * activated by the live trigger lifecycle (webhooks, cron, polling) and never call `emit` —
+ * the orchestrator pulls from the iterable they return and dispatches one run per item.
+ */
+interface TestTriggerSetupContext<TConfig extends TestTriggerNodeConfig<unknown> = TestTriggerNodeConfig<unknown>> {
+  readonly workflowId: WorkflowId;
+  readonly nodeId: NodeId;
+  readonly config: TConfig;
+  readonly testSuiteRunId: TestSuiteRunId;
+  /**
+   * Resolves a credential session for a slot declared on this trigger's
+   * {@link import("./workflowTypes").NodeConfigBase.getCredentialRequirements}. Same contract as
+   * {@link import("./runtimeTypes").ExecutionContext.getCredential}.
+   */
+  getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+  /** AbortSignal raised when the suite is cancelled — long-running pulls should bail out. */
+  readonly signal: AbortSignal;
+}
+/**
+ * A trigger config that emits **test cases**. Each item yielded by {@link generateItems}
+ * becomes one workflow run (with `executionOptions.testContext` set), so 10 yielded items
+ * → 10 runs marked under the same TestSuiteRun.
+ *
+ * The trigger is otherwise a normal {@link TriggerNodeConfig} (so the canvas treats it like
+ * any other trigger), but its `triggerKind` is `"test"` so the live activation policy skips it.
+ */
+interface TestTriggerNodeConfig<TOutputJson$1 = unknown> extends TriggerNodeConfig<TOutputJson$1, undefined> {
+  readonly triggerKind: "test";
+  /**
+   * Author-supplied async iterable of items, evaluated lazily. Implementations may fetch from
+   * credentialed APIs, read fixture files, or yield hard-coded items. The orchestrator iterates
+   * and dispatches one run per item, with concurrency capped by {@link concurrency} (default 4).
+   */
+  generateItems(ctx: TestTriggerSetupContext<TestTriggerNodeConfig<TOutputJson$1>>): AsyncIterable<Item<TOutputJson$1>>;
+  /** Per-suite-run cap on simultaneously-executing test cases. Default: 4. */
+  readonly concurrency?: number;
+  /**
+   * Free-form description of where the test cases come from — surfaced in the node properties
+   * panel and the suite-detail header so authors revisiting the workflow six months later
+   * remember which mailbox / folder / fixture file the cases originate from.
+   *
+   * Example: `"All emails in the Gmail label \"test/triage-fixtures\" — 14 messages as of 2026-05-03."`
+   */
+  readonly description?: string;
+  /**
+   * Resolves a human-readable label for one yielded test case (e.g. email subject). The
+   * orchestrator calls this once per yielded item, persists the result on the run, and the
+   * Tests-tab UI uses it to render the case row instead of the opaque runId. Return
+   * `undefined` to fall back to "Case #N".
+   */
+  caseLabel?(item: Item<TOutputJson$1>): string | undefined;
+}
+//#endregion
 //#region src/events/runEvents.d.ts
+/**
+ * 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
+ */
+type TestCaseRunStatus = "running" | "succeeded" | "failed" | "errored" | "cancelled";
+/** Aggregate outcome of a TestSuiteRun. */
+type TestSuiteRunStatus = "succeeded" | "failed" | "partial" | "errored" | "cancelled";
 type RunEvent = Readonly<{
   kind: "runCreated";
   runId: RunId;
@@ -45,6 +129,60 @@ type RunEvent = Readonly<{
   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;
 }>;
 interface RunEventSubscription {
   close(): Promise<void>;
@@ -104,74 +242,434 @@ declare const CoreTokens: {
   readonly WorkflowActivationPolicy: TypeToken<WorkflowActivationPolicy>;
 };
 //#endregion
-//#region src/contracts/credentialTypes.d.ts
-type CredentialTypeId = string;
-type CredentialInstanceId = string;
-type CredentialMaterialSourceKind = "db" | "env" | "code";
-type CredentialSetupStatus = "draft" | "ready";
-type CredentialHealthStatus = "unknown" | "healthy" | "failing";
-type CredentialFieldSchema = Readonly<{
-  key: string;
-  label: string;
-  type: "string" | "password" | "textarea" | "json" | "boolean";
-  required?: true;
-  order?: number;
-  /**
-   * Where this field appears in the credential dialog. Use `"advanced"` for optional or
-   * power-user fields; they render inside a collapsible section (see `CredentialTypeDefinition.advancedSection`).
-   * Defaults to `"default"` when omitted.
-   */
-  visibility?: "default" | "advanced";
-  placeholder?: string;
-  helpText?: string;
-  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
-  envVarName?: string;
+//#region src/contracts/runTypes.d.ts
+/**
+ * Test-suite linkage for a run. When set, this run was started by a TestSuiteOrchestrator
+ * as one test case inside a TestSuiteRun. The `IsTestRun` node and host-side persisters key
+ * off the presence of this field. Subworkflow runs inherit it from their parent run.
+ */
+interface RunTestContext {
+  readonly testSuiteRunId: string;
+  readonly testCaseIndex: number;
   /**
-   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
-   * pattern or documentation URL). Do not use for secret values.
+   * Optional human-friendly label for this test case (e.g. an email subject when fixtures
+   * are loaded from a mailbox). Resolved per item by `TestTrigger.caseLabel(item)` if set,
+   * persisted on `Run.test_case_label` so the Tests-tab tree-table can show "RFQ for batch 14"
+   * instead of "run_1777755971399_bbb86beac1396".
    */
-  copyValue?: string;
-  /** Accessible label for the copy control (default: Copy). */
-  copyButtonLabel?: string;
-}>;
-type CredentialRequirement = Readonly<{
-  slotKey: string;
-  label: string;
-  acceptedTypes: ReadonlyArray<CredentialTypeId>;
-  optional?: true;
-  helpText?: string;
-  helpUrl?: string;
+  readonly testCaseLabel?: string;
+}
+interface RunExecutionOptions {
+  /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
+  localOnly?: boolean;
+  /** Marks runs started from webhook handling so orchestration can apply webhook-specific continuation rules. */
+  webhook?: boolean;
+  mode?: "manual" | "debug";
+  sourceWorkflowId?: WorkflowId;
+  sourceRunId?: RunId;
+  derivedFromRunId?: RunId;
+  isMutable?: boolean;
+  /** Set by the engine for this run: 0 = root, 1 = first child subworkflow, … */
+  subworkflowDepth?: number;
+  /** Effective cap after engine policy merge (successful node completions per run). */
+  maxNodeActivations?: number;
+  /** Effective cap after engine policy merge (subworkflow nesting). */
+  maxSubworkflowDepth?: number;
+  /** Present iff started by a TestSuiteOrchestrator; propagates to subworkflow runs via {@link ParentExecutionRef.testContext}. */
+  testContext?: RunTestContext;
+}
+/** Engine-owned counters persisted with the run (worker-safe). */
+interface EngineRunCounters {
+  completedNodeActivations: number;
+}
+type RunStopCondition = Readonly<{
+  kind: "workflowCompleted";
+}> | Readonly<{
+  kind: "nodeCompleted";
+  nodeId: NodeId;
 }>;
-type CredentialBindingKey = Readonly<{
+interface RunStateResetRequest {
+  clearFromNodeId: NodeId;
+}
+interface PersistedRunControlState {
+  stopCondition?: RunStopCondition;
+}
+interface PersistedWorkflowSnapshotNode {
+  id: NodeId;
+  kind: NodeKind;
+  name?: string;
+  nodeTokenId: PersistedTokenId;
+  configTokenId: PersistedTokenId;
+  tokenName?: string;
+  configTokenName?: string;
+  config: unknown;
+}
+interface PersistedWorkflowSnapshot {
+  id: WorkflowId;
+  name: string;
+  nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
+  edges: ReadonlyArray<Edge>;
+  /** When the snapshot was built from a live workflow definition that configured a workflow error handler. */
+  workflowErrorHandlerConfigured?: boolean;
+  /** Connection metadata for child nodes not in the execution graph (e.g. AI agent attachments). */
+  connections?: ReadonlyArray<WorkflowNodeConnection>;
+}
+type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
+interface PersistedMutableNodeState {
+  pinnedOutputsByPort?: PinnedNodeOutputsByPort;
+  lastDebugInput?: Items;
+}
+interface PersistedMutableRunState {
+  nodesById: Readonly<Record<NodeId, PersistedMutableNodeState>>;
+}
+type NodeInputsByPort = Readonly<Record<InputPortKey, Items>>;
+interface RunQueueEntry {
+  nodeId: NodeId;
+  input: Items;
+  toInput?: InputPortKey;
+  batchId?: string;
+  from?: Readonly<{
+    nodeId: NodeId;
+    output: OutputPortKey;
+  }>;
+  collect?: Readonly<{
+    expectedInputs: ReadonlyArray<InputPortKey>;
+    received: Readonly<Record<InputPortKey, Items>>;
+  }>;
+}
+type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
+interface NodeExecutionError {
+  message: string;
+  name?: string;
+  stack?: string;
+  details?: JsonValue;
+}
+interface NodeExecutionSnapshot {
+  runId: RunId;
   workflowId: WorkflowId;
   nodeId: NodeId;
-  slotKey: string;
-}>;
-type CredentialBinding = Readonly<{
-  key: CredentialBindingKey;
-  instanceId: CredentialInstanceId;
+  activationId?: NodeActivationId;
+  parent?: ParentExecutionRef;
+  status: NodeExecutionStatus;
+  usedPinnedOutput?: boolean;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
   updatedAt: string;
+  inputsByPort?: NodeInputsByPort;
+  outputs?: NodeOutputs;
+  error?: NodeExecutionError;
+}
+/** Stable id for a single connection invocation row in {@link ConnectionInvocationRecord}. */
+type ConnectionInvocationId = string;
+/**
+ * One logical LLM or tool call under an owning workflow node (e.g. AI agent).
+ * The owning node defines what {@link managedInput} and {@link managedOutput} contain.
+ */
+interface ConnectionInvocationRecord {
+  readonly invocationId: ConnectionInvocationId;
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly connectionNodeId: NodeId;
+  readonly parentAgentNodeId: NodeId;
+  readonly parentAgentActivationId: NodeActivationId;
+  readonly status: NodeExecutionStatus;
+  readonly managedInput?: JsonValue;
+  readonly managedOutput?: JsonValue;
+  readonly error?: NodeExecutionError;
+  readonly queuedAt?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly updatedAt: string;
+  /** Per-item iteration id minted by the engine when this invocation occurred inside a runnable node's per-item loop. */
+  readonly iterationId?: NodeIterationId;
+  /** Item index (0-based) of the iteration that produced this invocation. */
+  readonly itemIndex?: number;
+  /** When set, this invocation was produced inside a sub-agent triggered by the named parent invocation. */
+  readonly parentInvocationId?: ConnectionInvocationId;
+}
+/** Arguments for appending a {@link ConnectionInvocationRecord} (engine fills run/workflow ids and timestamps). */
+type ConnectionInvocationAppendArgs = Readonly<{
+  invocationId: ConnectionInvocationId;
+  connectionNodeId: NodeId;
+  parentAgentNodeId: NodeId;
+  parentAgentActivationId: NodeActivationId;
+  status: NodeExecutionStatus;
+  managedInput?: JsonValue;
+  managedOutput?: JsonValue;
+  error?: NodeExecutionError;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  iterationId?: NodeIterationId;
+  itemIndex?: number;
+  parentInvocationId?: ConnectionInvocationId;
 }>;
-type CredentialHealth = Readonly<{
-  status: CredentialHealthStatus;
-  message?: string;
-  testedAt?: string;
-  expiresAt?: string;
-  details?: Readonly<Record<string, unknown>>;
-}>;
-type OAuth2ProviderFromPublicConfig = Readonly<{
-  authorizeUrlFieldKey: string;
-  tokenUrlFieldKey: string;
-  userInfoUrlFieldKey?: string;
-}>;
-type CredentialOAuth2ScopesFromPublicConfig = Readonly<{
-  presetFieldKey: string;
-  presetScopes: Readonly<Record<string, ReadonlyArray<string>>>;
-  customPresetKey?: string;
-  customScopesFieldKey?: string;
-}>;
-type CredentialOAuth2AuthDefinition = Readonly<{
-  kind: "oauth2";
+interface RunCurrentState {
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
+  /** Append-only history of connection-scoped invocations (LLM/tool) for inspector and canvas. */
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+  mutableState?: PersistedMutableRunState;
+}
+interface CurrentStateExecutionRequest {
+  workflow: WorkflowDefinition;
+  items?: Items;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  currentState?: RunCurrentState;
+  stopCondition?: RunStopCondition;
+  reset?: RunStateResetRequest;
+}
+interface ExecutionFrontierPlan {
+  rootNodeId?: NodeId;
+  rootNodeInput?: Items;
+  queue: RunQueueEntry[];
+  currentState: RunCurrentState;
+  stopCondition: RunStopCondition;
+  satisfiedNodeIds: ReadonlyArray<NodeId>;
+  skippedNodeIds: ReadonlyArray<NodeId>;
+  clearedNodeIds: ReadonlyArray<NodeId>;
+  preservedPinnedNodeIds: ReadonlyArray<NodeId>;
+}
+type RunStatus = "running" | "pending" | "completed" | "failed";
+interface RunSummary {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: RunStatus;
+  /**
+   * Test-case status for runs dispatched as part of a TestSuiteRun. Carries the
+   * assertion-rollup-corrected outcome the test orchestrator persists onto the row, so the
+   * executions list can show "failed" for a run whose workflow completed cleanly but whose
+   * assertions caught regressions. Absent for non-test runs and legacy rows.
+   */
+  testCaseStatus?: TestCaseRunStatus;
+  /** ISO timestamp when the run finished (derived from node snapshots or store `updatedAt`); omit while running/pending. */
+  finishedAt?: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+}
+interface PendingNodeExecution {
+  runId: RunId;
+  activationId: NodeActivationId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  itemsIn: number;
+  inputsByPort: NodeInputsByPort;
+  receiptId: string;
+  queue?: string;
+  batchId?: string;
+  enqueuedAt: string;
+}
+interface PersistedRunSchedulingState {
+  pending?: PendingNodeExecution;
+  queue: RunQueueEntry[];
+}
+interface PersistedRunState {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  /** Canonical terminal time for listings and retention when persisted on the run root. */
+  finishedAt?: string;
+  /** Optimistic concurrency / CAS on the run aggregate (repository may increment on save). */
+  revision?: number;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  control?: PersistedRunControlState;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  /** Frozen at createRun from workflow + runtime defaults for prune/storage decisions. */
+  policySnapshot?: PersistedRunPolicySnapshot;
+  /** Successful node completions so far (for activation budget). */
+  engineCounters?: EngineRunCounters;
+  status: RunStatus;
+  pending?: PendingNodeExecution;
+  queue: RunQueueEntry[];
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
+  /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+}
+interface WorkflowExecutionRepository {
+  createRun(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: RunExecutionOptions;
+    control?: PersistedRunControlState;
+    workflowSnapshot?: PersistedWorkflowSnapshot;
+    mutableState?: PersistedMutableRunState;
+    policySnapshot?: PersistedRunPolicySnapshot;
+    engineCounters?: EngineRunCounters;
+  }): Promise<void>;
+  load(runId: RunId): Promise<PersistedRunState | undefined>;
+  loadSchedulingState(runId: RunId): Promise<PersistedRunSchedulingState | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  deleteRun?(runId: RunId): Promise<void>;
+}
+interface WorkflowExecutionListingRepository {
+  listRuns(args?: Readonly<{
+    workflowId?: WorkflowId;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+}
+/** Runs eligible for retention-based pruning (completed or failed, older than cutoff). */
+interface RunPruneCandidate {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly startedAt: string;
+  readonly finishedAt: string;
+}
+interface WorkflowExecutionPruneRepository {
+  listRunsOlderThan(args: Readonly<{
+    nowIso: string;
+    defaultRetentionSeconds: number;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+type RunResult = {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "completed";
+  outputs: Items;
+} | {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "pending";
+  pending: PendingNodeExecution;
+} | {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "failed";
+  error: {
+    message: string;
+  };
+};
+type WebhookRunResult = Readonly<{
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  runStatus: "pending" | "completed";
+  response: Items;
+}>;
+interface PersistedWorkflowTokenRegistryLike {
+  register(type: TypeToken<unknown>, packageId: string, persistedNameOverride?: string): string;
+  getTokenId(type: TypeToken<unknown>): string | undefined;
+  resolve(tokenId: string): TypeToken<unknown> | undefined;
+  registerFromWorkflows?(workflows: ReadonlyArray<WorkflowDefinition>): void;
+}
+interface RunCompletionNotifier {
+  resolveRunCompletion(result: RunResult): void;
+  resolveWebhookResponse(result: WebhookRunResult): void;
+}
+interface RunEventPublisherDeps {
+  eventBus?: RunEventBus;
+}
+//#endregion
+//#region src/triggers/polling/PollingTriggerDedupWindow.d.ts
+/**
+ * Merges processed-ID windows for polling triggers, capping the total to avoid unbounded growth.
+ * Plugin code receives an instance of this class via {@link PollingTriggerHandle.dedup}.
+ */
+declare class PollingTriggerDedupWindow {
+  static readonly defaultCapN = 2000;
+  merge(previous: ReadonlyArray<string>, incoming: ReadonlyArray<string>, capN?: number): ReadonlyArray<string>;
+}
+//#endregion
+//#region src/triggers/polling/PollingTriggerLogger.d.ts
+/**
+ * Minimal logger surface for the polling-trigger runtime.
+ * Hosts supply this via {@link EngineDeps.pollingTriggerLogger};
+ * when absent the runtime is silent.
+ */
+interface PollingTriggerLogger {
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string, exception?: Error): void;
+  debug(message: string): void;
+}
+declare class NoOpPollingTriggerLogger implements PollingTriggerLogger {
+  info(): void;
+  warn(): void;
+  error(): void;
+  debug(): void;
+}
+//#endregion
+//#region src/contracts/credentialTypes.d.ts
+type CredentialTypeId = string;
+type CredentialInstanceId = string;
+type CredentialMaterialSourceKind = "db" | "env" | "code";
+type CredentialSetupStatus = "draft" | "ready";
+type CredentialHealthStatus = "unknown" | "healthy" | "failing";
+type CredentialFieldSchema = Readonly<{
+  key: string;
+  label: string;
+  type: "string" | "password" | "textarea" | "json" | "boolean";
+  required?: true;
+  order?: number;
+  /**
+   * Where this field appears in the credential dialog. Use `"advanced"` for optional or
+   * power-user fields; they render inside a collapsible section (see `CredentialTypeDefinition.advancedSection`).
+   * Defaults to `"default"` when omitted.
+   */
+  visibility?: "default" | "advanced";
+  placeholder?: string;
+  helpText?: string;
+  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
+  envVarName?: string;
+  /**
+   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
+   * pattern or documentation URL). Do not use for secret values.
+   */
+  copyValue?: string;
+  /** Accessible label for the copy control (default: Copy). */
+  copyButtonLabel?: string;
+}>;
+type CredentialRequirement = Readonly<{
+  slotKey: string;
+  label: string;
+  acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  optional?: true;
+  helpText?: string;
+  helpUrl?: string;
+}>;
+type CredentialBindingKey = Readonly<{
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  slotKey: string;
+}>;
+type CredentialBinding = Readonly<{
+  key: CredentialBindingKey;
+  instanceId: CredentialInstanceId;
+  updatedAt: string;
+}>;
+type CredentialHealth = Readonly<{
+  status: CredentialHealthStatus;
+  message?: string;
+  testedAt?: string;
+  expiresAt?: string;
+  details?: Readonly<Record<string, unknown>>;
+}>;
+type OAuth2ProviderFromPublicConfig = Readonly<{
+  authorizeUrlFieldKey: string;
+  tokenUrlFieldKey: string;
+  userInfoUrlFieldKey?: string;
+}>;
+type CredentialOAuth2ScopesFromPublicConfig = Readonly<{
+  presetFieldKey: string;
+  presetScopes: Readonly<Record<string, ReadonlyArray<string>>>;
+  customPresetKey?: string;
+  customScopesFieldKey?: string;
+}>;
+type CredentialOAuth2AuthDefinition = Readonly<{
+  kind: "oauth2";
   providerId: string;
   scopes: ReadonlyArray<string>;
   scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
@@ -184,6 +682,27 @@ type CredentialOAuth2AuthDefinition = Readonly<{
   scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
   clientIdFieldKey?: string;
   clientSecretFieldKey?: string;
+} | {
+  kind: "oauth2";
+  /**
+   * Free-form provider identifier for telemetry, DB rows, and Better Auth provider naming.
+   * Not used for any registry lookup — URLs come from {@link authorizeUrl} / {@link tokenUrl}.
+   */
+  providerId: string;
+  /**
+   * Authorization endpoint. May contain `{publicFieldKey}` placeholders that the runtime
+   * substitutes from the credential's resolved public config (URL-encoded).
+   * Example: `https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/authorize`
+   */
+  authorizeUrl: string;
+  /** Token endpoint. Same templating rules as {@link authorizeUrl}. */
+  tokenUrl: string;
+  /** Optional userinfo endpoint. Same templating rules as {@link authorizeUrl}. */
+  userInfoUrl?: string;
+  scopes: ReadonlyArray<string>;
+  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
+  clientIdFieldKey?: string;
+  clientSecretFieldKey?: string;
 }>;
 type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
 type CredentialAdvancedSectionPresentation = Readonly<{
@@ -274,9 +793,74 @@ declare class CredentialUnboundError extends Error {
   private static createMessage;
 }
 //#endregion
-//#region src/contracts/CostTrackingTelemetryContract.d.ts
-type CostTrackingComponent = "chat" | "ocr" | "rag";
-declare const CostTrackingTelemetryMetricNames: {
+//#region src/contracts/collectionTypes.d.ts
+/**
+ * Represents a typed store for a single collection.
+ * All rows include auto-managed id, created_at, and updated_at fields.
+ */
+interface CollectionStore<TRow extends Record<string, unknown> = Record<string, unknown>> {
+  /**
+   * Insert a new row. id, created_at, and updated_at are auto-populated.
+   */
+  insert(row: TRow): Promise<TRow & {
+    id: string;
+    created_at: Date;
+    updated_at: Date;
+  }>;
+  /**
+   * Get a single row by id.
+   */
+  get(id: string): Promise<(TRow & {
+    id: string;
+    created_at: Date;
+    updated_at: Date;
+  }) | null>;
+  /**
+   * Find a single row matching the provided filter.
+   */
+  findOne(filter: Partial<TRow>): Promise<(TRow & {
+    id: string;
+    created_at: Date;
+    updated_at: Date;
+  }) | null>;
+  /**
+   * List rows with optional pagination and filtering.
+   */
+  list(opts?: {
+    limit?: number;
+    offset?: number;
+    where?: Partial<TRow>;
+  }): Promise<{
+    rows: ReadonlyArray<TRow & {
+      id: string;
+      created_at: Date;
+      updated_at: Date;
+    }>;
+    total: number;
+  }>;
+  /**
+   * Update a row by id with partial data.
+   */
+  update(id: string, patch: Partial<TRow>): Promise<TRow & {
+    id: string;
+    created_at: Date;
+    updated_at: Date;
+  }>;
+  /**
+   * Delete a row by id. Hard delete only (no soft delete).
+   */
+  delete(id: string): Promise<{
+    deleted: boolean;
+  }>;
+}
+/**
+ * Runtime collections context: keyed by collection name.
+ */
+type CollectionsContext = Readonly<Record<string, CollectionStore>>;
+//#endregion
+//#region src/contracts/CostTrackingTelemetryContract.d.ts
+type CostTrackingComponent = "chat" | "ocr" | "rag";
+declare const CostTrackingTelemetryMetricNames: {
   readonly usage: "codemation.cost.usage";
   readonly estimatedCost: "codemation.cost.estimated";
 };
@@ -324,6 +908,8 @@ declare class NoOpTelemetryArtifactReference {
 //#region src/contracts/NoOpTelemetrySpanScope.d.ts
 declare class NoOpTelemetrySpanScope {
   static readonly value: TelemetrySpanScope;
+  /** Internal: the shared no-op {@link NodeExecutionTelemetry} that {@link NoOpNodeExecutionTelemetry} re-exposes. */
+  static readonly nodeExecutionTelemetryValue: NodeExecutionTelemetry;
 }
 //#endregion
 //#region src/contracts/NoOpNodeExecutionTelemetry.d.ts
@@ -358,6 +944,12 @@ declare class CodemationTelemetryAttributeNames {
   static readonly connectionInvocationId = "codemation.connection.invocation_id";
   static readonly toolName = "codemation.tool.name";
   static readonly traceParentRunId = "codemation.parent.run.id";
+  /** Per-item iteration that emitted this span/metric. Set on spans recorded inside a runnable per-item loop. */
+  static readonly iterationId = "codemation.iteration.id";
+  /** Item index (0-based) of the iteration. */
+  static readonly iterationIndex = "codemation.iteration.index";
+  /** Set when this span/metric was recorded under a sub-agent triggered by an outer LLM/tool call. */
+  static readonly parentInvocationId = "codemation.parent.invocation_id";
 }
 //#endregion
 //#region src/contracts/GenAiTelemetryAttributeNames.d.ts
@@ -437,322 +1029,36 @@ interface TelemetrySpanScope extends TelemetryScope {
   readonly traceId: string;
   readonly spanId: string;
   end(args?: TelemetrySpanEnd): Promise<void> | void;
-}
-interface NodeExecutionTelemetry extends ExecutionTelemetry, TelemetrySpanScope {
-  startChildSpan(args: TelemetryChildSpanStart): TelemetrySpanScope;
-}
-interface ExecutionTelemetry extends TelemetryScope {
-  readonly traceId: string;
-  readonly spanId: string;
-  forNode(args: Readonly<{
+  /**
+   * Lift this span into a {@link NodeExecutionTelemetry} scoped to a different (nodeId, activationId).
+   * Children created via the returned telemetry's `startChildSpan` get this span as their parent.
+   *
+   * Used at the sub-agent boundary so that nested runtime telemetry parents under the agent.tool.call
+   * span instead of the orchestrator's node-level span.
+   */
+  asNodeTelemetry(args: Readonly<{
     nodeId: NodeId;
     activationId: NodeActivationId;
   }>): NodeExecutionTelemetry;
 }
-interface ExecutionTelemetryFactory {
-  create(args: Readonly<{
-    runId: RunId;
-    workflowId: WorkflowId;
-    parent?: ParentExecutionRef;
-    policySnapshot?: PersistedRunPolicySnapshot;
-  }>): ExecutionTelemetry;
-}
-//#endregion
-//#region src/contracts/runTypes.d.ts
-interface RunExecutionOptions {
-  /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
-  localOnly?: boolean;
-  /** Marks runs started from webhook handling so orchestration can apply webhook-specific continuation rules. */
-  webhook?: boolean;
-  mode?: "manual" | "debug";
-  sourceWorkflowId?: WorkflowId;
-  sourceRunId?: RunId;
-  derivedFromRunId?: RunId;
-  isMutable?: boolean;
-  /** Set by the engine for this run: 0 = root, 1 = first child subworkflow, … */
-  subworkflowDepth?: number;
-  /** Effective cap after engine policy merge (successful node completions per run). */
-  maxNodeActivations?: number;
-  /** Effective cap after engine policy merge (subworkflow nesting). */
-  maxSubworkflowDepth?: number;
-}
-/** Engine-owned counters persisted with the run (worker-safe). */
-interface EngineRunCounters {
-  completedNodeActivations: number;
-}
-type RunStopCondition = Readonly<{
-  kind: "workflowCompleted";
-}> | Readonly<{
-  kind: "nodeCompleted";
-  nodeId: NodeId;
-}>;
-interface RunStateResetRequest {
-  clearFromNodeId: NodeId;
-}
-interface PersistedRunControlState {
-  stopCondition?: RunStopCondition;
-}
-interface PersistedWorkflowSnapshotNode {
-  id: NodeId;
-  kind: NodeKind;
-  name?: string;
-  nodeTokenId: PersistedTokenId;
-  configTokenId: PersistedTokenId;
-  tokenName?: string;
-  configTokenName?: string;
-  config: unknown;
-}
-interface PersistedWorkflowSnapshot {
-  id: WorkflowId;
-  name: string;
-  nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
-  edges: ReadonlyArray<Edge>;
-  /** When the snapshot was built from a live workflow definition that configured a workflow error handler. */
-  workflowErrorHandlerConfigured?: boolean;
-  /** Connection metadata for child nodes not in the execution graph (e.g. AI agent attachments). */
-  connections?: ReadonlyArray<WorkflowNodeConnection>;
-}
-type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
-interface PersistedMutableNodeState {
-  pinnedOutputsByPort?: PinnedNodeOutputsByPort;
-  lastDebugInput?: Items;
-}
-interface PersistedMutableRunState {
-  nodesById: Readonly<Record<NodeId, PersistedMutableNodeState>>;
-}
-type NodeInputsByPort = Readonly<Record<InputPortKey, Items>>;
-interface RunQueueEntry {
-  nodeId: NodeId;
-  input: Items;
-  toInput?: InputPortKey;
-  batchId?: string;
-  from?: Readonly<{
-    nodeId: NodeId;
-    output: OutputPortKey;
-  }>;
-  collect?: Readonly<{
-    expectedInputs: ReadonlyArray<InputPortKey>;
-    received: Readonly<Record<InputPortKey, Items>>;
-  }>;
-}
-type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
-interface NodeExecutionError {
-  message: string;
-  name?: string;
-  stack?: string;
-  details?: JsonValue;
-}
-interface NodeExecutionSnapshot {
-  runId: RunId;
-  workflowId: WorkflowId;
-  nodeId: NodeId;
-  activationId?: NodeActivationId;
-  parent?: ParentExecutionRef;
-  status: NodeExecutionStatus;
-  usedPinnedOutput?: boolean;
-  queuedAt?: string;
-  startedAt?: string;
-  finishedAt?: string;
-  updatedAt: string;
-  inputsByPort?: NodeInputsByPort;
-  outputs?: NodeOutputs;
-  error?: NodeExecutionError;
-}
-/** Stable id for a single connection invocation row in {@link ConnectionInvocationRecord}. */
-type ConnectionInvocationId = string;
-/**
- * One logical LLM or tool call under an owning workflow node (e.g. AI agent).
- * The owning node defines what {@link managedInput} and {@link managedOutput} contain.
- */
-interface ConnectionInvocationRecord {
-  readonly invocationId: ConnectionInvocationId;
-  readonly runId: RunId;
-  readonly workflowId: WorkflowId;
-  readonly connectionNodeId: NodeId;
-  readonly parentAgentNodeId: NodeId;
-  readonly parentAgentActivationId: NodeActivationId;
-  readonly status: NodeExecutionStatus;
-  readonly managedInput?: JsonValue;
-  readonly managedOutput?: JsonValue;
-  readonly error?: NodeExecutionError;
-  readonly queuedAt?: string;
-  readonly startedAt?: string;
-  readonly finishedAt?: string;
-  readonly updatedAt: string;
-}
-/** Arguments for appending a {@link ConnectionInvocationRecord} (engine fills run/workflow ids and timestamps). */
-type ConnectionInvocationAppendArgs = Readonly<{
-  invocationId: ConnectionInvocationId;
-  connectionNodeId: NodeId;
-  parentAgentNodeId: NodeId;
-  parentAgentActivationId: NodeActivationId;
-  status: NodeExecutionStatus;
-  managedInput?: JsonValue;
-  managedOutput?: JsonValue;
-  error?: NodeExecutionError;
-  queuedAt?: string;
-  startedAt?: string;
-  finishedAt?: string;
-}>;
-interface RunCurrentState {
-  outputsByNode: Record<NodeId, NodeOutputs>;
-  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
-  /** Append-only history of connection-scoped invocations (LLM/tool) for inspector and canvas. */
-  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
-  mutableState?: PersistedMutableRunState;
-}
-interface CurrentStateExecutionRequest {
-  workflow: WorkflowDefinition;
-  items?: Items;
-  parent?: ParentExecutionRef;
-  executionOptions?: RunExecutionOptions;
-  workflowSnapshot?: PersistedWorkflowSnapshot;
-  mutableState?: PersistedMutableRunState;
-  currentState?: RunCurrentState;
-  stopCondition?: RunStopCondition;
-  reset?: RunStateResetRequest;
-}
-interface ExecutionFrontierPlan {
-  rootNodeId?: NodeId;
-  rootNodeInput?: Items;
-  queue: RunQueueEntry[];
-  currentState: RunCurrentState;
-  stopCondition: RunStopCondition;
-  satisfiedNodeIds: ReadonlyArray<NodeId>;
-  skippedNodeIds: ReadonlyArray<NodeId>;
-  clearedNodeIds: ReadonlyArray<NodeId>;
-  preservedPinnedNodeIds: ReadonlyArray<NodeId>;
-}
-type RunStatus = "running" | "pending" | "completed" | "failed";
-interface RunSummary {
-  runId: RunId;
-  workflowId: WorkflowId;
-  startedAt: string;
-  status: RunStatus;
-  /** ISO timestamp when the run finished (derived from node snapshots or store `updatedAt`); omit while running/pending. */
-  finishedAt?: string;
-  parent?: ParentExecutionRef;
-  executionOptions?: RunExecutionOptions;
-}
-interface PendingNodeExecution {
-  runId: RunId;
-  activationId: NodeActivationId;
-  workflowId: WorkflowId;
-  nodeId: NodeId;
-  itemsIn: number;
-  inputsByPort: NodeInputsByPort;
-  receiptId: string;
-  queue?: string;
-  batchId?: string;
-  enqueuedAt: string;
-}
-interface PersistedRunSchedulingState {
-  pending?: PendingNodeExecution;
-  queue: RunQueueEntry[];
-}
-interface PersistedRunState {
-  runId: RunId;
-  workflowId: WorkflowId;
-  startedAt: string;
-  /** Canonical terminal time for listings and retention when persisted on the run root. */
-  finishedAt?: string;
-  /** Optimistic concurrency / CAS on the run aggregate (repository may increment on save). */
-  revision?: number;
-  parent?: ParentExecutionRef;
-  executionOptions?: RunExecutionOptions;
-  control?: PersistedRunControlState;
-  workflowSnapshot?: PersistedWorkflowSnapshot;
-  mutableState?: PersistedMutableRunState;
-  /** Frozen at createRun from workflow + runtime defaults for prune/storage decisions. */
-  policySnapshot?: PersistedRunPolicySnapshot;
-  /** Successful node completions so far (for activation budget). */
-  engineCounters?: EngineRunCounters;
-  status: RunStatus;
-  pending?: PendingNodeExecution;
-  queue: RunQueueEntry[];
-  outputsByNode: Record<NodeId, NodeOutputs>;
-  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
-  /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
-  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
-}
-interface WorkflowExecutionRepository {
-  createRun(args: {
-    runId: RunId;
-    workflowId: WorkflowId;
-    startedAt: string;
-    parent?: ParentExecutionRef;
-    executionOptions?: RunExecutionOptions;
-    control?: PersistedRunControlState;
-    workflowSnapshot?: PersistedWorkflowSnapshot;
-    mutableState?: PersistedMutableRunState;
-    policySnapshot?: PersistedRunPolicySnapshot;
-    engineCounters?: EngineRunCounters;
-  }): Promise<void>;
-  load(runId: RunId): Promise<PersistedRunState | undefined>;
-  loadSchedulingState(runId: RunId): Promise<PersistedRunSchedulingState | undefined>;
-  save(state: PersistedRunState): Promise<void>;
-  deleteRun?(runId: RunId): Promise<void>;
-}
-interface WorkflowExecutionListingRepository {
-  listRuns(args?: Readonly<{
-    workflowId?: WorkflowId;
-    limit?: number;
-  }>): Promise<ReadonlyArray<RunSummary>>;
-}
-/** Runs eligible for retention-based pruning (completed or failed, older than cutoff). */
-interface RunPruneCandidate {
-  readonly runId: RunId;
-  readonly workflowId: WorkflowId;
-  readonly startedAt: string;
-  readonly finishedAt: string;
-}
-interface WorkflowExecutionPruneRepository {
-  listRunsOlderThan(args: Readonly<{
-    nowIso: string;
-    defaultRetentionSeconds: number;
-    limit?: number;
-  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
-}
-type RunResult = {
-  runId: RunId;
-  workflowId: WorkflowId;
-  startedAt: string;
-  status: "completed";
-  outputs: Items;
-} | {
-  runId: RunId;
-  workflowId: WorkflowId;
-  startedAt: string;
-  status: "pending";
-  pending: PendingNodeExecution;
-} | {
-  runId: RunId;
-  workflowId: WorkflowId;
-  startedAt: string;
-  status: "failed";
-  error: {
-    message: string;
-  };
-};
-type WebhookRunResult = Readonly<{
-  runId: RunId;
-  workflowId: WorkflowId;
-  startedAt: string;
-  runStatus: "pending" | "completed";
-  response: Items;
-}>;
-interface PersistedWorkflowTokenRegistryLike {
-  register(type: TypeToken<unknown>, packageId: string, persistedNameOverride?: string): string;
-  getTokenId(type: TypeToken<unknown>): string | undefined;
-  resolve(tokenId: string): TypeToken<unknown> | undefined;
-  registerFromWorkflows?(workflows: ReadonlyArray<WorkflowDefinition>): void;
-}
-interface RunCompletionNotifier {
-  resolveRunCompletion(result: RunResult): void;
-  resolveWebhookResponse(result: WebhookRunResult): void;
+interface NodeExecutionTelemetry extends ExecutionTelemetry, TelemetrySpanScope {
+  startChildSpan(args: TelemetryChildSpanStart): TelemetrySpanScope;
 }
-interface RunEventPublisherDeps {
-  eventBus?: RunEventBus;
+interface ExecutionTelemetry extends TelemetryScope {
+  readonly traceId: string;
+  readonly spanId: string;
+  forNode(args: Readonly<{
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+  }>): NodeExecutionTelemetry;
+}
+interface ExecutionTelemetryFactory {
+  create(args: Readonly<{
+    runId: RunId;
+    workflowId: WorkflowId;
+    parent?: ParentExecutionRef;
+    policySnapshot?: PersistedRunPolicySnapshot;
+  }>): ExecutionTelemetry;
 }
 //#endregion
 //#region src/contracts/workflowActivationPolicy.d.ts
@@ -925,6 +1231,21 @@ interface ExecutionContext {
   telemetry: ExecutionTelemetry;
   binary: ExecutionBinaryService;
   getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+  /** Per-item iteration id, set by {@link NodeExecutor} on the ctx passed into runnable `execute`. */
+  iterationId?: NodeIterationId;
+  /** Item index (0-based) within the current activation's batch; set alongside {@link iterationId}. */
+  itemIndex?: number;
+  /** When set, this ctx is executing inside a sub-agent triggered by the named parent invocation. */
+  parentInvocationId?: ConnectionInvocationId;
+  /**
+   * Present iff the run was started by a TestSuiteOrchestrator. The {@link IsTestRunNode}
+   * branches on this; assertion-emitting nodes use it to decide whether to record results.
+   */
+  testContext?: RunTestContext;
+  /**
+   * Collections registered in the codemation config, keyed by collection name.
+   */
+  readonly collections?: CollectionsContext;
 }
 interface ExecutionContextFactory {
   create(args: {
@@ -939,6 +1260,7 @@ interface ExecutionContextFactory {
     nodeState?: NodeExecutionStatePublisher;
     telemetry?: ExecutionTelemetry;
     getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+    testContext?: RunTestContext;
   }): ExecutionContext;
 }
 interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase> extends ExecutionContext {
@@ -948,12 +1270,34 @@ interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase>
   telemetry: NodeExecutionTelemetry;
   binary: NodeBinaryAttachmentService;
 }
+interface PollingTriggerHandle {
+  /**
+   * Start the polling loop. The runtime registers its own cleanup handle so callers do not need to
+   * call {@link TriggerSetupContext.registerCleanup} for the loop.
+   * @returns The state returned by the first cycle (or `undefined` when the overlap guard fired).
+   */
+  start<TState, TItem>(args: {
+    intervalMs: number;
+    seedState?: TState;
+    runCycle: (cycleCtx: {
+      previousState: TState | undefined;
+      signal: AbortSignal;
+    }) => Promise<{
+      items: Items<TItem>;
+      nextState: TState;
+    }>;
+  }): Promise<TState | undefined>;
+  /** Convenience dedup-window helper. */
+  readonly dedup: PollingTriggerDedupWindow;
+}
 interface TriggerSetupContext<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>, TSetupState$1 extends JsonValue | undefined = TriggerNodeSetupState<TConfig>> extends ExecutionContext {
   trigger: TriggerInstanceId;
   config: TConfig;
   previousState: TSetupState$1;
   registerCleanup(cleanup: TriggerCleanupHandle): void;
   emit(items: Items): Promise<void>;
+  /** Generic polling-trigger surface. Pre-binds trigger id, emit, and registerCleanup. */
+  readonly polling: PollingTriggerHandle;
 }
 interface TriggerTestItemsContext<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>, TSetupState$1 extends JsonValue | undefined = TriggerNodeSetupState<TConfig>> extends ExecutionContext {
   trigger: TriggerInstanceId;
@@ -1148,6 +1492,8 @@ interface EngineDeps {
   workflowPolicyRuntimeDefaults?: WorkflowPolicyRuntimeDefaults;
   /** When set, logs inactive-workflow skips at boot and trigger start/stop on activation changes. */
   triggerRuntimeDiagnostics?: TriggerRuntimeDiagnostics;
+  /** When set, the polling-trigger runtime uses this logger for cycle info/debug/error. */
+  pollingTriggerLogger?: PollingTriggerLogger;
 }
 //#endregion
 //#region src/contracts/retryPolicySpec.types.d.ts
@@ -1179,14 +1525,9 @@ interface ExponentialRetryPolicySpec {
 }
 //#endregion
 //#region src/contracts/workflowTypes.d.ts
-type WorkflowId = string;
-type NodeId = string;
 type NodeIdRef<TJson = unknown> = NodeId & Readonly<{
   __codemationNodeJson?: TJson;
 }>;
-type OutputPortKey = string;
-type InputPortKey = string;
-type PersistedTokenId = string;
 type NodeKind = "trigger" | "node";
 type JsonPrimitive = string | number | boolean | null;
 interface JsonObject {
@@ -1206,7 +1547,6 @@ interface Edge {
     input: InputPortKey;
   };
 }
-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
@@ -1272,6 +1612,14 @@ 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;
 }
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
@@ -1301,6 +1649,12 @@ interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonV
   readonly kind: "trigger";
   readonly [triggerNodeOutputType]?: TOutputJson$1;
   readonly [triggerNodeSetupStateType]?: TSetupState$1;
+  /**
+   * 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";
 }
 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;
@@ -1351,6 +1705,12 @@ type Items<TJson = unknown> = ReadonlyArray<Item<TJson>>;
 type NodeOutputs = Partial<Record<OutputPortKey, Items>>;
 type RunId = string;
 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.
+ */
+type NodeIterationId = string;
 interface ParentExecutionRef {
   runId: RunId;
   workflowId: WorkflowId;
@@ -1361,6 +1721,12 @@ 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?: RunTestContext;
 }
 interface RunDataSnapshot {
   getOutputs(nodeId: NodeId): NodeOutputs | undefined;
@@ -1457,23 +1823,61 @@ interface WorkflowPolicyRuntimeDefaults {
   readonly storagePolicy?: WorkflowStoragePolicyMode;
 }
 //#endregion
-//#region src/contracts/emitPorts.d.ts
-declare const EMIT_PORTS_BRAND: unique symbol;
-type PortsEmission = Readonly<{
-  readonly [EMIT_PORTS_BRAND]: true;
-  readonly ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>;
-}>;
-declare function emitPorts(ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>): PortsEmission;
-declare function isPortsEmission(value: unknown): value is PortsEmission;
-declare function isUnbrandedPortsEmissionShape(value: unknown): value is Readonly<{
-  ports: unknown;
-}>;
-//#endregion
-//#region src/contracts/itemMeta.d.ts
+//#region src/contracts/assertionTypes.d.ts
 /**
- * Reads `meta._cm.originIndex` when present (used for fan-in merge-by-origin and Merge routing).
+ * One assertion emitted by an assertion-emitting node (a node whose config sets
+ * `emitsAssertions: true`). Each emitted item on `main` carries one of these as `item.json`.
+ *
+ * Pass/fail is derived from `score >= (passThreshold ?? 0.5)` — see {@link deriveAssertionPassed}.
+ * The `errored` marker is for cases where the assertion code itself threw (distinct from
+ * "the assertion was evaluated and the score was low") and is treated as a hard fail in rollups
+ * regardless of `score`.
  */
-declare function getOriginIndexFromItem(item: Item): number | undefined;
+interface AssertionResult {
+  readonly name: string;
+  /** 0..1 score. Source of truth for pass/fail (compared against `passThreshold`). */
+  readonly score: number;
+  /** 0..1 threshold for "passed". When omitted, consumers default to 0.5. */
+  readonly passThreshold?: number;
+  /** True when evaluating the assertion threw — treated as fail regardless of `score`. */
+  readonly errored?: true;
+  /** What the assertion expected. Free-form JSON; UIs render with a JSON viewer. */
+  readonly expected?: JsonValue;
+  /** What the workflow actually produced. */
+  readonly actual?: JsonValue;
+  /** Short human-readable explanation, especially for fails / errors. */
+  readonly message?: string;
+  /** Bag of supplemental fields (e.g. judge prompt, judge raw response, comparison method). */
+  readonly details?: Readonly<Record<string, JsonValue>>;
+}
+/**
+ * Default {@link AssertionResult.passThreshold} when authors omit it. Boolean-style assertions
+ * (assertEqual / contains / etc.) emit `score: 1` or `score: 0` so this default works for them;
+ * AI-judge assertions are expected to set their own threshold.
+ */
+declare const DEFAULT_ASSERTION_PASS_THRESHOLD = 0.5;
+/**
+ * Derive whether an assertion result is considered "passing" using the score-based contract:
+ * `errored` always fails, otherwise `score >= (passThreshold ?? 0.5)`. This is the canonical
+ * derivation — UI and rollup code should call it rather than inlining the comparison so future
+ * tweaks (e.g. NaN handling) land in one place.
+ */
+declare function deriveAssertionPassed(result: {
+  readonly score: number;
+  readonly passThreshold?: number;
+  readonly errored?: true;
+}): boolean;
+/**
+ * Provenance for a persisted {@link AssertionResult}: which node produced it and where in the
+ * per-item iteration tree it landed. Filled in by the host-side persister, not the node itself.
+ */
+interface AssertionResultProvenance {
+  readonly nodeId: NodeId;
+  /** Per-item iteration id when the emitting node ran inside a per-item loop. */
+  readonly iterationId?: string;
+  /** Item index (0-based) within the activation that produced this assertion. */
+  readonly itemIndex?: number;
+}
 //#endregion
 //#region src/contracts/itemExpr.d.ts
 declare const ITEM_EXPR_BRAND: unique symbol;
@@ -1515,34 +1919,6 @@ type Expr<T, TItemJson = unknown> = ItemExpr<T, TItemJson>;
 type Param<T, TItemJson = unknown> = T | Expr<T, TItemJson>;
 type ParamDeep<T, TItemJson = unknown> = Expr<T, TItemJson> | (T extends readonly (infer U)[] ? ReadonlyArray<ParamDeep<U, TItemJson>> : never) | (T extends object ? { [K in keyof T]: ParamDeep<T[K], TItemJson> } : T);
 //#endregion
-//#region src/contracts/NoRetryPolicy.d.ts
-declare class NoRetryPolicy implements NoneRetryPolicySpec {
-  readonly kind: "none";
-}
-//#endregion
-//#region src/contracts/RetryPolicy.d.ts
-declare class RetryPolicy implements FixedRetryPolicySpec {
-  readonly maxAttempts: number;
-  readonly delayMs: number;
-  readonly kind: "fixed";
-  constructor(maxAttempts: number, delayMs: number);
-  /** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
-  static readonly defaultForHttp: FixedRetryPolicySpec;
-  /** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
-  static readonly defaultForAiAgent: FixedRetryPolicySpec;
-}
-//#endregion
-//#region src/contracts/ExpRetryPolicy.d.ts
-declare class ExpRetryPolicy implements ExponentialRetryPolicySpec {
-  readonly maxAttempts: number;
-  readonly initialDelayMs: number;
-  readonly multiplier: number;
-  readonly maxDelayMs?: number | undefined;
-  readonly jitter?: boolean | undefined;
-  readonly kind: "exponential";
-  constructor(maxAttempts: number, initialDelayMs: number, multiplier: number, maxDelayMs?: number | undefined, jitter?: boolean | undefined);
-}
-//#endregion
 //#region src/contracts/CostCatalogContract.d.ts
 interface CostCatalogEntry {
   readonly component: CostTrackingUsageRecord["component"];
@@ -1558,19 +1934,6 @@ interface CostCatalog {
   findEntry(args: CostTrackingUsageRecord): CostCatalogEntry | undefined;
 }
 //#endregion
-//#region src/contracts/NoOpCostTrackingTelemetry.d.ts
-declare class NoOpCostTrackingTelemetry implements CostTrackingTelemetry {
-  captureUsage(_: CostTrackingUsageRecord): Promise<CostTrackingPriceQuote | undefined>;
-  forScope(_: TelemetryScope): CostTrackingTelemetry;
-}
-//#endregion
-//#region src/contracts/NoOpCostTrackingTelemetryFactory.d.ts
-declare class NoOpCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
-  create(_: Readonly<{
-    telemetry: ExecutionTelemetry;
-  }>): CostTrackingTelemetry;
-}
-//#endregion
 //#region src/contracts/executionPersistenceContracts.d.ts
 /** Canonical id for persisted execution rows (activation or connection invocation). */
 type ExecutionInstanceId = string;
@@ -1696,6 +2059,29 @@ interface WorkflowRunDetailDto {
   readonly mutableState?: PersistedMutableRunState;
   readonly slotStates: ReadonlyArray<SlotExecutionStateDto>;
   readonly executionInstances: ReadonlyArray<ExecutionInstanceDto>;
+  readonly iterations?: ReadonlyArray<RunIterationDto>;
+}
+/**
+ * Per-item iteration projected from connection invocations and node activations.
+ *
+ * One iteration = one item processed by an agent within an activation. Multiple invocations
+ * (LLM rounds, tool calls) belonging to the same iteration share the iterationId.
+ */
+interface RunIterationDto {
+  readonly iterationId: string;
+  readonly agentNodeId: NodeId;
+  readonly activationId: NodeActivationId;
+  readonly itemIndex: number;
+  readonly itemSummary?: string;
+  readonly status: NodeExecutionStatus;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly invocationIds: ReadonlyArray<string>;
+  readonly parentInvocationId?: string;
+  /** Estimated cost rolled up from telemetry cost metric points, keyed by ISO currency code (e.g. "USD"). Values are minor units (cents-of-cents per the metric's `cost.currency_scale`). */
+  readonly estimatedCostMinorByCurrency?: Readonly<Record<string, number>>;
+  /** Currency scale (denominator) per currency, when present on the metric points. Joined with `estimatedCostMinorByCurrency` to format human-readable amounts. */
+  readonly estimatedCostCurrencyScaleByCurrency?: Readonly<Record<string, number>>;
 }
 interface SlotExecutionStateDto {
   readonly slotNodeId: NodeId;
@@ -1724,12 +2110,77 @@ interface ExecutionInstanceDto {
   readonly inputJson?: JsonValue;
   readonly outputJson?: JsonValue;
   readonly error?: Readonly<NodeExecutionError>;
+  /** Per-item iteration that produced this instance. Set on connectionInvocation rows produced inside per-item runnable loops. */
+  readonly iterationId?: string;
+  /** Item index (0-based) of the iteration. */
+  readonly itemIndex?: number;
+  /** Parent invocation id when this instance was emitted by a sub-agent triggered by an outer LLM/tool call. */
+  readonly parentInvocationId?: string;
 }
 interface WorkflowDetailSelectionState {
   readonly selectedSlotNodeId: NodeId | null;
   readonly selectedInstanceId: ExecutionInstanceId | null;
 }
 //#endregion
+//#region src/contracts/emitPorts.d.ts
+declare const EMIT_PORTS_BRAND: unique symbol;
+type PortsEmission = Readonly<{
+  readonly [EMIT_PORTS_BRAND]: true;
+  readonly ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>;
+}>;
+declare function emitPorts(ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>): PortsEmission;
+declare function isPortsEmission(value: unknown): value is PortsEmission;
+declare function isUnbrandedPortsEmissionShape(value: unknown): value is Readonly<{
+  ports: unknown;
+}>;
+//#endregion
+//#region src/contracts/itemMeta.d.ts
+/**
+ * Reads `meta._cm.originIndex` when present (used for fan-in merge-by-origin and Merge routing).
+ */
+declare function getOriginIndexFromItem(item: Item): number | undefined;
+//#endregion
+//#region src/contracts/NoRetryPolicy.d.ts
+declare class NoRetryPolicy implements NoneRetryPolicySpec {
+  readonly kind: "none";
+}
+//#endregion
+//#region src/contracts/RetryPolicy.d.ts
+declare class RetryPolicy implements FixedRetryPolicySpec {
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly kind: "fixed";
+  constructor(maxAttempts: number, delayMs: number);
+  /** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
+  static readonly defaultForHttp: FixedRetryPolicySpec;
+  /** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
+  static readonly defaultForAiAgent: FixedRetryPolicySpec;
+}
+//#endregion
+//#region src/contracts/ExpRetryPolicy.d.ts
+declare class ExpRetryPolicy implements ExponentialRetryPolicySpec {
+  readonly maxAttempts: number;
+  readonly initialDelayMs: number;
+  readonly multiplier: number;
+  readonly maxDelayMs?: number | undefined;
+  readonly jitter?: boolean | undefined;
+  readonly kind: "exponential";
+  constructor(maxAttempts: number, initialDelayMs: number, multiplier: number, maxDelayMs?: number | undefined, jitter?: boolean | undefined);
+}
+//#endregion
+//#region src/contracts/NoOpCostTrackingTelemetry.d.ts
+declare class NoOpCostTrackingTelemetry implements CostTrackingTelemetry {
+  captureUsage(_: CostTrackingUsageRecord): Promise<CostTrackingPriceQuote | undefined>;
+  forScope(_: TelemetryScope): CostTrackingTelemetry;
+}
+//#endregion
+//#region src/contracts/NoOpCostTrackingTelemetryFactory.d.ts
+declare class NoOpCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
+  create(_: Readonly<{
+    telemetry: ExecutionTelemetry;
+  }>): CostTrackingTelemetry;
+}
+//#endregion
 //#region src/contracts/runFinishedAtFactory.d.ts
 type RunFinishedAtSource = Pick<PersistedRunState, "status" | "nodeSnapshotsByNodeId" | "finishedAt">;
 /** Derives workflow end time from persisted run root or node snapshots for run listings. */
@@ -1792,7 +2243,6 @@ declare class WorkflowBuilder {
   private readonly options?;
   private readonly nodes;
   private readonly edges;
-  private seq;
   constructor(meta: {
     id: WorkflowId;
     name: string;
@@ -1802,8 +2252,37 @@ declare class WorkflowBuilder {
   trigger<TConfig extends AnyTriggerNodeConfig>(config: TConfig): ChainCursor<TriggerNodeOutputJson<TConfig>>;
   start<TConfig extends AnyRunnableNodeConfig>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
   build(): WorkflowDefinition;
+  private validateNodeIds;
 }
 //#endregion
+//#region src/workflow/dsl/WorkflowDefinitionError.d.ts
+/**
+ * Thrown by {@link WorkflowBuilder.build} when the workflow definition is structurally invalid.
+ *
+ * Common causes:
+ * - A node has an empty effective id (label is blank and no explicit `id` was given).
+ * - Two or more nodes share the same effective id (label slugs collide or explicit ids clash).
+ *
+ * Fix: provide an explicit `id:` on the offending node configs.
+ */
+declare class WorkflowDefinitionError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/workflow/dsl/NodeIdSlugifier.d.ts
+/**
+ * Converts a human-readable node label into a stable, URL-safe identifier segment.
+ *
+ * Rules:
+ * - Lowercase the entire string.
+ * - Replace every run of characters outside `[a-z0-9]` with a single `-`.
+ * - Strip any leading or trailing `-` characters.
+ * - Return `""` for blank/empty input.
+ */
+declare const NodeIdSlugifier: {
+  slugify(label: string): string;
+};
+//#endregion
 //#region src/workflow/definition/ConnectionInvocationIdFactory.d.ts
 /**
  * Unique ids for persisted connection invocation history rows (LLM/tool calls under an owning node).
@@ -1838,6 +2317,22 @@ declare class ConnectionNodeIdFactory {
   static normalizeToolName(toolName: string): string;
 }
 //#endregion
+//#region src/workflow/definition/NodeIterationIdFactory.d.ts
+/**
+ * Unique ids for one per-item iteration of a runnable node's execute loop.
+ *
+ * Activations are per-batch (one scheduled execution of a node, possibly with N items).
+ * Iterations refine that to one identifier per item-index inside the batch loop, so per-item
+ * connection invocations and telemetry can be grouped without time-window heuristics.
+ */
+declare class NodeIterationIdFactory {
+  static create(): string;
+  /** Deterministic id for tests when a stable sequence is needed. */
+  static createForTest(seed: string, sequence: number): string;
+  /** Deterministic id derived from a connection node id (for sub-agent / tool-call scopes). */
+  static createForConnection(connectionNodeId: NodeId, sequence: number): string;
+}
+//#endregion
 //#region src/workflow/definition/WorkflowExecutableNodeClassifier.d.ts
 /**
  * Derives which workflow nodes participate in the main execution graph vs connection-only children.
@@ -2001,37 +2496,6 @@ declare class Engine implements NodeActivationContinuation, NodeExecutionRequest
   handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
 }
 //#endregion
-//#region src/workflowSnapshots/WorkflowSnapshotCodec.d.ts
-declare class WorkflowSnapshotCodec {
-  private readonly tokenRegistry;
-  constructor(tokenRegistry: PersistedWorkflowTokenRegistryLike);
-  create(workflow: WorkflowDefinition): PersistedWorkflowSnapshot;
-  hydrate(snapshotNode: PersistedWorkflowSnapshotNode, liveConfig: NodeConfigBase): NodeConfigBase;
-  private serializeConfig;
-  private injectTokenIds;
-  private mergeValue;
-  private mergeNestedValue;
-  private restoreNonSerializableProperties;
-  private restoreTypeProperty;
-  private resolveTokenId;
-  private resolveTokenName;
-  private asTypeToken;
-  private asRecord;
-}
-//#endregion
-//#region src/policies/executionLimits/EngineExecutionLimitsPolicyFactory.d.ts
-/**
- * Builds {@link EngineExecutionLimitsPolicy} by merging {@link ENGINE_EXECUTION_LIMITS_DEFAULTS} with optional `overrides` (e.g. host `runtime.engineExecutionLimits`).
- */
-declare class EngineExecutionLimitsPolicyFactory {
-  create(overrides?: Partial<EngineExecutionLimitsPolicyConfig>): EngineExecutionLimitsPolicy;
-}
-//#endregion
-//#region src/policies/storage/RunPolicySnapshotFactory.d.ts
-declare class RunPolicySnapshotFactory {
-  static create(workflow: WorkflowDefinition, defaults?: WorkflowPolicyRuntimeDefaults): PersistedRunPolicySnapshot;
-}
-//#endregion
 //#region src/policies/storage/WorkflowStoragePolicyEvaluator.d.ts
 declare class WorkflowStoragePolicyEvaluator {
   private readonly nodeResolver;
@@ -2061,6 +2525,37 @@ declare class WorkflowPolicyErrorServices {
   resolveWorkflowErrorHandler(spec: WorkflowErrorHandlerSpec | undefined): WorkflowErrorHandler | undefined;
 }
 //#endregion
+//#region src/policies/executionLimits/EngineExecutionLimitsPolicyFactory.d.ts
+/**
+ * Builds {@link EngineExecutionLimitsPolicy} by merging {@link ENGINE_EXECUTION_LIMITS_DEFAULTS} with optional `overrides` (e.g. host `runtime.engineExecutionLimits`).
+ */
+declare class EngineExecutionLimitsPolicyFactory {
+  create(overrides?: Partial<EngineExecutionLimitsPolicyConfig>): EngineExecutionLimitsPolicy;
+}
+//#endregion
+//#region src/policies/storage/RunPolicySnapshotFactory.d.ts
+declare class RunPolicySnapshotFactory {
+  static create(workflow: WorkflowDefinition, defaults?: WorkflowPolicyRuntimeDefaults): PersistedRunPolicySnapshot;
+}
+//#endregion
+//#region src/workflowSnapshots/WorkflowSnapshotCodec.d.ts
+declare class WorkflowSnapshotCodec {
+  private readonly tokenRegistry;
+  constructor(tokenRegistry: PersistedWorkflowTokenRegistryLike);
+  create(workflow: WorkflowDefinition): PersistedWorkflowSnapshot;
+  hydrate(snapshotNode: PersistedWorkflowSnapshotNode, liveConfig: NodeConfigBase): NodeConfigBase;
+  private serializeConfig;
+  private injectTokenIds;
+  private mergeValue;
+  private mergeNestedValue;
+  private restoreNonSerializableProperties;
+  private restoreTypeProperty;
+  private resolveTokenId;
+  private resolveTokenName;
+  private asTypeToken;
+  private asRecord;
+}
+//#endregion
 //#region src/runtime/EngineWorkflowRunnerService.d.ts
 declare class EngineWorkflowRunnerService {
   private readonly engine;
@@ -2143,5 +2638,5 @@ declare class RunIntentService {
   private createWebhookExecutionOptions;
 }
 //#endregion
-export { Expr as $, CredentialJsonRecord as $i, NodeExecutionContext as $n, RunCompletionNotifier as $r, RunIdFactory as $t, ExecutionInstanceDto as A, singleton as Aa, NoOpExecutionTelemetryFactory as Ai, RetryPolicySpec as An, WebhookTriggerRoutingDiagnostics as Ar, MutableRunData as At, RunSlotProjectionState as B, CostTrackingTelemetryMetricNames as Bi, ExecutableTriggerNode as Bn, NodeExecutionSnapshot as Br, NodeKind as Bt, BranchOutputGuard as C, inject as Ca, TelemetryScope as Ci, runnableNodeInputType as Cn, WorkflowSnapshotResolver as Cr, ItemBinary as Ct, RunFinishedAtFactory as D, instancePerContainerCachingFactory as Da, CodemationTelemetryMetricNames as Di, ExponentialRetryPolicySpec as Dn, WebhookInvocationMatch as Dr, JsonObject as Dt, ValidStepSequence as E, instanceCachingFactory as Ea, TelemetrySpanScope as Ei, triggerNodeSetupStateType as En, WebhookControlSignal as Er, JsonNonArray as Et, PersistedExecutionInstanceRecord as F, RunEvent as Fa, CostTrackingComponent as Fi, BinaryStorageStatResult as Fn, ConnectionInvocationRecord as Fr, NodeErrorHandler as Ft, WorkflowRunDetailDto as G, CredentialBinding as Gi, LiveWorkflowRepository as Gn, PersistedMutableRunState as Gr, OutputPortKey as Gt, WorkItemId as H, AnyCredentialType as Hi, ExecutionContext as Hn, NodeInputsByPort as Hr, NodeOutputs as Ht, PersistedRunSlotProjectionRecord as I, RunEventBus as Ia, CostTrackingPriceQuote as Ii, BinaryStorageWriteRequest as In, CurrentStateExecutionRequest as Ir, NodeErrorHandlerArgs as It, CostCatalog as J, CredentialHealth as Ji, NodeActivationReceipt as Jn, PersistedRunState as Jr, PersistedRunPolicySnapshot as Jt, NoOpCostTrackingTelemetryFactory as K, CredentialBindingKey as Ki, MultiInputNode as Kn, PersistedRunControlState as Kr, PairedItemRef as Kt, PersistedRunWorkItemKind as L, RunEventSubscription as La, CostTrackingTelemetry as Li, BinaryStorageWriteResult as Ln, EngineRunCounters as Lr, NodeErrorHandlerSpec as Lt, ExecutionPayloadPolicyFields as M, ENGINE_EXECUTION_LIMITS_DEFAULTS as Ma, NoOpNodeExecutionTelemetry as Mi, BinaryBody as Mn, WorkflowActivationPolicy as Mr, NodeConfigBase as Mt, PayloadStorageKind as N, EngineExecutionLimitsPolicy as Na, NoOpTelemetrySpanScope as Ni, BinaryStorage as Nn, ConnectionInvocationAppendArgs as Nr, NodeConnectionName as Nt, BatchId as O, predicateAwareClassFactory as Oa, GenAiTelemetryAttributeNames as Oi, FixedRetryPolicySpec as On, WebhookTriggerMatcher as Or, JsonPrimitive as Ot, PersistedExecutionInstanceKind as P, EngineExecutionLimitsPolicyConfig as Pa, NoOpTelemetryArtifactReference as Pi, BinaryStorageReadResult as Pn, ConnectionInvocationId as Pr, NodeDefinition as Pt, NoRetryPolicy as Q, CredentialInstanceRecord as Qi, NodeBinaryAttachmentService as Qn, PinnedNodeOutputsByPort as Qr, RunId as Qt, PersistedRunWorkItemRecord as R, CostTrackingTelemetryAttributeNames as Ri, EngineDeps as Rn, ExecutionFrontierPlan as Rr, NodeId as Rt, BranchMoreArgs as S, delay as Sa, TelemetryMetricRecord as Si, nodeRef as Sn, WorkflowSnapshotFactory as Sr, Item as St, StepSequenceOutput as T, injectable as Ta, TelemetrySpanEventRecord as Ti, triggerNodeOutputType as Tn, TriggerInstanceId as Tr, JsonArray as Tt, WorkItemStatus as U, CredentialAdvancedSectionPresentation as Ui, ExecutionContextFactory as Un, PendingNodeExecution as Ur, NodeRef as Ut, SlotExecutionStateDto as V, CostTrackingUsageRecord as Vi, ExecutionBinaryService as Vn, NodeExecutionStatus as Vr, NodeOffloadPolicy as Vt, WorkflowDetailSelectionState as W, CredentialAuthDefinition as Wi, ItemNode as Wn, PersistedMutableNodeState as Wr, NodeSchedulerDecision as Wt, ExpRetryPolicy as X, CredentialHealthTester as Xi, NodeActivationRequestBase as Xn, PersistedWorkflowSnapshotNode as Xr, RunDataFactory as Xt, CostCatalogEntry as Y, CredentialHealthStatus as Yi, NodeActivationRequest as Yn, PersistedWorkflowSnapshot as Yr, PersistedTokenId as Yt, RetryPolicy as Z, CredentialInstanceId as Zi, NodeActivationScheduler as Zn, PersistedWorkflowTokenRegistryLike as Zr, RunDataSnapshot as Zt, ChainCursor as _, InjectionToken$1 as _a, TelemetryArtifactAttachment as _i, WorkflowStoragePolicyDecisionArgs as _n, TriggerTestItemsContext as _r, BinaryAttachment as _t, RunTerminalPersistenceCoordinator as a, CredentialSessionFactoryArgs as aa, RunResult as ai, TriggerNodeSetupState as an, NodeResolver as ar, ItemExprContext as at, AnyTriggerNodeConfig as b, TypeToken as ba, TelemetryAttributes as bi, WorkflowStoragePolicySpec as bn, WorkflowRunnerResolver as br, ExecutionMode as bt, EngineExecutionLimitsPolicyFactory as c, CredentialType as ca, RunStopCondition as ci, WorkflowErrorContext as cn, RunnableNode as cr, itemExpr as ct, DefaultWorkflowGraphFactory as d, CredentialTypeRegistry as da, WorkflowExecutionListingRepository as di, WorkflowGraph as dn, TriggerCleanupHandle as dr, getOriginIndexFromItem as dt, CredentialMaterialSourceKind as ea, RunCurrentState as ei, RunnableNodeConfig as en, NodeExecutionRequest as er, Param as et, WorkflowExecutableNodeClassifierFactory as f, CredentialUnboundError as fa, WorkflowExecutionPruneRepository as fi, WorkflowGraphFactory as fn, TriggerNode as fr, PortsEmission as ft, WorkflowBuilder as g, Disposable as ga, NodeExecutionTelemetry as gi, WorkflowPrunePolicySpec as gn, TriggerSetupStateRepository as gr, ActivationIdFactory as gt, ConnectionInvocationIdFactory as h, DependencyContainer$1 as ha, ExecutionTelemetryFactory as hi, WorkflowPolicyRuntimeDefaults as hn, TriggerSetupStateFor as hr, isUnbrandedPortsEmissionShape as ht, WorkflowPolicyErrorServices as i, CredentialSessionFactory as ia, RunQueueEntry as ii, TriggerNodeOutputJson as in, NodeExecutor as ir, ItemExprCallback as it, ExecutionInstanceId as j, CoreTokens as ja, NoOpExecutionTelemetry as ji, BinaryAttachmentCreateRequest as jn, AllWorkflowsActiveWorkflowActivationPolicy as jr, NodeActivationId as jt, ConnectionInvocationKind as k, registry as ka, CodemationTelemetryAttributeNames as ki, NoneRetryPolicySpec as kn, WebhookTriggerResolution as kr, JsonValue as kt, WorkflowSnapshotCodec as l, CredentialTypeDefinition as la, RunSummary as li, WorkflowErrorHandler as ln, RunnableNodeExecuteArgs as lr, resolveItemExprsForExecution as lt, ConnectionNodeIdFactory as m, Container as ma, ExecutionTelemetry as mi, WorkflowNodeConnection as mn, TriggerSetupContext as mr, isPortsEmission as mt, InMemoryLiveWorkflowRepository as n, CredentialOAuth2ScopesFromPublicConfig as na, RunExecutionOptions as ni, RunnableNodeOutputJson as nn, NodeExecutionScheduler as nr, ItemExpr as nt, WorkflowStoragePolicyEvaluator as o, CredentialSessionService as oa, RunStateResetRequest as oi, UpstreamRefPlaceholder as on, PersistedTriggerSetupState as or, ItemExprResolvedContext as ot, WorkflowExecutableNodeClassifier as p, OAuth2ProviderFromPublicConfig as pa, WorkflowExecutionRepository as pi, WorkflowId as pn, TriggerRuntimeDiagnostics as pr, emitPorts as pt, NoOpCostTrackingTelemetry as q, CredentialFieldSchema as qi, NodeActivationContinuation as qn, PersistedRunSchedulingState as qr, ParentExecutionRef as qt, EngineWorkflowRunnerService as r, CredentialRequirement as ra, RunPruneCandidate as ri, TriggerNodeConfig as rn, NodeExecutionStatePublisher as rr, ItemExprArgs as rt, RunPolicySnapshotFactory as s, CredentialSetupStatus as sa, RunStatus as si, WorkflowDefinition as sn, PreparedNodeActivationDispatch as sr, isItemExpr as st, RunIntentService as t, CredentialOAuth2AuthDefinition as ta, RunEventPublisherDeps as ti, RunnableNodeInputJson as tn, NodeExecutionRequestHandler as tr, ParamDeep as tt, Engine as u, CredentialTypeId as ua, WebhookRunResult as ui, WorkflowErrorHandlerSpec as un, TestableTriggerNode as ur, resolveItemExprsInUnknown as ut, WhenBuilder as v, Lifecycle as va, TelemetryArtifactReference as vi, WorkflowStoragePolicyMode as vn, WorkflowNodeInstanceFactory as vr, BinaryPreviewKind as vt, BranchStepsArg as w, injectAll as wa, TelemetrySpanEnd as wi, runnableNodeOutputType as wn, HttpMethod as wr, Items as wt, BooleanWhenOverloads as x, container$1 as xa, TelemetryChildSpanStart as xi, branchRef as xn, WorkflowRunnerService as xr, InputPortKey as xt, AnyRunnableNodeConfig as y, RegistrationOptions as ya, TelemetryAttributePrimitive as yi, WorkflowStoragePolicyResolver as yn, WorkflowRepository as yr, Edge as yt, RunRevision as z, CostTrackingTelemetryFactory as zi, EngineHost as zn, NodeExecutionError as zr, NodeIdRef as zt };
-//# sourceMappingURL=RunIntentService-BqhmdoA1.d.ts.map
+export { RunRevision as $, InputPortKey as $a, PersistedMutableNodeState as $i, NodeActivationRequestBase as $n, NoOpExecutionTelemetryFactory as $r, PersistedRunPolicySnapshot as $t, RunFinishedAtFactory as A, TypeToken as Aa, CredentialSessionFactoryArgs as Ai, ExponentialRetryPolicySpec as An, WebhookControlSignal as Ar, ItemBinary as At, isUnbrandedPortsEmissionShape as B, singleton as Ba, PollingTriggerLogger as Bi, BinaryStorageWriteResult as Bn, TelemetryArtifactAttachment as Br, NodeDefinition as Bt, AnyTriggerNodeConfig as C, WorkflowExecutionRepository as Ca, CredentialInstanceRecord as Ci, WorkflowStoragePolicySpec as Cn, WorkflowRepository as Cr, deriveAssertionPassed as Ct, BranchStepsArg as D, InjectionToken$1 as Da, CredentialOAuth2ScopesFromPublicConfig as Di, runnableNodeOutputType as Dn, WorkflowSnapshotResolver as Dr, Edge as Dt, BranchOutputGuard as E, Disposable as Ea, CredentialOAuth2AuthDefinition as Ei, runnableNodeInputType as En, WorkflowSnapshotFactory as Er, BinaryPreviewKind as Et, NoRetryPolicy as F, injectable as Fa, CredentialTypeId as Fi, BinaryBody as Fn, AllWorkflowsActiveWorkflowActivationPolicy as Fr, JsonPrimitive as Ft, ExecutionPayloadPolicyFields as G, RunEvent as Ga, CurrentStateExecutionRequest as Gi, ExecutionContext as Gn, TelemetryMetricRecord as Gr, NodeIterationId as Gt, ConnectionInvocationKind as H, ENGINE_EXECUTION_LIMITS_DEFAULTS as Ha, ConnectionInvocationAppendArgs as Hi, EngineHost as Hn, TelemetryAttributePrimitive as Hr, NodeErrorHandlerArgs as Ht, getOriginIndexFromItem as I, instanceCachingFactory as Ia, CredentialTypeRegistry as Ii, BinaryStorage as In, WorkflowActivationPolicy as Ir, JsonValue as It, PersistedExecutionInstanceRecord as J, TestCaseRunStatus as Ja, NodeExecutionError as Ji, LiveWorkflowRepository as Jn, TelemetrySpanEventRecord as Jr, NodeOutputs as Jt, PayloadStorageKind as K, RunEventBus as Ka, EngineRunCounters as Ki, ExecutionContextFactory as Kn, TelemetryScope as Kr, NodeKind as Kt, PortsEmission as L, instancePerContainerCachingFactory as La, CredentialUnboundError as Li, BinaryStorageReadResult as Ln, ExecutionTelemetry as Lr, MutableRunData as Lt, NoOpCostTrackingTelemetry as M, delay as Ma, CredentialSetupStatus as Mi, NoneRetryPolicySpec as Mn, WebhookTriggerMatcher as Mr, JsonArray as Mt, ExpRetryPolicy as N, inject as Na, CredentialType as Ni, RetryPolicySpec as Nn, WebhookTriggerResolution as Nr, JsonNonArray as Nt, StepSequenceOutput as O, Lifecycle as Oa, CredentialRequirement as Oi, triggerNodeOutputType as On, HttpMethod as Or, ExecutionMode as Ot, RetryPolicy as P, injectAll as Pa, CredentialTypeDefinition as Pi, BinaryAttachmentCreateRequest as Pn, WebhookTriggerRoutingDiagnostics as Pr, JsonObject as Pt, RunIterationDto as Q, TestTriggerSetupContext as Qa, PendingNodeExecution as Qi, NodeActivationRequest as Qn, CodemationTelemetryAttributeNames as Qr, ParentExecutionRef as Qt, emitPorts as R, predicateAwareClassFactory as Ra, OAuth2ProviderFromPublicConfig as Ri, BinaryStorageStatResult as Rn, ExecutionTelemetryFactory as Rr, NodeActivationId as Rt, AnyRunnableNodeConfig as S, WorkflowExecutionPruneRepository as Sa, CredentialInstanceId as Si, WorkflowStoragePolicyResolver as Sn, WorkflowNodeInstanceFactory as Sr, DEFAULT_ASSERTION_PASS_THRESHOLD as St, BranchMoreArgs as T, DependencyContainer$1 as Ta, CredentialMaterialSourceKind as Ti, nodeRef as Tn, WorkflowRunnerService as Tr, BinaryAttachment as Tt, ExecutionInstanceDto as U, EngineExecutionLimitsPolicy as Ua, ConnectionInvocationId as Ui, ExecutableTriggerNode as Un, TelemetryAttributes as Ur, NodeErrorHandlerSpec as Ut, BatchId as V, CoreTokens as Va, PollingTriggerDedupWindow as Vi, EngineDeps as Vn, TelemetryArtifactReference as Vr, NodeErrorHandler as Vt, ExecutionInstanceId as W, EngineExecutionLimitsPolicyConfig as Wa, ConnectionInvocationRecord as Wi, ExecutionBinaryService as Wn, TelemetryChildSpanStart as Wr, NodeIdRef as Wt, PersistedRunWorkItemKind as X, TestSuiteRunId as Xa, NodeExecutionStatus as Xi, NodeActivationContinuation as Xn, CodemationTelemetryMetricNames as Xr, NodeSchedulerDecision as Xt, PersistedRunSlotProjectionRecord as Y, TestSuiteRunStatus as Ya, NodeExecutionSnapshot as Yi, MultiInputNode as Yn, TelemetrySpanScope as Yr, NodeRef as Yt, PersistedRunWorkItemRecord as Z, TestTriggerNodeConfig as Za, NodeInputsByPort as Zi, NodeActivationReceipt as Zn, GenAiTelemetryAttributeNames as Zr, PairedItemRef as Zt, NodeIdSlugifier as _, RunStopCondition as _a, CredentialBindingKey as _i, WorkflowNodeConnection as _n, TriggerRuntimeDiagnostics as _r, itemExpr as _t, RunPolicySnapshotFactory as a, PersistedWorkflowSnapshotNode as aa, CostTrackingPriceQuote as ai, RunnableNodeInputJson as an, NodeExecutionScheduler as ar, WorkflowRunDetailDto as at, ChainCursor as b, WebhookRunResult as ba, CredentialHealthStatus as bi, WorkflowStoragePolicyDecisionArgs as bn, TriggerSetupStateRepository as br, AssertionResult as bt, RunTerminalPersistenceCoordinator as c, RunCompletionNotifier as ca, CostTrackingTelemetryFactory as ci, TriggerNodeOutputJson as cn, NodeResolver as cr, Expr as ct, DefaultWorkflowGraphFactory as d, RunExecutionOptions as da, CollectionStore as di, WorkflowDefinition as dn, PreparedNodeActivationDispatch as dr, ItemExpr as dt, PersistedMutableRunState as ea, NoOpExecutionTelemetry as ei, RunDataFactory as en, NodeConnectionName as eo, NodeActivationScheduler as er, RunSlotProjectionState as et, WorkflowExecutableNodeClassifierFactory as f, RunPruneCandidate as fa, CollectionsContext as fi, WorkflowErrorContext as fn, RunnableNode as fr, ItemExprArgs as ft, ConnectionInvocationIdFactory as g, RunStatus as ga, CredentialBinding as gi, WorkflowGraphFactory as gn, TriggerNode as gr, isItemExpr as gt, ConnectionNodeIdFactory as h, RunStateResetRequest as ha, CredentialAuthDefinition as hi, WorkflowGraph as hn, TriggerCleanupHandle as hr, ItemExprResolvedContext as ht, WorkflowSnapshotCodec as i, PersistedWorkflowSnapshot as ia, CostTrackingComponent as ii, RunnableNodeConfig as in, WorkflowId as io, NodeExecutionRequestHandler as ir, WorkflowDetailSelectionState as it, NoOpCostTrackingTelemetryFactory as j, container$1 as ja, CredentialSessionService as ji, FixedRetryPolicySpec as jn, WebhookInvocationMatch as jr, Items as jt, ValidStepSequence as k, RegistrationOptions as ka, CredentialSessionFactory as ki, triggerNodeSetupStateType as kn, TriggerInstanceId as kr, Item as kt, WorkflowStoragePolicyEvaluator as l, RunCurrentState as la, CostTrackingTelemetryMetricNames as li, TriggerNodeSetupState as ln, PersistedTriggerSetupState as lr, Param as lt, NodeIterationIdFactory as m, RunResult as ma, CredentialAdvancedSectionPresentation as mi, WorkflowErrorHandlerSpec as mn, TestableTriggerNode as mr, ItemExprContext as mt, InMemoryLiveWorkflowRepository as n, PersistedRunSchedulingState as na, NoOpTelemetrySpanScope as ni, RunId as nn, OutputPortKey as no, NodeExecutionContext as nr, WorkItemId as nt, EngineExecutionLimitsPolicyFactory as o, PersistedWorkflowTokenRegistryLike as oa, CostTrackingTelemetry as oi, RunnableNodeOutputJson as on, NodeExecutionStatePublisher as or, CostCatalog as ot, WorkflowExecutableNodeClassifier as p, RunQueueEntry as pa, AnyCredentialType as pi, WorkflowErrorHandler as pn, RunnableNodeExecuteArgs as pr, ItemExprCallback as pt, PersistedExecutionInstanceKind as q, RunEventSubscription as qa, ExecutionFrontierPlan as qi, ItemNode as qn, TelemetrySpanEnd as qr, NodeOffloadPolicy as qt, EngineWorkflowRunnerService as r, PersistedRunState as ra, NoOpTelemetryArtifactReference as ri, RunIdFactory as rn, PersistedTokenId as ro, NodeExecutionRequest as rr, WorkItemStatus as rt, WorkflowPolicyErrorServices as s, PinnedNodeOutputsByPort as sa, CostTrackingTelemetryAttributeNames as si, TriggerNodeConfig as sn, NodeExecutor as sr, CostCatalogEntry as st, RunIntentService as t, PersistedRunControlState as ta, NoOpNodeExecutionTelemetry as ti, RunDataSnapshot as tn, NodeId as to, NodeBinaryAttachmentService as tr, SlotExecutionStateDto as tt, Engine as u, RunEventPublisherDeps as ua, CostTrackingUsageRecord as ui, UpstreamRefPlaceholder as un, PollingTriggerHandle as ur, ParamDeep as ut, WorkflowDefinitionError as v, RunSummary as va, CredentialFieldSchema as vi, WorkflowPolicyRuntimeDefaults as vn, TriggerSetupContext as vr, resolveItemExprsForExecution as vt, BooleanWhenOverloads as w, Container as wa, CredentialJsonRecord as wi, branchRef as wn, WorkflowRunnerResolver as wr, ActivationIdFactory as wt, WhenBuilder as x, WorkflowExecutionListingRepository as xa, CredentialHealthTester as xi, WorkflowStoragePolicyMode as xn, TriggerTestItemsContext as xr, AssertionResultProvenance as xt, WorkflowBuilder as y, RunTestContext as ya, CredentialHealth as yi, WorkflowPrunePolicySpec as yn, TriggerSetupStateFor as yr, resolveItemExprsInUnknown as yt, isPortsEmission as z, registry as za, NoOpPollingTriggerLogger as zi, BinaryStorageWriteRequest as zn, NodeExecutionTelemetry as zr, NodeConfigBase as zt };
+//# sourceMappingURL=RunIntentService-BE9CAkbf.d.ts.map