@codemation/core 0.14.0 → 0.15.0

package/dist/{index-CbJdbIHe.d.ts → index-CRv3_pY3.d.ts}

@@ -4,11 +4,6 @@ import { ZodType, z } from "zod";
 import { ReadableStream } from "node:stream/web";
 
 //#region src/contracts/baseTypes.d.ts
-/**
- * Minimal base types that have no dependencies on other contracts.
- * Used by credentialTypes, workflowTypes, and other contract layers
- * to avoid circular dependencies.
- */
 type WorkflowId = string;
 type NodeId = string;
 type OutputPortKey = string;
@@ -17,21 +12,12 @@ type PersistedTokenId = string;
 type NodeConnectionName = string;
 //#endregion
 //#region src/triggers/polling/PollingTriggerDedupWindow.d.ts
-/**
- * Merges processed-ID windows for polling triggers, capping the total to avoid unbounded growth.
- * Plugin code receives an instance of this class via {@link PollingTriggerHandle.dedup}.
- */
 declare class PollingTriggerDedupWindow {
   static readonly defaultCapN = 2000;
   merge(previous: ReadonlyArray<string>, incoming: ReadonlyArray<string>, capN?: number): ReadonlyArray<string>;
 }
 //#endregion
 //#region src/triggers/polling/PollingTriggerLogger.d.ts
-/**
- * Minimal logger surface for the polling-trigger runtime.
- * Hosts supply this via {@link EngineDeps.pollingTriggerLogger};
- * when absent the runtime is silent.
- */
 interface PollingTriggerLogger {
   info(message: string): void;
   warn(message: string): void;
@@ -57,22 +43,11 @@ type CredentialFieldSchema = Readonly<{
   type: "string" | "password" | "textarea" | "json" | "boolean";
   required?: true;
   order?: number;
-  /**
-   * Where this field appears in the credential dialog. Use `"advanced"` for optional or
-   * power-user fields; they render inside a collapsible section (see `CredentialTypeDefinition.advancedSection`).
-   * Defaults to `"default"` when omitted.
-   */
   visibility?: "default" | "advanced";
   placeholder?: string;
   helpText?: string;
-  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
   envVarName?: string;
-  /**
-   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
-   * pattern or documentation URL). Do not use for secret values.
-   */
   copyValue?: string;
-  /** Accessible label for the copy control (default: Copy). */
   copyButtonLabel?: string;
 }>;
 type CredentialRequirement = Readonly<{
@@ -127,20 +102,9 @@ type CredentialOAuth2AuthDefinition = Readonly<{
   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;
@@ -149,11 +113,8 @@ type CredentialOAuth2AuthDefinition = Readonly<{
 }>;
 type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
 type CredentialAdvancedSectionPresentation = Readonly<{
-  /** Collapsible section title (default: "Advanced"). */
   title?: string;
-  /** Optional short helper text shown inside the section (above the fields). */
   description?: string;
-  /** When true, the advanced section starts expanded. Default: false (collapsed). */
   defaultOpen?: boolean;
 }>;
 type CredentialTypeDefinition = Readonly<{
@@ -162,23 +123,11 @@ type CredentialTypeDefinition = Readonly<{
   description?: string;
   publicFields?: ReadonlyArray<CredentialFieldSchema>;
   secretFields?: ReadonlyArray<CredentialFieldSchema>;
-  /**
-   * Optional labels for the collapsible block that contains every field with `visibility: "advanced"`.
-   * If omitted, the UI still shows that block with defaults (title "Advanced", collapsed).
-   */
   advancedSection?: CredentialAdvancedSectionPresentation;
   supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
   auth?: CredentialAuthDefinition;
 }>;
-/**
- * JSON-shaped credential field bag (public config, resolved secret material, etc.).
- */
 type CredentialJsonRecord = Readonly<Record<string, unknown>>;
-/**
- * Persisted credential instance with typed `publicConfig`.
- * Hosts may specialize `secretRef` with a stricter union while remaining
- * assignable here for session/test callbacks.
- */
 type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
   instanceId: CredentialInstanceId;
   typeId: CredentialTypeId;
@@ -190,46 +139,30 @@ type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = Crede
   setupStatus: CredentialSetupStatus;
   createdAt: string;
   updatedAt: string;
-  /**
-   * Pointer to where the credential material bytes live. For OSS / standalone
-   * rows this is `{source: "local", ref: instanceId}` and the bytes co-locate
-   * with the row in the workspace DB. For managed-mode rows this is
-   * `{source: "control-plane", ref: <cp_id>}` and the bytes live at CP.
-   *
-   * The seam is read through `CredentialMaterialProvider`. See
-   * `docs/design/credentials-oauth-unification.md` ("Material provider seam").
-   */
   material: Readonly<{
     source: "local" | "control-plane";
     ref: string;
   }>;
 }>;
-/**
- * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
- * Declare `TPublicConfig` / `TMaterial` on `CredentialType` so implementations are checked
- * against your credential shapes (similar to `NodeExecutionContext.config` for nodes).
- */
 type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
   instance: CredentialInstanceRecord<TPublicConfig>;
   material: TMaterial;
   publicConfig: TPublicConfig;
 }>;
 type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
+type CredentialAccessTokenSessionArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  accessToken: string;
+  grantedScopes: ReadonlyArray<string>;
+  publicConfig: TPublicConfig;
+}>;
+type CredentialAccessTokenSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialAccessTokenSessionArgs<TPublicConfig>) => Promise<TSession>;
 type CredentialHealthTester<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<CredentialHealth>;
-/**
- * Full credential type implementation: `definition` (UI/schema), `createSession`, and `test`.
- * Use this at registration and config boundaries; `CredentialTypeDefinition` is only the schema slice.
- */
 type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = Readonly<{
   definition: CredentialTypeDefinition;
   createSession: CredentialSessionFactory<TPublicConfig, TMaterial, TSession>;
+  createSessionFromAccessToken?: CredentialAccessTokenSessionFactory<TPublicConfig, TSession>;
   test: CredentialHealthTester<TPublicConfig, TMaterial>;
 }>;
