@codemation/core 0.13.2 → 0.15.0

package/dist/{runtime-_VdHwGkJ.cjs → runtime-Due-FOZ2.cjs}

@@ -1,12 +1,12 @@
-const require_di = require('./di-LP2qSHkY.cjs');
+const require_di = require('./di-C6Ubf9o5.cjs');
+const require_workflowTypes = require('./workflowTypes-BW6Hhee7.cjs');
+const require_contracts = require('./contracts-7L1wJHdk.cjs');
+let node_crypto = require("node:crypto");
+node_crypto = require_di.__toESM(node_crypto);
 let zod = require("zod");
 zod = require_di.__toESM(zod);
 let node_stream_web = require("node:stream/web");
 node_stream_web = require_di.__toESM(node_stream_web);
-let node_crypto = require("node:crypto");
-node_crypto = require_di.__toESM(node_crypto);
-let tsyringe = require("tsyringe");
-tsyringe = require_di.__toESM(tsyringe);
 
 //#region src/contracts/humanTaskStoreTypes.ts
 const HumanTaskStoreToken = Symbol.for("codemation.core.HumanTaskStore");
@@ -15,12 +15,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
@@ -35,115 +29,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) => {
-			(0, tsyringe.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, require("url").pathToFileURL(__filename).href);
-}
-/** Marks a class as a persisted tool runtime type and an injectable tsyringe service. */
-function tool(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("tool", options, require("url").pathToFileURL(__filename).href);
-}
-/** Marks a class as a persisted chat-model runtime type and an injectable tsyringe service. */
-function chatModel(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, require("url").pathToFileURL(__filename).href);
-}
-
 //#endregion
 //#region src/authoring/defineNode.types.ts
 const definedNodeCredentialRequirementFactory = {
@@ -204,16 +89,20 @@ function defineNode(options) {
 			return await options.execute(payload, context);
 		}
 	};
