@codemation/core 1.0.1 → 2.0.0

package/dist/{index-CyfGTfU1.d.ts → index-DeLl1Tne.d.ts}

@@ -1,60 +1,13 @@
-import { $t as RunDataFactory, Aa as RunPruneCandidate, Ai as CredentialType, Ar as WebhookInvocationMatch, Ba as WorkflowExecutionRepository, Bn as BinaryStorageWriteResult, Bt as NodeId, Ca as PersistedWorkflowSnapshotNode, Di as CredentialSessionFactoryArgs, Dr as HttpMethod, Et as Items, Fn as BinaryBody, Fr as WorkflowActivationPolicy, Ft as NodeConnectionName, Gn as ExecutionContext, Gt as NodeOutputs, Hi as TypeToken, Ia as RunSummary, In as BinaryStorage, Ir as ExecutionTelemetry, It as NodeDefinition, Jr as TelemetrySpanScope, Kn as ExecutionContextFactory, Ln as BinaryStorageReadResult, Lr as ExecutionTelemetryFactory, Mi as CredentialTypeId, Mt as MutableRunData, Nn as RetryPolicySpec, Nr as WebhookTriggerRoutingDiagnostics, Nt as NodeActivationId, Oi as CredentialSessionService, Pt as NodeConfigBase, Qn as NodeActivationRequest, Ra as WorkflowExecutionListingRepository, Rn as BinaryStorageStatResult, Sr as WorkflowRepository, St as ExecutionMode, Ti as CredentialRequirement, Vn as EngineDeps, Wn as ExecutionBinaryService, Wt as NodeOffloadPolicy, X as CostCatalog, Xn as NodeActivationContinuation, Xt as ParentExecutionRef, Z as CostCatalogEntry, Zt as PersistedRunPolicySnapshot, aa as RunEventSubscription, ai as CostTrackingTelemetry, ar as NodeExecutionScheduler, ba as PersistedRunSchedulingState, ca as ConnectionInvocationRecord, cr as NodeResolver, en as RunDataSnapshot, er as NodeActivationScheduler, gi as CredentialHealth, gn as WorkflowId, hi as CredentialFieldSchema, ia as RunEventBus, in as RunnableNodeInputJson, ji as CredentialTypeDefinition, jr as WebhookTriggerMatcher, jt as JsonValue, l as WorkflowSnapshotCodec, li as CostTrackingUsageRecord, nr as NodeExecutionContext, or as NodeExecutionStatePublisher, pa as NodeExecutionSnapshot, qt as NodeSchedulerDecision, ra as RunEvent, rn as RunnableNodeConfig, rr as NodeExecutionRequest, rt as ParamDeep, sa as ConnectionInvocationId, si as CostTrackingTelemetryFactory, ta as EngineExecutionLimitsPolicy, tn as RunId, tr as NodeBinaryAttachmentService, tt as Expr, u as Engine, ua as EngineRunCounters, ui as AnyCredentialType, un as WorkflowDefinition, ur as PreparedNodeActivationDispatch, vt as ActivationIdFactory, wt as Item, xa as PersistedRunState, xi as CredentialJsonRecord, xr as WorkflowNodeInstanceFactory, yt as BinaryAttachment, za as WorkflowExecutionPruneRepository } from "./RunIntentService-dteLjNiT.js";
+import { $t as PersistedRunPolicySnapshot, Aa as TypeToken, Ai as CredentialSessionFactoryArgs, Bi as PollingTriggerLogger, Bn as BinaryStorageWriteResult, Bt as NodeDefinition, Ca as WorkflowExecutionRepository, Cr as WorkflowRepository, Fi as CredentialTypeId, Fn as BinaryBody, Ga as RunEvent, Gn as ExecutionContext, In as BinaryStorage, Ir as WorkflowActivationPolicy, It as JsonValue, Ja as TestCaseRunStatus, Jt as NodeOutputs, Ka as RunEventBus, Ki as EngineRunCounters, Kn as ExecutionContextFactory, Ln as BinaryStorageReadResult, Lr as ExecutionTelemetry, Lt as MutableRunData, Mr as WebhookTriggerMatcher, Ni as CredentialType, Nn as RetryPolicySpec, Oi as CredentialRequirement, Or as HttpMethod, Ot as ExecutionMode, Pi as CredentialTypeDefinition, Pr as WebhookTriggerRoutingDiagnostics, Qn as NodeActivationRequest, Qt as ParentExecutionRef, Rn as BinaryStorageStatResult, Rr as ExecutionTelemetryFactory, Rt as NodeActivationId, Sa as WorkflowExecutionPruneRepository, Sr as WorkflowNodeInstanceFactory, Tt as BinaryAttachment, Ua as EngineExecutionLimitsPolicy, Ui as ConnectionInvocationId, Vn as EngineDeps, Wi as ConnectionInvocationRecord, Wn as ExecutionBinaryService, Xa as TestSuiteRunId, Xn as NodeActivationContinuation, Xt as NodeSchedulerDecision, Ya as TestSuiteRunStatus, Yi as NodeExecutionSnapshot, Yr as TelemetrySpanScope, aa as PersistedWorkflowSnapshotNode, an as RunnableNodeInputJson, ar as NodeExecutionScheduler, br as TriggerSetupStateRepository, ci as CostTrackingTelemetryFactory, cr as NodeResolver, ct as Expr, da as RunExecutionOptions, dn as WorkflowDefinition, dr as PreparedNodeActivationDispatch, en as RunDataFactory, eo as NodeConnectionName, er as NodeActivationScheduler, fa as RunPruneCandidate, fi as CollectionsContext, i as WorkflowSnapshotCodec, in as RunnableNodeConfig, io as WorkflowId, ji as CredentialSessionService, jr as WebhookInvocationMatch, jt as Items, kr as TriggerInstanceId, kt as Item, ma as RunResult, na as PersistedRunSchedulingState, nn as RunId, nr as NodeExecutionContext, oi as CostTrackingTelemetry, or as NodeExecutionStatePublisher, ot as CostCatalog, pi as AnyCredentialType, qa as RunEventSubscription, qt as NodeOffloadPolicy, ra as PersistedRunState, rr as NodeExecutionRequest, sn as TriggerNodeConfig, st as CostCatalogEntry, tn as RunDataSnapshot, to as NodeId, tr as NodeBinaryAttachmentService, u as Engine, ui as CostTrackingUsageRecord, ut as ParamDeep, va as RunSummary, vi as CredentialFieldSchema, wi as CredentialJsonRecord, wt as ActivationIdFactory, xa as WorkflowExecutionListingRepository, xr as TriggerTestItemsContext, ya as RunTestContext, yi as CredentialHealth, zt as NodeConfigBase } from "./RunIntentService-BE9CAkbf.js";
 import { ZodType, input, output, z } from "zod";
 
