@codemation/core 0.14.0 → 0.15.0

package/dist/{runtime-CSunvf7A.js → runtime-CBFDpmiz.js}

@@ -1,7 +1,9 @@
-import { E as ConnectionNodeIdFactory, _ as CredentialUnboundError, a as injectable, g as SuspensionRequest, h as BINARY_DEFAULT_MAX_BYTES, v as NodeIterationIdFactory, w as resolveItemExprsForExecution, x as AgentConfigInspector, y as AgentConnectionNodeCollector } from "./di-CEV6wTc4.js";
+import { a as SuspensionRequest, c as AgentConnectionNodeCollector, i as BINARY_DEFAULT_MAX_BYTES, o as CredentialUnboundError, s as NodeIterationIdFactory, u as ConnectionNodeIdFactory } from "./workflowTypes-DZtBTmKf.js";
+import { f as AgentConfigInspector, h as resolveItemExprsForExecution } from "./di-Cjiil7U-.js";
+import { a as WorkflowSnapshotCodec, l as node } from "./contracts-CjJ5CZ7N.js";
+import { createHash } from "node:crypto";
 import { ZodError, z } from "zod";
 import { ReadableStream } from "node:stream/web";
-import { createHash } from "node:crypto";
 
 //#region src/contracts/humanTaskStoreTypes.ts
 const HumanTaskStoreToken = Symbol.for("codemation.core.HumanTaskStore");
@@ -10,12 +12,6 @@ const HumanTaskStoreToken = Symbol.for("codemation.core.HumanTaskStore");
 //#region src/contracts/hitlSeamTypes.ts
 const HitlResumeTokenSignerToken = Symbol.for("codemation.core.HitlResumeTokenSigner");
 const HitlTimeoutJobSchedulerToken = Symbol.for("codemation.core.HitlTimeoutJobScheduler");
-/**
-* Optional workspace ID injected into NodeSuspensionHandler in managed mode (T7 security fix).
-* Allows the handler to stamp the workspaceId on each HumanTaskRecord so HitlCallbackHandler
-* can assert workspace identity independently of the HMAC middleware.
-* Not registered in non-managed mode; NodeSuspensionHandler defaults to null.
-*/
 const HitlWorkspaceIdToken = Symbol.for("codemation.core.HitlWorkspaceId");
 
 //#endregion
@@ -30,115 +26,6 @@ var DefinedNodeRegistry = class {
 	}
 };
 
