@codemation/core 1.0.1 → 2.0.0

package/dist/{RunIntentService-Dyh_dH0k.d.cts → RunIntentService-siBSjaaY.d.cts}

@@ -1,8 +1,263 @@
-import { ReadableStream } from "node:stream/web";
 import { DependencyContainer as Container, DependencyContainer as DependencyContainer$1, Disposable, InjectionToken as InjectionToken$1, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+import { ReadableStream } from "node:stream/web";
 import { ZodType } from "zod";
 
+//#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;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+}> | Readonly<{
+  kind: "runSaved";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  state: PersistedRunState;
+}> | Readonly<{
+  kind: "nodeQueued";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeStarted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeCompleted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeFailed";
+  runId: RunId;
+  workflowId: WorkflowId;
+  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>;
+}
+interface RunEventBus {
+  publish(event: RunEvent): Promise<void>;
+  subscribe(onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+  subscribeToWorkflow(workflowId: WorkflowId, onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+}
+//#endregion
+//#region src/policies/executionLimits/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#endregion
+//#region src/di/CoreTokens.d.ts
+declare const CoreTokens: {
+  readonly PersistedWorkflowTokenRegistry: TypeToken<PersistedWorkflowTokenRegistryLike>;
+  readonly CredentialSessionService: TypeToken<CredentialSessionService>;
+  readonly CredentialTypeRegistry: TypeToken<CredentialTypeRegistry>;
+  readonly WorkflowRunnerService: TypeToken<WorkflowRunnerService>;
+  readonly LiveWorkflowRepository: TypeToken<LiveWorkflowRepository>;
+  readonly WorkflowRepository: TypeToken<WorkflowRepository>;
+  readonly NodeResolver: TypeToken<NodeResolver>;
+  readonly WorkflowNodeInstanceFactory: TypeToken<WorkflowNodeInstanceFactory>;
+  readonly RunIdFactory: TypeToken<RunIdFactory>;
+  readonly ActivationIdFactory: TypeToken<ActivationIdFactory>;
+  readonly WorkflowExecutionRepository: TypeToken<WorkflowExecutionRepository>;
+  readonly TriggerSetupStateRepository: TypeToken<TriggerSetupStateRepository>;
+  readonly NodeActivationScheduler: TypeToken<NodeActivationScheduler>;
+  readonly RunDataFactory: TypeToken<RunDataFactory>;
+  readonly ExecutionContextFactory: TypeToken<ExecutionContextFactory>;
+  readonly RunEventBus: TypeToken<RunEventBus>;
+  readonly BinaryStorage: TypeToken<BinaryStorage>;
+  readonly WebhookBasePath: TypeToken<string>;
+  /** Engine execution limits (defaults + optional host overrides). Consumers may bind a custom instance to override. */
+  readonly EngineExecutionLimitsPolicy: TypeToken<EngineExecutionLimitsPolicy>;
+  readonly WorkflowActivationPolicy: TypeToken<WorkflowActivationPolicy>;
+};
+//#endregion
 //#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;
+  /**
+   * 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".
+   */
+  readonly testCaseLabel?: string;
+}
 interface RunExecutionOptions {
   /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
   localOnly?: boolean;
@@ -19,6 +274,8 @@ interface RunExecutionOptions {
   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 {
@@ -182,6 +439,13 @@ interface RunSummary {
   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;
@@ -308,127 +572,34 @@ interface RunEventPublisherDeps {
   eventBus?: RunEventBus;
 }
 //#endregion
-//#region src/events/runEvents.d.ts
-type RunEvent = Readonly<{
-  kind: "runCreated";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-}> | Readonly<{
-  kind: "runSaved";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  state: PersistedRunState;
-}> | Readonly<{
-  kind: "nodeQueued";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  snapshot: NodeExecutionSnapshot;
-}> | Readonly<{
-  kind: "nodeStarted";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  snapshot: NodeExecutionSnapshot;
-}> | Readonly<{
-  kind: "nodeCompleted";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  snapshot: NodeExecutionSnapshot;
-}> | Readonly<{
-  kind: "nodeFailed";
-  runId: RunId;
-  workflowId: WorkflowId;
-  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;
-}>;
-interface RunEventSubscription {
-  close(): Promise<void>;
-}
-interface RunEventBus {
-  publish(event: RunEvent): Promise<void>;
-  subscribe(onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
-  subscribeToWorkflow(workflowId: WorkflowId, onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
+//#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/policies/executionLimits/EngineExecutionLimitsPolicy.d.ts
-interface EngineExecutionLimitsPolicyConfig {
-  readonly defaultMaxNodeActivations: number;
-  readonly hardMaxNodeActivations: number;
-  readonly defaultMaxSubworkflowDepth: number;
-  readonly hardMaxSubworkflowDepth: number;
-}
-/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
-declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+//#region src/triggers/polling/PollingTriggerLogger.d.ts
 /**
- * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ * Minimal logger surface for the polling-trigger runtime.
+ * Hosts supply this via {@link EngineDeps.pollingTriggerLogger};
+ * when absent the runtime is silent.
  */
-declare class EngineExecutionLimitsPolicy {
-  private readonly config;
-  constructor(config?: EngineExecutionLimitsPolicyConfig);
-  /**
-   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
-   * Replaces a separate one-method factory for root-run bootstrap.
-   */
-  createRootExecutionOptions(): RunExecutionOptions;
-  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
-  private capNumber;
+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/di/CoreTokens.d.ts
-declare const CoreTokens: {
-  readonly PersistedWorkflowTokenRegistry: TypeToken<PersistedWorkflowTokenRegistryLike>;
-  readonly CredentialSessionService: TypeToken<CredentialSessionService>;
-  readonly CredentialTypeRegistry: TypeToken<CredentialTypeRegistry>;
-  readonly WorkflowRunnerService: TypeToken<WorkflowRunnerService>;
-  readonly LiveWorkflowRepository: TypeToken<LiveWorkflowRepository>;
-  readonly WorkflowRepository: TypeToken<WorkflowRepository>;
-  readonly NodeResolver: TypeToken<NodeResolver>;
-  readonly WorkflowNodeInstanceFactory: TypeToken<WorkflowNodeInstanceFactory>;
-  readonly RunIdFactory: TypeToken<RunIdFactory>;
-  readonly ActivationIdFactory: TypeToken<ActivationIdFactory>;
-  readonly WorkflowExecutionRepository: TypeToken<WorkflowExecutionRepository>;
-  readonly TriggerSetupStateRepository: TypeToken<TriggerSetupStateRepository>;
-  readonly NodeActivationScheduler: TypeToken<NodeActivationScheduler>;
-  readonly RunDataFactory: TypeToken<RunDataFactory>;
-  readonly ExecutionContextFactory: TypeToken<ExecutionContextFactory>;
-  readonly RunEventBus: TypeToken<RunEventBus>;
-  readonly BinaryStorage: TypeToken<BinaryStorage>;
-  readonly WebhookBasePath: TypeToken<string>;
-  /** Engine execution limits (defaults + optional host overrides). Consumers may bind a custom instance to override. */
-  readonly EngineExecutionLimitsPolicy: TypeToken<EngineExecutionLimitsPolicy>;
-  readonly WorkflowActivationPolicy: TypeToken<WorkflowActivationPolicy>;
-};
 //#endregion
 //#region src/contracts/credentialTypes.d.ts
 type CredentialTypeId = string;
@@ -510,6 +681,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<{
@@ -600,6 +792,71 @@ declare class CredentialUnboundError extends Error {
   private static createMessage;
 }
 //#endregion
+//#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: {
@@ -979,6 +1236,15 @@ interface ExecutionContext {
   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: {
@@ -993,6 +1259,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 {
@@ -1002,12 +1269,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;
@@ -1202,6 +1491,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
@@ -1233,14 +1524,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 {
@@ -1260,7 +1546,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
@@ -1326,6 +1611,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;
@@ -1355,6 +1648,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;
@@ -1421,6 +1720,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;
@@ -1719,5 +2024,5 @@ declare class RunIntentService {
   private createWebhookExecutionOptions;
 }
 //#endregion
-export { WorkflowErrorHandlerSpec as $, CredentialBinding as $n, NodeExecutionSnapshot as $r, TestableTriggerNode as $t, NodeOffloadPolicy as A, TelemetryMetricRecord as An, delay as Ar, ExecutionBinaryService as At, RunDataSnapshot as B, NoOpNodeExecutionTelemetry as Bn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Br, NodeActivationScheduler as Bt, NodeErrorHandler as C, WebhookRunResult as Ci, ExecutionTelemetryFactory as Cn, DependencyContainer$1 as Cr, BinaryStorageReadResult as Ct, NodeIdRef as D, TelemetryAttributePrimitive as Dn, RegistrationOptions as Dr, EngineDeps as Dt, NodeId as E, WorkflowExecutionRepository as Ei, TelemetryArtifactReference as En, Lifecycle as Er, BinaryStorageWriteResult as Et, PairedItemRef as F, CodemationTelemetryMetricNames as Fn, instancePerContainerCachingFactory as Fr, MultiInputNode as Ft, RunnableNodeOutputJson as G, CostTrackingTelemetry as Gn, RunEventSubscription as Gr, NodeExecutionScheduler as Gt, RunIdFactory as H, NoOpTelemetryArtifactReference as Hn, EngineExecutionLimitsPolicyConfig as Hr, NodeExecutionContext as Ht, ParentExecutionRef as I, GenAiTelemetryAttributeNames as In, predicateAwareClassFactory as Ir, NodeActivationContinuation as It, TriggerNodeSetupState as J, CostTrackingTelemetryMetricNames as Jn, ConnectionInvocationRecord as Jr, NodeResolver as Jt, TriggerNodeConfig as K, CostTrackingTelemetryAttributeNames as Kn, ConnectionInvocationAppendArgs as Kr, NodeExecutionStatePublisher as Kt, PersistedRunPolicySnapshot as L, CodemationTelemetryAttributeNames as Ln, registry as Lr, NodeActivationReceipt as Lt, NodeRef as M, TelemetrySpanEnd as Mn, injectAll as Mr, ExecutionContextFactory as Mt, NodeSchedulerDecision as N, TelemetrySpanEventRecord as Nn, injectable as Nr, ItemNode as Nt, NodeIterationId as O, TelemetryAttributes as On, TypeToken as Or, EngineHost as Ot, OutputPortKey as P, TelemetrySpanScope as Pn, instanceCachingFactory as Pr, LiveWorkflowRepository as Pt, WorkflowErrorHandler as Q, CredentialAuthDefinition as Qn, NodeExecutionError as Qr, RunnableNodeExecuteArgs as Qt, PersistedTokenId as R, NoOpExecutionTelemetryFactory as Rn, singleton as Rr, NodeActivationRequest as Rt, NodeDefinition as S, RunSummary as Si, ExecutionTelemetry as Sn, Container as Sr, BinaryStorage as St, NodeErrorHandlerSpec as T, WorkflowExecutionPruneRepository as Ti, TelemetryArtifactAttachment as Tn, InjectionToken$1 as Tr, BinaryStorageWriteRequest as Tt, RunnableNodeConfig as U, CostTrackingComponent as Un, RunEvent as Ur, NodeExecutionRequest as Ut, RunId as V, NoOpTelemetrySpanScope as Vn, EngineExecutionLimitsPolicy as Vr, NodeBinaryAttachmentService as Vt, RunnableNodeInputJson as W, CostTrackingPriceQuote as Wn, RunEventBus as Wr, NodeExecutionRequestHandler as Wt, WorkflowDefinition as X, AnyCredentialType as Xn, EngineRunCounters as Xr, PreparedNodeActivationDispatch as Xt, UpstreamRefPlaceholder as Y, CostTrackingUsageRecord as Yn, CurrentStateExecutionRequest as Yr, PersistedTriggerSetupState as Yt, WorkflowErrorContext as Z, CredentialAdvancedSectionPresentation as Zn, ExecutionFrontierPlan as Zr, RunnableNode as Zt, JsonValue as _, RunQueueEntry as _i, WebhookTriggerMatcher as _n, CredentialTypeDefinition as _r, FixedRetryPolicySpec as _t, BinaryAttachment as a, PersistedRunControlState as ai, TriggerSetupStateRepository as an, CredentialInstanceId as ar, WorkflowPrunePolicySpec as at, NodeConfigBase as b, RunStatus as bi, AllWorkflowsActiveWorkflowActivationPolicy as bn, CredentialUnboundError as br, BinaryAttachmentCreateRequest as bt, ExecutionMode as c, PersistedWorkflowSnapshot as ci, WorkflowRepository as cn, CredentialMaterialSourceKind as cr, WorkflowStoragePolicyResolver as ct, ItemBinary as d, PinnedNodeOutputsByPort as di, WorkflowSnapshotFactory as dn, CredentialRequirement as dr, nodeRef as dt, NodeExecutionStatus as ei, TriggerCleanupHandle as en, CredentialBindingKey as er, WorkflowGraph as et, Items as f, RunCompletionNotifier as fi, WorkflowSnapshotResolver as fn, CredentialSessionFactory as fr, runnableNodeInputType as ft, JsonPrimitive as g, RunPruneCandidate as gi, WebhookInvocationMatch as gn, CredentialType as gr, ExponentialRetryPolicySpec as gt, JsonObject as h, RunExecutionOptions as hi, WebhookControlSignal as hn, CredentialSetupStatus as hr, triggerNodeSetupStateType as ht, ActivationIdFactory as i, PersistedMutableRunState as ii, TriggerSetupStateFor as in, CredentialHealthTester as ir, WorkflowPolicyRuntimeDefaults as it, NodeOutputs as j, TelemetryScope as jn, inject as jr, ExecutionContext as jt, NodeKind as k, TelemetryChildSpanStart as kn, container as kr, ExecutableTriggerNode as kt, InputPortKey as l, PersistedWorkflowSnapshotNode as li, WorkflowRunnerResolver as ln, CredentialOAuth2AuthDefinition as lr, WorkflowStoragePolicySpec as lt, JsonNonArray as m, RunEventPublisherDeps as mi, TriggerInstanceId as mn, CredentialSessionService as mr, triggerNodeOutputType as mt, InMemoryLiveWorkflowRepository as n, PendingNodeExecution as ni, TriggerRuntimeDiagnostics as nn, CredentialHealth as nr, WorkflowId as nt, BinaryPreviewKind as o, PersistedRunSchedulingState as oi, TriggerTestItemsContext as on, CredentialInstanceRecord as or, WorkflowStoragePolicyDecisionArgs as ot, JsonArray as p, RunCurrentState as pi, HttpMethod as pn, CredentialSessionFactoryArgs as pr, runnableNodeOutputType as pt, TriggerNodeOutputJson as q, CostTrackingTelemetryFactory as qn, ConnectionInvocationId as qr, NodeExecutor as qt, Engine as r, PersistedMutableNodeState as ri, TriggerSetupContext as rn, CredentialHealthStatus as rr, WorkflowNodeConnection as rt, Edge as s, PersistedRunState as si, WorkflowNodeInstanceFactory as sn, CredentialJsonRecord as sr, WorkflowStoragePolicyMode as st, RunIntentService as t, NodeInputsByPort as ti, TriggerNode as tn, CredentialFieldSchema as tr, WorkflowGraphFactory as tt, Item as u, PersistedWorkflowTokenRegistryLike as ui, WorkflowRunnerService as un, CredentialOAuth2ScopesFromPublicConfig as ur, branchRef as ut, MutableRunData as v, RunResult as vi, WebhookTriggerResolution as vn, CredentialTypeId as vr, NoneRetryPolicySpec as vt, NodeErrorHandlerArgs as w, WorkflowExecutionListingRepository as wi, NodeExecutionTelemetry as wn, Disposable as wr, BinaryStorageStatResult as wt, NodeConnectionName as x, RunStopCondition as xi, WorkflowActivationPolicy as xn, OAuth2ProviderFromPublicConfig as xr, BinaryBody as xt, NodeActivationId as y, RunStateResetRequest as yi, WebhookTriggerRoutingDiagnostics as yn, CredentialTypeRegistry as yr, RetryPolicySpec as yt, RunDataFactory as z, NoOpExecutionTelemetry as zn, CoreTokens as zr, NodeActivationRequestBase as zt };
-//# sourceMappingURL=RunIntentService-Dyh_dH0k.d.cts.map
+export { WorkflowPrunePolicySpec as $, CredentialHealth as $n, RunTestContext as $r, TriggerSetupStateFor as $t, NodeSchedulerDecision as A, TestSuiteRunId as Ai, CodemationTelemetryMetricNames as An, NodeExecutionStatus as Ar, NodeActivationContinuation as At, RunnableNodeOutputJson as B, CostTrackingTelemetry as Bn, PersistedWorkflowTokenRegistryLike as Br, NodeExecutionStatePublisher as Bt, NodeErrorHandlerSpec as C, EngineExecutionLimitsPolicy as Ci, TelemetryAttributes as Cn, ConnectionInvocationId as Cr, ExecutableTriggerNode as Ct, NodeOffloadPolicy as D, RunEventSubscription as Di, TelemetrySpanEnd as Dn, ExecutionFrontierPlan as Dr, ItemNode as Dt, NodeKind as E, RunEventBus as Ei, TelemetryScope as En, EngineRunCounters as Er, ExecutionContextFactory as Et, RunDataSnapshot as F, NodeId as Fi, NoOpNodeExecutionTelemetry as Fn, PersistedRunControlState as Fr, NodeBinaryAttachmentService as Ft, WorkflowDefinition as G, CollectionStore as Gn, RunExecutionOptions as Gr, PreparedNodeActivationDispatch as Gt, TriggerNodeOutputJson as H, CostTrackingTelemetryFactory as Hn, RunCompletionNotifier as Hr, NodeResolver as Ht, RunId as I, OutputPortKey as Ii, NoOpTelemetrySpanScope as In, PersistedRunSchedulingState as Ir, NodeExecutionContext as It, WorkflowErrorHandlerSpec as J, CredentialAdvancedSectionPresentation as Jn, RunResult as Jr, TestableTriggerNode as Jt, WorkflowErrorContext as K, CollectionsContext as Kn, RunPruneCandidate as Kr, RunnableNode as Kt, RunIdFactory as L, PersistedTokenId as Li, NoOpTelemetryArtifactReference as Ln, PersistedRunState as Lr, NodeExecutionRequest as Lt, ParentExecutionRef as M, TestTriggerSetupContext as Mi, CodemationTelemetryAttributeNames as Mn, PendingNodeExecution as Mr, NodeActivationRequest as Mt, PersistedRunPolicySnapshot as N, InputPortKey as Ni, NoOpExecutionTelemetryFactory as Nn, PersistedMutableNodeState as Nr, NodeActivationRequestBase as Nt, NodeOutputs as O, TestCaseRunStatus as Oi, TelemetrySpanEventRecord as On, NodeExecutionError as Or, LiveWorkflowRepository as Ot, RunDataFactory as P, NodeConnectionName as Pi, NoOpExecutionTelemetry as Pn, PersistedMutableRunState as Pr, NodeActivationScheduler as Pt, WorkflowPolicyRuntimeDefaults as Q, CredentialFieldSchema as Qn, RunSummary as Qr, TriggerSetupContext as Qt, RunnableNodeConfig as R, WorkflowId as Ri, CostTrackingComponent as Rn, PersistedWorkflowSnapshot as Rr, NodeExecutionRequestHandler as Rt, NodeErrorHandlerArgs as S, ENGINE_EXECUTION_LIMITS_DEFAULTS as Si, TelemetryAttributePrimitive as Sn, ConnectionInvocationAppendArgs as Sr, EngineHost as St, NodeIterationId as T, RunEvent as Ti, TelemetryMetricRecord as Tn, CurrentStateExecutionRequest as Tr, ExecutionContext as Tt, TriggerNodeSetupState as U, CostTrackingTelemetryMetricNames as Un, RunCurrentState as Ur, PersistedTriggerSetupState as Ut, TriggerNodeConfig as V, CostTrackingTelemetryAttributeNames as Vn, PinnedNodeOutputsByPort as Vr, NodeExecutor as Vt, UpstreamRefPlaceholder as W, CostTrackingUsageRecord as Wn, RunEventPublisherDeps as Wr, PollingTriggerHandle as Wt, WorkflowGraphFactory as X, CredentialBinding as Xn, RunStatus as Xr, TriggerNode as Xt, WorkflowGraph as Y, CredentialAuthDefinition as Yn, RunStateResetRequest as Yr, TriggerCleanupHandle as Yt, WorkflowNodeConnection as Z, CredentialBindingKey as Zn, RunStopCondition as Zr, TriggerRuntimeDiagnostics as Zt, MutableRunData as _, instancePerContainerCachingFactory as _i, ExecutionTelemetry as _n, CredentialUnboundError as _r, BinaryStorageReadResult as _t, BinaryAttachment as a, DependencyContainer$1 as ai, WorkflowRunnerService as an, CredentialMaterialSourceKind as ar, nodeRef as at, NodeDefinition as b, singleton as bi, TelemetryArtifactAttachment as bn, PollingTriggerLogger as br, BinaryStorageWriteResult as bt, ExecutionMode as c, Lifecycle as ci, HttpMethod as cn, CredentialRequirement as cr, triggerNodeOutputType as ct, Items as d, container as di, WebhookInvocationMatch as dn, CredentialSessionService as dr, FixedRetryPolicySpec as dt, WebhookRunResult as ei, TriggerSetupStateRepository as en, CredentialHealthStatus as er, WorkflowStoragePolicyDecisionArgs as et, JsonArray as f, delay as fi, WebhookTriggerMatcher as fn, CredentialSetupStatus as fr, NoneRetryPolicySpec as ft, JsonValue as g, instanceCachingFactory as gi, WorkflowActivationPolicy as gn, CredentialTypeRegistry as gr, BinaryStorage as gt, JsonPrimitive as h, injectable as hi, AllWorkflowsActiveWorkflowActivationPolicy as hn, CredentialTypeId as hr, BinaryBody as ht, ActivationIdFactory as i, Container as ii, WorkflowRunnerResolver as in, CredentialJsonRecord as ir, branchRef as it, PairedItemRef as j, TestTriggerNodeConfig as ji, GenAiTelemetryAttributeNames as jn, NodeInputsByPort as jr, NodeActivationReceipt as jt, NodeRef as k, TestSuiteRunStatus as ki, TelemetrySpanScope as kn, NodeExecutionSnapshot as kr, MultiInputNode as kt, Item as l, RegistrationOptions as li, TriggerInstanceId as ln, CredentialSessionFactory as lr, triggerNodeSetupStateType as lt, JsonObject as m, injectAll as mi, WebhookTriggerRoutingDiagnostics as mn, CredentialTypeDefinition as mr, BinaryAttachmentCreateRequest as mt, InMemoryLiveWorkflowRepository as n, WorkflowExecutionPruneRepository as ni, WorkflowNodeInstanceFactory as nn, CredentialInstanceId as nr, WorkflowStoragePolicyResolver as nt, BinaryPreviewKind as o, Disposable as oi, WorkflowSnapshotFactory as on, CredentialOAuth2AuthDefinition as or, runnableNodeInputType as ot, JsonNonArray as p, inject as pi, WebhookTriggerResolution as pn, CredentialType as pr, RetryPolicySpec as pt, WorkflowErrorHandler as q, AnyCredentialType as qn, RunQueueEntry as qr, RunnableNodeExecuteArgs as qt, Engine as r, WorkflowExecutionRepository as ri, WorkflowRepository as rn, CredentialInstanceRecord as rr, WorkflowStoragePolicySpec as rt, Edge as s, InjectionToken$1 as si, WorkflowSnapshotResolver as sn, CredentialOAuth2ScopesFromPublicConfig as sr, runnableNodeOutputType as st, RunIntentService as t, WorkflowExecutionListingRepository as ti, TriggerTestItemsContext as tn, CredentialHealthTester as tr, WorkflowStoragePolicyMode as tt, ItemBinary as u, TypeToken as ui, WebhookControlSignal as un, CredentialSessionFactoryArgs as ur, ExponentialRetryPolicySpec as ut, NodeActivationId as v, predicateAwareClassFactory as vi, ExecutionTelemetryFactory as vn, OAuth2ProviderFromPublicConfig as vr, BinaryStorageStatResult as vt, NodeIdRef as w, EngineExecutionLimitsPolicyConfig as wi, TelemetryChildSpanStart as wn, ConnectionInvocationRecord as wr, ExecutionBinaryService as wt, NodeErrorHandler as x, CoreTokens as xi, TelemetryArtifactReference as xn, PollingTriggerDedupWindow as xr, EngineDeps as xt, NodeConfigBase as y, registry as yi, NodeExecutionTelemetry as yn, NoOpPollingTriggerLogger as yr, BinaryStorageWriteRequest as yt, RunnableNodeInputJson as z, CostTrackingPriceQuote as zn, PersistedWorkflowSnapshotNode as zr, NodeExecutionScheduler as zt };
+//# sourceMappingURL=RunIntentService-siBSjaaY.d.cts.map