-	node({ name: options.key })(DefinedNodeRuntime);
+	require_contracts.node({ name: options.key })(DefinedNodeRuntime);
 	const DefinedRunnableNodeConfig = class {
 		kind = "node";
 		type = DefinedNodeRuntime;
 		icon = options.icon;
 		inputSchema = options.inputSchema;
 		keepBinaries = options.keepBinaries ?? false;
-		constructor(name, config, id) {
+		id;
+		description;
+		constructor(name, config, idOrOptions) {
 			this.name = name;
-			this.id = id;
+			const resolved = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+			this.id = resolved?.id;
+			this.description = resolved?.description;
 			this.config = config;
 		}
 		config;
@@ -229,8 +118,8 @@ function defineNode(options) {
 		key: options.key,
 		title: options.title,
 		description: options.description,
-		create(config, name = options.title, id) {
-			return new DefinedRunnableNodeConfig(name, config, id);
+		create(config, name = options.title, idOrOptions) {
+			return new DefinedRunnableNodeConfig(name, config, idOrOptions);
 		},
 		register(context) {
 			context.registerNode(DefinedNodeRuntime);
@@ -255,14 +144,18 @@ function defineBatchNode(options) {
 			return [...await options.run(args.items.map((item) => item.json), context)];
 		}
 	};
-	node({ name: options.key })(DefinedNodeRuntime);
+	require_contracts.node({ name: options.key })(DefinedNodeRuntime);
 	const DefinedRunnableNodeConfig = class {
 		kind = "node";
 		type = DefinedNodeRuntime;
 		icon = options.icon;
-		constructor(name, config, id) {
+		id;
+		description;
+		constructor(name, config, idOrOptions) {
 			this.name = name;
-			this.id = id;
+			const resolved = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+			this.id = resolved?.id;
+			this.description = resolved?.description;
 			this.config = config;
 		}
 		config;
@@ -278,8 +171,8 @@ function defineBatchNode(options) {
 		key: options.key,
 		title: options.title,
 		description: options.description,
-		create(config, name = options.title, id) {
-			return new DefinedRunnableNodeConfig(name, config, id);
+		create(config, name = options.title, idOrOptions) {
+			return new DefinedRunnableNodeConfig(name, config, idOrOptions);
 		},
 		register(context) {
 			context.registerNode(DefinedNodeRuntime);
@@ -291,60 +184,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";
@@ -361,7 +203,7 @@ function defineHumanApprovalNode(opts) {
 		async execute(args, { config, execution: ctx }) {
 			if (!ctx.resumeContext) {
 				const subject = buildSubject(opts.title, args.item, ctx);
-				throw new require_di.SuspensionRequest({
+				throw new require_workflowTypes.SuspensionRequest({
 					decisionSchema: opts.decisionSchema,
 					timeout,
 					onTimeout,
@@ -446,10 +288,12 @@ async function handleResume(item, resumeContext, decisionSchema, resolvedPredica
 //#endregion
 //#region src/workflow/dsl/WhenBuilder.ts
 var WhenBuilder = class WhenBuilder {
-	constructor(wf, from, branchPort) {
+	armEndpoint;
+	constructor(wf, from, branchPort, priorEndpoints = []) {
 		this.wf = wf;
 		this.from = from;
 		this.branchPort = branchPort;
+		this.priorEndpoints = priorEndpoints;
 	}
 	addBranch(steps) {
 		const created = [];
@@ -470,20 +314,48 @@ var WhenBuilder = class WhenBuilder {
 				return nodeId ? { nodeId } : { nodeId: r };
 			});
 		}
+		this.armEndpoint = prev ? {
+			node: prev,
+			output: "main",
+			inputPortHint: this.branchPort
+		} : {
+			node: this.from,
+			output: this.branchPort,
+			inputPortHint: this.branchPort
+		};
 		return this;
 	}
 	when = (branch, steps, ...more) => {
 		const list = Array.isArray(steps) ? steps : [steps, ...more];
 		const port = branch ? "true" : "false";
-		const b = new WhenBuilder(this.wf, this.from, port);
+		const b = new WhenBuilder(this.wf, this.from, port, this.accumulatedEndpoints);
 		b.addBranch(list);
 		return b;
 	};
+	then(config) {
+		return this.toCursor().then(config);
+	}
+	humanApproval(node$1, config, metadata) {
+		return this.toCursor().humanApproval(node$1, config, metadata);
+	}
 	build() {
 		return this.wf.build();
 	}
+	get accumulatedEndpoints() {
+		return this.armEndpoint ? [...this.priorEndpoints, this.armEndpoint] : this.priorEndpoints;
+	}
+	toCursor() {
+		return new ChainCursor(this.wf, this.accumulatedEndpoints);
+	}
 };
 
+//#endregion
+//#region src/workflow/dsl/workflowBuilderTypes.ts
+function mergeForward(config) {
+	config.mergeJson = true;
+	return config;
+}
+
 //#endregion
 //#region src/workflow/dsl/ChainCursorResolver.ts
 var ChainCursor = class ChainCursor {
@@ -501,6 +373,10 @@ var ChainCursor = class ChainCursor {
 			...inputPortHint ? { inputPortHint } : {}
 		}]);
 	}
+	thenMerge(config) {
+		mergeForward(config);
+		return this.then(config);
+	}
 	thenIntoInputHints(config) {
 		const next = this.wf.add(config);
 		for (const e of this.endpoints) this.wf.connect(e.node, next, e.output, e.inputPortHint ?? "in");
@@ -569,21 +445,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));
@@ -600,15 +461,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, "");
@@ -616,15 +468,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);
@@ -699,7 +542,7 @@ var WorkflowBuilder = class {
 				tokenName,
 				label: node$1.name ?? ""
 			});
-			if (require_di.AgentConfigInspector.isAgentNodeConfig(node$1.config)) for (const child of require_di.AgentConnectionNodeCollector.collect(node$1.id, node$1.config)) entries.push({
+			if (require_di.AgentConfigInspector.isAgentNodeConfig(node$1.config)) for (const child of require_workflowTypes.AgentConnectionNodeCollector.collect(node$1.id, node$1.config)) entries.push({
 				nodeId: child.nodeId,
 				tokenName: child.typeName,
 				label: child.name
@@ -736,17 +579,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}`;
 	}
@@ -754,9 +590,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) {
@@ -776,9 +609,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;
@@ -843,13 +673,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;
@@ -877,7 +700,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;
@@ -897,20 +719,7 @@ 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 = require_di.BINARY_DEFAULT_MAX_BYTES) {
+async function boundedReadBinary(result, attachment, maxBytes = require_workflowTypes.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);
 	const reader = result.body.getReader();
@@ -926,18 +735,15 @@ async function boundedReadBinary(result, attachment, maxBytes = require_di.BINAR
 	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 {
@@ -1281,19 +1087,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;
@@ -1323,9 +1116,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;
@@ -1333,17 +1123,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();
@@ -1393,11 +1172,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) {
@@ -1544,13 +1318,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,
@@ -1620,12 +1392,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",
@@ -1660,7 +1426,6 @@ const noOpTelemetrySpanScope = {
 };
 var NoOpTelemetrySpanScope = class {
 	static value = noOpTelemetrySpanScope;
-	/** Internal: the shared no-op {@link NodeExecutionTelemetry} that {@link NoOpNodeExecutionTelemetry} re-exposes. */
 	static nodeExecutionTelemetryValue = noOpNodeExecutionTelemetry;
 };
 
@@ -1697,7 +1462,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;
@@ -1717,25 +1481,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";
 };
 
@@ -1950,7 +1704,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) {
@@ -2042,9 +1795,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");
@@ -2090,10 +1840,16 @@ var NodeOutputNormalizer = class {
 	isItemLike(value) {
 		return typeof value === "object" && value !== null && "json" in value;
 	}
+	isPlainJsonObject(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
+	}
 	applyOutput(baseItem, next, behavior) {
 		const explicitBinary = next.binary;
 		return {
-			json: next.json,
+			json: behavior.mergeJson && this.isPlainJsonObject(baseItem.json) && this.isPlainJsonObject(next.json) ? {
+				...baseItem.json,
+				...next.json
+			} : next.json,
 			...explicitBinary !== void 0 ? { binary: explicitBinary } : behavior.keepBinaries && baseItem.binary ? { binary: baseItem.binary } : {},
 			...next.meta ? { meta: next.meta } : {},
 			...next.paired ? { paired: next.paired } : {}
@@ -2105,11 +1861,17 @@ var NodeOutputNormalizer = class {
 //#region src/execution/RunnableOutputBehaviorResolver.ts
 var RunnableOutputBehaviorResolver = class {
 	resolve(config) {
-		return { keepBinaries: this.isKeepBinariesEnabled(config) };
+		return {
+			keepBinaries: this.isKeepBinariesEnabled(config),
+			mergeJson: this.isMergeJsonEnabled(config)
+		};
 	}
 	isKeepBinariesEnabled(config) {
 		return config.keepBinaries === true;
 	}
+	isMergeJsonEnabled(config) {
+		return config.mergeJson === true;
+	}
 };
 
 //#endregion
@@ -2122,9 +1884,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;
@@ -2216,16 +1975,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}`);
@@ -2267,8 +2016,8 @@ var NodeExecutor = class {
 		}
 	}
 	isCredentialError(e) {
-		if (e instanceof require_di.CredentialUnboundError) return true;
-		return (e instanceof Error ? e.cause : void 0) instanceof require_di.CredentialUnboundError;
+		if (e instanceof require_workflowTypes.CredentialUnboundError) return true;
+		return (e instanceof Error ? e.cause : void 0) instanceof require_workflowTypes.CredentialUnboundError;
 	}
 	async executeMultiInputActivation(request, node$1) {
 		const multiInputNode = node$1;
@@ -2355,7 +2104,7 @@ var NodeExecutor = class {
 			const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
 			const iterationCtx = {
 				...this.pickExecutionContext(runnableCtx, resolvedCtx),
-				iterationId: require_di.NodeIterationIdFactory.create(),
+				iterationId: require_workflowTypes.NodeIterationIdFactory.create(),
 				itemIndex: i
 			};
 			const args = {
@@ -2369,7 +2118,7 @@ var NodeExecutor = class {
 			try {
 				raw = await Promise.resolve(node$1.execute(args));
 			} catch (e) {
-				if (e instanceof require_di.SuspensionRequest || e instanceof Error && e.name === "SuspensionRequest" && typeof e.request === "object") {
+				if (e instanceof require_workflowTypes.SuspensionRequest || e instanceof Error && e.name === "SuspensionRequest" && typeof e.request === "object") {
 					if (!this.suspensionHandler || !this.loadRunState) throw new Error(`Node ${request.nodeId} threw SuspensionRequest but this NodeExecutor has no suspensionHandler configured.`, { cause: e });
 					const state = await this.loadRunState(request.runId);
 					if (!state) throw new Error(`NodeExecutor: run state not found for runId ${request.runId} during suspension`, { cause: e });
@@ -2402,7 +2151,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;
@@ -2503,246 +2251,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,
-				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 };
 	}
 };
 
@@ -3011,9 +2554,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 {
@@ -3111,9 +2651,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;
@@ -3232,7 +2769,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;
@@ -3250,6 +2787,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)]);
@@ -3492,6 +3030,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,
@@ -3663,20 +3202,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}`);
@@ -3735,6 +3260,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,
@@ -3969,6 +3495,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,
@@ -4083,10 +3610,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);
@@ -4143,11 +3666,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;
@@ -4188,7 +3706,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);
 	}
@@ -4443,7 +3960,7 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 	isRuntimeDescendant(nodeId, descendantNodeIds) {
 		for (const descendantNodeId of descendantNodeIds) {
 			if (nodeId === descendantNodeId) return false;
-			if (require_di.ConnectionNodeIdFactory.isConnectionOwnedDescendantOf(descendantNodeId, nodeId)) return true;
+			if (require_workflowTypes.ConnectionNodeIdFactory.isConnectionOwnedDescendantOf(descendantNodeId, nodeId)) return true;
 		}
 		return false;
 	}
@@ -4940,12 +4457,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",
@@ -5011,14 +4522,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);
@@ -5130,24 +4633,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);
 	}
@@ -5375,10 +4870,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) {
@@ -5392,11 +4883,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();
@@ -5498,7 +4984,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;
@@ -5508,6 +4994,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)]);
@@ -5591,6 +5078,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;
@@ -5765,12 +5253,6 @@ var RunQueuePlanner = class {
 		const received = queueEntry.collect.received;
 		for (const input of queueEntry.collect.expectedInputs ?? []) if (!(input in received)) received[input] = [];
 	}
-	/**
-	* 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;
@@ -6170,11 +5652,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;
@@ -6248,10 +5725,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);
 	}
@@ -6262,11 +5735,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();
@@ -6275,10 +5743,12 @@ var EngineFactory = class {
 		const nodeStatePublisherFactory = new NodeRunStateWriterFactory(deps.workflowExecutionRepository, nodeEventPublisher, deps.eventBus);
 		const planningFactory = new EngineWorkflowPlanningFactory(deps.workflowNodeInstanceFactory);
 		const executionLimitsPolicy = deps.executionLimitsPolicy ?? new EngineExecutionLimitsPolicy();
-		const workflowSnapshotCodec = deps.workflowSnapshotCodec ?? new WorkflowSnapshotCodec(deps.tokenRegistry);
+		const workflowSnapshotCodec = deps.workflowSnapshotCodec ?? new require_contracts.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);
@@ -6288,8 +5758,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);
@@ -6472,10 +5942,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,
@@ -6494,10 +5960,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;
@@ -6803,12 +6265,6 @@ Object.defineProperty(exports, 'InProcessRetryRunnerFactory', {
     return InProcessRetryRunnerFactory;
   }
 });
-Object.defineProperty(exports, 'InjectableRuntimeDecoratorComposer', {
-  enumerable: true,
-  get: function () {
-    return InjectableRuntimeDecoratorComposer;
-  }
-});
 Object.defineProperty(exports, 'InlineDrivingScheduler', {
   enumerable: true,
   get: function () {
@@ -6827,6 +6283,12 @@ Object.defineProperty(exports, 'LocalOnlyScheduler', {
     return LocalOnlyScheduler;
   }
 });
+Object.defineProperty(exports, 'MissingRuntimeParityGuard', {
+  enumerable: true,
+  get: function () {
+    return MissingRuntimeParityGuard;
+  }
+});
 Object.defineProperty(exports, 'MissingRuntimeTriggerToken', {
   enumerable: true,
   get: function () {
@@ -6929,24 +6391,6 @@ Object.defineProperty(exports, 'NodeOutputNormalizer', {
     return NodeOutputNormalizer;
   }
 });
-Object.defineProperty(exports, 'PersistedRuntimeTypeMetadataStore', {
-  enumerable: true,
-  get: function () {
-    return PersistedRuntimeTypeMetadataStore;
-  }
-});
-Object.defineProperty(exports, 'PersistedRuntimeTypeNameResolver', {
-  enumerable: true,
-  get: function () {
-    return PersistedRuntimeTypeNameResolver;
-  }
-});
-Object.defineProperty(exports, 'PersistedWorkflowTokenRegistry', {
-  enumerable: true,
-  get: function () {
-    return PersistedWorkflowTokenRegistry;
-  }
-});
 Object.defineProperty(exports, 'PollingTriggerDedupWindow', {
   enumerable: true,
   get: function () {
@@ -7001,12 +6445,6 @@ Object.defineProperty(exports, 'RunnableOutputBehaviorResolver', {
     return RunnableOutputBehaviorResolver;
   }
 });
-Object.defineProperty(exports, 'StackTraceCallSitePathResolver', {
-  enumerable: true,
-  get: function () {
-    return StackTraceCallSitePathResolver;
-  }
-});
 Object.defineProperty(exports, 'StaticCostCatalog', {
   enumerable: true,
   get: function () {
@@ -7049,6 +6487,12 @@ Object.defineProperty(exports, 'WorkflowExecutableNodeClassifierFactory', {
     return WorkflowExecutableNodeClassifierFactory;
   }
 });
+Object.defineProperty(exports, 'WorkflowParityMismatchError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowParityMismatchError;
+  }
+});
 Object.defineProperty(exports, 'WorkflowPolicyErrorServices', {
   enumerable: true,
   get: function () {
@@ -7067,24 +6511,12 @@ Object.defineProperty(exports, 'WorkflowRepositoryWebhookTriggerMatcherFactory',
     return WorkflowRepositoryWebhookTriggerMatcherFactory;
   }
 });
-Object.defineProperty(exports, 'WorkflowSnapshotCodec', {
-  enumerable: true,
-  get: function () {
-    return WorkflowSnapshotCodec;
-  }
-});
 Object.defineProperty(exports, 'WorkflowStoragePolicyEvaluator', {
   enumerable: true,
   get: function () {
     return WorkflowStoragePolicyEvaluator;
   }
 });
-Object.defineProperty(exports, 'chatModel', {
-  enumerable: true,
-  get: function () {
-    return chatModel;
-  }
-});
 Object.defineProperty(exports, 'defineBatchNode', {
   enumerable: true,
   get: function () {
@@ -7115,12 +6547,6 @@ Object.defineProperty(exports, 'getOriginIndexFromItem', {
     return getOriginIndexFromItem;
   }
 });
-Object.defineProperty(exports, 'getPersistedRuntimeTypeMetadata', {
-  enumerable: true,
-  get: function () {
-    return getPersistedRuntimeTypeMetadata;
-  }
-});
 Object.defineProperty(exports, 'isHumanApprovalNode', {
   enumerable: true,
   get: function () {
@@ -7139,16 +6565,10 @@ Object.defineProperty(exports, 'isUnbrandedPortsEmissionShape', {
     return isUnbrandedPortsEmissionShape;
   }
 });
-Object.defineProperty(exports, 'node', {
-  enumerable: true,
-  get: function () {
-    return node;
-  }
-});
-Object.defineProperty(exports, 'tool', {
+Object.defineProperty(exports, 'mergeForward', {
   enumerable: true,
   get: function () {
-    return tool;
+    return mergeForward;
   }
 });
-//# sourceMappingURL=runtime-_VdHwGkJ.cjs.map
+//# sourceMappingURL=runtime-Due-FOZ2.cjs.map