-//#endregion
-//#region src/runtime-types/persistedRuntimeTypeModelRegistry.ts
-/** Shared metadata key used to attach persisted runtime-type information to decorated classes. */
-const persistedRuntimeTypeMetadataKey = Symbol.for("codemation.core.persistedRuntimeTypeMetadata");
-/** Normalizes decorator options so persistence metadata has stable defaults. */
-var PersistedRuntimeTypeDecoratorDefaults = class {
-	static appPackageName = "app";
-	static apply(options) {
-		return {
-			...options,
-			packageName: options.packageName ?? this.appPackageName
-		};
-	}
-};
-
-//#endregion
-//#region src/runtime-types/PersistedRuntimeTypeNameResolver.ts
-/** Resolves the persisted type name from either an explicit override or the class name itself. */
-var PersistedRuntimeTypeNameResolver = class {
-	static resolve(target, override) {
-		const resolved = override ?? target.name;
-		if (!resolved) throw new Error("Persisted runtime token metadata requires a named class or an explicit decorator name override.");
-		return resolved;
-	}
-};
-
-//#endregion
-//#region src/runtime-types/StackTraceCallSitePathResolver.ts
-var StackTraceCallSitePathResolver = class {
-	static resolve(decoratorFileUrl) {
-		const stack = (/* @__PURE__ */ new Error()).stack ?? "";
-		for (const line of stack.split("\n")) {
-			const candidate = this.extractPath(line.trim());
-			if (!candidate) continue;
-			if (candidate === decoratorFileUrl || candidate.includes("runtimeTypeDecorators")) continue;
-			return candidate;
-		}
-	}
-	static extractPath(line) {
-		const fileUrlMatch = line.match(/file:\/\/[^\s)]+/);
-		if (fileUrlMatch) return fileUrlMatch[0];
-		const parenMatch = line.match(/\((\/[^)]+)\)/);
-		if (parenMatch) return parenMatch[1];
-		return line.match(/at (\/[^\s]+)/)?.[1];
-	}
-};
-
-//#endregion
-//#region src/runtime-types/PersistedRuntimeTypeMetadataStoreRegistry.ts
-/**
-* Defines and retrieves persisted runtime metadata on decorated classes.
-* The metadata is attached as a non-enumerable property so runtime objects stay serializable.
-*/
-var PersistedRuntimeTypeMetadataStore = class {
-	static define(target, kind, options, decoratorFileUrl) {
-		const normalizedOptions = PersistedRuntimeTypeDecoratorDefaults.apply(options);
-		const metadata = {
-			persistedName: PersistedRuntimeTypeNameResolver.resolve(target, normalizedOptions.name),
-			kind,
-			packageName: normalizedOptions.packageName ?? PersistedRuntimeTypeDecoratorDefaults.appPackageName,
-			sourceHint: normalizedOptions.moduleUrl ?? StackTraceCallSitePathResolver.resolve(decoratorFileUrl)
-		};
-		Object.defineProperty(target, persistedRuntimeTypeMetadataKey, {
-			configurable: false,
-			enumerable: false,
-			writable: false,
-			value: metadata
-		});
-	}
-	static get(target) {
-		if (!target || typeof target !== "function" && typeof target !== "object") return;
-		return target[persistedRuntimeTypeMetadataKey];
-	}
-};
-
-//#endregion
-//#region src/runtime-types/InjectableRuntimeDecoratorComposerRegistry.ts
-/**
-* Applies both tsyringe injectability and persisted runtime metadata in one decorator.
-* This keeps runtime-type decorators thin while still recording enough data for snapshot hydration.
-*/
-var InjectableRuntimeDecoratorComposer = class {
-	static compose(kind, options, decoratorFileUrl) {
-		return (target) => {
-			injectable()(target);
-			PersistedRuntimeTypeMetadataStore.define(target, kind, options, decoratorFileUrl);
-		};
-	}
-};
-
-//#endregion
-//#region src/runtime-types/runtimeTypeDecorators.types.ts
-/** Reads persisted runtime metadata from a decorated class or object. */
-function getPersistedRuntimeTypeMetadata(target) {
-	return PersistedRuntimeTypeMetadataStore.get(target);
-}
-/** Marks a class as a persisted node runtime type and an injectable tsyringe service. */
-function node(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("node", options, import.meta.url);
-}
-/** Marks a class as a persisted tool runtime type and an injectable tsyringe service. */
-function tool(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("tool", options, import.meta.url);
-}
-/** Marks a class as a persisted chat-model runtime type and an injectable tsyringe service. */
-function chatModel(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, import.meta.url);
-}
-
 //#endregion
 //#region src/authoring/defineNode.types.ts
 const definedNodeCredentialRequirementFactory = {
@@ -294,60 +181,9 @@ function defineBatchNode(options) {
 
 //#endregion
 //#region src/authoring/defineHumanApprovalNode.types.ts
-/**
-* Returns `true` when `node` was created by {@link defineHumanApprovalNode}.
-* Uses the `humanApprovalToolBehavior` typed field as the discriminant.
-*/
 function isHumanApprovalNode(node$1) {
 	return typeof node$1 === "object" && node$1 !== null && "humanApprovalToolBehavior" in node$1 && typeof node$1.humanApprovalToolBehavior === "object";
 }
-/**
-* 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 ? "✅" : "❌");
-*   },
-* });
-* ```
-*/
 function defineHumanApprovalNode(opts) {
 	const resolvedPredicate = resolveApprovedPredicate(opts.decisionSchema, opts.approvedPredicate);
 	const timeout = opts.defaultTimeout ?? "24h";
@@ -449,7 +285,6 @@ async function handleResume(item, resumeContext, decisionSchema, resolvedPredica
 //#endregion
 //#region src/workflow/dsl/WhenBuilder.ts
 var WhenBuilder = class WhenBuilder {
-	/** Tail endpoint of the arm this builder added (set by addBranch). */
 	armEndpoint;
 	constructor(wf, from, branchPort, priorEndpoints = []) {
 		this.wf = wf;
@@ -494,27 +329,15 @@ var WhenBuilder = class WhenBuilder {
 		b.addBranch(list);
 		return b;
 	};
-	/**
-	* 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(config) {
 		return this.toCursor().then(config);
 	}
-	/**
-	* Chainable human-approval step after a boolean `.when(...)` branch chain — merges every
-	* branch tail into the approval node. Mirrors `ChainCursor.humanApproval`.
-	*/
 	humanApproval(node$1, config, metadata) {
 		return this.toCursor().humanApproval(node$1, config, metadata);
 	}
 	build() {
 		return this.wf.build();
 	}
-	/** Endpoints of every arm added so far in this chain (prior arms + this one). */
 	get accumulatedEndpoints() {
 		return this.armEndpoint ? [...this.priorEndpoints, this.armEndpoint] : this.priorEndpoints;
 	}
@@ -525,30 +348,6 @@ var WhenBuilder = class WhenBuilder {
 
 //#endregion
 //#region src/workflow/dsl/workflowBuilderTypes.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();
-* ```
-*/
 function mergeForward(config) {
 	config.mergeJson = true;
 	return config;
@@ -571,11 +370,6 @@ var ChainCursor = class ChainCursor {
 			...inputPortHint ? { inputPortHint } : {}
 		}]);
 	}
-	/**
-	* 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(config) {
 		mergeForward(config);
 		return this.then(config);
@@ -648,21 +442,6 @@ var ChainCursor = class ChainCursor {
 		}
 		return new ChainCursor(this.wf, nextEndpoints);
 	}
-	/**
-	* 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(node$1, config, metadata) {
 		if (!isHumanApprovalNode(node$1)) throw new Error(`.humanApproval() requires a node created via defineHumanApprovalNode (got '${node$1.key ?? String(node$1)}').`);
 		return this.then(node$1.create(config, metadata?.name, metadata?.nodeId));
@@ -679,15 +458,6 @@ var ChainCursor = class ChainCursor {
 
 //#endregion
 //#region src/workflow/dsl/NodeIdSlugifier.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.
-*/
 const NodeIdSlugifier = { slugify(label) {
 	if (!label) return "";
 	return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -695,15 +465,6 @@ const NodeIdSlugifier = { slugify(label) {
 
 //#endregion
 //#region src/workflow/dsl/WorkflowDefinitionError.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.
-*/
 var WorkflowDefinitionError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -815,17 +576,10 @@ var WorkflowBuilder = class {
 
 //#endregion
 //#region src/workflow/definition/ConnectionInvocationIdFactory.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.
-*/
 var ConnectionInvocationIdFactory = class {
 	static create() {
 		return `cinv_${globalThis.crypto.randomUUID()}`;
 	}
-	/** Deterministic id for tests when a stable sequence is needed. */
 	static createForTest(runId, connectionNodeId, sequence) {
 		return `cinv_${runId}_${connectionNodeId}_${sequence}`;
 	}
@@ -833,9 +587,6 @@ var ConnectionInvocationIdFactory = class {
 
 //#endregion
 //#region src/workflow/definition/WorkflowExecutableNodeClassifier.ts
-/**
-* Derives which workflow nodes participate in the main execution graph vs connection-only children.
-*/
 var WorkflowExecutableNodeClassifier = class {
 	connectionOwnedIds;
 	constructor(workflow) {
@@ -855,9 +606,6 @@ var WorkflowExecutableNodeClassifier = class {
 		for (const connection of workflow.connections ?? []) for (const childId of connection.childNodeIds) ids.add(childId);
 		return ids;
 	}
-	/**
-	* Resolves the default start node: first trigger, else first executable node with no incoming edges from executable nodes.
-	*/
 	findDefaultExecutableStartNodeId(workflow) {
 		const firstTrigger = workflow.nodes.find((n) => n.kind === "trigger" && this.isExecutableNodeId(n.id))?.id;
 		if (firstTrigger) return firstTrigger;
@@ -922,13 +670,6 @@ var DefaultWorkflowGraphFactory = class {
 
 //#endregion
 //#region src/events/ConnectionInvocationEventPublisher.ts
-/**
-* Publishes per-invocation lifecycle records onto the run {@link RunEventBus}.
-*
-* Surgical, per-invocation events let the UI update the right-side inspector
-* timeline as each LLM round / tool call transitions through `running` → `completed`
-* (or `failed`) without depending on a coarse `runSaved` poll.
-*/
 var ConnectionInvocationEventPublisher = class {
 	constructor(eventBus, parent) {
 		this.eventBus = eventBus;
@@ -956,7 +697,6 @@ var ConnectionInvocationEventPublisher = class {
 
 //#endregion
 //#region src/events/NodeEventPublisher.ts
-/** Publishes node lifecycle snapshots onto the run {@link RunEventBus}. */
 var NodeEventPublisher = class {
 	constructor(eventBus) {
 		this.eventBus = eventBus;
@@ -976,19 +716,6 @@ var NodeEventPublisher = class {
 
 //#endregion
 //#region src/binaries/boundedReadBinary.types.ts
-/**
-* Reads all bytes from an already-opened binary stream into a contiguous `Uint8Array`.
-*
-* Safety contract:
-*  - `attachment.size` is checked against `maxBytes` *before* any allocation (no OOM).
-*  - A single buffer of exactly `attachment.size` is pre-allocated; the stream fills it
-*    directly — no chunks array, no doubling.
-*  - A byte-count mismatch between the declared size and actual stream content is an error.
-*
-* This is the single canonical implementation; `ExecutionBinaryService.getBytes`,
-* `getText`, and `getJson` all delegate here. The per-package `readBinaryBody` helpers
-* in `core-nodes` and `core-nodes-ocr` have been removed in favour of this function.
-*/
 async function boundedReadBinary(result, attachment, maxBytes = BINARY_DEFAULT_MAX_BYTES) {
 	if (attachment.size > maxBytes) throw new Error(`Binary attachment size ${attachment.size} bytes exceeds maxBytes ${maxBytes}. Raise the node's maxBytes setting if this document is expected to be larger.`);
 	const out = new Uint8Array(attachment.size);
@@ -1005,18 +732,15 @@ async function boundedReadBinary(result, attachment, maxBytes = BINARY_DEFAULT_M
 	if (offset !== out.byteLength) throw new Error(`Binary stream produced ${offset} bytes but attachment declared size ${attachment.size}.`);
 	return out;
 }
-/** Shared implementation of `getBytes` used by both binary-service classes. */
 async function readBinaryAsBytes(storage, attachment, maxBytes) {
 	const result = await storage.openReadStream(attachment.storageKey);
 	if (!result) throw new Error("Binary attachment stream is unavailable.");
 	return boundedReadBinary(result, attachment, maxBytes);
 }
-/** Shared implementation of `getText` used by both binary-service classes. */
 async function readBinaryAsText(storage, attachment, maxBytes) {
 	const bytes = await readBinaryAsBytes(storage, attachment, maxBytes);
 	return new TextDecoder().decode(bytes);
 }
-/** Shared implementation of `getJson` used by both binary-service classes. */
 async function readBinaryAsJson(storage, attachment, maxBytes) {
 	const text = await readBinaryAsText(storage, attachment, maxBytes);
 	try {
@@ -1360,19 +1084,6 @@ var ActivationEnqueueService = class {
 
 //#endregion
 //#region src/execution/ChildExecutionScopeFactory.ts
-/**
-* Builds a re-rooted child execution context for sub-agent (and other deeply-nested) invocations.
-*
-* At the orchestrator's `agent.tool.call` boundary the inner runtime needs a ctx whose:
-* - `nodeId` is the tool's connection node id (so inner LLM/tool connection ids derive correctly),
-* - `activationId` is fresh (so its connection-invocation rows are uniquely identifiable),
-* - `telemetry` parents children under the tool-call span (not the orchestrator's node span),
-* - `binary` is scoped to the new (nodeId, activationId),
-* - `parentInvocationId` points back to the tool-call invocation for downstream lineage.
-*
-* Registered via factory in {@link EngineRuntimeRegistrar} so constructors stay free of parameter
-* decorators (Next/SWC and coverage tooling cannot parse them on in-repo sources).
-*/
 var ChildExecutionScopeFactory = class {
 	constructor(activationIdFactory) {
 		this.activationIdFactory = activationIdFactory;
@@ -1402,9 +1113,6 @@ var ChildExecutionScopeFactory = class {
 
 //#endregion
 //#region src/contracts/itemMeta.ts
-/**
-* Reads `meta._cm.originIndex` when present (used for fan-in merge-by-origin and Merge routing).
-*/
 function getOriginIndexFromItem(item) {
 	const v = (item.meta?._cm)?.originIndex;
 	return typeof v === "number" && Number.isFinite(v) ? v : void 0;
@@ -1412,17 +1120,6 @@ function getOriginIndexFromItem(item) {
 
 //#endregion
 //#region src/execution/FanInMergeByOriginMerger.ts
-/**
-* Default fan-in: combine multi-port {@link NodeInputsByPort} into one {@link Items} batch for per-item nodes.
-*
-* This is used when a single-input per-item node has multiple inbound edges (for example, branch reconverge
-* after an `If` / `Switch`). The default behavior is **append / union** (preserving item payloads) with a
-* deterministic order:
-*
-* - When router origin metadata exists (`meta._cm.originIndex`), items are sorted by origin index so the
-*   downstream batch preserves original ordering across branches.
-* - Otherwise, items are appended by port-key order, preserving each port's local order.
-*/
 var FanInMergeByOriginMerger = class {
 	merge(inputsByPort) {
 		const portKeys = Object.keys(inputsByPort).sort();
@@ -1472,11 +1169,6 @@ var NodeInputContractError = class extends Error {
 
 //#endregion
 //#region src/execution/NodeActivationRequestInputPreparer.ts
-/**
-* Validates per-item inputs for {@link RunnableNode} before enqueue persistence (Zod on `item.json`).
-* Does not rewrite `item.json` (wire stays as emitted upstream; engine passes parsed input via `execute` args).
-* Converts multi-input activations into a single-input batch when the node is per-item only (engine fan-in).
-*/
 var NodeActivationRequestInputPreparer = class {
 	fanInMerger = new FanInMergeByOriginMerger();
 	constructor(workflowNodeInstanceFactory) {
@@ -1623,13 +1315,11 @@ var RetryPolicy = class {
 		if (!Number.isFinite(maxAttempts) || maxAttempts < 1 || !Number.isInteger(maxAttempts)) throw new Error(`RetryPolicy.maxAttempts must be a positive integer, got ${maxAttempts}`);
 		if (!Number.isFinite(delayMs) || delayMs < 0) throw new Error(`RetryPolicy.delayMs must be a non-negative finite number, got ${delayMs}`);
 	}
-	/** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
 	static defaultForHttp = {
 		kind: "fixed",
 		maxAttempts: 3,
 		delayMs: 1e3
 	};
-	/** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
 	static defaultForAiAgent = {
 		kind: "fixed",
 		maxAttempts: 3,
@@ -1699,12 +1389,6 @@ var NoOpTelemetryArtifactReference = class {
 
 //#endregion
 //#region src/contracts/NoOpTelemetrySpanScope.ts
-/**
-* Standalone no-op {@link NodeExecutionTelemetry} value used as the return for `asNodeTelemetry`.
-*
-* Defined here (instead of in `NoOpNodeExecutionTelemetry.ts`) so that {@link NoOpTelemetrySpanScope}
-* can return it without importing the other module — both no-ops share this leaf.
-*/
 const noOpNodeExecutionTelemetry = {
 	traceId: "00000000000000000000000000000000",
 	spanId: "0000000000000000",
@@ -1739,7 +1423,6 @@ const noOpTelemetrySpanScope = {
 };
 var NoOpTelemetrySpanScope = class {
 	static value = noOpTelemetrySpanScope;
-	/** Internal: the shared no-op {@link NodeExecutionTelemetry} that {@link NoOpNodeExecutionTelemetry} re-exposes. */
 	static nodeExecutionTelemetryValue = noOpNodeExecutionTelemetry;
 };
 
@@ -1776,7 +1459,6 @@ var NoOpExecutionTelemetryFactory = class {
 
 //#endregion
 //#region src/contracts/workflowActivationPolicy.ts
-/** Default for tests and harnesses: every workflow is treated as active (legacy behavior). */
 var AllWorkflowsActiveWorkflowActivationPolicy = class {
 	isActive(_workflowId) {
 		return true;
@@ -1796,25 +1478,15 @@ var CodemationTelemetryAttributeNames = class {
 	static connectionInvocationId = "codemation.connection.invocation_id";
 	static toolName = "codemation.tool.name";
 	static traceParentRunId = "codemation.parent.run.id";
-	/** Per-item iteration that emitted this span/metric. Set on spans recorded inside a runnable per-item loop. */
 	static iterationId = "codemation.iteration.id";
-	/** Item index (0-based) of the iteration. */
 	static iterationIndex = "codemation.iteration.index";
-	/** Set when this span/metric was recorded under a sub-agent triggered by an outer LLM/tool call. */
 	static parentInvocationId = "codemation.parent.invocation_id";
-	/** MCP server id on spans created for callTool invocations. */
 	static mcpServerId = "mcp.server_id";
-	/** MCP tool name on spans created for callTool invocations. */
 	static mcpToolName = "mcp.tool_name";
-	/** Terminal node-execution status (e.g. `"hitl-approved"`, `"hitl-rejected"`) on HITL outcome spans. */
 	static nodeExecutionStatus = "codemation.node.execution_status";
-	/** Populated on run-halted spans; discriminates the halt reason (e.g. `"hitl-rejected"`). */
 	static runHaltReason = "codemation.run.halt_reason";
-	/** Human task ID on `hitl.task.*` span events. */
 	static hitlTaskId = "codemation.hitl.task_id";
-	/** HITL channel name (e.g. `"inbox"`, `"control-plane-inbox"`) on `hitl.task.*` span events. */
 	static hitlChannel = "codemation.hitl.channel";
-	/** Decision outcome (e.g. `"approved"`, `"rejected"`) on `hitl.task.decided` span events. */
 	static hitlDecisionStatus = "codemation.hitl.decision_status";
 };
 
@@ -2029,7 +1701,6 @@ var CatalogBackedCostTrackingTelemetryFactory = class {
 
 //#endregion
 //#region src/execution/InProcessRetryRunner.ts
-/** Maximum permitted retry attempts — workflow-declared values above this are clamped. */
 const HARD_MAX_RETRY_ATTEMPTS = 10;
 var InProcessRetryRunner = class InProcessRetryRunner {
 	constructor(sleeper) {
@@ -2121,9 +1792,6 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 
 //#endregion
 //#region src/execution/ItemExprResolver.ts
-/**
-* Resolves {@link import("../contracts/itemExpr").ItemExpr} leaves on runnable config before {@link RunnableNode.execute}.
-*/
 var ItemExprResolver = class {
 	async resolveConfigForItem(ctx, item, itemIndex, items) {
 		if (!ctx) throw new Error("ItemExprResolver.resolveConfigForItem: ctx is required");
@@ -2213,9 +1881,6 @@ var InProcessRetryRunnerFactory = class {
 
 //#endregion
 //#region src/execution/NodeActivationRequestComposer.ts
-/**
-* Builds {@link NodeActivationRequest} values shared by workflow starters and continuation.
-*/
 var NodeActivationRequestComposer = class {
 	constructor(activationIdFactory, credentialResolverFactory) {
 		this.activationIdFactory = activationIdFactory;
@@ -2307,16 +1972,6 @@ var NodeActivationRequestComposer = class {
 
 //#endregion
 //#region src/execution/RunSuspendedError.ts
-/**
-* Internal sentinel thrown by {@link NodeSuspensionHandler} after persisting a suspension
-* entry. `NodeExecutionRequestHandlerService` catches this specifically and returns cleanly —
-* no continuation call, preventing `resumeFromNodeResult` / `resumeFromNodeError` from
-* overwriting the `"suspended"` run status.
-*
-* The `Error` suffix satisfies the ESLint `no-manual-di-new` allowlist. This is NOT a
-* user-facing error — it is an engine-internal control-flow primitive and should NOT be
-* exported from the public barrel.
-*/
 var RunSuspendedError = class extends Error {
 	constructor(runId, taskId) {
 		super(`RunSuspendedError: run ${runId} suspended on task ${taskId}`);
@@ -2493,7 +2148,6 @@ var NodeExecutor = class {
 		if (hasSuspension) throw new RunSuspendedError(request.runId, "unknown");
 		return byPort;
 	}
-	/** Use resolver ctx only when {@link NodeExecutionContext.config} is non-nullish. */
 	pickExecutionContext(runnableCtx, resolvedCtx) {
 		if (resolvedCtx != null && resolvedCtx.config != null) return resolvedCtx;
 		return runnableCtx;
@@ -2594,247 +2248,41 @@ var MissingRuntimeNode = class {
 };
 
 //#endregion
-//#region src/workflowSnapshots/MissingRuntimeTrigger.ts
-var MissingRuntimeTrigger = class {
-	kind = "trigger";
-	outputPorts = ["main"];
-	async setup(_ctx) {}
-	async execute(items) {
-		return { main: items };
-	}
-};
-
-//#endregion
-//#region src/workflowSnapshots/PersistedRuntimeTypeIdFactory.ts
-var PersistedRuntimeTypeIdFactory = class {
-	static fromMetadata(args) {
-		const metadata = getPersistedRuntimeTypeMetadata(args.type);
-		if (!metadata) return;
-		const packageName = metadata.packageName;
-		if (!packageName) return;
-		return `${packageName}::${metadata.persistedName}`;
+//#region src/workflowSnapshots/WorkflowParityMismatchError.ts
+var WorkflowParityMismatchError = class extends Error {
+	name = "WorkflowParityMismatchError";
+	missingNodes;
+	constructor(missingNodes) {
+		const labels = missingNodes.map((n) => `${n.nodeId} (token: ${n.missingTokenId ?? "unknown"})`).join(", ");
+		super(`Workflow parity mismatch: nodes resolve to MissingRuntime and cannot execute: ${labels}`);
+		this.missingNodes = missingNodes;
 	}
 };
 
 //#endregion
-//#region src/workflowSnapshots/PersistedWorkflowTokenRegistry.ts
-var PersistedWorkflowTokenRegistry = class {
-	tokensById = /* @__PURE__ */ new Map();
-	tokenIdsByToken = /* @__PURE__ */ new Map();
-	/**
-	* Register a token with its package ID. Token ID is inferred as `packageId::tokenName`.
-	*/
-	register(type, packageId, persistedNameOverride) {
-		const tokenId = `${packageId}::${persistedNameOverride ?? this.displayNameForTypeToken(type)}`;
-		this.tokensById.set(tokenId, type);
-		this.tokenIdsByToken.set(type, tokenId);
-		return tokenId;
-	}
-	/**
-	* Register all decorated runtime types discovered in workflows.
-	*/
-	registerFromWorkflows(workflows) {
-		for (const workflow of workflows) for (const node$1 of workflow.nodes) {
-			this.registerDecoratedType(node$1.type);
-			this.registerDecoratedType(node$1.config.type);
-			this.registerNestedTypes(node$1.config);
-		}
-	}
-	registerDecoratedType(type) {
-		if (this.tokenIdsByToken.has(type)) return;
-		const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type });
-		if (!tokenId) return;
-		this.tokensById.set(tokenId, type);
-		this.tokenIdsByToken.set(type, tokenId);
-	}
-	registerNestedTypes(value) {
-		if (Array.isArray(value)) {
-			for (const entry of value) this.registerNestedTypes(entry);
-			return;
-		}
-		if (!value || typeof value !== "object") return;
-		const record = value;
-		const type = this.asTypeToken(record.type);
-		if (type) this.registerDecoratedType(type);
-		for (const v of Object.values(record)) this.registerNestedTypes(v);
-	}
-	displayNameForTypeToken(token) {
-		if (typeof token === "function" && token.name) return token.name;
-		if (typeof token === "string") return token;
-		return "";
-	}
-	asTypeToken(value) {
-		if (typeof value === "function" || typeof value === "string" || typeof value === "symbol") return value;
-	}
-	getTokenId(token) {
-		const existing = this.tokenIdsByToken.get(token);
-		if (existing) return existing;
-		const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type: token });
-		if (!tokenId) return;
-		this.tokensById.set(tokenId, token);
-		this.tokenIdsByToken.set(token, tokenId);
-		return tokenId;
-	}
-	resolve(tokenId) {
-		return this.tokensById.get(tokenId);
+//#region src/workflowSnapshots/MissingRuntimeParityGuard.ts
+var MissingRuntimeParityGuard = class {
+	constructor(marker) {
+		this.marker = marker;
+	}
+	assertNone(workflow, nodeIds) {
+		const missing = (nodeIds ? workflow.nodes.filter((n) => nodeIds.includes(n.id)) : workflow.nodes).filter((n) => this.marker.isMarked(n.config)).map((n) => ({
+			nodeId: n.id,
+			kind: n.kind,
+			missingTokenId: n.config.missingTokenId
+		}));
+		if (missing.length > 0) throw new WorkflowParityMismatchError(missing);
 	}
 };
 
 //#endregion
-//#region src/workflowSnapshots/WorkflowSnapshotCodec.ts
-var WorkflowSnapshotCodec = class {
-	constructor(tokenRegistry) {
-		this.tokenRegistry = tokenRegistry;
-	}
-	create(workflow) {
-		return {
-			id: workflow.id,
-			name: workflow.name,
-			workflowErrorHandlerConfigured: workflow.workflowErrorHandler !== void 0,
-			...workflow.connections !== void 0 && workflow.connections.length > 0 ? { connections: workflow.connections } : {},
-			nodes: workflow.nodes.map((node$1) => {
-				const inspectorSummaryRows = this.safeInspectorSummary(node$1.config);
-				return {
-					id: node$1.id,
-					kind: node$1.kind,
-					name: node$1.name,
-					nodeTokenId: this.resolveTokenId(node$1.type),
-					configTokenId: this.resolveTokenId(node$1.config.type),
-					tokenName: this.resolveTokenName(node$1.type),
-					configTokenName: this.resolveTokenName(node$1.config.type),
-					config: this.serializeConfig(node$1.config),
-					...inspectorSummaryRows !== void 0 ? { inspectorSummary: inspectorSummaryRows } : {}
-				};
-			}),
-			edges: workflow.edges.map((edge) => ({
-				from: {
-					nodeId: edge.from.nodeId,
-					output: edge.from.output
-				},
-				to: {
-					nodeId: edge.to.nodeId,
-					input: edge.to.input
-				}
-			}))
-		};
-	}
-	hydrate(snapshotNode, liveConfig) {
-		const hydrated = this.mergeValue(liveConfig, snapshotNode.config);
-		const configToken = this.tokenRegistry.resolve(snapshotNode.configTokenId);
-		Object.assign(hydrated, {
-			type: configToken ?? liveConfig.type,
-			kind: snapshotNode.kind
-		});
-		if (snapshotNode.name && !("name" in hydrated && hydrated.name)) Object.assign(hydrated, { name: snapshotNode.name });
-		return hydrated;
-	}
-	serializeConfig(config) {
-		try {
-			const cloned = JSON.parse(JSON.stringify(config));
-			this.injectTokenIds(cloned, config);
-			return cloned;
-		} catch {
-			const fallback = {
-				kind: config.kind,
-				name: config.name,
-				id: config.id,
-				icon: config.icon,
-				description: config.description,
-				execution: config.execution
-			};
-			this.injectTokenIds(fallback, config);
-			return fallback;
-		}
-	}
-	/**
-	* Safely call `config.inspectorSummary()` and return a plain JSON-safe array, or undefined.
-	* Returns undefined if the method is absent, throws, or produces no valid rows.
-	*/
-	safeInspectorSummary(config) {
-		const fn = config.inspectorSummary;
-		if (typeof fn !== "function") return void 0;
-		let raw;
-		try {
-			raw = fn.call(config);
-		} catch {
-			return;
-		}
-		if (!Array.isArray(raw)) return void 0;
-		const rows = [];
-		for (const entry of raw) {
-			if (!entry || typeof entry !== "object") continue;
-			const { label, value } = entry;
-			if (typeof label !== "string" || typeof value !== "string") continue;
-			const trimmedLabel = label.trim();
-			if (trimmedLabel.length === 0) continue;
-			rows.push({
-				label: trimmedLabel,
-				value
-			});
-		}
-		return rows.length > 0 ? rows : void 0;
-	}
-	injectTokenIds(target, source) {
-		const type = this.asTypeToken(source.type);
-		if (type) target.tokenId = this.tokenRegistry.getTokenId(type) ?? this.resolveTokenName(type) ?? "unknown";
-		for (const [key, value] of Object.entries(source)) {
-			if (key === "type" || value == null) continue;
-			if (Array.isArray(value)) {
-				const targetArray = target[key];
-				if (Array.isArray(targetArray)) value.forEach((item, index) => {
-					if (item && typeof item === "object" && targetArray[index] && typeof targetArray[index] === "object") this.injectTokenIds(targetArray[index], item);
-				});
-				continue;
-			}
-			if (typeof value === "object") {
-				const targetValue = target[key];
-				if (targetValue && typeof targetValue === "object") this.injectTokenIds(targetValue, value);
-			}
-		}
-	}
-	mergeValue(liveValue, snapshotValue) {
-		const liveRecord = this.asRecord(liveValue);
-		const snapshotRecord = this.asRecord(snapshotValue);
-		const hydrated = Object.create(liveValue && typeof liveValue === "object" ? Object.getPrototypeOf(liveValue) ?? Object.prototype : Object.prototype);
-		for (const [key, value] of Object.entries(snapshotRecord)) hydrated[key] = this.mergeNestedValue(liveRecord[key], value);
-		this.restoreNonSerializableProperties(liveRecord, hydrated);
-		this.restoreTypeProperty(hydrated);
-		return hydrated;
-	}
-	mergeNestedValue(liveValue, snapshotValue) {
-		if (Array.isArray(snapshotValue)) {
-			const liveArray = Array.isArray(liveValue) ? liveValue : [];
-			return snapshotValue.map((entry, index) => this.mergeNestedValue(liveArray[index], entry));
-		}
-		if (snapshotValue && typeof snapshotValue === "object") return this.mergeValue(liveValue, snapshotValue);
-		return snapshotValue;
-	}
-	restoreNonSerializableProperties(liveRecord, hydrated) {
-		for (const [key, value] of Object.entries(liveRecord)) if (typeof value === "function" || typeof value === "symbol") hydrated[key] = value;
-		for (const sym of Object.getOwnPropertySymbols(liveRecord)) hydrated[sym] = liveRecord[sym];
-	}
-	restoreTypeProperty(record) {
-		const tokenId = typeof record.tokenId === "string" ? record.tokenId : void 0;
-		if (!tokenId) return;
-		const type = this.tokenRegistry.resolve(tokenId);
-		if (type) record.type = type;
-	}
-	resolveTokenId(token) {
-		return this.tokenRegistry.getTokenId(token) ?? this.resolveTokenName(token) ?? "unknown";
-	}
-	resolveTokenName(token) {
-		if (typeof token === "function" && token.name) return token.name;
-		if (typeof token === "string") return token;
-	}
-	asTypeToken(value) {
-		if (typeof value === "function" || typeof value === "string" || typeof value === "symbol") return value;
-	}
-	asRecord(value) {
-		if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-		const record = value;
-		const out = { ...record };
-		for (const sym of Object.getOwnPropertySymbols(value)) out[sym] = record[sym];
-		return out;
+//#region src/workflowSnapshots/MissingRuntimeTrigger.ts
+var MissingRuntimeTrigger = class {
+	kind = "trigger";
+	outputPorts = ["main"];
+	async setup(_ctx) {}
+	async execute(items) {
+		return { main: items };
 	}
 };
 
@@ -3103,9 +2551,6 @@ var NodeRunStateWriterFactory = class {
 
 //#endregion
 //#region src/execution/PersistedRunStateTerminalBuilder.ts
-/**
-* Merges common terminal-run fields onto a loaded {@link PersistedRunState} without repeating object literals.
-*/
 var PersistedRunStateTerminalBuilder = class {
 	mergeTerminal(args) {
 		return {
@@ -3203,9 +2648,6 @@ var RunStateSemantics = class {
 
 //#endregion
 //#region src/execution/WorkflowRunExecutionContextFactory.ts
-/**
-* Shared {@link ExecutionContextFactory#create} wiring for workflow runners (base context before node-specific fields).
-*/
 var WorkflowRunExecutionContextFactory = class {
 	constructor(executionContextFactory, credentialResolverFactory) {
 		this.executionContextFactory = executionContextFactory;
@@ -3324,7 +2766,7 @@ var WorkflowTopology = class WorkflowTopology {
 //#endregion
 //#region src/orchestration/RunContinuationService.ts
 var RunContinuationService = class {
-	constructor(activationIdFactory, workflowExecutionRepository, runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy) {
+	constructor(activationIdFactory, workflowExecutionRepository, runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy, parityGuard) {
 		this.activationIdFactory = activationIdFactory;
 		this.workflowExecutionRepository = workflowExecutionRepository;
 		this.runDataFactory = runDataFactory;
@@ -3342,6 +2784,7 @@ var RunContinuationService = class {
 		this.policyErrorServices = policyErrorServices;
 		this.terminalPersistence = terminalPersistence;
 		this.executionLimitsPolicy = executionLimitsPolicy;
+		this.parityGuard = parityGuard;
 	}
 	async markNodeRunning(args) {
 		const [state, schedulingState] = await Promise.all([this.workflowExecutionRepository.load(args.runId), this.workflowExecutionRepository.loadSchedulingState(args.runId)]);
@@ -3584,6 +3027,7 @@ var RunContinuationService = class {
 			nodeDefinition: def
 		});
 		try {
+			this.parityGuard.assertNone(wf, [next.nodeId]);
 			const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
 				runId: state.runId,
 				workflowId: state.workflowId,
@@ -3755,20 +3199,6 @@ var RunContinuationService = class {
 	async waitForWebhookResponse(runId) {
 		return await this.waiters.waitForWebhookResponse(runId);
 	}
-	/**
-	* Re-activate a previously suspended run item with a human decision.
-	*
-	* Called by the HITL resume endpoint. This method:
-	* 1. Loads `PersistedRunState` and locates the suspension entry by `taskId`.
-	* 2. Removes the entry from the `suspension` array; if empty, run stays `"suspended"` until
-	*    enqueue flips it to `"pending"`.
-	* 3. Writes `pendingResume` onto the state so `NodeExecutionRequestHandlerService` can
-	*    splice `resumeContext` into the node's execution context.
-	* 4. Reconstructs the original input from `outputsByNode` of the upstream node and
-	*    enqueues a new activation via `activationEnqueueService`.
-	*
-	* @throws if the run is not found, not suspended, or the `taskId` is unknown.
-	*/
 	async resumeRun(args) {
 		const state = await this.workflowExecutionRepository.load(args.runId);
 		if (!state) throw new Error(`Unknown runId: ${args.runId}`);
@@ -3827,6 +3257,7 @@ var RunContinuationService = class {
 			batchId,
 			input: resumeInput
 		});
+		this.parityGuard.assertNone(wf, [suspensionEntry.nodeId]);
 		const { result, queuedSnapshot } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
 			runId: state.runId,
 			workflowId: state.workflowId,
@@ -4061,6 +3492,7 @@ var RunContinuationService = class {
 			nodeDefinition: nextDefinition
 		});
 		try {
+			this.parityGuard.assertNone(args.workflow, [next.nodeId]);
 			const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
 				runId: args.state.runId,
 				workflowId: args.state.workflowId,
@@ -4175,10 +3607,6 @@ var RunContinuationService = class {
 			engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fb.maxSubworkflowDepth
 		};
 	}
-	/**
-	* Next activation could not be enqueued (e.g. input contract / mapping failed in the preparer).
-	* Marks the target node failed and terminates the run.
-	*/
 	async terminateRunAfterActivationEnqueueRejected(args) {
 		const finishedAt = args.completedAt;
 		const inputsByPort = NodeInputsByPortFactory.fromRequest(args.request);
@@ -4235,11 +3663,6 @@ var RunContinuationService = class {
 		this.waiters.resolveRunCompletion(result);
 		return result;
 	}
-	/**
-	* Inspects node outputs for a `decision.status` written by `defineHumanApprovalNode`.
-	* Returns the first-class HITL node status and halt classification, or `undefined`
-	* when the node is not a HITL approval node.
-	*/
 	resolveHitlStatus(outputs) {
 		const firstItem = outputs?.main?.[0];
 		const decisionStatus = firstItem && typeof firstItem === "object" && "json" in firstItem && firstItem.json && typeof firstItem.json === "object" && "decision" in firstItem.json && firstItem.json.decision && typeof firstItem.json.decision === "object" && "status" in firstItem.json.decision ? firstItem.json.decision.status : void 0;
@@ -4280,7 +3703,6 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 	constructor(topology) {
 		this.topology = topology;
 	}
-	/** Composition-root-friendly factory (avoids `new` at orchestration call sites under ESLint manual-DI rules). */
 	static createFromTopology(topology) {
 		return new CurrentStateFrontierPlanner(topology);
 	}
@@ -5032,12 +4454,6 @@ var DefaultDrivingScheduler = class {
 		}
 		return await this.prepareInlineDispatch(request);
 	}
-	/**
-	* Scheduler precedence is explicit:
-	* 1. run-intent override (`executionOptions.localOnly`)
-	* 2. node-level execution hint / queue policy
-	* 3. container-default scheduler policy fallback
-	*/
 	async selectScheduler(request) {
 		if (request.executionOptions?.localOnly) return {
 			mode: "local",
@@ -5103,14 +4519,6 @@ var InlineDrivingScheduler = class {
 	setContinuation(continuation) {
 		this.continuation = continuation;
 	}
-	/**
-	* Prevents new drain cycles from being scheduled and waits for all currently-running
-	* drains to complete. Call before closing the DB connection or rolling back test transactions
-	* to ensure no in-flight writes hit a closed/rolled-back connection.
-	*
-	* Bounded: only the drains already in-flight at call time are awaited. Runs that keep
-	* re-scheduling will not schedule new work once stopped is set.
-	*/
 	async stop() {
 		this.stopped = true;
 		if (this.activeDrainPromises.size > 0) await Promise.allSettled(this.activeDrainPromises);
@@ -5222,24 +4630,16 @@ var LocalOnlyScheduler = class {
 
 //#endregion
 //#region src/policies/executionLimits/EngineExecutionLimitsPolicy.ts
-/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
 const ENGINE_EXECUTION_LIMITS_DEFAULTS = {
 	defaultMaxNodeActivations: 1e5,
 	hardMaxNodeActivations: 1e5,
 	defaultMaxSubworkflowDepth: 32,
 	hardMaxSubworkflowDepth: 32
 };
-/**
-* Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
-*/
 var EngineExecutionLimitsPolicy = class {
 	constructor(config = ENGINE_EXECUTION_LIMITS_DEFAULTS) {
 		this.config = config;
 	}
-	/**
-	* 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() {
 		return this.mergeExecutionOptionsForNewRun(void 0, void 0);
 	}
@@ -5467,10 +4867,6 @@ var InMemoryRunDataFactory = class {
 
 //#endregion
 //#region src/triggers/polling/PollingTriggerDedupWindow.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}.
-*/
 var PollingTriggerDedupWindow = class PollingTriggerDedupWindow {
 	static defaultCapN = 2e3;
 	merge(previous, incoming, capN = PollingTriggerDedupWindow.defaultCapN) {
@@ -5484,11 +4880,6 @@ var PollingTriggerDedupWindow = class PollingTriggerDedupWindow {
 
 //#endregion
 //#region src/triggers/polling/PollingTriggerRuntime.ts
-/**
-* Generic polling-trigger runtime. Owns the set-interval loop, overlap guard, and persistence.
-* Constructed by {@link import("../../runtime/EngineFactory").EngineFactory} and exposed to plugin
-* authors via {@link import("../../contracts/runtimeTypes").TriggerSetupContext}.polling.
-*/
 var PollingTriggerRuntime = class {
 	activeTriggers = /* @__PURE__ */ new Set();
 	intervalsByTrigger = /* @__PURE__ */ new Map();
@@ -5590,7 +4981,7 @@ var NoOpPollingTriggerLogger = class {
 //#endregion
 //#region src/orchestration/NodeExecutionRequestHandlerService.ts
 var NodeExecutionRequestHandlerService = class {
-	constructor(workflowExecutionRepository, workflowSnapshotResolver, runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, nodeExecutor, continuation, executionLimitsPolicy) {
+	constructor(workflowExecutionRepository, workflowSnapshotResolver, runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, nodeExecutor, continuation, executionLimitsPolicy, parityGuard) {
 		this.workflowExecutionRepository = workflowExecutionRepository;
 		this.workflowSnapshotResolver = workflowSnapshotResolver;
 		this.runDataFactory = runDataFactory;
@@ -5600,6 +4991,7 @@ var NodeExecutionRequestHandlerService = class {
 		this.nodeExecutor = nodeExecutor;
 		this.continuation = continuation;
 		this.executionLimitsPolicy = executionLimitsPolicy;
+		this.parityGuard = parityGuard;
 	}
 	async handleNodeExecutionRequest(request) {
 		const [state, schedulingState] = await Promise.all([this.workflowExecutionRepository.load(request.runId), this.workflowExecutionRepository.loadSchedulingState(request.runId)]);
@@ -5683,6 +5075,7 @@ var NodeExecutionRequestHandlerService = class {
 		});
 		let outputs;
 		try {
+			this.parityGuard.assertNone(workflow, [request.nodeId]);
 			outputs = await this.nodeExecutor.execute(activationRequest);
 		} catch (error) {
 			if (error instanceof RunSuspendedError) return;
@@ -5857,12 +5250,6 @@ var RunQueuePlanner = class {
 		const received = queueEntry.collect.received;
 		for (const input$1 of queueEntry.collect.expectedInputs ?? []) if (!(input$1 in received)) received[input$1] = [];
 	}
-	/**
-	* Matches `CurrentStateFrontierPlanner.buildFrontierQueue`: anything that is not exactly one input
-	* port named `in` participates in multi-port collect (Merge after `If` branches, etc.). Routing must
-	* not depend solely on `nodeInstances.get(toNodeId)?.executeMulti`, or a Merge can be enqueued as a
-	* single-input job and `NodeExecutor` will call `execute` on a multi-input-only implementation.
-	*/
 	usesTopologyCollectMerge(toNodeId) {
 		const expectedInputs = this.topology.expectedInputsByNode.get(toNodeId) ?? [];
 		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") return true;
@@ -6262,11 +5649,6 @@ var EngineWaiters = class {
 
 //#endregion
 //#region src/orchestration/Engine.ts
-/**
-* Runtime facade for orchestration, continuation, triggers, and webhook routing.
-* Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
-* The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
-*/
 var Engine = class {
 	constructor(deps) {
 		this.deps = deps;
@@ -6340,10 +5722,6 @@ var Engine = class {
 	async waitForWebhookResponse(runId) {
 		return await this.deps.runContinuationService.waitForWebhookResponse(runId);
 	}
-	/**
-	* Re-activate a suspended run item with a human decision (HITL).
-	* The HTTP resume endpoint calls this; this method exposes the engine primitive.
-	*/
 	async resumeRun(args) {
 		return await this.deps.runContinuationService.resumeRun(args);
 	}
@@ -6354,11 +5732,6 @@ var Engine = class {
 
 //#endregion
 //#region src/runtime/EngineFactory.ts
-/**
-* Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
-* {@link import("../bootstrap/runtime/EngineRuntimeRegistrar").EngineRuntimeRegistrar}; this factory remains for tests and custom composition.
-* Exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
-*/
 var EngineFactory = class {
 	create(deps) {
 		const waiters = new EngineWaiters();
@@ -6370,7 +5743,9 @@ var EngineFactory = class {
 		const workflowSnapshotCodec = deps.workflowSnapshotCodec ?? new WorkflowSnapshotCodec(deps.tokenRegistry);
 		const missingRuntimeFallbacks = deps.missingRuntimeFallbacks ?? new MissingRuntimeFallbacks();
 		const workflowSnapshotResolver = new WorkflowSnapshotResolver(deps.workflowRepository, deps.tokenRegistry, workflowSnapshotCodec, missingRuntimeFallbacks);
-		const semantics = new RunStateSemantics(new MissingRuntimeExecutionMarker());
+		const missingRuntimeExecutionMarker = new MissingRuntimeExecutionMarker();
+		const semantics = new RunStateSemantics(missingRuntimeExecutionMarker);
+		const parityGuard = new MissingRuntimeParityGuard(missingRuntimeExecutionMarker);
 		const nodeActivationRequestInputPreparer = new NodeActivationRequestInputPreparer(deps.workflowNodeInstanceFactory);
 		const activationEnqueueService = new ActivationEnqueueService(deps.activationScheduler, deps.workflowExecutionRepository, nodeEventPublisher, nodeActivationRequestInputPreparer);
 		const runExecutionContextFactory = new WorkflowRunExecutionContextFactory(deps.executionContextFactory, credentialResolverFactory);
@@ -6380,8 +5755,8 @@ var EngineFactory = class {
 		const terminalPersistence = new RunTerminalPersistenceCoordinator(deps.workflowExecutionRepository, storagePolicyEvaluator);
 		const policyErrorServices = new WorkflowPolicyErrorServices(deps.nodeResolver);
 		const runStartService = new RunStartService(deps.runIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, workflowSnapshotCodec, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy, nodeEventPublisher, persistedRunStateTerminalBuilder);
-		const runContinuationService = new RunContinuationService(deps.activationIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy);
-		const nodeExecutionRequestHandler = new NodeExecutionRequestHandlerService(deps.workflowExecutionRepository, workflowSnapshotResolver, deps.runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, deps.nodeExecutor, runContinuationService, executionLimitsPolicy);
+		const runContinuationService = new RunContinuationService(deps.activationIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy, parityGuard);
+		const nodeExecutionRequestHandler = new NodeExecutionRequestHandlerService(deps.workflowExecutionRepository, workflowSnapshotResolver, deps.runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, deps.nodeExecutor, runContinuationService, executionLimitsPolicy, parityGuard);
 		const pollingTriggerLogger = deps.pollingTriggerLogger ?? new NoOpPollingTriggerLogger();
 		const pollingTriggerDedupWindow = new PollingTriggerDedupWindow();
 		const pollingTriggerRuntime = new PollingTriggerRuntime(deps.triggerSetupStateRepository, pollingTriggerLogger);
@@ -6564,10 +5939,6 @@ var RunIntentService = class {
 			};
 		})]);
 	}
-	/**
-	* Webhook-triggered runs always force inline execution first.
-	* This is the highest-precedence scheduler override: it wins over node hints and container defaults.
-	*/
 	createWebhookExecutionOptions() {
 		return {
 			localOnly: true,
@@ -6586,10 +5957,6 @@ var RunIntentServiceFactory = class {
 
 //#endregion
 //#region src/runtime/WorkflowRepositoryWebhookTriggerMatcher.ts
-/**
-* Resolves webhook HTTP routes from the live workflow repository (no trigger setup / registration).
-* Maintains an in-memory index keyed by user-defined endpoint path for O(1) lookups after reload.
-*/
 var WorkflowRepositoryWebhookTriggerMatcher = class {
 	routeByPath = /* @__PURE__ */ new Map();
 	engineRoutesActive = false;
@@ -6679,5 +6046,5 @@ var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
 };
 
 //#endregion
-export { CostTrackingTelemetryAttributeNames as $, PersistedWorkflowTokenRegistry as A, getPersistedRuntimeTypeMetadata as At, CatalogBackedCostTrackingTelemetryFactory as B, HitlWorkspaceIdToken as Bt, DefaultDrivingScheduler as C, mergeForward as Ct, NodeInstanceFactoryFactory as D, defineBatchNode as Dt, StaticCostCatalog as E, isHumanApprovalNode as Et, InProcessRetryRunnerFactory as F, StackTraceCallSitePathResolver as Ft, AllWorkflowsActiveWorkflowActivationPolicy as G, CodemationTelemetryMetricNames as H, RunnableOutputBehaviorResolver as I, PersistedRuntimeTypeNameResolver as It, NoOpNodeExecutionTelemetry as J, NoOpExecutionTelemetryFactory as K, NodeOutputNormalizer as L, DefinedNodeRegistry as Lt, NodeExecutorFactory as M, tool as Mt, NodeExecutor as N, InjectableRuntimeDecoratorComposer as Nt, NodeInstanceFactory as O, defineNode as Ot, RunSuspendedError as P, PersistedRuntimeTypeMetadataStore as Pt, NoOpCostTrackingTelemetry as Q, ItemExprResolver as R, HitlResumeTokenSignerToken as Rt, HintOnlyOffloadPolicy as S, ChainCursor as St, RunPolicySnapshotFactory as T, defineHumanApprovalNode as Tt, GenAiTelemetryAttributeNames as U, DefaultExecutionContextFactory as V, HumanTaskStoreToken as Vt, CodemationTelemetryAttributeNames as W, NoOpTelemetryArtifactReference as X, NoOpTelemetrySpanScope as Y, NoOpCostTrackingTelemetryFactory as Z, RunTerminalPersistenceCoordinator as _, WorkflowExecutableNodeClassifier as _t, InMemoryLiveWorkflowRepository as a, isPortsEmission as at, LocalOnlyScheduler as b, WorkflowDefinitionError as bt, EngineFactory as c, CredentialResolverFactory as ct, PollingTriggerRuntime as d, DefaultExecutionBinaryService as dt, CostTrackingTelemetryMetricNames as et, PollingTriggerDedupWindow as f, UnavailableBinaryStorage as ft, WorkflowPolicyErrorServices as g, WorkflowExecutableNodeClassifierFactory as gt, WorkflowStoragePolicyEvaluator as h, DefaultWorkflowGraphFactory as ht, RunIntentService as i, emitPorts as it, MissingRuntimeTriggerToken as j, node as jt, WorkflowSnapshotCodec as k, chatModel as kt, Engine as l, getOriginIndexFromItem as lt, InMemoryBinaryStorage as m, ConnectionInvocationEventPublisher as mt, WorkflowRepositoryWebhookTriggerMatcher as n, RetryPolicy as nt, EngineWorkflowRunnerServiceFactory as o, isUnbrandedPortsEmissionShape as ot, InMemoryRunDataFactory as p, NodeEventPublisher as pt, NoOpExecutionTelemetry as q, RunIntentServiceFactory as r, NoRetryPolicy as rt, EngineWorkflowRunnerService as s, DefaultAsyncSleeper as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, ExpRetryPolicy as tt, NoOpPollingTriggerLogger as u, ChildExecutionScopeFactory as ut, ENGINE_EXECUTION_LIMITS_DEFAULTS as v, ConnectionInvocationIdFactory as vt, ConfigDrivenOffloadPolicy as w, WhenBuilder as wt, InlineDrivingScheduler as x, NodeIdSlugifier as xt, EngineExecutionLimitsPolicy as y, WorkflowBuilder as yt, InProcessRetryRunner as z, HitlTimeoutJobSchedulerToken as zt };
-//# sourceMappingURL=runtime-CSunvf7A.js.map
+export { CostTrackingTelemetryAttributeNames as $, WorkflowParityMismatchError as A, HitlResumeTokenSignerToken as At, CatalogBackedCostTrackingTelemetryFactory as B, DefaultDrivingScheduler as C, mergeForward as Ct, NodeInstanceFactoryFactory as D, defineBatchNode as Dt, StaticCostCatalog as E, isHumanApprovalNode as Et, InProcessRetryRunnerFactory as F, AllWorkflowsActiveWorkflowActivationPolicy as G, CodemationTelemetryMetricNames as H, RunnableOutputBehaviorResolver as I, NoOpNodeExecutionTelemetry as J, NoOpExecutionTelemetryFactory as K, NodeOutputNormalizer as L, NodeExecutorFactory as M, HitlWorkspaceIdToken as Mt, NodeExecutor as N, HumanTaskStoreToken as Nt, NodeInstanceFactory as O, defineNode as Ot, RunSuspendedError as P, NoOpCostTrackingTelemetry as Q, ItemExprResolver as R, HintOnlyOffloadPolicy as S, ChainCursor as St, RunPolicySnapshotFactory as T, defineHumanApprovalNode as Tt, GenAiTelemetryAttributeNames as U, DefaultExecutionContextFactory as V, CodemationTelemetryAttributeNames as W, NoOpTelemetryArtifactReference as X, NoOpTelemetrySpanScope as Y, NoOpCostTrackingTelemetryFactory as Z, RunTerminalPersistenceCoordinator as _, WorkflowExecutableNodeClassifier as _t, InMemoryLiveWorkflowRepository as a, isPortsEmission as at, LocalOnlyScheduler as b, WorkflowDefinitionError as bt, EngineFactory as c, CredentialResolverFactory as ct, PollingTriggerRuntime as d, DefaultExecutionBinaryService as dt, CostTrackingTelemetryMetricNames as et, PollingTriggerDedupWindow as f, UnavailableBinaryStorage as ft, WorkflowPolicyErrorServices as g, WorkflowExecutableNodeClassifierFactory as gt, WorkflowStoragePolicyEvaluator as h, DefaultWorkflowGraphFactory as ht, RunIntentService as i, emitPorts as it, MissingRuntimeTriggerToken as j, HitlTimeoutJobSchedulerToken as jt, MissingRuntimeParityGuard as k, DefinedNodeRegistry as kt, Engine as l, getOriginIndexFromItem as lt, InMemoryBinaryStorage as m, ConnectionInvocationEventPublisher as mt, WorkflowRepositoryWebhookTriggerMatcher as n, RetryPolicy as nt, EngineWorkflowRunnerServiceFactory as o, isUnbrandedPortsEmissionShape as ot, InMemoryRunDataFactory as p, NodeEventPublisher as pt, NoOpExecutionTelemetry as q, RunIntentServiceFactory as r, NoRetryPolicy as rt, EngineWorkflowRunnerService as s, DefaultAsyncSleeper as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, ExpRetryPolicy as tt, NoOpPollingTriggerLogger as u, ChildExecutionScopeFactory as ut, ENGINE_EXECUTION_LIMITS_DEFAULTS as v, ConnectionInvocationIdFactory as vt, ConfigDrivenOffloadPolicy as w, WhenBuilder as wt, InlineDrivingScheduler as x, NodeIdSlugifier as xt, EngineExecutionLimitsPolicy as y, WorkflowBuilder as yt, InProcessRetryRunner as z };
+//# sourceMappingURL=runtime-CBFDpmiz.js.map