-/**
- * Credential type with unspecified generics — used for `CodemationConfig.credentialTypes`, the host registry,
- * and anywhere a concrete `CredentialType<YourPublic, YourMaterial, YourSession>` is placed in a heterogeneous list.
- * Using `any` here avoids unsafe `as` casts while keeping typed `satisfies CredentialType<…>` definitions.
- */
 type AnyCredentialType = CredentialType<any, any, unknown>;
 interface CredentialSessionService {
   getSession<TSession = unknown>(args: Readonly<{
@@ -250,38 +183,22 @@ declare class CredentialUnboundError extends Error {
 }
 //#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;
@@ -294,24 +211,15 @@ interface CollectionStore<TRow extends Record<string, unknown> = Record<string,
     }>;
     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
@@ -364,7 +272,6 @@ declare class NoOpTelemetryArtifactReference {
 //#region src/contracts/NoOpTelemetrySpanScope.d.ts
 declare class NoOpTelemetrySpanScope {
   static readonly value: TelemetrySpanScope;
-  /** Internal: the shared no-op {@link NodeExecutionTelemetry} that {@link NoOpNodeExecutionTelemetry} re-exposes. */
   static readonly nodeExecutionTelemetryValue: NodeExecutionTelemetry;
 }
 //#endregion
@@ -400,25 +307,15 @@ declare class CodemationTelemetryAttributeNames {
   static readonly connectionInvocationId = "codemation.connection.invocation_id";
   static readonly toolName = "codemation.tool.name";
   static readonly traceParentRunId = "codemation.parent.run.id";
-  /** Per-item iteration that emitted this span/metric. Set on spans recorded inside a runnable per-item loop. */
   static readonly iterationId = "codemation.iteration.id";
-  /** Item index (0-based) of the iteration. */
   static readonly iterationIndex = "codemation.iteration.index";
-  /** Set when this span/metric was recorded under a sub-agent triggered by an outer LLM/tool call. */
   static readonly parentInvocationId = "codemation.parent.invocation_id";
-  /** MCP server id on spans created for callTool invocations. */
   static readonly mcpServerId = "mcp.server_id";
-  /** MCP tool name on spans created for callTool invocations. */
   static readonly mcpToolName = "mcp.tool_name";
-  /** Terminal node-execution status (e.g. `"hitl-approved"`, `"hitl-rejected"`) on HITL outcome spans. */
   static readonly nodeExecutionStatus = "codemation.node.execution_status";
-  /** Populated on run-halted spans; discriminates the halt reason (e.g. `"hitl-rejected"`). */
   static readonly runHaltReason = "codemation.run.halt_reason";
-  /** Human task ID on `hitl.task.*` span events. */
   static readonly hitlTaskId = "codemation.hitl.task_id";
-  /** HITL channel name (e.g. `"inbox"`, `"control-plane-inbox"`) on `hitl.task.*` span events. */
   static readonly hitlChannel = "codemation.hitl.channel";
-  /** Decision outcome (e.g. `"approved"`, `"rejected"`) on `hitl.task.decided` span events. */
   static readonly hitlDecisionStatus = "codemation.hitl.decision_status";
 }
 //#endregion
@@ -499,13 +396,6 @@ interface TelemetrySpanScope extends TelemetryScope {
   readonly traceId: string;
   readonly spanId: string;
   end(args?: TelemetrySpanEnd): Promise<void> | void;
-  /**
-   * Lift this span into a {@link NodeExecutionTelemetry} scoped to a different (nodeId, activationId).
-   * Children created via the returned telemetry's `startChildSpan` get this span as their parent.
-   *
-   * Used at the sub-agent boundary so that nested runtime telemetry parents under the agent.tool.call
-   * span instead of the orchestrator's node-level span.
-   */
   asNodeTelemetry(args: Readonly<{
     nodeId: NodeId;
     activationId: NodeActivationId;
@@ -532,14 +422,9 @@ interface ExecutionTelemetryFactory {
 }
 //#endregion
 //#region src/contracts/workflowActivationPolicy.d.ts
-/**
- * Host-controlled policy: when false, trigger {@link TriggerNode} setup is skipped and webhook routes
- * for that workflow are not registered (see engine trigger runtime + webhook matcher).
- */
 interface WorkflowActivationPolicy {
   isActive(workflowId: WorkflowId): boolean;
 }
-/** Default for tests and harnesses: every workflow is treated as active (legacy behavior). */
 declare class AllWorkflowsActiveWorkflowActivationPolicy implements WorkflowActivationPolicy {
   isActive(_workflowId: WorkflowId): boolean;
 }
@@ -554,23 +439,19 @@ interface WebhookControlSignal {
 }
 interface WebhookTriggerRoutingDiagnostics {
   warn(message: string): void;
-  /** Inactive workflows omitted from the webhook route index (optional; host should wire for clarity at boot/reload). */
   info?(message: string): void;
 }
 interface TriggerInstanceId {
   workflowId: WorkflowId;
   nodeId: NodeId;
 }
-/** Match for an incoming HTTP request: user-defined URL segment + workflow trigger node. */
 interface WebhookInvocationMatch {
-  /** Same value as the webhook trigger's configured endpoint key (URL segment under the webhook base path). */
   endpointPath: string;
   workflowId: WorkflowId;
   nodeId: NodeId;
   methods: ReadonlyArray<HttpMethod>;
   parseJsonBody?: (body: unknown) => unknown;
 }
-/** Result of resolving an HTTP method + endpoint path against the catalog webhook index (404 vs 405 vs match). */
 type WebhookTriggerResolution = {
   status: "notFound";
 } | {
@@ -580,9 +461,6 @@ type WebhookTriggerResolution = {
   status: "ok";
   match: WebhookInvocationMatch;
 };
-/**
- * Resolves webhook routes from workflow definitions (catalog-backed index, no registration at trigger setup).
- */
 interface WebhookTriggerMatcher {
   match(args: {
     endpointPath: string;
@@ -591,52 +469,29 @@ interface WebhookTriggerMatcher {
   lookup(endpointPath: string): WebhookInvocationMatch | undefined;
   onEngineWorkflowsLoaded?(): void;
   onEngineStopped?(): void;
-  /** Rebuild route index after activation changes without stopping the engine. */
   reloadWebhookRoutes?(): void;
 }
 //#endregion
 //#region src/contracts/runtimeTypes.d.ts
-/** Opaque unique identifier for a single HumanTask instance. */
 type HumanTaskId = string;
-/**
- * Duration string — ISO 8601 duration ("PT24H") or shorthand ("24h").
- * Parsed by the timeout job; stored as-is in the suspension record.
- */
 type Duration = string;
-/**
- * Minimal handle handed to the `deliver` callback so it can route to the correct
- * inbox channel.
- */
 interface HumanTaskHandle {
   readonly taskId: HumanTaskId;
   readonly runId: string;
   readonly nodeId: string;
   readonly expiresAt: Date;
-  /** TODO: real signed URL; placeholder empty string for now. */
   readonly resumeUrl: string;
-  /**
-   * Arbitrary JSON metadata copied from `SuspensionRequest.request.metadata` at suspension time.
-   * Used by the agent runtime to round-trip the `agentCheckpoint` back to the
-   * resumed node via `ctx.resumeContext.task.metadata`.
-   */
   readonly metadata?: Readonly<Record<string, JsonValue>>;
 }
-/** Human-readable description surface shown to the reviewer. */
 interface HumanTaskSubject {
   readonly title: string;
   readonly summary: string;
   readonly attributes?: JsonValue;
 }
-/** Identity of the person who made a decision on the task. */
 interface HumanTaskActor {
   readonly actorId: string;
   readonly displayName?: string;
 }
-/**
- * Resume context injected into `NodeExecutionContext` when the engine re-activates
- * a previously suspended node. `defineHumanApprovalNode` wraps this with parsed
- * `TDecision`; at the engine layer `decision.value` is `unknown`.
- */
 interface ResumeContext {
   readonly decision: Readonly<{
     kind: "decided";
@@ -653,25 +508,6 @@ interface ResumeContext {
   readonly delivery: JsonValue;
   readonly task: HumanTaskHandle;
 }
-/**
- * Thrown by a node's `execute()` to request durable suspension of the current item.
- * The engine catches this, persists the suspension entry, calls `deliver`, and
- * continues to the next item (per-item semantics).
- *
- * @example
- * ```ts
- * throw new SuspensionRequest({
- *   decisionSchema: z.object({ approved: z.boolean() }),
- *   timeout: "PT24H",
- *   onTimeout: "halt",
- *   subject: { title: "Approve invoice", summary: "Invoice #1234 needs approval" },
- *   deliver: async (handle) => {
- *     await notifySlack(handle);
- *     return { channel: "slack", ts: "..." };
- *   },
- * });
- * ```
- */
 declare class SuspensionRequest<TDecision = unknown, TDelivery extends JsonValue = JsonValue> extends Error {
   readonly request: Readonly<{
     decisionSchema: ZodType<TDecision>;
@@ -735,11 +571,6 @@ interface NodeExecutionStatePublisher {
     error: Error;
   }): Promise<void>;
   appendConnectionInvocation(args: ConnectionInvocationAppendArgs): Promise<void>;
-  /**
-   * Annotates the current snapshot for `nodeId` with the id of the child run spawned by a
-   * SubWorkflow invocation. Called from `SubWorkflowNode.execute` after `runById` resolves.
-   * The engine's subsequent `markCompleted` call preserves the value via `previous.childRunId`.
-   */
   setChildRunId?(args: {
     nodeId: NodeId;
     childRunId: RunId;
@@ -769,9 +600,7 @@ interface BinaryStorage {
   openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
   stat(storageKey: string): Promise<BinaryStorageStatResult>;
   delete(storageKey: string): Promise<void>;
-  /** Deletes multiple objects in bulk. Keys are batched internally. */
   deleteMany(storageKeys: ReadonlyArray<string>): Promise<void>;
-  /** Lists all keys sharing a common prefix. Returns keys in arbitrary order. */
   listByPrefix(prefix: string): Promise<ReadonlyArray<string>>;
 }
 interface BinaryAttachmentCreateRequest {
@@ -785,7 +614,6 @@ interface NodeBinaryAttachmentService extends ExecutionBinaryService {
   attach(args: BinaryAttachmentCreateRequest): Promise<BinaryAttachment>;
   withAttachment<TJson>(item: Item<TJson>, name: string, attachment: BinaryAttachment): Item<TJson>;
 }
-/** Default maximum bytes read into memory by the bounded helpers (50 MiB). */
 declare const BINARY_DEFAULT_MAX_BYTES: number;
 interface ExecutionBinaryService {
   forNode(args: {
@@ -793,32 +621,16 @@ interface ExecutionBinaryService {
     activationId: NodeActivationId;
   }): NodeBinaryAttachmentService;
   openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
-  /**
-   * Reads all bytes from the attachment into a contiguous `Uint8Array`.
-   * Checks `attachment.size` against `maxBytes` *before* any allocation; throws a bounded-read
-   * error when exceeded (no OOM). Throws if the stream is unavailable or the byte count mismatches.
-   */
   getBytes(attachment: BinaryAttachment, maxBytes?: number): Promise<Uint8Array>;
-  /**
-   * Reads the attachment and decodes the bytes as UTF-8 text.
-   * Subject to the same bounded-read safety as `getBytes`.
-   */
   getText(attachment: BinaryAttachment, maxBytes?: number): Promise<string>;
-  /**
-   * Reads the attachment, decodes as UTF-8 text, and parses as JSON.
-   * Throws a clear error on invalid JSON. Subject to the same bounded-read safety.
-   */
   getJson<T = unknown>(attachment: BinaryAttachment, maxBytes?: number): Promise<T>;
 }
 interface ExecutionContext {
   runId: RunId;
   workflowId: WorkflowId;
   parent?: ParentExecutionRef;
-  /** This run's subworkflow depth (0 = root). */
   subworkflowDepth: number;
-  /** Effective activation budget cap for this run (after policy merge). */
   engineMaxNodeActivations: number;
-  /** Effective subworkflow nesting cap for this run (after policy merge). */
   engineMaxSubworkflowDepth: number;
   now: () => Date;
   data: RunDataSnapshot;
@@ -826,28 +638,11 @@ interface ExecutionContext {
   telemetry: ExecutionTelemetry;
   binary: ExecutionBinaryService;
   getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
-  /** Per-item iteration id, set by {@link NodeExecutor} on the ctx passed into runnable `execute`. */
   iterationId?: NodeIterationId;
-  /** Item index (0-based) within the current activation's batch; set alongside {@link iterationId}. */
   itemIndex?: number;
-  /** When set, this ctx is executing inside a sub-agent triggered by the named parent invocation. */
   parentInvocationId?: ConnectionInvocationId;
-  /**
-   * Present iff the run was started by a TestSuiteOrchestrator. The {@link IsTestRunNode}
-   * branches on this; assertion-emitting nodes use it to decide whether to record results.
-   */
   testContext?: RunTestContext;
-  /**
-   * Collections registered in the codemation config, keyed by collection name.
-   */
   readonly collections?: CollectionsContext;
-  /**
-   * Resolve a DI token from the host container.
-   * Allows nodes to reach host-side services (e.g. `InboxChannelResolverToken`)
-   * without importing host code. Wired by `DefaultExecutionContextFactory`; throws
-   * a clear error when no resolver is configured (e.g. in unit tests that don't
-   * set up the full container).
-   */
   resolve<T>(token: TypeToken<T>): T;
 }
 interface ExecutionContextFactory {
@@ -872,18 +667,9 @@ interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase>
   config: TConfig;
   telemetry: NodeExecutionTelemetry;
   binary: NodeBinaryAttachmentService;
-  /**
-   * Present when this node activation is a HITL resume.
-   * The node checks `ctx.resumeContext !== undefined` and takes the resume branch.
-   */
   resumeContext?: ResumeContext;
 }
-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).
-   */
+interface TriggerPollingPort {
   start<TState, TItem>(args: {
     intervalMs: number;
     seedState?: TState;
@@ -895,7 +681,8 @@ interface PollingTriggerHandle {
       nextState: TState;
     }>;
   }): Promise<TState | undefined>;
-  /** Convenience dedup-window helper. */
+}
+interface PollingTriggerHandle extends TriggerPollingPort {
   readonly dedup: PollingTriggerDedupWindow;
 }
 interface TriggerSetupContext<TConfig extends TriggerNodeConfig<any, any> = TriggerNodeConfig<any, any>, TSetupState$1 extends JsonValue | undefined = TriggerNodeSetupState<TConfig>> extends ExecutionContext {
@@ -904,7 +691,6 @@ interface TriggerSetupContext<TConfig extends TriggerNodeConfig<any, any> = Trig
   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 {
@@ -913,11 +699,6 @@ interface TriggerTestItemsContext<TConfig extends TriggerNodeConfig<any, any> =
   config: TConfig;
   previousState: TSetupState$1;
 }
-/**
- * Trigger setup state is intentionally engine-owned so future ownership and
- * leader-election metadata can be coordinated centrally rather than pushed into
- * package-level setup code.
- */
 interface PersistedTriggerSetupState<TState extends JsonValue | undefined = JsonValue | undefined> {
   trigger: TriggerInstanceId;
   updatedAt: string;
@@ -935,12 +716,6 @@ interface EngineHost {
   credentialSessions: CredentialSessionService;
   workflows?: WorkflowRunnerService;
 }
-/**
- * Per-item runnable node: return JSON, an array to fan-out on `main`, an explicit `Item`, or {@link emitPorts}
- * for multi-port emission. Engine applies `inputSchema.parse(item.json)` and passes the result as `args.input`
- * (wire `item.json` is unchanged). Transform helpers may opt into binary preservation, while routers and
- * pass-through nodes should return explicit items when they need to preserve full item state.
- */
 interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown> {
   readonly input: TInputJson$1;
   readonly item: Item;
@@ -950,27 +725,13 @@ interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> =
 }
 interface RunnableNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, _TOutputJson = unknown> {
   readonly kind: "node";
-  /**
-   * Declared output ports (e.g. `["main"]`).
-   *
-   * Prefer describing dynamic router ports (Switch) and fixed multi-ports (If true/false)
-   * via {@link NodeConfigBase.declaredOutputPorts}. Engine defaults to `["main"]` when omitted.
-   */
   readonly outputPorts?: ReadonlyArray<OutputPortKey>;
-  /** When omitted, engine uses {@link RunnableNodeConfig.inputSchema} or `z.unknown()`. */
   readonly inputSchema?: ZodType<TInputJson$1>;
   execute(args: RunnableNodeExecuteArgs<TConfig, TInputJson$1>): Promise<unknown> | unknown;
 }
-/** @deprecated Use {@link RunnableNode} */
 type ItemNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, TOutputJson$1 = unknown> = RunnableNode<TConfig, TInputJson$1, TOutputJson$1>;
 interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
   kind: "node";
-  /**
-   * Declared output ports (typically `["main"]`).
-   *
-   * Prefer describing ports for authoring/canvas via {@link NodeConfigBase.declaredOutputPorts}.
-   * Engine defaults to `["main"]` when omitted.
-   */
   outputPorts?: ReadonlyArray<OutputPortKey>;
   executeMulti(inputsByPort: NodeInputsByPort, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
 }
@@ -1071,7 +832,6 @@ interface WorkflowSnapshotResolver {
     workflowSnapshot?: PersistedWorkflowSnapshot;
   }): WorkflowDefinition | undefined;
 }
-/** Optional host wiring for trigger lifecycle logs (boot skip + activation sync). */
 interface TriggerRuntimeDiagnostics {
   info(message: string): void;
   warn(message: string): void;
@@ -1080,7 +840,6 @@ interface EngineDeps {
   credentialSessions: CredentialSessionService;
   liveWorkflowRepository: LiveWorkflowRepository;
   workflowRepository: WorkflowRepository;
-  /** When {@link AllWorkflowsActiveWorkflowActivationPolicy}, all workflows behave as active (tests). */
   workflowActivationPolicy: WorkflowActivationPolicy;
   nodeResolver: NodeResolver;
   triggerSetupStateRepository: TriggerSetupStateRepository;
@@ -1096,39 +855,27 @@ interface EngineDeps {
   eventBus?: RunEventBus;
   tokenRegistry: PersistedWorkflowTokenRegistryLike;
   workflowNodeInstanceFactory: WorkflowNodeInstanceFactory;
-  /** Defaults for prune/storage snapshot when workflow omits explicit policy fields. */
   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
-/**
- * In-process retry policy for runnable nodes. Serialized configs use the same
- * `kind` discriminator (`JSON.stringify` / persisted workflows).
- *
- * `maxAttempts` is the total number of tries including the first (e.g. 3 means up to 2 delays after failures).
- */
 type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
 interface NoneRetryPolicySpec {
   readonly kind: "none";
 }
 interface FixedRetryPolicySpec {
   readonly kind: "fixed";
-  /** Total attempts including the first execution. Must be >= 1. */
   readonly maxAttempts: number;
   readonly delayMs: number;
 }
 interface ExponentialRetryPolicySpec {
   readonly kind: "exponential";
-  /** Total attempts including the first execution. Must be >= 1. */
   readonly maxAttempts: number;
   readonly initialDelayMs: number;
   readonly multiplier: number;
   readonly maxDelayMs?: number;
-  /** When true, each delay is multiplied by a random factor in [1, 1.2). */
   readonly jitter?: boolean;
 }
 //#endregion
@@ -1143,7 +890,6 @@ interface JsonObject {
 }
 type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 type JsonArray = ReadonlyArray<JsonValue>;
-/** JSON value that is not a top-level array (nested arrays inside objects are allowed). */
 type JsonNonArray = JsonPrimitive | JsonObject;
 interface Edge {
   from: {
@@ -1155,11 +901,6 @@ interface Edge {
     input: InputPortKey;
   };
 }
-/**
- * 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
- * also be connection-owned nodes for recursive agent attachments.
- */
 interface WorkflowNodeConnection {
   readonly parentNodeId: NodeId;
   readonly connectionName: NodeConnectionName;
@@ -1170,18 +911,10 @@ interface WorkflowDefinition {
   name: string;
   nodes: NodeDefinition[];
   edges: Edge[];
-  /**
-   * Optional metadata: which nodes are connection-owned children (e.g. AI agent `llm` / `tools` slots).
-   * When omitted, all nodes in {@link nodes} are treated as executable for topology.
-   */
   readonly connections?: ReadonlyArray<WorkflowNodeConnection>;
-  /** Directory + file-stem path under a workflow discovery root (for UI grouping only). */
   discoveryPathSegments?: readonly string[];
-  /** Retention for run JSON and binaries (seconds). Host/env may supply defaults when omitted. */
   readonly prunePolicy?: WorkflowPrunePolicySpec;
-  /** Whether to keep run data after completion. Host/env may supply defaults when omitted. */
   readonly storagePolicy?: WorkflowStoragePolicySpec;
-  /** Invoked after a node fails permanently (retries exhausted) and node error handler did not recover. */
   readonly workflowErrorHandler?: WorkflowErrorHandlerSpec;
 }
 interface WorkflowGraph {
@@ -1199,59 +932,26 @@ interface NodeConfigBase {
   readonly name?: string;
   readonly id?: NodeId;
   readonly icon?: string;
-  /**
-   * Plain-language, non-technical explanation of what this node does, surfaced in the workflow
-   * inspector / node properties sidebar. A first-class config option every authorable node accepts
-   * directly (alongside `id`), so it flows into the persisted config the mappers read. Distinct from
-   * {@link inspectorSummary} (config-derived label/value rows).
-   */
   readonly description?: string;
   readonly execution?: Readonly<{
     hint?: "local" | "worker";
     queue?: string;
   }>;
-  /** In-process execute retries (runnable nodes). Triggers typically omit this. */
   readonly retryPolicy?: RetryPolicySpec;
-  /** Recover from execute failures; return outputs to continue, or rethrow to fail the node. */
   readonly nodeErrorHandler?: NodeErrorHandlerSpec;
-  /**
-   * When true, edges carrying zero items on an output port still schedule single-input downstream nodes.
-   * Decided from the **source** node that produced the (empty) output. Default (false/undefined): empty
-   * main batches skip downstream execution and propagate the empty path.
-   */
   readonly continueWhenEmptyOutput?: boolean;
-  /**
-   * Declared I/O port names for canvas authoring (unioned with ports inferred from edges).
-   * Use for dynamic routers (Switch) and future error ports.
-   */
   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;
-  /**
-   * Static configuration summary surfaced in the workflow inspector — the design-time
-   * "what does this node do" panel that renders before any run telemetry exists.
-   *
-   * Return 2–6 short label/value pairs derived from this config (method + url for an HTTP
-   * call, model + tool list for an agent, schedule + timezone for a cron trigger, etc.).
-   * Values are truncated by the UI; aim for one line each. Return `undefined` to opt out
-   * — the inspector hides the section when no rows are produced.
-   *
-   * Implement on the config class instance so the function can read sibling config fields.
-   * `defineNode({ inspectorSummary })` plumbs through to this.
-   */
   inspectorSummary?(): ReadonlyArray<NodeInspectorSummaryRow> | undefined;
 }
-/**
- * One row of a node's static configuration summary. See {@link NodeConfigBase.inspectorSummary}.
- */
+interface PollingTriggerConfig {
+  getTriggerPollConfig(): Readonly<{
+    config: JsonObject;
+    pollIntervalMs?: number;
+  }>;
+}
 interface NodeInspectorSummaryRow {
   readonly label: string;
   readonly value: string;
@@ -1259,24 +959,11 @@ interface NodeInspectorSummaryRow {
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
 declare const triggerNodeOutputType: unique symbol;
-/**
- * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
- * **`TOutputJson`** is emitted `item.json` on outputs.
- */
 interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
   readonly kind: "node";
   readonly [runnableNodeInputType]?: TInputJson$1;
   readonly [runnableNodeOutputType]?: TOutputJson$1;
-  /**
-   * Optional Zod input contract for {@link RunnableNode} when not set on the node class.
-   * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
-   */
   readonly inputSchema?: ZodType<TInputJson$1>;
-  /**
-   * When an activation receives **zero** input items, the engine normally runs `execute` zero times.
-   * Set to **`runOnce`** to run `execute` once with an empty `items` batch (and a synthetic wire item for schema parsing).
-   * Used by batch-style callback nodes (built-in `Callback`) so `callback([], ctx)` still runs.
-   */
   readonly emptyBatchExecution?: "skip" | "runOnce";
 }
 declare const triggerNodeSetupStateType: unique symbol;
@@ -1284,11 +971,6 @@ 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;
@@ -1340,27 +1022,14 @@ type Items<TJson = unknown> = ReadonlyArray<Item<TJson>>;
 type NodeOutputs = Partial<Record<OutputPortKey, Items>>;
 type RunId = string;
 type NodeActivationId = string;
-/**
- * One per-item iteration of a runnable node's execute loop. Refines `NodeActivationId` for
- * per-item connection invocations and telemetry. Undefined when the executing node is a batch
- * node or trigger that does not iterate items.
- */
 type NodeIterationId = string;
 interface ParentExecutionRef {
   runId: RunId;
   workflowId: WorkflowId;
   nodeId: NodeId;
-  /** Subworkflow depth of the **spawning** run (0 = root). Passed when starting a child run. */
   subworkflowDepth?: number;
-  /** Effective max node activations from the parent run (propagated to child policy merge). */
   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 {
@@ -1395,7 +1064,6 @@ interface NodeOffloadPolicy {
     config: NodeConfigBase;
   }): NodeSchedulerDecision;
 }
-/** Whether to persist run execution data after the workflow finishes. */
 type WorkflowStoragePolicyMode = "ALL" | "SUCCESS" | "ERROR" | "NEVER";
 type WorkflowStoragePolicySpec = WorkflowStoragePolicyMode | TypeToken<WorkflowStoragePolicyResolver>;
 interface WorkflowStoragePolicyResolver {
@@ -1448,7 +1116,6 @@ interface NodeErrorHandler {
   handle<TConfig extends NodeConfigBase>(args: NodeErrorHandlerArgs<TConfig>): Promise<NodeOutputs>;
 }
 type NodeErrorHandlerSpec = TypeToken<NodeErrorHandler> | NodeErrorHandler;
-/** Runtime defaults when workflow omits prune/storage fields (typically from host env). */
 interface WorkflowPolicyRuntimeDefaults {
   readonly retentionSeconds?: number;
   readonly binaryRetentionSeconds?: number;
@@ -1459,76 +1126,25 @@ interface WorkflowPolicyRuntimeDefaults {
 }
 //#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";
@@ -1642,23 +1258,20 @@ interface EngineExecutionLimitsPolicyConfig {
   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/contracts/triggerInvokerTypes.d.ts
+interface TriggerInvoker {
+  invoke(trigger: TriggerInstanceId, config: TriggerNodeConfig, lastRanAt: string | undefined): Promise<Items>;
+}
+//#endregion
 //#region src/di/CoreTokens.d.ts
 declare const CoreTokens: {
   readonly PersistedWorkflowTokenRegistry: TypeToken<PersistedWorkflowTokenRegistryLike>;
@@ -1679,54 +1292,31 @@ declare const CoreTokens: {
   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>;
-  /**
-   * Optional. When registered, AIAgentNode uses it to resolve mcpServers bindings,
-   * validate scopes, open pool connections, and prepare the MCP ToolSet map.
-   * Not registered in the default core bootstrap — the host provides the implementation.
-   */
   readonly AgentMcpIntegration: TypeToken<AgentMcpIntegration>;
+  readonly TriggerInvoker: TypeToken<TriggerInvoker>;
 };
 //#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;
-  /** Marks runs started from webhook handling so orchestration can apply webhook-specific continuation rules. */
   webhook?: boolean;
   mode?: "manual" | "debug";
   sourceWorkflowId?: WorkflowId;
   sourceRunId?: RunId;
   derivedFromRunId?: RunId;
   isMutable?: boolean;
-  /** Set by the engine for this run: 0 = root, 1 = first child subworkflow, … */
   subworkflowDepth?: number;
-  /** Effective cap after engine policy merge (successful node completions per run). */
   maxNodeActivations?: number;
-  /** Effective cap after engine policy merge (subworkflow nesting). */
   maxSubworkflowDepth?: number;
-  /** Present iff started by a TestSuiteOrchestrator; propagates to subworkflow runs via {@link ParentExecutionRef.testContext}. */
   testContext?: RunTestContext;
 }
-/** Engine-owned counters persisted with the run (worker-safe). */
 interface EngineRunCounters {
   completedNodeActivations: number;
 }
@@ -1751,7 +1341,6 @@ interface PersistedWorkflowSnapshotNode {
   tokenName?: string;
   configTokenName?: string;
   config: unknown;
-  /** Pre-computed static configuration summary; populated by WorkflowSnapshotCodec. */
   inspectorSummary?: ReadonlyArray<Readonly<{
     label: string;
     value: string;
@@ -1762,9 +1351,7 @@ interface PersistedWorkflowSnapshot {
   name: string;
   nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
   edges: ReadonlyArray<Edge>;
-  /** When the snapshot was built from a live workflow definition that configured a workflow error handler. */
   workflowErrorHandlerConfigured?: boolean;
-  /** Connection metadata for child nodes not in the execution graph (e.g. AI agent attachments). */
   connections?: ReadonlyArray<WorkflowNodeConnection>;
 }
 type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
@@ -1812,18 +1399,9 @@ interface NodeExecutionSnapshot {
   inputsByPort?: NodeInputsByPort;
   outputs?: NodeOutputs;
   error?: NodeExecutionError;
-  /**
-   * When the node is a SubWorkflow invocation, the run id of the child run it spawned.
-   * Populated after the child run completes so the UI can deep-link to that specific execution.
-   */
   childRunId?: RunId;
 }
-/** Stable id for a single connection invocation row in {@link ConnectionInvocationRecord}. */
 type ConnectionInvocationId = string;
-/**
- * One logical LLM or tool call under an owning workflow node (e.g. AI agent).
- * The owning node defines what {@link managedInput} and {@link managedOutput} contain.
- */
 interface ConnectionInvocationRecord {
   readonly invocationId: ConnectionInvocationId;
   readonly runId: RunId;
@@ -1834,23 +1412,17 @@ interface ConnectionInvocationRecord {
   readonly status: NodeExecutionStatus;
   readonly managedInput?: JsonValue;
   readonly managedOutput?: JsonValue;
-  /** Short human-readable description of what this invocation is doing right now (e.g. `"calling search_messages"`). Rendered as a sub-line on the canvas node card. */
   readonly statusLabel?: string;
-  /** Stable identifier for the thing this invocation acts on (e.g. an MCP tool name like `"search_messages"`). Persists across status transitions so the inspector can show it on completed/failed entries too. Connection nodes that ARE the tool (e.g. node-backed agent tools) leave this unset — the parent node id already identifies the subject. */
   readonly subjectName?: string;
   readonly error?: NodeExecutionError;
   readonly queuedAt?: string;
   readonly startedAt?: string;
   readonly finishedAt?: string;
   readonly updatedAt: string;
-  /** Per-item iteration id minted by the engine when this invocation occurred inside a runnable node's per-item loop. */
   readonly iterationId?: NodeIterationId;
-  /** Item index (0-based) of the iteration that produced this invocation. */
   readonly itemIndex?: number;
-  /** When set, this invocation was produced inside a sub-agent triggered by the named parent invocation. */
   readonly parentInvocationId?: ConnectionInvocationId;
 }
-/** Arguments for appending a {@link ConnectionInvocationRecord} (engine fills run/workflow ids and timestamps). */
 type ConnectionInvocationAppendArgs = Readonly<{
   invocationId: ConnectionInvocationId;
   connectionNodeId: NodeId;
@@ -1872,7 +1444,6 @@ type ConnectionInvocationAppendArgs = Readonly<{
 interface RunCurrentState {
   outputsByNode: Record<NodeId, NodeOutputs>;
   nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
-  /** Append-only history of connection-scoped invocations (LLM/tool) for inspector and canvas. */
   connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
   mutableState?: PersistedMutableRunState;
 }
@@ -1899,21 +1470,13 @@ interface ExecutionFrontierPlan {
   preservedPinnedNodeIds: ReadonlyArray<NodeId>;
 }
 type RunStatus = "running" | "pending" | "completed" | "failed" | "suspended" | "halted";
-/** Reason a run transitioned to {@link RunStatus} `"halted"`. */
 type RunHaltReason = "hitl-rejected" | "hitl-timeout" | "hitl-cancelled";
 interface RunSummary {
   runId: RunId;
   workflowId: WorkflowId;
   startedAt: string;
   status: RunStatus;
-  /**
-   * Test-case status for runs dispatched as part of a TestSuiteRun. Carries the
-   * assertion-rollup-corrected outcome the test orchestrator persists onto the row, so the
-   * executions list can show "failed" for a run whose workflow completed cleanly but whose
-   * assertions caught regressions. Absent for non-test runs and legacy rows.
-   */
   testCaseStatus?: TestCaseRunStatus;
-  /** ISO timestamp when the run finished (derived from node snapshots or store `updatedAt`); omit while running/pending. */
   finishedAt?: string;
   parent?: ParentExecutionRef;
   executionOptions?: RunExecutionOptions;
@@ -1934,70 +1497,42 @@ interface PersistedRunSchedulingState {
   pending?: PendingNodeExecution;
   queue: RunQueueEntry[];
 }
-/** One persisted suspension entry per suspended item. */
 interface PersistedSuspensionEntry {
-  /** Opaque task identifier (UUID v4). */
   readonly taskId: string;
   readonly nodeId: NodeId;
   readonly activationId: NodeActivationId;
   readonly itemIndex: number;
-  /** SHA-256 hex digest of the decision schema JSON (for schema-drift detection). */
   readonly decisionSchemaHash: string;
-  /** Serialized return value from `SuspensionRequest.deliver` (stored on the HumanTask row). */
   readonly deliveryRef: JsonValue;
-  /** ISO timestamp when the task expires. */
   readonly timeoutAt: string;
   readonly onTimeout: "halt" | "auto-accept";
 }
-/**
- * When a node is re-activated after suspension, the engine writes the resume context here
- * so `NodeExecutionRequestHandlerService` can splice `resumeContext` into ctx.
- * Cleared once the re-activation is consumed.
- */
 interface PendingResumeEntry {
   readonly activationId: NodeActivationId;
   readonly nodeId: NodeId;
-  /**
-   * Typed as `unknown` here to avoid a circular import between runTypes ↔ runtimeTypes.
-   * `NodeExecutionRequestHandlerService` casts this to `ResumeContext` from runtimeTypes.
-   */
   readonly resumeContext: unknown;
 }
 interface PersistedRunState {
   runId: RunId;
   workflowId: WorkflowId;
   startedAt: string;
-  /** Canonical terminal time for listings and retention when persisted on the run root. */
   finishedAt?: string;
-  /** Optimistic concurrency / CAS on the run aggregate (repository may increment on save). */
   revision?: number;
   parent?: ParentExecutionRef;
   executionOptions?: RunExecutionOptions;
   control?: PersistedRunControlState;
   workflowSnapshot?: PersistedWorkflowSnapshot;
   mutableState?: PersistedMutableRunState;
-  /** Frozen at createRun from workflow + runtime defaults for prune/storage decisions. */
   policySnapshot?: PersistedRunPolicySnapshot;
-  /** Successful node completions so far (for activation budget). */
   engineCounters?: EngineRunCounters;
   status: RunStatus;
-  /** Populated when `status === "halted"` to discriminate why the run was halted. */
   reason?: RunHaltReason;
   pending?: PendingNodeExecution;
   queue: RunQueueEntry[];
   outputsByNode: Record<NodeId, NodeOutputs>;
   nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
-  /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
   connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
-  /**
-   * One entry per outstanding HITL suspension (per-item).
-   * Present and non-empty iff `status === "suspended"`.
-   */
   suspension?: ReadonlyArray<PersistedSuspensionEntry>;
-  /**
-   * Written by `resumeRun()` so `NodeExecutionRequestHandlerService` can splice `resumeContext`
-   * into the ctx when re-executing the suspended node. Cleared once consumed.
-   */
   pendingResume?: PendingResumeEntry;
 }
 interface WorkflowExecutionRepository {
@@ -2024,7 +1559,6 @@ interface WorkflowExecutionListingRepository {
     limit?: number;
   }>): Promise<ReadonlyArray<RunSummary>>;
 }
-/** Runs eligible for retention-based pruning (completed or failed, older than cutoff). */
 interface RunPruneCandidate {
   readonly runId: RunId;
   readonly workflowId: WorkflowId;
@@ -2087,42 +1621,13 @@ interface RunEventPublisherDeps {
 }
 //#endregion
 //#region src/contracts/agentMcpTypes.d.ts
-/**
- * Emitted as a span event when a credential is missing required scopes
- * (bind-time) or when callTool returns a permission error (runtime).
- * The credential type id can be looked up from the credential instance when needed.
- */
 interface NeedsReconsentEvent {
   readonly serverId: string;
   readonly credentialInstanceId: string;
   readonly missingScopesHint?: readonly string[];
 }
-/**
- * An opaque MCP tool map: keyed by serverId → (toolName → tool definition).
- * Typed as unknown so core does not depend on the AI SDK's ToolSet type.
- * AIAgentNode (in core-nodes, which does depend on ai) casts this to
- * ReadonlyMap<string, ToolSet> before passing to DeferredMetaToolStrategyFactory.
- */
 type AgentMcpToolMap = ReadonlyMap<string, Readonly<Record<string, unknown>>>;
-/**
- * Contract implemented by the host. Resolves MCP server bindings for an agent run
- * via the standard credential-binding table (one slot per declared server, keyed
- * by `(workflowId, mcpConnectionNodeId, "credential")`), and returns a ready-to-use
- * tool map with wrapped execute callbacks for telemetry and 403 detection.
- * Core-nodes imports this interface so AIAgentNode can inject it without
- * depending on the host.
- */
 interface AgentMcpIntegration {
-  /**
-   * Look up the credential binding per server, validate scopes, open pool
-   * connections, and return a tool map keyed by serverId. Each tool's
-   * execute callback includes:
-   * - Telemetry child span (mcp.server_id, mcp.tool_name attributes)
-   * - 403/permission error detection → emits a NeedsReconsentEvent span event
-   *
-   * Throws `AgentBindError` on validation failures (missing server, unbound
-   * credential slot, missing credential instance, insufficient scopes).
-   */
   prepareMcpTools(args: {
     readonly workflowId: WorkflowId;
     readonly agentNodeId: NodeId;
@@ -2138,93 +1643,63 @@ interface AgentMcpIntegration {
         statusMessage?: string;
       }) => void;
     };
-    /** Per-MCP-tool-call invocation appender. Optional; when omitted the wrapper emits only telemetry spans. */
     readonly appendMcpInvocation?: (args: ConnectionInvocationAppendArgs) => Promise<void>;
-    /** Agent activation id to attach to each invocation record (used by canvas + inspector grouping). */
     readonly parentAgentActivationId?: NodeActivationId;
-    /** Per-item iteration id when the agent runs inside a per-item loop. */
     readonly iterationId?: NodeIterationId;
-    /** Item index (0-based) of the iteration that owns these tool calls. */
     readonly itemIndex?: number;
-    /** Parent invocation id when this agent is itself executing as a sub-agent. */
     readonly parentInvocationId?: ConnectionInvocationId;
   }): Promise<AgentMcpToolMap>;
 }
 //#endregion
+//#region src/contracts/dispatchTypes.d.ts
+type WorkspaceId = string;
+type DispatchBinaryRef = BinaryAttachment;
+interface DispatchItemMeta {
+  readonly id: string;
+  readonly json?: JsonValue;
+  readonly binary?: Readonly<Record<string, DispatchBinaryRef>>;
+}
+interface WorkflowDispatch {
+  readonly runId: RunId;
+  readonly workspaceId: WorkspaceId;
+  readonly workflowId: WorkflowId;
+  readonly triggerNodeId: NodeId;
+  readonly items: ReadonlyArray<DispatchItemMeta>;
+  readonly triggerContext: JsonValue;
+}
+declare function serializeDispatch(dispatch: WorkflowDispatch): string;
+declare function deserializeDispatch(raw: string): WorkflowDispatch;
+//#endregion
 //#region src/contracts/AgentBindError.d.ts
-/**
- * Thrown at agent bind time when mcpServers declarations cannot be resolved.
- * Causes include: unknown server id, missing credential instance, insufficient scopes,
- * and ambiguous shorthand binding (multiple credential instances match).
- */
 declare class AgentBindError extends Error {
   constructor(message: string);
 }
 //#endregion
 //#region src/contracts/NoOpAgentMcpIntegration.d.ts
-/**
- * No-op implementation of AgentMcpIntegration.
- * Registered by the core engine runtime as a fallback when the host does not
- * supply a real implementation (e.g. in unit tests or headless engine setups).
- * Always returns an empty tool map so the agent runs with node-backed tools only.
- */
 declare class NoOpAgentMcpIntegration implements AgentMcpIntegration {
   prepareMcpTools(): Promise<AgentMcpToolMap>;
 }
 //#endregion
 //#region src/contracts/assertionTypes.d.ts
-/**
- * One assertion emitted by an assertion-emitting node (a node whose config sets
- * `emitsAssertions: true`). Each emitted item on `main` carries one of these as `item.json`.
- *
- * Pass/fail is derived from `score >= (passThreshold ?? 0.5)` — see {@link deriveAssertionPassed}.
- * The `errored` marker is for cases where the assertion code itself threw (distinct from
- * "the assertion was evaluated and the score was low") and is treated as a hard fail in rollups
- * regardless of `score`.
- */
 interface AssertionResult {
   readonly name: string;
-  /** 0..1 score. Source of truth for pass/fail (compared against `passThreshold`). */
   readonly score: number;
-  /** 0..1 threshold for "passed". When omitted, consumers default to 0.5. */
   readonly passThreshold?: number;
-  /** True when evaluating the assertion threw — treated as fail regardless of `score`. */
   readonly errored?: true;
-  /** What the assertion expected. Free-form JSON; UIs render with a JSON viewer. */
   readonly expected?: JsonValue;
-  /** What the workflow actually produced. */
   readonly actual?: JsonValue;
-  /** Short human-readable explanation, especially for fails / errors. */
   readonly message?: string;
-  /** Bag of supplemental fields (e.g. judge prompt, judge raw response, comparison method). */
   readonly details?: Readonly<Record<string, JsonValue>>;
 }
-/**
- * Default {@link AssertionResult.passThreshold} when authors omit it. Boolean-style assertions
- * (assertEqual / contains / etc.) emit `score: 1` or `score: 0` so this default works for them;
- * AI-judge assertions are expected to set their own threshold.
- */
 declare const DEFAULT_ASSERTION_PASS_THRESHOLD = 0.5;
-/**
- * Derive whether an assertion result is considered "passing" using the score-based contract:
- * `errored` always fails, otherwise `score >= (passThreshold ?? 0.5)`. This is the canonical
- * derivation — UI and rollup code should call it rather than inlining the comparison so future
- * tweaks (e.g. NaN handling) land in one place.
- */
 declare function deriveAssertionPassed(result: {
   readonly score: number;
   readonly passThreshold?: number;
   readonly errored?: true;
 }): boolean;
-/**
- * Provenance for a persisted {@link AssertionResult}: which node produced it and where in the
- * per-item iteration tree it landed. Filled in by the host-side persister, not the node itself.
- */
 interface AssertionResultProvenance {
   readonly nodeId: NodeId;
-  /** Per-item iteration id when the emitting node ran inside a per-item loop. */
   readonly iterationId?: string;
-  /** Item index (0-based) within the activation that produced this assertion. */
   readonly itemIndex?: number;
 }
 //#endregion
@@ -2236,9 +1711,6 @@ type ItemExprResolvedContext = Readonly<{
   activationId: NodeActivationId;
   data: RunDataSnapshot;
 }>;
-/**
- * Context aligned with former {@link ItemInputMapperContext} — use **`data`** to read any completed upstream node.
- */
 type ItemExprContext = ItemExprResolvedContext;
 type ItemExprArgs<TItemJson = unknown> = Readonly<{
   item: Item<TItemJson>;
@@ -2253,13 +1725,7 @@ type ItemExpr<T, TItemJson = unknown> = Readonly<{
 }>;
 declare function itemExpr<T, TItemJson = unknown>(fn: ItemExprCallback<T, TItemJson>): ItemExpr<T, TItemJson>;
 declare function isItemExpr<T, TItemJson = unknown>(value: unknown): value is ItemExpr<T, TItemJson>;
-/**
- * Deep-resolves {@link itemExpr} leaves. Returns a new graph (does not mutate the original config object).
- */
 declare function resolveItemExprsInUnknown(value: unknown, args: ItemExprArgs, seen?: WeakSet<object>): Promise<unknown>;
-/**
- * Clones runnable config (best-effort) so per-item {@link itemExpr} resolution never mutates shared instances.
- */
 declare function resolveItemExprsForExecution(config: unknown, nodeCtx: NodeExecutionContext, item: Item, itemIndex: number, items: Items): Promise<unknown | undefined>;
 //#endregion
 //#region src/contracts/params.d.ts
@@ -2283,23 +1749,15 @@ interface CostCatalog {
 }
 //#endregion
 //#region src/contracts/executionPersistenceContracts.d.ts
-/** Canonical id for persisted execution rows (activation or connection invocation). */
 type ExecutionInstanceId = string;
-/** Stable id for persisted work-queue rows. */
 type WorkItemId = string;
-/** Batch grouping for planner activations. */
 type BatchId = string;
-/** Optimistic concurrency on the run root. */
 type RunRevision = number;
 type PersistedRunWorkItemKind = "queue" | "pending";
 type WorkItemStatus = "queued" | "claimed" | "completed" | "failed" | "cancelled";
 type PersistedExecutionInstanceKind = "workflowNodeActivation" | "connectionInvocation";
 type ConnectionInvocationKind = "languageModel" | "tool" | "nestedAgent";
 type PayloadStorageKind = "inline" | "external" | "omitted";
-/**
- * Persisted run-work-queue row (queue entry or pending activation).
- * Serialized to {@link RunWorkItem} in Prisma; engine still uses {@link PersistedRunState} queue + pending.
- */
 interface PersistedRunWorkItemRecord {
   readonly workItemId: WorkItemId;
   readonly runId: RunId;
@@ -2318,13 +1776,9 @@ interface PersistedRunWorkItemRecord {
   readonly sourceInstanceId?: ExecutionInstanceId;
   readonly parentInstanceId?: ExecutionInstanceId;
   readonly itemsIn: number;
-  /** Queue entry when kind is queue; pending activation when kind is pending. */
   readonly payloadJson: string;
   readonly error?: Readonly<NodeExecutionError>;
 }
-/**
- * Payload policy fields for large-batch externalization (optional on first rollout).
- */
 interface ExecutionPayloadPolicyFields {
   readonly inputStorageKind: PayloadStorageKind;
   readonly outputStorageKind: PayloadStorageKind;
@@ -2337,9 +1791,6 @@ interface ExecutionPayloadPolicyFields {
   readonly inputTruncated?: boolean;
   readonly outputTruncated?: boolean;
 }
-/**
- * One persisted execution row (workflow node activation or connection invocation).
- */
 interface PersistedExecutionInstanceRecord {
   readonly instanceId: ExecutionInstanceId;
   readonly runId: RunId;
@@ -2374,9 +1825,6 @@ interface PersistedExecutionInstanceRecord {
   readonly usedPinnedOutput?: boolean;
   readonly payloadPolicy?: ExecutionPayloadPolicyFields;
 }
-/**
- * Cached slot projection for planner/debugger/UI (not canonical history).
- */
 interface RunSlotProjectionState {
   readonly runId: RunId;
   readonly workflowId: WorkflowId;
@@ -2409,12 +1857,6 @@ interface WorkflowRunDetailDto {
   readonly executionInstances: ReadonlyArray<ExecutionInstanceDto>;
   readonly iterations?: ReadonlyArray<RunIterationDto>;
 }
-/**
- * Per-item iteration projected from connection invocations and node activations.
- *
- * One iteration = one item processed by an agent within an activation. Multiple invocations
- * (LLM rounds, tool calls) belonging to the same iteration share the iterationId.
- */
 interface RunIterationDto {
   readonly iterationId: string;
   readonly agentNodeId: NodeId;
@@ -2426,9 +1868,7 @@ interface RunIterationDto {
   readonly finishedAt?: string;
   readonly invocationIds: ReadonlyArray<string>;
   readonly parentInvocationId?: string;
-  /** Estimated cost rolled up from telemetry cost metric points, keyed by ISO currency code (e.g. "USD"). Values are minor units (cents-of-cents per the metric's `cost.currency_scale`). */
   readonly estimatedCostMinorByCurrency?: Readonly<Record<string, number>>;
-  /** Currency scale (denominator) per currency, when present on the metric points. Joined with `estimatedCostMinorByCurrency` to format human-readable amounts. */
   readonly estimatedCostCurrencyScaleByCurrency?: Readonly<Record<string, number>>;
 }
 interface SlotExecutionStateDto {
@@ -2458,16 +1898,9 @@ interface ExecutionInstanceDto {
   readonly inputJson?: JsonValue;
   readonly outputJson?: JsonValue;
   readonly error?: Readonly<NodeExecutionError>;
-  /** Per-item iteration that produced this instance. Set on connectionInvocation rows produced inside per-item runnable loops. */
   readonly iterationId?: string;
-  /** Item index (0-based) of the iteration. */
   readonly itemIndex?: number;
-  /** Parent invocation id when this instance was emitted by a sub-agent triggered by an outer LLM/tool call. */
   readonly parentInvocationId?: string;
-  /**
-   * When this instance is a SubWorkflow node activation, the run id of the child run it spawned.
-   * Used by the UI to deep-link directly to the child execution.
-   */
   readonly childRunId?: string;
 }
 interface WorkflowDetailSelectionState {
@@ -2475,32 +1908,60 @@ interface WorkflowDetailSelectionState {
   readonly selectedInstanceId: ExecutionInstanceId | null;
 }
 //#endregion
+//#region src/contracts/deploymentManifestTypes.d.ts
+declare const DEPLOYMENT_MANIFEST_SCHEMA_VERSION: 2;
+type DeploymentManifestSchemaVersion = typeof DEPLOYMENT_MANIFEST_SCHEMA_VERSION;
+type ManifestTriggerConfig = Readonly<{
+  nodeId: NodeId;
+  triggerKind: "live" | "test";
+  config: JsonObject;
+  pollIntervalMs?: number;
+  nodeTypeId?: string;
+}>;
+type ManifestNodeCredentialShape = Readonly<{
+  nodeId: NodeId;
+  requirements: ReadonlyArray<CredentialRequirement>;
+}>;
+type WorkflowDeploymentManifest<TCanvas = JsonObject> = Readonly<{
+  manifestId: string;
+  schemaVersion: DeploymentManifestSchemaVersion;
+  workflowId: WorkflowId;
+  canvas: TCanvas;
+  snapshot: PersistedWorkflowSnapshot;
+  triggers: ReadonlyArray<ManifestTriggerConfig>;
+  credentialShapes: ReadonlyArray<ManifestNodeCredentialShape>;
+}>;
+declare function serializeManifest<TCanvas>(manifest: WorkflowDeploymentManifest<TCanvas>): string;
+declare function deserializeManifest<TCanvas = JsonObject>(raw: string): WorkflowDeploymentManifest<TCanvas>;
+type ManifestCanvasNode = Readonly<{
+  id: NodeId;
+  kind: string;
+  name: string | undefined;
+  type?: string;
+  role?: string;
+  triggerKind?: "live" | "test";
+  declaredOutputPorts?: ReadonlyArray<string>;
+  declaredInputPorts?: ReadonlyArray<string>;
+}>;
+type ManifestCanvas = Readonly<{
+  id: WorkflowId;
+  name: string;
+  nodes: ReadonlyArray<ManifestCanvasNode>;
+  edges: WorkflowDefinition["edges"];
+}>;
+declare function emitWorkflowManifest(workflow: WorkflowDefinition): WorkflowDeploymentManifest<ManifestCanvas>;
+//#endregion
 //#region src/contracts/mcpTypes.d.ts
 type McpServerTransport = "http";
 interface McpServerDeclaration {
-  /** Globally unique slug, e.g. "gmail". Workflow authors reference this. */
   id: string;
   displayName: string;
   description: string;
   transport: McpServerTransport;
   url: string;
-  /**
-   * Credential types accepted by this MCP server, matching CredentialRequirement.acceptedTypes.
-   * Absent or empty means no credential is required.
-   */
   acceptedCredentialTypes?: ReadonlyArray<string>;
-  /**
-   * Documentation only in MVP. The bind-time validator checks
-   * requiredScopes ⊆ CredentialInstance.scopesGranted.
-   */
   requiredScopes?: string[];
-  /** Non-secret static headers merged onto every MCP request. */
   staticHeaders?: Record<string, string>;
-  /**
-   * Overrides for tool descriptions advertised by the MCP server.
-   * Applied by the connection pool after tools/list.
-   * Key: exact tool name as returned by the server.
-   */
   toolDescriptionOverrides?: Record<string, string>;
 }
 //#endregion
@@ -2517,9 +1978,6 @@ declare function isUnbrandedPortsEmissionShape(value: unknown): value is Readonl
 }>;
 //#endregion
 //#region src/contracts/itemMeta.d.ts
-/**
- * Reads `meta._cm.originIndex` when present (used for fan-in merge-by-origin and Merge routing).
- */
 declare function getOriginIndexFromItem(item: Item): number | undefined;
 //#endregion
 //#region src/contracts/NoRetryPolicy.d.ts
@@ -2533,9 +1991,7 @@ declare class RetryPolicy implements FixedRetryPolicySpec {
   readonly delayMs: number;
   readonly kind: "fixed";
   constructor(maxAttempts: number, delayMs: number);
-  /** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
   static readonly defaultForHttp: FixedRetryPolicySpec;
-  /** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
   static readonly defaultForAiAgent: FixedRetryPolicySpec;
 }
 //#endregion
@@ -2565,26 +2021,11 @@ declare class NoOpCostTrackingTelemetryFactory implements CostTrackingTelemetryF
 //#endregion
 //#region src/contracts/runFinishedAtFactory.d.ts
 type RunFinishedAtSource = Pick<PersistedRunState, "status" | "nodeSnapshotsByNodeId" | "finishedAt">;
-/** Derives workflow end time from persisted run root or node snapshots for run listings. */
 declare class RunFinishedAtFactory {
   static resolveIso(state: RunFinishedAtSource): string | undefined;
 }
 //#endregion
 //#region src/authoring/nodeBaseOptions.types.d.ts
-/**
- * Core-local copy of the per-instance authoring options every `define*` factory's `create(...)`
- * accepts in its trailing argument: a stable `id` plus a plain-language `description` (the
- * non-technical "what does this step do" line surfaced in the node sidebar).
- *
- * `description` is a first-class option — passed inline exactly like `id` — and is threaded onto
- * the config instance as an OWN ENUMERABLE field so it flows into the persisted workflow snapshot
- * (`WorkflowSnapshotCodec` serializes via `JSON.parse(JSON.stringify(config))`, which only captures
- * own enumerable properties — never a getter).
- *
- * `@codemation/core-nodes` declares an identical `NodeBaseOptions` for its bare-id built-in nodes;
- * core keeps its own copy because core must not depend on `@codemation/core-nodes` (dependency
- * direction). The two types are structurally identical by design.
- */
 interface NodeBaseOptions {
   readonly id?: string;
   readonly description?: string;
@@ -2611,10 +2052,6 @@ interface DefinedNodeRunContext<TConfig extends CredentialJsonRecord, TBindings
   readonly credentials: DefinedNodeCredentialAccessors<TBindings>;
   readonly execution: NodeExecutionContext<RunnableNodeConfig<TConfig, unknown>>;
 }
-/**
- * Arguments for {@link defineNode} `execute` (engine `ctx` matches {@link RunnableNode.execute};
- * the second callback parameter adds {@link DefinedNodeRunContext} for credential accessors).
- */
 type DefineNodeExecuteArgs<TConfig extends CredentialJsonRecord, TInputJson$1> = Readonly<{
   input: TInputJson$1;
   item: Item;
@@ -2635,42 +2072,21 @@ interface DefinedNode<TKey$1 extends string, TConfig extends CredentialJsonRecor
     registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
   }): void;
 }
-/**
- * Plugin / DSL-friendly node: per-item `execute` with optional {@link RunnableNodeConfig.inputSchema}.
- */
 interface DefineNodeOptions<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
   readonly key: TKey$1;
   readonly title: string;
   readonly description?: string;
-  /**
-   * Canvas icon for this node (same contract as `NodeConfigBase.icon` on runnable configs).
-   * The Next host resolves Lucide (`lucide:…`), built-in SVGs (`builtin:…`), Simple Icons (`si:…`), and image URLs (`https:`, `data:`, `/…`).
-   */
   readonly icon?: string;
-  /** Default values / form hints for **static** node configuration (credentials, retry, IDs), not per-item payload. */
   readonly input?: Readonly<Record<keyof TConfig & string, unknown>>;
   readonly configSchema?: z.ZodType<TConfig>;
   readonly credentials?: TBindings;
-  /**
-   * Validates **`input`** (engine also accepts `inputSchema` on the node class).
-   */
   readonly inputSchema?: ZodType<TInputJson$1>;
-  /** Preserve inbound `item.binary` when `execute` returns plain JSON or item-shaped results without `binary`. */
   readonly keepBinaries?: boolean;
-  /**
-   * Static configuration summary surfaced in the workflow inspector — see
-   * {@link import("../contracts/workflowTypes").NodeConfigBase.inspectorSummary}.
-   *
-   * Receives the static config; returns 2–6 short label/value pairs (or `undefined` to skip).
-   */
   readonly inspectorSummary?: (args: Readonly<{
     config: TConfig;
   }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
   execute(args: DefineNodeExecuteArgs<TConfig, TInputJson$1>, context: DefinedNodeRunContext<TConfig, TBindings>): MaybePromise<TOutputJson$1>;
 }
-/**
- * Batch-oriented defined node: `run` receives all item JSON once (last item in activation); emits one output per input row.
- */
 interface DefineBatchNodeOptions<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
   readonly key: TKey$1;
   readonly title: string;
@@ -2688,103 +2104,22 @@ declare function defineNode<TKey$1 extends string, TConfig extends CredentialJso
 declare function defineBatchNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineBatchNodeOptions<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>): DefinedNode<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>;
 //#endregion
 //#region src/authoring/defineHumanApprovalNode.types.d.ts
-/**
- * Decision shape merged into `item.json` after a HITL approval task resolves.
- *
- * - `"approved"` / `"rejected"` — from a human decision (uses `approvedPredicate`).
- * - `"timed-out"` — timeout fired with `onTimeout: "halt"`.
- * - `"auto-accepted"` — timeout fired with `onTimeout: "auto-accept"`.
- */
 interface HumanApprovalDecisionResult {
   readonly status: "approved" | "rejected" | "timed-out" | "auto-accepted";
-  /** Identity of the person who decided; absent for automated outcomes. */
   readonly actor?: HumanTaskActor;
-  /** ISO 8601 timestamp of the decision. */
   readonly decidedAt?: Date;
-  /** Optional free-text note from the reviewer. */
   readonly note?: string;
-  /**
-   * Full raw decision payload (only present for `"approved"` / `"rejected"`).
-   * Shape is determined by the channel's `decisionSchema`.
-   */
   readonly payload?: Record<string, unknown>;
 }
-/**
- * Output item shape emitted by a `defineHumanApprovalNode`-based node.
- * Original `item.json` fields are preserved and `decision` is merged in.
- * If the input `item.json` already contained a `decision` key it is **overwritten**.
- */
 type HumanApprovalOutputJson<TInputJson$1 extends Record<string, unknown>> = TInputJson$1 & {
   readonly decision: HumanApprovalDecisionResult;
 };
-/**
- * Extends {@link DefinedNode} with the `humanApprovalToolBehavior` metadata marker.
- * Story 10 reads this field when attaching the node as an agent tool.
- */
 interface DefinedHumanApprovalNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1 extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> extends DefinedNode<TKey$1, TConfig, TInputJson$1, HumanApprovalOutputJson<TInputJson$1>, TBindings> {
-  /**
-   * Behavior hint consumed by the agent runtime (story 10) when this node is attached as a tool.
-   * `"return"` (default) — return the rejection to the agent as a tool result.
-   * `"halt"` — halt the agent run on rejection.
-   *
-   * Standalone DSL usage ignores this field.
-   */
   readonly humanApprovalToolBehavior: {
     onRejected: "return" | "halt";
   };
 }
-/**
- * Returns `true` when `node` was created by {@link defineHumanApprovalNode}.
- * Uses the `humanApprovalToolBehavior` typed field as the discriminant.
- */
 declare function isHumanApprovalNode(node: unknown): node is DefinedHumanApprovalNode<string, Record<string, unknown>, Record<string, unknown>, undefined>;
-/**
- * Authoring helper that compiles a HITL approval channel down to a regular
- * {@link defineNode}-backed node with `SuspensionRequest` semantics.
- *
- * **Fast-forward decision semantics:**
- * - On the first `execute` call (no `ctx.resumeContext`): throws a `SuspensionRequest`
- *   that calls the author's `deliver`. The engine persists the suspension and continues.
- * - On resume (`ctx.resumeContext` set): calls `onDecision`/`onTimeout` as appropriate,
- *   merges a `decision` key into `item.json`, and returns an item with the original
- *   `binary` map passed by reference (no copy).
- *
- * **Output shape per item:**
- * ```ts
- * // Input:  { json: { invoiceId: 42 }, binary?: {...} }
- * // Output: { json: { invoiceId: 42, decision: { status: "approved", actor, decidedAt } }, binary: <unchanged> }
- * ```
- * If `item.json` already has a `decision` key it is **overwritten**. Namespace as
- * needed if your schema reserves that key for another purpose.
- *
- * **Predicate persistence:**
- * The `approvedPredicate` function is NOT serialized to the suspension record (except
- * as an audit-only string via `toString()`). On resume, the workflow definition is
- * reloaded from code at process start and the predicate closure is rebuilt naturally.
- * If a deploy ships a changed predicate between suspend and resume, the *new* predicate
- * runs — document this in your runbook when the predicate carries business logic that
- * may change across deploys.
- *
- * @example
- * ```ts
- * export const slackApprovalNode = defineHumanApprovalNode({
- *   key: "my-plugin.slackApproval",
- *   title: "Slack Approval",
- *   channel: "slack",
- *   configSchema: z.object({ channel: z.string(), message: z.string() }),
- *   decisionSchema: z.object({ approved: z.boolean(), note: z.string().optional() }),
- *
- *   async deliver({ task, config, item }, ctx) {
- *     const ts = await postSlackMessage(config.channel, `Approve? <${task.resumeUrl}>`);
- *     return { channel: config.channel, ts };
- *   },
- *
- *   async onDecision({ decision, actor, delivery }, ctx) {
- *     await updateSlackMessage(delivery.channel, delivery.ts, decision.approved ? "✅" : "❌");
- *   },
- * });
- * ```
- */
 declare function defineHumanApprovalNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1 extends Record<string, unknown>, TDecision extends Record<string, unknown>, TDelivery extends JsonValue, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(opts: {
   key: TKey$1;
   title: string;
@@ -2795,16 +2130,8 @@ declare function defineHumanApprovalNode<TKey$1 extends string, TConfig extends
   inputSchema?: ZodType<TInputJson$1>;
   decisionSchema: ZodType<TDecision>;
   credentials?: TBindings;
-  /**
-   * Custom predicate that decides whether a decision counts as "approved".
-   * When omitted, the helper checks if `decisionSchema` is a Zod object with an
-   * `approved: boolean` field; if so it uses `decision.approved === true`.
-   * If neither holds, `defineHumanApprovalNode` throws at **definition time** (not runtime).
-   */
   approvedPredicate?: (decision: TDecision) => boolean;
-  /** Default suspension timeout. Defaults to `"24h"`. */
   defaultTimeout?: Duration;
-  /** What to do when the task times out. Defaults to `"halt"`. */
   defaultOnTimeout?: "halt" | "auto-accept";
   inspectorSummary?: (config: TConfig) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
   deliver: (args: {
@@ -2829,30 +2156,6 @@ declare function defineHumanApprovalNode<TKey$1 extends string, TConfig extends
 }): DefinedHumanApprovalNode<TKey$1, TConfig, TInputJson$1, TBindings>;
 //#endregion
 //#region src/workflow/dsl/workflowBuilderTypes.d.ts
-/**
- * Flags a node's config so its output is MERGED onto `item.json` (shallow, output-wins) instead of
- * replacing it — the config-level twin of {@link ChainCursor.thenMerge}.
- *
- * Unlike `.thenMerge` (a cursor method that only works on the trunk), `mergeForward` operates on a
- * bare config, so it is usable in ANY position — including inside a `.when({ true: [...] })` branch
- * arm, where the steps are a flat array of configs (not a cursor). Wrap a payload-REPLACING node
- * (e.g. an extractor) in `mergeForward(node.create(...))` so prior fields survive into the next step.
- *
- * The OUTPUT type becomes `TIn & TOut` (the intersection), mirroring `.thenMerge`'s return type at
- * the config level — so the next step in the branch array sees both the prior fields and the node's
- * output. The INPUT type stays `TIn` (the node still receives the pre-merge item).
- *
- * @example
- * ```ts
- * workflow
- *   .trigger(...)
- *   .when({
- *     true: [mergeForward(extractor.create(...))], // output merges onto item.json; { a } survives
- *     false: [...],
- *   })
- *   .build();
- * ```
- */
 declare function mergeForward<TIn, TOut>(config: RunnableNodeConfig<TIn, TOut>): RunnableNodeConfig<TIn, TIn & TOut>;
 type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
 type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
@@ -2868,7 +2171,6 @@ type BooleanWhenOverloads<TCurrentJson, TReturn> = {
 };
 //#endregion
 //#region src/workflow/dsl/WhenBuilder.d.ts
-/** Structurally identical to ChainCursorResolver's (unexported) ChainCursorEndpoint. */
 type WhenEndpoint = Readonly<{
   node: NodeRef;
   output: OutputPortKey;
@@ -2878,32 +2180,17 @@ declare class WhenBuilder<TCurrentJson> {
   private readonly wf;
   private readonly from;
   private readonly branchPort;
-  /** Tails of arms added by earlier `.when(...)` calls in this chain. */
   private readonly priorEndpoints;
-  /** Tail endpoint of the arm this builder added (set by addBranch). */
   private armEndpoint;
-  constructor(wf: WorkflowBuilder, from: NodeRef, branchPort: OutputPortKey, /** Tails of arms added by earlier `.when(...)` calls in this chain. */
-  priorEndpoints?: ReadonlyArray<WhenEndpoint>);
+  constructor(wf: WorkflowBuilder, from: NodeRef, branchPort: OutputPortKey, priorEndpoints?: ReadonlyArray<WhenEndpoint>);
   addBranch<TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(steps: TSteps & ValidStepSequence<TCurrentJson, TSteps>): this;
   readonly when: BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>>;
-  /**
-   * Continue the trunk after a boolean `.when(...)` branch chain, auto-merging EVERY branch
-   * tail accumulated across the chain into the next node — the same fan-in the object form
-   * produces. Typed as `ChainCursor<TCurrentJson>` (the pre-branch item type): boolean arms
-   * carry no output guard so the merged item type is underdetermined — use the object form
-   * `.when({ true: [...], false: [...] })` when you need a precise merged type inline.
-   */
   then<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
-  /**
-   * Chainable human-approval step after a boolean `.when(...)` branch chain — merges every
-   * branch tail into the approval node. Mirrors `ChainCursor.humanApproval`.
-   */
   humanApproval<TKey$1 extends string, TConfig extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(node: DefinedHumanApprovalNode<TKey$1, TConfig, TCurrentJson & Record<string, unknown>, TBindings>, config: TConfig, metadata?: {
     name?: string;
     nodeId?: string;
   }): ChainCursor<HumanApprovalOutputJson<TCurrentJson & Record<string, unknown>>>;
   build(): WorkflowDefinition;
-  /** Endpoints of every arm added so far in this chain (prior arms + this one). */
   private get accumulatedEndpoints();
   private toCursor;
 }
@@ -2925,30 +2212,10 @@ declare class ChainCursor<TCurrentJson> {
   private readonly endpoints;
   constructor(wf: WorkflowBuilder, endpoints: ReadonlyArray<ChainCursorEndpoint>);
   then<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
-  /**
-   * Append a step whose output is MERGED onto `item.json` (shallow, output-wins) instead of
-   * replacing it — so earlier fields (e.g. trigger metadata) survive a transform/OCR/extraction
-   * node. Use for any node in a pipeline where you need data from before it.
-   */
   thenMerge<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<TCurrentJson & RunnableNodeOutputJson<TConfig>>;
   thenIntoInputHints<TOutputJson$1, TConfig extends RunnableNodeConfig<any, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
   readonly when: ChainCursorWhenOverloads<TCurrentJson>;
   route<TNextJson$1>(branches: Readonly<Record<OutputPortKey, (branch: ChainCursor<TCurrentJson>) => ChainCursor<TNextJson$1> | undefined>>): ChainCursor<TNextJson$1>;
-  /**
-   * Chainable shorthand for `.then(node.create(config, metadata?.name, metadata?.nodeId))`.
-   *
-   * Signals to readers that this step suspends the run and waits for a human decision.
-   * Throws at workflow-build time if `node` was not created via `defineHumanApprovalNode`.
-   *
-   * @example
-   * ```ts
-   * workflow
-   *   .trigger(...)
-   *   .humanApproval(inboxApproval, { title: "Approve?", body: "...", priority: "normal" })
-   *   .then(nextStep.create(...))
-   *   .build();
-   * ```
-   */
   humanApproval<TKey$1 extends string, TConfig extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(node: DefinedHumanApprovalNode<TKey$1, TConfig, TCurrentJson & Record<string, unknown>, TBindings>, config: TConfig, metadata?: {
     name?: string;
     nodeId?: string;
@@ -2976,51 +2243,22 @@ declare class WorkflowBuilder {
 }
 //#endregion
 //#region src/workflow/dsl/WorkflowDefinitionError.d.ts
-/**
- * Thrown by {@link WorkflowBuilder.build} when the workflow definition is structurally invalid.
- *
- * Common causes:
- * - A node has an empty effective id (label is blank and no explicit `id` was given).
- * - Two or more nodes share the same effective id (label slugs collide or explicit ids clash).
- *
- * Fix: provide an explicit `id:` on the offending node configs.
- */
 declare class WorkflowDefinitionError extends Error {
   constructor(message: string);
 }
 //#endregion
 //#region src/workflow/dsl/NodeIdSlugifier.d.ts
-/**
- * Converts a human-readable node label into a stable, URL-safe identifier segment.
- *
- * Rules:
- * - Lowercase the entire string.
- * - Replace every run of characters outside `[a-z0-9]` with a single `-`.
- * - Strip any leading or trailing `-` characters.
- * - Return `""` for blank/empty input.
- */
 declare const NodeIdSlugifier: {
   slugify(label: string): string;
 };
 //#endregion
 //#region src/workflow/definition/ConnectionInvocationIdFactory.d.ts
-/**
- * Unique ids for persisted connection invocation history rows (LLM/tool calls under an owning node).
- *
- * Uses Web Crypto's `randomUUID` so this module is safe in browser-bundle contexts —
- * paired with `NodeIterationIdFactory` which had the same `node:crypto` regression.
- */
 declare class ConnectionInvocationIdFactory {
   static create(): string;
-  /** Deterministic id for tests when a stable sequence is needed. */
   static createForTest(runId: string, connectionNodeId: NodeId, sequence: number): string;
 }
 //#endregion
 //#region src/workflow/definition/ConnectionNodeIdFactory.d.ts
-/**
- * Deterministic ids for workflow connection-owned child nodes (LLM slot, tools, etc.).
- * These are stable across loads.
- */
 declare class ConnectionNodeIdFactory {
   static readonly connectionSegment: "__conn__";
   static languageModelConnectionNodeId(parentNodeId: NodeId): NodeId;
@@ -3040,36 +2278,18 @@ declare class ConnectionNodeIdFactory {
     parentNodeId: NodeId;
     normalizedToolName: string;
   }> | undefined;
-  /** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
   static isConnectionOwnedDescendantOf(parentNodeId: NodeId, nodeId: NodeId): boolean;
-  /** Normalizes a tool display name to a stable id segment. */
   static normalizeToolName(toolName: string): string;
 }
 //#endregion
 //#region src/workflow/definition/NodeIterationIdFactory.d.ts
-/**
- * Unique ids for one per-item iteration of a runnable node's execute loop.
- *
- * Activations are per-batch (one scheduled execution of a node, possibly with N items).
- * Iterations refine that to one identifier per item-index inside the batch loop, so per-item
- * connection invocations and telemetry can be grouped without time-window heuristics.
- *
- * Uses Web Crypto's `randomUUID` (Node 19+ and all modern browsers) so this module is safe
- * to include in the browser entry. Importing `node:crypto` here previously leaked into the
- * canvas client bundle through `browser.ts` and OOM'd consumers' Turbopack builds.
- */
 declare class NodeIterationIdFactory {
   static create(): string;
-  /** Deterministic id for tests when a stable sequence is needed. */
   static createForTest(seed: string, sequence: number): string;
-  /** Deterministic id derived from a connection node id (for sub-agent / tool-call scopes). */
   static createForConnection(connectionNodeId: NodeId, sequence: number): string;
 }
 //#endregion
 //#region src/workflow/definition/WorkflowExecutableNodeClassifier.d.ts
-/**
- * Derives which workflow nodes participate in the main execution graph vs connection-only children.
- */
 declare class WorkflowExecutableNodeClassifier {
   private readonly connectionOwnedIds;
   constructor(workflow: WorkflowDefinition);
@@ -3077,9 +2297,6 @@ declare class WorkflowExecutableNodeClassifier {
   isExecutableNodeId(nodeId: NodeId): boolean;
   filterExecutableNodeDefinitions(nodes: ReadonlyArray<NodeDefinition>): ReadonlyArray<NodeDefinition>;
   private collectConnectionOwnedIds;
-  /**
-   * Resolves the default start node: first trigger, else first executable node with no incoming edges from executable nodes.
-   */
   findDefaultExecutableStartNodeId(workflow: WorkflowDefinition): NodeId;
   firstExecutableNodeIdInDefinitionOrder(workflow: WorkflowDefinition): NodeId | undefined;
   lastExecutableNodeIdInDefinitionOrder(workflow: WorkflowDefinition): NodeId;
@@ -3095,5 +2312,5 @@ declare class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
   create(def: WorkflowDefinition): WorkflowGraph;
 }
 //#endregion
-export { ExecutionInstanceDto as $, CredentialAuthDefinition as $a, TriggerCleanupHandle as $i, ActivationIdFactory as $n, WorkflowStoragePolicySpec as $r, PersistedRunControlState as $t, DefinedNodeConfigInput as A, TelemetryScope as Aa, LiveWorkflowRepository as Ai, TypeToken as An, PersistedTokenId as Ao, RunDataFactory as Ar, AssertionResult as At, NoOpCostTrackingTelemetry as B, NoOpTelemetrySpanScope as Ba, NodeExecutionRequestHandler as Bi, singleton as Bn, UpstreamRefPlaceholder as Br, ConnectionInvocationId as Bt, HumanApprovalOutputJson as C, NodeExecutionTelemetry as Ca, ExecutionContext as Ci, WorkflowExecutionRepository as Cn, NoOpPollingTriggerLogger as Co, NodeOffloadPolicy as Cr, ItemExprCallback as Ct, DefineNodeExecuteArgs as D, TelemetryAttributes as Da, HumanTaskId as Di, InjectionToken$1 as Dn, NodeConnectionName as Do, PairedItemRef as Dr, itemExpr as Dt, DefineBatchNodeOptions as E, TelemetryAttributePrimitive as Ea, HumanTaskHandle as Ei, Disposable as En, InputPortKey as Eo, NodeSchedulerDecision as Er, isItemExpr as Et, defineBatchNode as F, GenAiTelemetryAttributeNames as Fa, NodeActivationRequestBase as Fi, injectable as Fn, RunnableNodeInputJson as Fr, AgentBindError as Ft, PortsEmission as G, CostTrackingTelemetryAttributeNames as Ga, PersistedTriggerSetupState as Gi, RunEvent as Gn, WorkflowGraph as Gr, NodeExecutionError as Gt, RetryPolicy as H, CostTrackingComponent as Ha, NodeExecutionStatePublisher as Hi, ENGINE_EXECUTION_LIMITS_DEFAULTS as Hn, WorkflowErrorContext as Hr, CurrentStateExecutionRequest as Ht, defineNode as I, CodemationTelemetryAttributeNames as Ia, NodeActivationScheduler as Ii, instanceCachingFactory as In, RunnableNodeOutputJson as Ir, AgentMcpIntegration as It, isUnbrandedPortsEmissionShape as J, CostTrackingUsageRecord as Ja, ResumeContext as Ji, TestCaseRunStatus as Jn, WorkflowPolicyRuntimeDefaults as Jr, NodeInputsByPort as Jt, emitPorts as K, CostTrackingTelemetryFactory as Ka, PollingTriggerHandle as Ki, RunEventBus as Kn, WorkflowGraphFactory as Kr, NodeExecutionSnapshot as Kt, NodeBaseOptions as L, NoOpExecutionTelemetryFactory as La, NodeBinaryAttachmentService as Li, instancePerContainerCachingFactory as Ln, TriggerNodeConfig as Lr, AgentMcpToolMap as Lt, DefinedNodeCredentialBinding as M, TelemetrySpanEventRecord as Ma, NodeActivationContinuation as Mi, delay as Mn, RunId as Mr, DEFAULT_ASSERTION_PASS_THRESHOLD as Mt, DefinedNodeCredentialBindings as N, TelemetrySpanScope as Na, NodeActivationReceipt as Ni, inject as Nn, RunIdFactory as Nr, deriveAssertionPassed as Nt, DefineNodeOptions as O, TelemetryChildSpanStart as Oa, HumanTaskSubject as Oi, Lifecycle as On, NodeId as Oo, ParentExecutionRef as Or, resolveItemExprsForExecution as Ot, DefinedNodeRunContext as P, CodemationTelemetryMetricNames as Pa, NodeActivationRequest as Pi, injectAll as Pn, RunnableNodeConfig as Pr, NoOpAgentMcpIntegration as Pt, ConnectionInvocationKind as Q, CredentialAdvancedSectionPresentation as Qa, TestableTriggerNode as Qi, TestTriggerSetupContext as Qn, WorkflowStoragePolicyResolver as Qr, PersistedMutableRunState as Qt, RunFinishedAtFactory as R, NoOpExecutionTelemetry as Ra, NodeExecutionContext as Ri, predicateAwareClassFactory as Rn, TriggerNodeOutputJson as Rr, NeedsReconsentEvent as Rt, HumanApprovalDecisionResult as S, ExecutionTelemetryFactory as Sa, ExecutionBinaryService as Si, WorkflowExecutionPruneRepository as Sn, OAuth2ProviderFromPublicConfig as So, NodeKind as Sr, ItemExprArgs as St, isHumanApprovalNode as T, TelemetryArtifactReference as Ta, HumanTaskActor as Ti, DependencyContainer$1 as Tn, PollingTriggerDedupWindow as To, NodeRef as Tr, ItemExprResolvedContext as Tt, NoRetryPolicy as U, CostTrackingPriceQuote as Ua, NodeExecutor as Ui, EngineExecutionLimitsPolicy as Un, WorkflowErrorHandler as Ur, EngineRunCounters as Ut, ExpRetryPolicy as V, NoOpTelemetryArtifactReference as Va, NodeExecutionScheduler as Vi, CoreTokens as Vn, WorkflowDefinition as Vr, ConnectionInvocationRecord as Vt, getOriginIndexFromItem as W, CostTrackingTelemetry as Wa, NodeResolver as Wi, EngineExecutionLimitsPolicyConfig as Wn, WorkflowErrorHandlerSpec as Wr, ExecutionFrontierPlan as Wt, McpServerTransport as X, CollectionsContext as Xa, RunnableNodeExecuteArgs as Xi, TestSuiteRunId as Xn, WorkflowStoragePolicyDecisionArgs as Xr, PendingResumeEntry as Xt, McpServerDeclaration as Y, CollectionStore as Ya, RunnableNode as Yi, TestSuiteRunStatus as Yn, WorkflowPrunePolicySpec as Yr, PendingNodeExecution as Yt, BatchId as Z, AnyCredentialType as Za, SuspensionRequest as Zi, TestTriggerNodeConfig as Zn, WorkflowStoragePolicyMode as Zr, PersistedMutableNodeState as Zt, BranchStepsArg as _, WebhookTriggerResolution as _a, BinaryStorageWriteResult as _i, RunStopCondition as _n, CredentialType as _o, NodeErrorHandlerArgs as _r, CostCatalogEntry as _t, ConnectionNodeIdFactory as a, TriggerTestItemsContext as aa, triggerNodeSetupStateType as ai, PersistedWorkflowTokenRegistryLike as an, CredentialHealthTester as ao, ItemBinary as ar, PersistedRunSlotProjectionRecord as at, mergeForward as b, WorkflowActivationPolicy as ba, EngineHost as bi, WebhookRunResult as bn, CredentialTypeRegistry as bo, NodeInspectorSummaryRow as br, ParamDeep as bt, WorkflowDefinitionError as c, WorkflowRunnerResolver as ca, NoneRetryPolicySpec as ci, RunCurrentState as cn, CredentialJsonRecord as co, JsonNonArray as cr, RunIterationDto as ct, WhenBuilder as d, WorkflowSnapshotResolver as da, BinaryAttachmentCreateRequest as di, RunHaltReason as dn, CredentialOAuth2ScopesFromPublicConfig as do, JsonValue as dr, SlotExecutionStateDto as dt, TriggerNode as ea, branchRef as ei, PersistedRunSchedulingState as en, CredentialBinding as eo, BinaryAttachment as er, ExecutionInstanceId as et, AnyRunnableNodeConfig as f, HttpMethod as fa, BinaryBody as fi, RunPruneCandidate as fn, CredentialRequirement as fo, MutableRunData as fr, WorkItemId as ft, BranchOutputGuard as g, WebhookTriggerMatcher as ga, BinaryStorageWriteRequest as gi, RunStatus as gn, CredentialSetupStatus as go, NodeErrorHandler as gr, CostCatalog as gt, BranchMoreArgs as h, WebhookInvocationMatch as ha, BinaryStorageStatResult as hi, RunStateResetRequest as hn, CredentialSessionService as ho, NodeDefinition as hr, WorkflowRunDetailDto as ht, NodeIterationIdFactory as i, TriggerSetupStateRepository as ia, triggerNodeOutputType as ii, PersistedWorkflowSnapshotNode as in, CredentialHealthStatus as io, Item as ir, PersistedExecutionInstanceRecord as it, DefinedNodeCredentialAccessors as j, TelemetrySpanEnd as ja, MultiInputNode as ji, container$1 as jn, WorkflowId as jo, RunDataSnapshot as jr, AssertionResultProvenance as jt, DefinedNode as k, TelemetryMetricRecord as ka, ItemNode as ki, RegistrationOptions as kn, OutputPortKey as ko, PersistedRunPolicySnapshot as kr, resolveItemExprsInUnknown as kt, WorkflowBuilder as l, WorkflowRunnerService as la, RetryPolicySpec as li, RunEventPublisherDeps as ln, CredentialMaterialSourceKind as lo, JsonObject as lr, RunRevision as lt, BooleanWhenOverloads as m, WebhookControlSignal as ma, BinaryStorageReadResult as mi, RunResult as mn, CredentialSessionFactoryArgs as mo, NodeConfigBase as mr, WorkflowDetailSelectionState as mt, WorkflowExecutableNodeClassifierFactory as n, TriggerSetupContext as na, runnableNodeInputType as ni, PersistedSuspensionEntry as nn, CredentialFieldSchema as no, Edge as nr, PayloadStorageKind as nt, ConnectionInvocationIdFactory as o, WorkflowNodeInstanceFactory as oa, ExponentialRetryPolicySpec as oi, PinnedNodeOutputsByPort as on, CredentialInstanceId as oo, Items as or, PersistedRunWorkItemKind as ot, AnyTriggerNodeConfig as p, TriggerInstanceId as pa, BinaryStorage as pi, RunQueueEntry as pn, CredentialSessionFactory as po, NodeActivationId as pr, WorkItemStatus as pt, isPortsEmission as q, CostTrackingTelemetryMetricNames as qa, PreparedNodeActivationDispatch as qi, RunEventSubscription as qn, WorkflowNodeConnection as qr, NodeExecutionStatus as qt, WorkflowExecutableNodeClassifier as r, TriggerSetupStateFor as ra, runnableNodeOutputType as ri, PersistedWorkflowSnapshot as rn, CredentialHealth as ro, ExecutionMode as rr, PersistedExecutionInstanceKind as rt, NodeIdSlugifier as s, WorkflowRepository as sa, FixedRetryPolicySpec as si, RunCompletionNotifier as sn, CredentialInstanceRecord as so, JsonArray as sr, PersistedRunWorkItemRecord as st, DefaultWorkflowGraphFactory as t, TriggerRuntimeDiagnostics as ta, nodeRef as ti, PersistedRunState as tn, CredentialBindingKey as to, BinaryPreviewKind as tr, ExecutionPayloadPolicyFields as tt, ChainCursor as u, WorkflowSnapshotFactory as ua, BINARY_DEFAULT_MAX_BYTES as ui, RunExecutionOptions as un, CredentialOAuth2AuthDefinition as uo, JsonPrimitive as ur, RunSlotProjectionState as ut, StepSequenceOutput as v, WebhookTriggerRoutingDiagnostics as va, Duration as vi, RunSummary as vn, CredentialTypeDefinition as vo, NodeErrorHandlerSpec as vr, Expr as vt, defineHumanApprovalNode as w, TelemetryArtifactAttachment as wa, ExecutionContextFactory as wi, Container as wn, PollingTriggerLogger as wo, NodeOutputs as wr, ItemExprContext as wt, DefinedHumanApprovalNode as x, ExecutionTelemetry as xa, ExecutableTriggerNode as xi, WorkflowExecutionListingRepository as xn, CredentialUnboundError as xo, NodeIterationId as xr, ItemExpr as xt, ValidStepSequence as y, AllWorkflowsActiveWorkflowActivationPolicy as ya, EngineDeps as yi, RunTestContext as yn, CredentialTypeId as yo, NodeIdRef as yr, Param as yt, NoOpCostTrackingTelemetryFactory as z, NoOpNodeExecutionTelemetry as za, NodeExecutionRequest as zi, registry as zn, TriggerNodeSetupState as zr, ConnectionInvocationAppendArgs as zt };
-//# sourceMappingURL=index-CbJdbIHe.d.ts.map
+export { ManifestNodeCredentialShape as $, NoOpExecutionTelemetryFactory as $a, NodeExecutionContext as $i, singleton as $n, TriggerNodeOutputJson as $r, ConnectionInvocationId as $t, DefinedNodeConfigInput as A, WebhookControlSignal as Aa, BinaryStorageStatResult as Ai, RunStopCondition as An, CredentialRequirement as Ao, NodeErrorHandler as Ar, ItemExprArgs as At, NoOpCostTrackingTelemetry as B, TelemetryArtifactAttachment as Ba, HumanTaskActor as Bi, InjectionToken$1 as Bn, OAuth2ProviderFromPublicConfig as Bo, NodeSchedulerDecision as Br, DEFAULT_ASSERTION_PASS_THRESHOLD as Bt, HumanApprovalOutputJson as C, WorkflowRepository as Ca, NoneRetryPolicySpec as Ci, RunExecutionOptions as Cn, CredentialHealthTester as Co, JsonObject as Cr, WorkflowRunDetailDto as Ct, DefineNodeExecuteArgs as D, WorkflowSnapshotResolver as Da, BinaryBody as Di, RunResult as Dn, CredentialMaterialSourceKind as Do, NodeActivationId as Dr, Param as Dt, DefineBatchNodeOptions as E, WorkflowSnapshotFactory as Ea, BinaryAttachmentCreateRequest as Ei, RunQueueEntry as En, CredentialJsonRecord as Eo, MutableRunData as Er, Expr as Et, defineBatchNode as F, AllWorkflowsActiveWorkflowActivationPolicy as Fa, EngineHost as Fi, WorkflowExecutionPruneRepository as Fn, CredentialType as Fo, NodeIterationId as Fr, itemExpr as Ft, PortsEmission as G, TelemetryMetricRecord as Ga, LiveWorkflowRepository as Gi, delay as Gn, NodeConnectionName as Go, RunDataFactory as Gr, WorkflowDispatch as Gt, RetryPolicy as H, TelemetryAttributePrimitive as Ha, HumanTaskId as Hi, RegistrationOptions as Hn, PollingTriggerLogger as Ho, ParentExecutionRef as Hr, NoOpAgentMcpIntegration as Ht, defineNode as I, WorkflowActivationPolicy as Ia, ExecutableTriggerNode as Ii, WorkflowExecutionRepository as In, CredentialTypeDefinition as Io, NodeKind as Ir, resolveItemExprsForExecution as It, isUnbrandedPortsEmissionShape as J, TelemetrySpanEventRecord as Ja, NodeActivationReceipt as Ji, injectable as Jn, PersistedTokenId as Jo, RunIdFactory as Jr, serializeDispatch as Jt, emitPorts as K, TelemetryScope as Ka, MultiInputNode as Ki, inject as Kn, NodeId as Ko, RunDataSnapshot as Kr, WorkspaceId as Kt, NodeBaseOptions as L, ExecutionTelemetry as La, ExecutionBinaryService as Li, Container as Ln, CredentialTypeId as Lo, NodeOffloadPolicy as Lr, resolveItemExprsInUnknown as Lt, DefinedNodeCredentialBinding as M, WebhookTriggerMatcher as Ma, BinaryStorageWriteResult as Mi, RunTestContext as Mn, CredentialSessionFactoryArgs as Mo, NodeErrorHandlerSpec as Mr, ItemExprContext as Mt, DefinedNodeCredentialBindings as N, WebhookTriggerResolution as Na, Duration as Ni, WebhookRunResult as Nn, CredentialSessionService as No, NodeIdRef as Nr, ItemExprResolvedContext as Nt, DefineNodeOptions as O, HttpMethod as Oa, BinaryStorage as Oi, RunStateResetRequest as On, CredentialOAuth2AuthDefinition as Oo, NodeConfigBase as Or, ParamDeep as Ot, DefinedNodeRunContext as P, WebhookTriggerRoutingDiagnostics as Pa, EngineDeps as Pi, WorkflowExecutionListingRepository as Pn, CredentialSetupStatus as Po, NodeInspectorSummaryRow as Pr, isItemExpr as Pt, DeploymentManifestSchemaVersion as Q, CodemationTelemetryAttributeNames as Qa, NodeBinaryAttachmentService as Qi, registry as Qn, TriggerNodeConfig as Qr, ConnectionInvocationAppendArgs as Qt, RunFinishedAtFactory as R, ExecutionTelemetryFactory as Ra, ExecutionContext as Ri, DependencyContainer$1 as Rn, CredentialTypeRegistry as Ro, NodeOutputs as Rr, AssertionResult as Rt, HumanApprovalDecisionResult as S, WorkflowNodeInstanceFactory as Sa, FixedRetryPolicySpec as Si, RunEventPublisherDeps as Sn, CredentialHealthStatus as So, JsonNonArray as Sr, WorkflowDetailSelectionState as St, isHumanApprovalNode as T, WorkflowRunnerService as Ta, BINARY_DEFAULT_MAX_BYTES as Ti, RunPruneCandidate as Tn, CredentialInstanceRecord as To, JsonValue as Tr, CostCatalogEntry as Tt, NoRetryPolicy as U, TelemetryAttributes as Ua, HumanTaskSubject as Ui, TypeToken as Un, PollingTriggerDedupWindow as Uo, PersistedRunPolicySnapshot as Ur, AgentBindError as Ut, ExpRetryPolicy as V, TelemetryArtifactReference as Va, HumanTaskHandle as Vi, Lifecycle as Vn, NoOpPollingTriggerLogger as Vo, PairedItemRef as Vr, deriveAssertionPassed as Vt, getOriginIndexFromItem as W, TelemetryChildSpanStart as Wa, ItemNode as Wi, container$1 as Wn, InputPortKey as Wo, PollingTriggerConfig as Wr, DispatchItemMeta as Wt, McpServerTransport as X, CodemationTelemetryMetricNames as Xa, NodeActivationRequestBase as Xi, instancePerContainerCachingFactory as Xn, RunnableNodeInputJson as Xr, AgentMcpToolMap as Xt, McpServerDeclaration as Y, TelemetrySpanScope as Ya, NodeActivationRequest as Yi, instanceCachingFactory as Yn, WorkflowId as Yo, RunnableNodeConfig as Yr, AgentMcpIntegration as Yt, DEPLOYMENT_MANIFEST_SCHEMA_VERSION as Z, GenAiTelemetryAttributeNames as Za, NodeActivationScheduler as Zi, predicateAwareClassFactory as Zn, RunnableNodeOutputJson as Zr, NeedsReconsentEvent as Zt, BranchStepsArg as _, TriggerRuntimeDiagnostics as _a, runnableNodeInputType as _i, PersistedWorkflowSnapshotNode as _n, CredentialAuthDefinition as _o, ExecutionMode as _r, RunRevision as _t, ConnectionNodeIdFactory as a, NodeResolver as aa, WorkflowErrorHandlerSpec as ai, NodeExecutionSnapshot as an, CostTrackingPriceQuote as ao, RunEvent as ar, BatchId as at, mergeForward as b, TriggerSetupStateRepository as ba, triggerNodeSetupStateType as bi, RunCompletionNotifier as bn, CredentialFieldSchema as bo, Items as br, WorkItemId as bt, WorkflowDefinitionError as c, PreparedNodeActivationDispatch as ca, WorkflowNodeConnection as ci, PendingNodeExecution as cn, CostTrackingTelemetryFactory as co, TestCaseRunStatus as cr, ExecutionInstanceId as ct, WhenBuilder as d, RunnableNodeExecuteArgs as da, WorkflowStoragePolicyDecisionArgs as di, PersistedMutableRunState as dn, CollectionStore as do, TestTriggerNodeConfig as dr, PersistedExecutionInstanceKind as dt, NodeExecutionRequest as ea, TriggerNodeSetupState as ei, ConnectionInvocationRecord as en, NoOpExecutionTelemetry as eo, CoreTokens as er, ManifestTriggerConfig as et, AnyRunnableNodeConfig as f, SuspensionRequest as fa, WorkflowStoragePolicyMode as fi, PersistedRunControlState as fn, CollectionsContext as fo, TestTriggerSetupContext as fr, PersistedExecutionInstanceRecord as ft, BranchOutputGuard as g, TriggerPollingPort as ga, nodeRef as gi, PersistedWorkflowSnapshot as gn, CredentialAdvancedSectionPresentation as go, Edge as gr, RunIterationDto as gt, BranchMoreArgs as h, TriggerNode as ha, branchRef as hi, PersistedSuspensionEntry as hn, CredentialAccessTokenSessionFactory as ho, BinaryPreviewKind as hr, PersistedRunWorkItemRecord as ht, NodeIterationIdFactory as i, NodeExecutor as ia, WorkflowErrorHandler as ii, NodeExecutionError as in, CostTrackingComponent as io, EngineExecutionLimitsPolicyConfig as ir, serializeManifest as it, DefinedNodeCredentialAccessors as j, WebhookInvocationMatch as ja, BinaryStorageWriteRequest as ji, RunSummary as jn, CredentialSessionFactory as jo, NodeErrorHandlerArgs as jr, ItemExprCallback as jt, DefinedNode as k, TriggerInstanceId as ka, BinaryStorageReadResult as ki, RunStatus as kn, CredentialOAuth2ScopesFromPublicConfig as ko, NodeDefinition as kr, ItemExpr as kt, WorkflowBuilder as l, ResumeContext as la, WorkflowPolicyRuntimeDefaults as li, PendingResumeEntry as ln, CostTrackingTelemetryMetricNames as lo, TestSuiteRunStatus as lr, ExecutionPayloadPolicyFields as lt, BooleanWhenOverloads as m, TriggerCleanupHandle as ma, WorkflowStoragePolicySpec as mi, PersistedRunState as mn, CredentialAccessTokenSessionArgs as mo, BinaryAttachment as mr, PersistedRunWorkItemKind as mt, WorkflowExecutableNodeClassifierFactory as n, NodeExecutionScheduler as na, WorkflowDefinition as ni, EngineRunCounters as nn, NoOpTelemetrySpanScope as no, ENGINE_EXECUTION_LIMITS_DEFAULTS as nr, deserializeManifest as nt, ConnectionInvocationIdFactory as o, PersistedTriggerSetupState as oa, WorkflowGraph as oi, NodeExecutionStatus as on, CostTrackingTelemetry as oo, RunEventBus as or, ConnectionInvocationKind as ot, AnyTriggerNodeConfig as p, TestableTriggerNode as pa, WorkflowStoragePolicyResolver as pi, PersistedRunSchedulingState as pn, AnyCredentialType as po, ActivationIdFactory as pr, PersistedRunSlotProjectionRecord as pt, isPortsEmission as q, TelemetrySpanEnd as qa, NodeActivationContinuation as qi, injectAll as qn, OutputPortKey as qo, RunId as qr, deserializeDispatch as qt, WorkflowExecutableNodeClassifier as r, NodeExecutionStatePublisher as ra, WorkflowErrorContext as ri, ExecutionFrontierPlan as rn, NoOpTelemetryArtifactReference as ro, EngineExecutionLimitsPolicy as rr, emitWorkflowManifest as rt, NodeIdSlugifier as s, PollingTriggerHandle as sa, WorkflowGraphFactory as si, NodeInputsByPort as sn, CostTrackingTelemetryAttributeNames as so, RunEventSubscription as sr, ExecutionInstanceDto as st, DefaultWorkflowGraphFactory as t, NodeExecutionRequestHandler as ta, UpstreamRefPlaceholder as ti, CurrentStateExecutionRequest as tn, NoOpNodeExecutionTelemetry as to, TriggerInvoker as tr, WorkflowDeploymentManifest as tt, ChainCursor as u, RunnableNode as ua, WorkflowPrunePolicySpec as ui, PersistedMutableNodeState as un, CostTrackingUsageRecord as uo, TestSuiteRunId as ur, PayloadStorageKind as ut, StepSequenceOutput as v, TriggerSetupContext as va, runnableNodeOutputType as vi, PersistedWorkflowTokenRegistryLike as vn, CredentialBinding as vo, Item as vr, RunSlotProjectionState as vt, defineHumanApprovalNode as w, WorkflowRunnerResolver as wa, RetryPolicySpec as wi, RunHaltReason as wn, CredentialInstanceId as wo, JsonPrimitive as wr, CostCatalog as wt, DefinedHumanApprovalNode as x, TriggerTestItemsContext as xa, ExponentialRetryPolicySpec as xi, RunCurrentState as xn, CredentialHealth as xo, JsonArray as xr, WorkItemStatus as xt, ValidStepSequence as y, TriggerSetupStateFor as ya, triggerNodeOutputType as yi, PinnedNodeOutputsByPort as yn, CredentialBindingKey as yo, ItemBinary as yr, SlotExecutionStateDto as yt, NoOpCostTrackingTelemetryFactory as z, NodeExecutionTelemetry as za, ExecutionContextFactory as zi, Disposable as zn, CredentialUnboundError as zo, NodeRef as zr, AssertionResultProvenance as zt };
+//# sourceMappingURL=index-CRv3_pY3.d.ts.map