-//#region src/workflowSnapshots/MissingRuntimeFallbacksFactory.d.ts
-declare class MissingRuntimeFallbacks {
-  createDefinition(snapshotNode: PersistedWorkflowSnapshotNode): NodeDefinition;
-}
-//#endregion
-//#region src/runtime/EngineFactory.d.ts
-/**
- * {@link EngineDeps} plus optional overrides for workflow-snapshot materialization.
- * Overrides keep default construction in this factory while allowing tests or advanced wiring to inject instances.
- */
-type EngineCompositionDeps = EngineDeps & {
-  workflowSnapshotCodec?: WorkflowSnapshotCodec;
-  missingRuntimeFallbacks?: MissingRuntimeFallbacks;
-  /** When set, used for run-start, trigger, and continuation limit defaults. */
-  executionLimitsPolicy?: EngineExecutionLimitsPolicy;
-};
-/**
- * Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
- * {@link import("../bootstrap/runtime/EngineRuntimeRegistrar").EngineRuntimeRegistrar}; this factory remains for tests and custom composition.
- * Exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
- */
-declare class EngineFactory {
-  create(deps: EngineCompositionDeps): Engine;
-}
-//#endregion
-//#region src/events/NodeEventPublisher.d.ts
-/** Publishes node lifecycle snapshots onto the run {@link RunEventBus}. */
-declare class NodeEventPublisher {
-  private readonly eventBus;
-  constructor(eventBus: RunEventBus | undefined);
-  publish(kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed", snapshot: NodeExecutionSnapshot): Promise<void>;
-}
-//#endregion
-//#region src/execution/ChildExecutionScopeFactory.d.ts
+//#region src/orchestration/AbortControllerFactory.d.ts
 /**
- * Builds a re-rooted child execution context for sub-agent (and other deeply-nested) invocations.
- *
- * At the orchestrator's `agent.tool.call` boundary the inner runtime needs a ctx whose:
- * - `nodeId` is the tool's connection node id (so inner LLM/tool connection ids derive correctly),
- * - `activationId` is fresh (so its connection-invocation rows are uniquely identifiable),
- * - `telemetry` parents children under the tool-call span (not the orchestrator's node span),
- * - `binary` is scoped to the new (nodeId, activationId),
- * - `parentInvocationId` points back to the tool-call invocation for downstream lineage.
+ * Mints fresh {@link AbortController}s. Injected (rather than direct `new`) to honor the
+ * codebase's no-direct-construction rule and to give tests a seam for substituting a fake.
  */
-declare class ChildExecutionScopeFactory {
-  private readonly activationIdFactory;
-  constructor(activationIdFactory: ActivationIdFactory);
-  forSubAgent<TConfig$1 extends RunnableNodeConfig<any, any>>(args: Readonly<{
-    parentCtx: NodeExecutionContext<TConfig$1>;
-    childNodeId: NodeId;
-    childConfig: TConfig$1;
-    parentInvocationId: ConnectionInvocationId;
-    parentSpan: TelemetrySpanScope;
-  }>): NodeExecutionContext<TConfig$1>;
+declare class AbortControllerFactory {
+  create(): AbortController;
 }
 //#endregion
 //#region src/execution/CredentialResolverFactory.d.ts
@@ -64,122 +17,12 @@ declare class CredentialResolverFactory {
   create(workflowId: WorkflowId, nodeId: NodeId, config?: NodeExecutionContext["config"]): NodeExecutionContext["getCredential"];
 }
 //#endregion
-//#region src/execution/asyncSleeper.types.d.ts
-interface AsyncSleeper {
-  sleep(ms: number): Promise<void>;
-}
-//#endregion
-//#region src/execution/DefaultAsyncSleeper.d.ts
-declare class DefaultAsyncSleeper implements AsyncSleeper {
-  sleep(ms: number): Promise<void>;
-}
-//#endregion
-//#region src/execution/DefaultExecutionContextFactory.d.ts
-declare class DefaultExecutionContextFactory implements ExecutionContextFactory {
-  private readonly binaryStorage;
-  private readonly telemetryFactory;
-  private readonly costTrackingFactory;
-  private readonly currentDate;
-  private readonly telemetryDecoratorFactory;
-  constructor(binaryStorage?: BinaryStorage, telemetryFactory?: ExecutionTelemetryFactory, costTrackingFactory?: CostTrackingTelemetryFactory, currentDate?: () => Date);
-  create(args: {
-    runId: RunId;
-    workflowId: WorkflowId;
-    parent?: ParentExecutionRef;
-    policySnapshot?: PersistedRunPolicySnapshot;
-    subworkflowDepth: number;
-    engineMaxNodeActivations: number;
-    engineMaxSubworkflowDepth: number;
-    data: RunDataSnapshot;
-    nodeState?: NodeExecutionStatePublisher;
-    telemetry?: ExecutionContext["telemetry"];
-    getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
-  }): ExecutionContext;
-}
-//#endregion
-//#region src/execution/CatalogBackedCostTrackingTelemetryFactory.d.ts
-declare class CatalogBackedCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
-  private readonly costCatalog;
-  constructor(costCatalog: CostCatalog);
-  create(args: Readonly<{
-    telemetry: ExecutionTelemetry;
-  }>): CostTrackingTelemetry;
-}
-//#endregion
-//#region src/execution/InProcessRetryRunner.d.ts
-declare class InProcessRetryRunner {
-  private readonly sleeper;
-  constructor(sleeper: AsyncSleeper);
-  run<T>(policy: RetryPolicySpec | undefined, work: () => Promise<T>): Promise<T>;
-  private static delayAfterFailureMs;
-  private static normalizePolicy;
-  private static assertPositiveInt;
-  private static assertNonNegativeFinite;
-  private static assertMultiplier;
-}
-//#endregion
-//#region src/execution/ItemExprResolver.d.ts
-/**
- * Resolves {@link import("../contracts/itemExpr").ItemExpr} leaves on runnable config before {@link RunnableNode.execute}.
- */
-declare class ItemExprResolver {
-  resolveConfigForItem<TConfig$1 extends RunnableNodeConfig<any, any>>(ctx: NodeExecutionContext<TConfig$1>, item: Item, itemIndex: number, items: ReadonlyArray<Item>): Promise<NodeExecutionContext<TConfig$1>>;
-}
-//#endregion
-//#region src/execution/RunnableOutputBehaviorResolver.d.ts
-type RunnableOutputBehavior = Readonly<{
-  keepBinaries: boolean;
-}>;
-declare class RunnableOutputBehaviorResolver {
-  resolve(config: RunnableNodeConfig): RunnableOutputBehavior;
-  private isKeepBinariesEnabled;
-}
-//#endregion
-//#region src/execution/NodeOutputNormalizer.d.ts
-declare class NodeOutputNormalizer {
-  normalizeExecuteResult(args: Readonly<{
-    baseItem: Item;
-    raw: unknown;
-    behavior: RunnableOutputBehavior;
-  }>): NodeOutputs;
-  private arrayFanOutToMain;
-  private emitPortsToOutputs;
-  private normalizePortPayload;
-  private isItemLike;
-  private applyOutput;
-}
-//#endregion
-//#region src/execution/NodeExecutor.d.ts
-declare class NodeExecutor {
-  private readonly nodeInstanceFactory;
-  private readonly retryRunner;
-  private readonly fanInMerger;
-  private readonly outputNormalizer;
-  private readonly itemExprResolver;
-  private readonly outputBehaviorResolver;
-  constructor(nodeInstanceFactory: WorkflowNodeInstanceFactory, retryRunner: InProcessRetryRunner, itemExprResolver?: ItemExprResolver, outputBehaviorResolver?: RunnableOutputBehaviorResolver);
-  execute(request: NodeActivationRequest): Promise<NodeOutputs>;
-  private executeMultiInputActivation;
-  private executeSingleInputNode;
-  private isTriggerNode;
-  private isRunnableNode;
-  private hasExecuteMulti;
-  private asMultiFromSingleActivation;
-  private executeRunnableActivation;
-  /** Use resolver ctx only when {@link NodeExecutionContext.config} is non-nullish. */
-  private pickExecutionContext;
-  private resolveInputSchema;
-  private assertItemJsonNotTopLevelArray;
-  private assertNoPortEnvelopeBypass;
-}
-//#endregion
-//#region src/execution/NodeInstanceFactory.d.ts
-declare class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
-  private readonly nodeResolver;
-  constructor(nodeResolver: NodeResolver);
-  createNodes(workflow: WorkflowDefinition): Map<NodeId, unknown>;
-  createNode(definition: WorkflowDefinition["nodes"][number]): unknown;
-  createByType(type: TypeToken<unknown>): unknown;
+//#region src/events/NodeEventPublisher.d.ts
+/** Publishes node lifecycle snapshots onto the run {@link RunEventBus}. */
+declare class NodeEventPublisher {
+  private readonly eventBus;
+  constructor(eventBus: RunEventBus | undefined);
+  publish(kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed", snapshot: NodeExecutionSnapshot): Promise<void>;
 }
 //#endregion
 //#region src/contracts/Clock.d.ts
@@ -192,7 +35,7 @@ declare class SystemClock implements Clock {
 }
 //#endregion
 //#region src/authoring/defineNode.types.d.ts
-type MaybePromise$1<TValue> = TValue | Promise<TValue>;
+type MaybePromise$2<TValue> = TValue | Promise<TValue>;
 type ResolvableCredentialType = AnyCredentialType | CredentialTypeId;
 type SessionForCredentialType<TCredential extends ResolvableCredentialType> = TCredential extends AnyCredentialType ? Awaited<ReturnType<TCredential["createSession"]>> : unknown;
 type DefinedNodeCredentialBinding = ResolvableCredentialType | Readonly<{
@@ -258,7 +101,7 @@ interface DefineNodeOptions<TKey$1 extends string, TConfig$1 extends CredentialJ
   readonly inputSchema?: ZodType<TInputJson>;
   /** Preserve inbound `item.binary` when `execute` returns plain JSON or item-shaped results without `binary`. */
   readonly keepBinaries?: boolean;
-  execute(args: DefineNodeExecuteArgs<TConfig$1, TInputJson>, context: DefinedNodeRunContext<TConfig$1, TBindings>): MaybePromise$1<TOutputJson>;
+  execute(args: DefineNodeExecuteArgs<TConfig$1, TInputJson>, context: DefinedNodeRunContext<TConfig$1, TBindings>): MaybePromise$2<TOutputJson>;
 }
 /**
  * Batch-oriented defined node: `run` receives all item JSON once (last item in activation); emits one output per input row.
@@ -271,7 +114,7 @@ interface DefineBatchNodeOptions<TKey$1 extends string, TConfig$1 extends Creden
   readonly input?: Readonly<Record<keyof TConfig$1 & string, unknown>>;
   readonly configSchema?: z.ZodType<TConfig$1>;
   readonly credentials?: TBindings;
-  run(items: ReadonlyArray<TInputJson>, context: DefinedNodeRunContext<TConfig$1, TBindings>): MaybePromise$1<ReadonlyArray<TOutputJson>>;
+  run(items: ReadonlyArray<TInputJson>, context: DefinedNodeRunContext<TConfig$1, TBindings>): MaybePromise$2<ReadonlyArray<TOutputJson>>;
 }
 declare function defineNode<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson, TOutputJson, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineNodeOptions<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>): DefinedNode<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>;
 declare function defineBatchNode<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson, TOutputJson, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineBatchNodeOptions<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>): DefinedNode<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>;
@@ -284,7 +127,7 @@ declare class DefinedNodeRegistry {
 }
 //#endregion
 //#region src/authoring/defineCredential.types.d.ts
-type MaybePromise<TValue> = TValue | Promise<TValue>;
+type MaybePromise$1<TValue> = TValue | Promise<TValue>;
 type CredentialFieldInput = CredentialFieldSchema["type"] | Readonly<Omit<CredentialFieldSchema, "key">>;
 type CredentialFieldMap<TConfig$1 extends CredentialJsonRecord> = Readonly<Record<keyof TConfig$1 & string, CredentialFieldInput>>;
 type ZodObjectSchema<TConfig$1 extends CredentialJsonRecord = CredentialJsonRecord> = z.ZodType<TConfig$1>;
@@ -297,8 +140,8 @@ interface DefineCredentialOptions<TPublicSource extends CredentialFieldMap<any>
   readonly secret: TSecretSource;
   readonly supportedSourceKinds?: CredentialTypeDefinition["supportedSourceKinds"];
   readonly auth?: CredentialTypeDefinition["auth"];
-  createSession(args: CredentialSessionFactoryArgs<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>>): MaybePromise<TSession>;
-  test(args: CredentialSessionFactoryArgs<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>>): MaybePromise<CredentialHealth>;
+  createSession(args: CredentialSessionFactoryArgs<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>>): MaybePromise$1<TSession>;
+  test(args: CredentialSessionFactoryArgs<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>>): MaybePromise$1<CredentialHealth>;
 }
 declare function defineCredential<TPublicSource extends CredentialFieldMap<any> | ZodObjectSchema<any>, TSecretSource extends CredentialFieldMap<any> | ZodObjectSchema<any>, TSession>(options: DefineCredentialOptions<TPublicSource, TSecretSource, TSession>): CredentialType<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>, TSession> & {
   readonly key: string;
@@ -592,6 +435,219 @@ type AgentAttachmentRole = "languageModel" | "tool" | "nestedAgent";
  */
 declare function callableTool<TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny>(options: CallableToolConfigOptions<TInputSchema, TOutputSchema>): CallableToolConfig<TInputSchema, TOutputSchema>;
 //#endregion
+//#region src/authoring/defineCollection.types.d.ts
+type CollectionFieldType = "text" | "int" | "bigint" | "double" | "bool" | "timestamptz" | "jsonb" | "uuid";
+interface CollectionColumnBuilder {
+  notNull(): CollectionColumnBuilder;
+  default(value: unknown): CollectionColumnBuilder;
+  readonly _type: CollectionFieldType;
+  readonly _nullable: boolean;
+  readonly _default?: unknown;
+}
+declare const c: {
+  readonly text: () => CollectionColumnBuilder;
+  readonly int: () => CollectionColumnBuilder;
+  readonly bigint: () => CollectionColumnBuilder;
+  readonly double: () => CollectionColumnBuilder;
+  readonly bool: () => CollectionColumnBuilder;
+  readonly timestamptz: () => CollectionColumnBuilder;
+  readonly jsonb: () => CollectionColumnBuilder;
+  readonly uuid: () => CollectionColumnBuilder;
+};
+interface CollectionFieldDefinition {
+  readonly type: CollectionFieldType;
+  readonly nullable: boolean;
+  readonly default?: unknown;
+}
+interface CollectionIndexDefinition {
+  readonly on: ReadonlyArray<string>;
+  readonly unique?: boolean;
+}
+interface CollectionDefinition {
+  readonly name: string;
+  readonly fields: Readonly<Record<string, CollectionFieldDefinition>>;
+  readonly indexes: ReadonlyArray<CollectionIndexDefinition>;
+}
+interface DefinedCollection<TDefinition extends CollectionDefinition = CollectionDefinition> {
+  readonly kind: "defined-collection";
+  readonly definition: TDefinition;
+  register(context: {
+    registerCollection(d: CollectionDefinition): void;
+  }): void;
+}
+interface DefineCollectionOptions {
+  readonly name: string;
+  readonly fields: Record<string, CollectionColumnBuilder>;
+  readonly indexes?: ReadonlyArray<CollectionIndexDefinition>;
+}
+declare function defineCollection<TName extends string>(options: DefineCollectionOptions & {
+  name: TName;
+}): DefinedCollection<CollectionDefinition & {
+  name: TName;
+}>;
+//#endregion
+//#region src/authoring/DefinedCollectionRegistry.d.ts
+declare class DefinedCollectionRegistry {
+  private static readonly definitions;
+  static register(definition: CollectionDefinition): void;
+  static resolve(name: string): CollectionDefinition | undefined;
+  static list(): ReadonlyArray<CollectionDefinition>;
+}
+//#endregion
+//#region src/authoring/definePollingTrigger.types.d.ts
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+/**
+ * Context passed into the `poll` callback on each tick.
+ */
+interface DefinePollingTriggerPollContext<TConfig$1 extends CredentialJsonRecord, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined> {
+  readonly config: TConfig$1;
+  readonly state: TState;
+  readonly credentials: DefinedNodeCredentialAccessors<TBindings>;
+}
+/**
+ * What `poll` must return each tick.
+ */
+interface DefinePollingTriggerPollResult<TItemJson, TState extends JsonValue | undefined> {
+  /**
+   * New items to emit. Each item may carry an optional `dedupKey`; duplicate keys are
+   * filtered out against a rolling dedup window (managed internally by the runtime).
+   * Items without a `dedupKey` are always emitted.
+   */
+  readonly items: ReadonlyArray<{
+    json: TItemJson;
+    dedupKey?: string;
+  }>;
+  /** Persisted as the trigger's setup state for the next tick. */
+  readonly nextState: TState;
+}
+/**
+ * Context passed into the `execute` callback for post-emit enrichment (e.g. fetching
+ * attachment bytes). Mirrors `NodeExecutionContext` so plugin authors use familiar patterns.
+ */
+type DefinePollingTriggerExecuteContext<TConfig$1 extends TriggerNodeConfig<any, any>> = NodeExecutionContext<TConfig$1>;
+/**
+ * Context passed into the `testItems` callback.
+ */
+type DefinePollingTriggerTestItemsContext<TConfig$1 extends TriggerNodeConfig<any, any>> = TriggerTestItemsContext<TConfig$1>;
+/**
+ * Options accepted by `definePollingTrigger`.
+ */
+interface DefinePollingTriggerOptions<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  /**
+   * Unique node-token-id-style key, e.g. `"msgraph-mail.on-new-mail"`.
+   * Used as the persisted runtime type name — must be stable across deployments.
+   */
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  /** Canvas icon (same contract as `NodeConfigBase.icon`). */
+  readonly icon?: string;
+  /**
+   * Zod schema for the trigger's user-facing configuration.
+   * When provided, the returned `create()` method is typed against the inferred config type.
+   */
+  readonly configSchema?: ZodType<TConfig$1>;
+  /** Credential bindings keyed by slot (same format as `defineNode`). */
+  readonly credentials?: TBindings;
+  /**
+   * Called once when the trigger arms (or re-arms after a server restart) to provide the
+   * initial value for `state` when no persisted state exists.
+   */
+  initialState?(): TState;
+  /**
+   * Polling interval in milliseconds. The runtime enforces a minimum of 25 ms.
+   * @default 60_000
+   */
+  readonly pollIntervalMs?: number;
+  /**
+   * The per-tick poll logic. Called by the runtime each interval.
+   * Must return new items plus the next persisted state.
+   */
+  poll(pollCtx: DefinePollingTriggerPollContext<TConfig$1, TState, TBindings>): MaybePromise<DefinePollingTriggerPollResult<TItemJson, TState>>;
+  /**
+   * Optional post-emit enrichment step (runs in the normal node-execute phase after the
+   * trigger fires and the workflow run starts). Use for expensive per-item work such as
+   * fetching attachment bytes via `ctx.binary.attach`. When omitted, the trigger passes
+   * items through unchanged.
+   */
+  execute?(items: Items<TItemJson>, ctx: NodeExecutionContext<DefinedPollingTriggerConfig<TConfig$1, TItemJson>>): MaybePromise<NodeOutputs>;
+  /**
+   * Optional implementation for the workflow UI's "Test" button. Should return a small
+   * sample of current items without consulting or mutating polling state.
+   */
+  testItems?(ctx: TriggerTestItemsContext<DefinedPollingTriggerConfig<TConfig$1, TItemJson>>): MaybePromise<Items<TItemJson>>;
+}
+/**
+ * The object returned by `definePollingTrigger`. Register it via
+ * `definePlugin({ nodes: [myTrigger] })` or call `.register(ctx)` directly.
+ *
+ * `poll` is also directly callable for unit-testing — no runtime needed.
+ */
+interface DefinedPollingTrigger<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  readonly kind: "defined-polling-trigger";
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  /**
+   * Create the trigger config for use in workflow definitions.
+   * @param cfg - User-facing trigger configuration.
+   * @param name - Display name (defaults to `title`).
+   * @param id - Optional stable node id.
+   */
+  create(cfg: TConfig$1, name?: string, id?: string): DefinedPollingTriggerConfig<TConfig$1, TItemJson>;
+  /**
+   * Test seam: call `poll` directly without starting the runtime.
+   * Returns `{ items, nextState }` just like the real runtime receives.
+   */
+  poll(pollCtx: Omit<DefinePollingTriggerPollContext<TConfig$1, TState, TBindings>, "credentials"> & {
+    credentials?: DefinedNodeCredentialAccessors<TBindings>;
+  }): MaybePromise<DefinePollingTriggerPollResult<TItemJson, TState>>;
+  /** Registers the synthesised runtime class with the plugin container. */
+  register(context: {
+    registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
+  }): void;
+}
+/**
+ * TriggerNodeConfig produced by `DefinedPollingTrigger.create(...)`.
+ * Holds user configuration and credential requirements for the engine.
+ * The setup state type is opaque `JsonValue | undefined` — the runtime
+ * uses an internal wrapped shape that plugin authors never see.
+ */
+declare class DefinedPollingTriggerConfig<TConfig$1 extends CredentialJsonRecord, TItemJson> implements TriggerNodeConfig<TItemJson, JsonValue | undefined> {
+  readonly name: string;
+  readonly cfg: TConfig$1;
+  private readonly credentialRequirements;
+  readonly id?: string | undefined;
+  readonly kind: "trigger";
+  readonly type: TypeToken<unknown>;
+  readonly icon: string | undefined;
+  constructor(name: string, cfg: TConfig$1, typeToken: TypeToken<unknown>, icon: string | undefined, credentialRequirements: ReadonlyArray<CredentialRequirement>, id?: string | undefined);
+  getCredentialRequirements(): ReadonlyArray<CredentialRequirement>;
+}
+/**
+ * Declarative helper for authoring polling triggers.
+ *
+ * ```ts
+ * export const onNewMail = definePollingTrigger({
+ *   key: "my-plugin.on-new-mail",
+ *   title: "On new mail",
+ *   configSchema: z.object({ folder: z.string() }),
+ *   credentials: { auth: myOAuthCredentialType },
+ *   initialState: () => ({ lastSeenId: undefined }),
+ *   pollIntervalMs: 60_000,
+ *   async poll({ config, state, credentials }) {
+ *     const session = await credentials.auth();
+ *     const messages = await fetchMessages(session, config.folder, state.lastSeenId);
+ *     return {
+ *       items: messages.map(m => ({ json: m, dedupKey: m.id })),
+ *       nextState: { lastSeenId: messages[0]?.id ?? state.lastSeenId },
+ *     };
+ *   },
+ * });
+ * ```
+ */
+declare function definePollingTrigger<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefinePollingTriggerOptions<TKey$1, TConfig$1, TItemJson, TState, TBindings>): DefinedPollingTrigger<TKey$1, TConfig$1, TItemJson, TState, TBindings>;
+//#endregion
 //#region src/ai/AgentConnectionNodeCollector.d.ts
 type AgentConnectionNodeRole = "languageModel" | "tool" | "nestedAgent";
 type AgentConnectionCredentialSource = Readonly<{
@@ -756,84 +812,150 @@ declare class DefaultExecutionBinaryService implements ExecutionBinaryService {
   openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
 }
 //#endregion
-//#region src/runStorage/InMemoryBinaryStorageRegistry.d.ts
-declare class InMemoryBinaryStorage implements BinaryStorage {
-  readonly driverName = "memory";
-  private readonly values;
-  write(args: {
-    storageKey: string;
-    body: BinaryBody;
-  }): Promise<BinaryStorageWriteResult>;
-  openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
-  stat(storageKey: string): Promise<BinaryStorageStatResult>;
-  delete(storageKey: string): Promise<void>;
+//#region src/execution/ChildExecutionScopeFactory.d.ts
+/**
+ * Builds a re-rooted child execution context for sub-agent (and other deeply-nested) invocations.
+ *
+ * At the orchestrator's `agent.tool.call` boundary the inner runtime needs a ctx whose:
+ * - `nodeId` is the tool's connection node id (so inner LLM/tool connection ids derive correctly),
+ * - `activationId` is fresh (so its connection-invocation rows are uniquely identifiable),
+ * - `telemetry` parents children under the tool-call span (not the orchestrator's node span),
+ * - `binary` is scoped to the new (nodeId, activationId),
+ * - `parentInvocationId` points back to the tool-call invocation for downstream lineage.
+ *
+ * Registered via factory in {@link EngineRuntimeRegistrar} so constructors stay free of parameter
+ * decorators (Next/SWC and coverage tooling cannot parse them on in-repo sources).
+ */
+declare class ChildExecutionScopeFactory {
+  private readonly activationIdFactory;
+  constructor(activationIdFactory: ActivationIdFactory);
+  forSubAgent<TConfig$1 extends RunnableNodeConfig<any, any>>(args: Readonly<{
+    parentCtx: NodeExecutionContext<TConfig$1>;
+    childNodeId: NodeId;
+    childConfig: TConfig$1;
+    parentInvocationId: ConnectionInvocationId;
+    parentSpan: TelemetrySpanScope;
+  }>): NodeExecutionContext<TConfig$1>;
 }
 //#endregion
-//#region src/runStorage/InMemoryRunDataFactory.d.ts
-declare class InMemoryRunDataFactory implements RunDataFactory {
-  create(initial?: Record<NodeId, NodeOutputs>): MutableRunData;
+//#region src/execution/asyncSleeper.types.d.ts
+interface AsyncSleeper {
+  sleep(ms: number): Promise<void>;
 }
 //#endregion
-//#region src/runStorage/InMemoryWorkflowExecutionRepository.d.ts
-declare class InMemoryWorkflowExecutionRepository implements WorkflowExecutionRepository, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository {
-  private readonly runs;
-  createRun(args: {
+//#region src/execution/DefaultAsyncSleeper.d.ts
+declare class DefaultAsyncSleeper implements AsyncSleeper {
+  sleep(ms: number): Promise<void>;
+}
+//#endregion
+//#region src/execution/DefaultExecutionContextFactory.d.ts
+declare class DefaultExecutionContextFactory implements ExecutionContextFactory {
+  private readonly binaryStorage;
+  private readonly telemetryFactory;
+  private readonly costTrackingFactory;
+  private readonly currentDate;
+  private readonly collections?;
+  private readonly telemetryDecoratorFactory;
+  constructor(binaryStorage?: BinaryStorage, telemetryFactory?: ExecutionTelemetryFactory, costTrackingFactory?: CostTrackingTelemetryFactory, currentDate?: () => Date, collections?: CollectionsContext | undefined);
+  create(args: {
     runId: RunId;
     workflowId: WorkflowId;
-    startedAt: string;
     parent?: ParentExecutionRef;
-    executionOptions?: PersistedRunState["executionOptions"];
-    control?: PersistedRunState["control"];
-    workflowSnapshot?: PersistedRunState["workflowSnapshot"];
-    mutableState?: PersistedRunState["mutableState"];
-    policySnapshot?: PersistedRunState["policySnapshot"];
-    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>;
-  listRuns(args?: Readonly<{
-    workflowId?: WorkflowId;
-    limit?: number;
-  }>): Promise<ReadonlyArray<RunSummary>>;
-  listRunsOlderThan(args: Readonly<{
-    nowIso: string;
-    defaultRetentionSeconds: number;
-    limit?: number;
-  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+    policySnapshot?: PersistedRunPolicySnapshot;
+    subworkflowDepth: number;
+    engineMaxNodeActivations: number;
+    engineMaxSubworkflowDepth: number;
+    data: RunDataSnapshot;
+    nodeState?: NodeExecutionStatePublisher;
+    telemetry?: ExecutionContext["telemetry"];
+    getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+    testContext?: RunTestContext;
+  }): ExecutionContext;
 }
 //#endregion
-//#region src/runStorage/RunSummaryMapper.d.ts
-/** Maps persisted run state to API run summaries for listings. */
-declare class RunSummaryMapper {
-  static fromPersistedState(state: PersistedRunState): RunSummary;
+//#region src/execution/CatalogBackedCostTrackingTelemetryFactory.d.ts
+declare class CatalogBackedCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
+  private readonly costCatalog;
+  constructor(costCatalog: CostCatalog);
+  create(args: Readonly<{
+    telemetry: ExecutionTelemetry;
+  }>): CostTrackingTelemetry;
 }
 //#endregion
-//#region src/runtime/WorkflowRepositoryWebhookTriggerMatcher.d.ts
+//#region src/execution/InProcessRetryRunner.d.ts
+declare class InProcessRetryRunner {
+  private readonly sleeper;
+  constructor(sleeper: AsyncSleeper);
+  run<T>(policy: RetryPolicySpec | undefined, work: () => Promise<T>): Promise<T>;
+  private static delayAfterFailureMs;
+  private static normalizePolicy;
+  private static assertPositiveInt;
+  private static assertNonNegativeFinite;
+  private static assertMultiplier;
+}
+//#endregion
+//#region src/execution/ItemExprResolver.d.ts
 /**
- * Resolves webhook HTTP routes from the live workflow repository (no trigger setup / registration).
- * Maintains an in-memory index keyed by user-defined endpoint path for O(1) lookups after reload.
+ * Resolves {@link import("../contracts/itemExpr").ItemExpr} leaves on runnable config before {@link RunnableNode.execute}.
  */
-declare class WorkflowRepositoryWebhookTriggerMatcher implements WebhookTriggerMatcher {
-  private readonly workflowRepository;
-  private readonly workflowActivationPolicy;
-  private readonly diagnostics?;
-  private readonly routeByPath;
-  private engineRoutesActive;
-  constructor(workflowRepository: WorkflowRepository, workflowActivationPolicy: WorkflowActivationPolicy, diagnostics?: WebhookTriggerRoutingDiagnostics | undefined);
-  onEngineWorkflowsLoaded(): void;
-  onEngineStopped(): void;
-  reloadWebhookRoutes(): void;
-  lookup(endpointPath: string): WebhookInvocationMatch | undefined;
-  match(args: {
-    endpointPath: string;
-    method: HttpMethod;
-  }): WebhookInvocationMatch | undefined;
-  private rebuildRouteIndex;
-  private collectWebhookEndpointPaths;
-  private tryMatchFromTriggerNode;
-  private normalizeEndpointPath;
+declare class ItemExprResolver {
+  resolveConfigForItem<TConfig$1 extends RunnableNodeConfig<any, any>>(ctx: NodeExecutionContext<TConfig$1>, item: Item, itemIndex: number, items: ReadonlyArray<Item>): Promise<NodeExecutionContext<TConfig$1>>;
+}
+//#endregion
+//#region src/execution/RunnableOutputBehaviorResolver.d.ts
+type RunnableOutputBehavior = Readonly<{
+  keepBinaries: boolean;
+}>;
+declare class RunnableOutputBehaviorResolver {
+  resolve(config: RunnableNodeConfig): RunnableOutputBehavior;
+  private isKeepBinariesEnabled;
+}
+//#endregion
+//#region src/execution/NodeOutputNormalizer.d.ts
+declare class NodeOutputNormalizer {
+  normalizeExecuteResult(args: Readonly<{
+    baseItem: Item;
+    raw: unknown;
+    behavior: RunnableOutputBehavior;
+  }>): NodeOutputs;
+  private arrayFanOutToMain;
+  private emitPortsToOutputs;
+  private normalizePortPayload;
+  private isItemLike;
+  private applyOutput;
+}
+//#endregion
+//#region src/execution/NodeExecutor.d.ts
+declare class NodeExecutor {
+  private readonly nodeInstanceFactory;
+  private readonly retryRunner;
+  private readonly fanInMerger;
+  private readonly outputNormalizer;
+  private readonly itemExprResolver;
+  private readonly outputBehaviorResolver;
+  constructor(nodeInstanceFactory: WorkflowNodeInstanceFactory, retryRunner: InProcessRetryRunner, itemExprResolver?: ItemExprResolver, outputBehaviorResolver?: RunnableOutputBehaviorResolver);
+  execute(request: NodeActivationRequest): Promise<NodeOutputs>;
+  private executeMultiInputActivation;
+  private executeSingleInputNode;
+  private isTriggerNode;
+  private isRunnableNode;
+  private hasExecuteMulti;
+  private asMultiFromSingleActivation;
+  private executeRunnableActivation;
+  /** Use resolver ctx only when {@link NodeExecutionContext.config} is non-nullish. */
+  private pickExecutionContext;
+  private resolveInputSchema;
+  private assertItemJsonNotTopLevelArray;
+  private assertNoPortEnvelopeBypass;
+}
+//#endregion
+//#region src/execution/NodeInstanceFactory.d.ts
+declare class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
+  private readonly nodeResolver;
+  constructor(nodeResolver: NodeResolver);
+  createNodes(workflow: WorkflowDefinition): Map<NodeId, unknown>;
+  createNode(definition: WorkflowDefinition["nodes"][number]): unknown;
+  createByType(type: TypeToken<unknown>): unknown;
 }
 //#endregion
 //#region src/execution/StaticCostCatalog.d.ts
@@ -910,5 +1032,215 @@ declare class LocalOnlyScheduler implements NodeExecutionScheduler {
   }>;
 }
 //#endregion
-export { AgentTurnLimitBehavior as $, EngineFactory as $t, AgentConnectionNodeCollector as A, DefinedNodeConfigInput as At, AgentMessageDto as B, NodeExecutor as Bt, PersistedRuntimeTypeDecoratorOptions as C, DefineCredentialOptions as Ct, InMemoryRunEventBus as D, DefineNodeExecuteArgs as Dt, EventPublishingWorkflowExecutionRepository as E, DefineBatchNodeOptions as Et, AgentCanvasPresentation as F, defineBatchNode as Ft, AgentModelInvocationOptions as G, CatalogBackedCostTrackingTelemetryFactory as Gt, AgentMessageRole as H, RunnableOutputBehaviorResolver as Ht, AgentGuardrailConfig as I, defineNode as It, AgentToolCall as J, AsyncSleeper as Jt, AgentNodeConfig as K, DefaultExecutionContextFactory as Kt, AgentGuardrailDefaults as L, Clock as Lt, AgentConnectionNodeRole as M, DefinedNodeCredentialBinding as Mt, callableTool as N, DefinedNodeCredentialBindings as Nt, ConnectionInvocationEventPublisher as O, DefineNodeOptions as Ot, AgentAttachmentRole as P, DefinedNodeRunContext as Pt, AgentToolToken as Q, EngineCompositionDeps as Qt, AgentMessageBuildArgs as R, SystemClock as Rt, InjectableRuntimeDecoratorComposer as S, NodeBackedToolConfig as St, PersistedRuntimeTypeMetadata as T, DefinedNodeRegistry as Tt, AgentMessageTemplate as U, ItemExprResolver as Ut, AgentMessageLine as V, NodeOutputNormalizer as Vt, AgentMessageTemplateContent as W, InProcessRetryRunner as Wt, AgentToolDefinition as X, ChildExecutionScopeFactory as Xt, AgentToolCallPlanner as Y, CredentialResolverFactory as Yt, AgentToolExecuteArgs as Z, NodeEventPublisher as Zt, node as _, CallableToolKindToken as _t, ConfigDrivenOffloadPolicy as a, NodeBackedToolInputMapper as at, PersistedRuntimeTypeNameResolver as b, CallableToolConfigOptions as bt, RunSummaryMapper as c, NodeBackedToolOutputMapperArgs as ct, InMemoryBinaryStorage as d, ToolConfig as dt, ChatLanguageModel as et, DefaultExecutionBinaryService as f, ToolExecuteArgs as ft, getPersistedRuntimeTypeMetadata as g, AgentToolFactory as gt, chatModel as h, AgentMessageConfigNormalizer as ht, InlineDrivingScheduler as i, NodeBackedToolConfigOptions as it, AgentConnectionNodeDescriptor as j, DefinedNodeCredentialAccessors as jt, AgentConnectionCredentialSource as k, DefinedNode as kt, InMemoryWorkflowExecutionRepository as l, StructuredOutputOptions as lt, ItemsInputNormalizer as m, AgentConfigInspector as mt, HintOnlyOffloadPolicy as n, ChatModelConfig as nt, StaticCostCatalog as o, NodeBackedToolInputMapperArgs as ot, UnavailableBinaryStorage as p, ZodSchemaAny as pt, AgentTool as q, DefaultAsyncSleeper as qt, DefaultDrivingScheduler as r, ChatModelFactory as rt, WorkflowRepositoryWebhookTriggerMatcher as s, NodeBackedToolOutputMapper as st, LocalOnlyScheduler as t, ChatLanguageModelCallOptions as tt, InMemoryRunDataFactory as u, Tool as ut, tool as v, CallableToolFactory as vt, PersistedRuntimeTypeKind as w, defineCredential as wt, PersistedRuntimeTypeMetadataStore as x, CallableToolExecuteHandler as xt, StackTraceCallSitePathResolver as y, CallableToolConfig as yt, AgentMessageConfig as z, NodeInstanceFactory as zt };
-//# sourceMappingURL=index-CyfGTfU1.d.ts.map
+//#region src/runStorage/InMemoryBinaryStorageRegistry.d.ts
+declare class InMemoryBinaryStorage implements BinaryStorage {
+  readonly driverName = "memory";
+  private readonly values;
+  write(args: {
+    storageKey: string;
+    body: BinaryBody;
+  }): Promise<BinaryStorageWriteResult>;
+  openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
+  stat(storageKey: string): Promise<BinaryStorageStatResult>;
+  delete(storageKey: string): Promise<void>;
+}
+//#endregion
+//#region src/runStorage/InMemoryRunDataFactory.d.ts
+declare class InMemoryRunDataFactory implements RunDataFactory {
+  create(initial?: Record<NodeId, NodeOutputs>): MutableRunData;
+}
+//#endregion
+//#region src/runStorage/InMemoryWorkflowExecutionRepository.d.ts
+declare class InMemoryWorkflowExecutionRepository implements WorkflowExecutionRepository, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository {
+  private readonly runs;
+  createRun(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: PersistedRunState["executionOptions"];
+    control?: PersistedRunState["control"];
+    workflowSnapshot?: PersistedRunState["workflowSnapshot"];
+    mutableState?: PersistedRunState["mutableState"];
+    policySnapshot?: PersistedRunState["policySnapshot"];
+    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>;
+  listRuns(args?: Readonly<{
+    workflowId?: WorkflowId;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+  listRunsOlderThan(args: Readonly<{
+    nowIso: string;
+    defaultRetentionSeconds: number;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+//#endregion
+//#region src/runStorage/RunSummaryMapper.d.ts
+/** Maps persisted run state to API run summaries for listings. */
+declare class RunSummaryMapper {
+  static fromPersistedState(state: PersistedRunState): RunSummary;
+}
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeFallbacksFactory.d.ts
+declare class MissingRuntimeFallbacks {
+  createDefinition(snapshotNode: PersistedWorkflowSnapshotNode): NodeDefinition;
+}
+//#endregion
+//#region src/runtime/EngineFactory.d.ts
+/**
+ * {@link EngineDeps} plus optional overrides for workflow-snapshot materialization.
+ * Overrides keep default construction in this factory while allowing tests or advanced wiring to inject instances.
+ */
+type EngineCompositionDeps = EngineDeps & {
+  workflowSnapshotCodec?: WorkflowSnapshotCodec;
+  missingRuntimeFallbacks?: MissingRuntimeFallbacks;
+  /** When set, used for run-start, trigger, and continuation limit defaults. */
+  executionLimitsPolicy?: EngineExecutionLimitsPolicy;
+};
+/**
+ * Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
+ * {@link import("../bootstrap/runtime/EngineRuntimeRegistrar").EngineRuntimeRegistrar}; this factory remains for tests and custom composition.
+ * Exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+ */
+declare class EngineFactory {
+  create(deps: EngineCompositionDeps): Engine;
+}
+//#endregion
+//#region src/runtime/WorkflowRepositoryWebhookTriggerMatcher.d.ts
+/**
+ * Resolves webhook HTTP routes from the live workflow repository (no trigger setup / registration).
+ * Maintains an in-memory index keyed by user-defined endpoint path for O(1) lookups after reload.
+ */
+declare class WorkflowRepositoryWebhookTriggerMatcher implements WebhookTriggerMatcher {
+  private readonly workflowRepository;
+  private readonly workflowActivationPolicy;
+  private readonly diagnostics?;
+  private readonly routeByPath;
+  private engineRoutesActive;
+  constructor(workflowRepository: WorkflowRepository, workflowActivationPolicy: WorkflowActivationPolicy, diagnostics?: WebhookTriggerRoutingDiagnostics | undefined);
+  onEngineWorkflowsLoaded(): void;
+  onEngineStopped(): void;
+  reloadWebhookRoutes(): void;
+  lookup(endpointPath: string): WebhookInvocationMatch | undefined;
+  match(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookInvocationMatch | undefined;
+  private rebuildRouteIndex;
+  private collectWebhookEndpointPaths;
+  private tryMatchFromTriggerNode;
+  private normalizeEndpointPath;
+}
+//#endregion
+//#region src/triggers/polling/PollingTriggerRuntime.d.ts
+interface PollingRunCycleArgs<TState> {
+  previousState: TState | undefined;
+  signal: AbortSignal;
+}
+interface PollingRunCycleResult<TState, TItem> {
+  items: Items<TItem>;
+  nextState: TState;
+}
+interface PollingTriggerStartArgs<TState, TItem> {
+  trigger: TriggerInstanceId;
+  intervalMs: number;
+  seedState?: TState;
+  runCycle: (cycleCtx: PollingRunCycleArgs<TState>) => Promise<PollingRunCycleResult<TState, TItem>>;
+  emit: (items: Items) => Promise<void>;
+}
+/**
+ * Generic polling-trigger runtime. Owns the set-interval loop, overlap guard, and persistence.
+ * Constructed by {@link import("../../runtime/EngineFactory").EngineFactory} and exposed to plugin
+ * authors via {@link import("../../contracts/runtimeTypes").TriggerSetupContext}.polling.
+ */
+declare class PollingTriggerRuntime {
+  private readonly triggerSetupStateRepository;
+  private readonly logger;
+  private readonly activeTriggers;
+  private readonly intervalsByTrigger;
+  private readonly busyTriggers;
+  constructor(triggerSetupStateRepository: TriggerSetupStateRepository, logger: PollingTriggerLogger);
+  start<TState, TItem>(args: PollingTriggerStartArgs<TState, TItem>): Promise<TState | undefined>;
+  stop(trigger: TriggerInstanceId): Promise<void>;
+  private ensureLoop;
+  private runCycle;
+  private toKey;
+  private describe;
+  private logError;
+}
+//#endregion
+//#region src/orchestration/TestSuiteRunIdFactory.d.ts
+/**
+ * Mints unique TestSuiteRun identifiers. Separated from {@link import("../types").RunIdFactory}
+ * so suite ids and per-case workflow run ids never alias.
+ */
+declare class TestSuiteRunIdFactory {
+  makeTestSuiteRunId(): TestSuiteRunId;
+}
+//#endregion
+//#region src/orchestration/TestSuiteOrchestrator.d.ts
+/**
+ * Engine-facade subset the orchestrator needs. Kept narrow on purpose so unit tests can
+ * substitute a fake without depending on the full Engine wiring.
+ */
+interface TestSuiteOrchestratorEngine {
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+}
+interface TestSuiteCaseOutcome {
+  readonly testCaseIndex: number;
+  readonly runId: RunId;
+  readonly status: TestCaseRunStatus;
+}
+interface TestSuiteRunResult {
+  readonly testSuiteRunId: TestSuiteRunId;
+  readonly workflowId: WorkflowId;
+  readonly triggerNodeId: NodeId;
+  readonly status: TestSuiteRunStatus;
+  readonly totalCases: number;
+  readonly passedCases: number;
+  readonly failedCases: number;
+  readonly cases: ReadonlyArray<TestSuiteCaseOutcome>;
+}
+interface RunTestSuiteArgs {
+  readonly workflow: WorkflowDefinition;
+  readonly triggerNodeId: NodeId;
+  readonly testSuiteRunId?: TestSuiteRunId;
+  readonly concurrency?: number;
+  readonly signal?: AbortSignal;
+}
+/**
+ * Drives a {@link TestTriggerNodeConfig.generateItems} iterable into one workflow run per item,
+ * with bounded concurrency. Pure engine logic — no persistence, no HTTP, no UI. Hosts adapt by
+ * subscribing to {@link RunEventBus} and writing rows on `testSuite*` / `testCase*` / `nodeCompleted`.
+ *
+ * Cancellation: the supplied `AbortSignal` aborts the source iterable (so credentialed pulls bail)
+ * and stops scheduling further cases. In-flight cases are awaited; engine-level cancellation of
+ * an already-dispatched run is not yet wired (Phase 2).
+ */
+declare class TestSuiteOrchestrator {
+  private readonly engine;
+  private readonly testSuiteRunIdFactory;
+  private readonly credentialResolverFactory;
+  private readonly abortControllerFactory;
+  private readonly eventBus;
+  private readonly currentDate;
+  constructor(engine: TestSuiteOrchestratorEngine, testSuiteRunIdFactory: TestSuiteRunIdFactory, credentialResolverFactory: CredentialResolverFactory, abortControllerFactory: AbortControllerFactory, eventBus: RunEventBus | undefined, currentDate?: () => Date);
+  runSuite(args: RunTestSuiteArgs): Promise<TestSuiteRunResult>;
+  private runOneCase;
+  private deriveSuiteStatus;
+  private now;
+  /** Defensive label resolver — author-supplied callbacks throw / return non-strings; we tolerate both. */
+  private resolveCaseLabel;
+  private publish;
+}
+//#endregion
+export { AgentConnectionNodeCollector as $, ZodSchemaAny as $t, CatalogBackedCostTrackingTelemetryFactory as A, AgentMessageTemplateContent as At, node as B, ChatLanguageModel as Bt, StaticCostCatalog as C, Clock as Cn, AgentGuardrailDefaults as Ct, RunnableOutputBehaviorResolver as D, AbortControllerFactory as Dn, AgentMessageLine as Dt, NodeOutputNormalizer as E, CredentialResolverFactory as En, AgentMessageDto as Et, DefaultExecutionBinaryService as F, AgentToolCallPlanner as Ft, InjectableRuntimeDecoratorComposer as G, NodeBackedToolInputMapper as Gt, StackTraceCallSitePathResolver as H, ChatModelConfig as Ht, UnavailableBinaryStorage as I, AgentToolDefinition as It, PersistedRuntimeTypeMetadata as J, NodeBackedToolOutputMapperArgs as Jt, PersistedRuntimeTypeDecoratorOptions as K, NodeBackedToolInputMapperArgs as Kt, ItemsInputNormalizer as L, AgentToolExecuteArgs as Lt, DefaultAsyncSleeper as M, AgentNodeConfig as Mt, AsyncSleeper as N, AgentTool as Nt, ItemExprResolver as O, AgentMessageRole as Ot, ChildExecutionScopeFactory as P, AgentToolCall as Pt, AgentConnectionCredentialSource as Q, ToolExecuteArgs as Qt, chatModel as R, AgentToolToken as Rt, ConfigDrivenOffloadPolicy as S, defineNode as Sn, AgentGuardrailConfig as St, NodeExecutor as T, NodeEventPublisher as Tn, AgentMessageConfig as Tt, PersistedRuntimeTypeNameResolver as U, ChatModelFactory as Ut, tool as V, ChatLanguageModelCallOptions as Vt, PersistedRuntimeTypeMetadataStore as W, NodeBackedToolConfigOptions as Wt, InMemoryRunEventBus as X, Tool as Xt, EventPublishingWorkflowExecutionRepository as Y, StructuredOutputOptions as Yt, ConnectionInvocationEventPublisher as Z, ToolConfig as Zt, InMemoryBinaryStorage as _, DefinedNodeCredentialAccessors as _n, c as _t, TestSuiteRunResult as a, CallableToolConfig as an, DefinePollingTriggerPollResult as at, DefaultDrivingScheduler as b, DefinedNodeRunContext as bn, AgentAttachmentRole as bt, PollingRunCycleResult as c, NodeBackedToolConfig as cn, DefinedPollingTriggerConfig as ct, WorkflowRepositoryWebhookTriggerMatcher as d, DefinedNodeRegistry as dn, CollectionColumnBuilder as dt, AgentConfigInspector as en, AgentConnectionNodeDescriptor as et, EngineCompositionDeps as f, DefineBatchNodeOptions as fn, CollectionDefinition as ft, InMemoryRunDataFactory as g, DefinedNodeConfigInput as gn, DefinedCollection as gt, InMemoryWorkflowExecutionRepository as h, DefinedNode as hn, DefineCollectionOptions as ht, TestSuiteOrchestratorEngine as i, CallableToolFactory as in, DefinePollingTriggerPollContext as it, DefaultExecutionContextFactory as j, AgentModelInvocationOptions as jt, InProcessRetryRunner as k, AgentMessageTemplate as kt, PollingTriggerRuntime as l, DefineCredentialOptions as ln, definePollingTrigger as lt, RunSummaryMapper as m, DefineNodeOptions as mn, CollectionIndexDefinition as mt, TestSuiteCaseOutcome as n, AgentToolFactory as nn, DefinePollingTriggerExecuteContext as nt, TestSuiteRunIdFactory as o, CallableToolConfigOptions as on, DefinePollingTriggerTestItemsContext as ot, EngineFactory as p, DefineNodeExecuteArgs as pn, CollectionFieldDefinition as pt, PersistedRuntimeTypeKind as q, NodeBackedToolOutputMapper as qt, TestSuiteOrchestrator as r, CallableToolKindToken as rn, DefinePollingTriggerOptions as rt, PollingRunCycleArgs as s, CallableToolExecuteHandler as sn, DefinedPollingTrigger as st, RunTestSuiteArgs as t, AgentMessageConfigNormalizer as tn, AgentConnectionNodeRole as tt, PollingTriggerStartArgs as u, defineCredential as un, DefinedCollectionRegistry as ut, LocalOnlyScheduler as v, DefinedNodeCredentialBinding as vn, defineCollection as vt, NodeInstanceFactory as w, SystemClock as wn, AgentMessageBuildArgs as wt, InlineDrivingScheduler as x, defineBatchNode as xn, AgentCanvasPresentation as xt, HintOnlyOffloadPolicy as y, DefinedNodeCredentialBindings as yn, callableTool as yt, getPersistedRuntimeTypeMetadata as z, AgentTurnLimitBehavior as zt };
+//# sourceMappingURL=index-DeLl1Tne.d.ts.map