@codemation/core 1.0.1 → 2.0.0

package/dist/index.cjs

@@ -1,9 +1,7 @@
-const require_runtime = require('./runtime-B3Og-_St.cjs');
-const require_InMemoryRunEventBusRegistry = require('./InMemoryRunEventBusRegistry-B0_C4OnP.cjs');
+const require_runtime = require('./runtime-DKXJwTNv.cjs');
+const require_InMemoryRunEventBusRegistry = require('./InMemoryRunEventBusRegistry-VM3OWnHo.cjs');
 let zod = require("zod");
 zod = require_runtime.__toESM(zod);
-let node_crypto = require("node:crypto");
-node_crypto = require_runtime.__toESM(node_crypto);
 let tsyringe = require("tsyringe");
 tsyringe = require_runtime.__toESM(tsyringe);
 
@@ -28,7 +26,7 @@ var DefinedNodeRegistry = class {
 
 //#endregion
 //#region src/authoring/defineNode.types.ts
-const definedNodeCredentialRequirementFactory = {
+const definedNodeCredentialRequirementFactory$1 = {
 	create(bindings) {
 		if (!bindings) return [];
 		return Object.entries(bindings).map(([slotKey, binding]) => {
@@ -58,13 +56,13 @@ const definedNodeCredentialRequirementFactory = {
 		return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim().replace(/^./, (character) => character.toUpperCase());
 	}
 };
-const definedNodeCredentialAccessorFactory = { create(bindings, ctx) {
+const definedNodeCredentialAccessorFactory$1 = { create(bindings, ctx) {
 	if (!bindings) return {};
 	const entries = Object.keys(bindings).map((slotKey) => [slotKey, () => ctx.getCredential(slotKey)]);
 	return Object.fromEntries(entries);
 } };
 function defineNode(options) {
-	const credentialRequirements = definedNodeCredentialRequirementFactory.create(options.credentials);
+	const credentialRequirements = definedNodeCredentialRequirementFactory$1.create(options.credentials);
 	const DefinedNodeRuntime = class {
 		kind = "node";
 		outputPorts = ["main"];
@@ -73,7 +71,7 @@ function defineNode(options) {
 			const ctx = args.ctx;
 			const context = {
 				config: ctx.config.config,
-				credentials: definedNodeCredentialAccessorFactory.create(options.credentials, ctx),
+				credentials: definedNodeCredentialAccessorFactory$1.create(options.credentials, ctx),
 				execution: ctx
 			};
 			const payload = {
@@ -119,7 +117,7 @@ function defineNode(options) {
 	return definition;
 }
 function defineBatchNode(options) {
-	const credentialRequirements = definedNodeCredentialRequirementFactory.create(options.credentials);
+	const credentialRequirements = definedNodeCredentialRequirementFactory$1.create(options.credentials);
 	const DefinedNodeRuntime = class {
 		kind = "node";
 		outputPorts = ["main"];
@@ -128,7 +126,7 @@ function defineBatchNode(options) {
 			const ctx = args.ctx;
 			const context = {
 				config: ctx.config.config,
-				credentials: definedNodeCredentialAccessorFactory.create(options.credentials, ctx),
+				credentials: definedNodeCredentialAccessorFactory$1.create(options.credentials, ctx),
 				execution: ctx
 			};
 			return [...await options.run(args.items.map((item) => item.json), context)];
@@ -336,84 +334,295 @@ function callableTool(options) {
 }
 
 //#endregion
-//#region src/ai/NodeBackedToolConfig.ts
-var NodeBackedToolConfig = class {
-	type;
-	toolKind = "nodeBacked";
-	description;
-	presentation;
-	inputSchemaValue;
-	outputSchemaValue;
-	mapInputValue;
-	mapOutputValue;
-	constructor(name, node$1, options) {
-		this.name = name;
-		this.node = node$1;
-		this.type = node$1.type;
-		this.description = options.description;
-		this.presentation = options.presentation;
-		this.inputSchemaValue = options.inputSchema;
-		this.outputSchemaValue = options.outputSchema;
-		this.mapInputValue = options.mapInput;
-		this.mapOutputValue = options.mapOutput;
+//#region src/authoring/DefinedCollectionRegistry.ts
+var DefinedCollectionRegistry = class {
+	static definitions = /* @__PURE__ */ new Map();
+	static register(definition) {
+		this.definitions.set(definition.name, definition);
 	}
-	getCredentialRequirements() {
-		return this.node.getCredentialRequirements?.() ?? [];
+	static resolve(name) {
+		return this.definitions.get(name);
 	}
-	getInputSchema() {
-		return this.inputSchemaValue;
+	static list() {
+		return Array.from(this.definitions.values());
 	}
-	getOutputSchema() {
-		return this.outputSchemaValue;
+};
+
+//#endregion
+//#region src/authoring/defineCollection.types.ts
+var CollectionColumnBuilderImpl = class {
+	_nullable;
+	_default;
+	constructor(_type) {
+		this._type = _type;
+		this._nullable = true;
+	}
+	notNull() {
+		this._nullable = false;
+		return this;
+	}
+	default(value) {
+		this._default = value;
+		this._nullable = false;
+		return this;
 	}
-	toNodeItem(args) {
-		const mapped = this.mapInputValue?.(args) ?? args.input;
-		if (this.isItem(mapped)) return mapped;
-		return { json: mapped };
+};
+const c = {
+	text() {
+		return new CollectionColumnBuilderImpl("text");
+	},
+	int() {
+		return new CollectionColumnBuilderImpl("int");
+	},
+	bigint() {
+		return new CollectionColumnBuilderImpl("bigint");
+	},
+	double() {
+		return new CollectionColumnBuilderImpl("double");
+	},
+	bool() {
+		return new CollectionColumnBuilderImpl("bool");
+	},
+	timestamptz() {
+		return new CollectionColumnBuilderImpl("timestamptz");
+	},
+	jsonb() {
+		return new CollectionColumnBuilderImpl("jsonb");
+	},
+	uuid() {
+		return new CollectionColumnBuilderImpl("uuid");
 	}
-	toToolOutput(args) {
-		const raw = this.mapOutputValue?.(args) ?? this.readDefaultToolOutput(args.outputs);
-		return this.outputSchemaValue.parse(raw);
+};
+/**
+* Validates that a name follows the required pattern: lowercase + underscores, starts with letter.
+*/
+function validateCollectionName(name) {
+	if (!/^[a-z][a-z0-9_]*$/.test(name)) throw new Error(`Collection name "${name}" must start with a lowercase letter and contain only lowercase letters, digits, and underscores.`);
+}
+/**
+* Validates that all field names follow the required pattern.
+*/
+function validateFieldNames(fields) {
+	const pattern = /^[a-z][a-z0-9_]*$/;
+	const reserved = [
+		"id",
+		"created_at",
+		"updated_at"
+	];
+	for (const fieldName of Object.keys(fields)) {
+		if (reserved.includes(fieldName)) throw new Error(`Field name "${fieldName}" is reserved for internal use.`);
+		if (!pattern.test(fieldName)) throw new Error(`Field name "${fieldName}" must start with a lowercase letter and contain only lowercase letters, digits, and underscores.`);
 	}
-	readDefaultToolOutput(outputs) {
-		const firstMainItem = outputs.main?.[0];
-		if (!firstMainItem) throw new Error(`Node-backed tool "${this.name}" did not produce a main output item.`);
-		return firstMainItem.json;
+}
+/**
+* Validates that all indexed fields exist in the declared fields.
+*/
+function validateIndexes(indexes, fieldNames) {
+	for (const index of indexes) for (const fieldName of index.on) if (!fieldNames.has(fieldName)) throw new Error(`Index references non-existent field "${fieldName}".`);
+}
+function defineCollection(options) {
+	validateCollectionName(options.name);
+	const fields = {};
+	for (const [fieldName, builder] of Object.entries(options.fields)) {
+		const columnBuilder = builder;
+		fields[fieldName] = {
+			type: columnBuilder._type,
+			nullable: columnBuilder._nullable,
+			default: columnBuilder._default
+		};
 	}
-	isItem(value) {
-		return typeof value === "object" && value !== null && "json" in value;
+	validateFieldNames(fields);
+	const fieldNames = new Set(Object.keys(fields));
+	const indexes = options.indexes ?? [];
+	validateIndexes(indexes, fieldNames);
+	const definition = {
+		name: options.name,
+		fields,
+		indexes
+	};
+	DefinedCollectionRegistry.register(definition);
+	return {
+		kind: "defined-collection",
+		definition,
+		register(context) {
+			context.registerCollection(definition);
+		}
+	};
+}
+
+//#endregion
+//#region src/authoring/definePollingTriggerInternals.ts
+const definedNodeCredentialRequirementFactory = {
+	create(bindings) {
+		if (!bindings) return [];
+		return Object.entries(bindings).map(([slotKey, binding]) => {
+			if (typeof binding === "string" || this.isCredentialType(binding)) return {
+				slotKey,
+				label: this.humanize(slotKey),
+				acceptedTypes: [this.resolveTypeId(binding)]
+			};
+			const types = Array.isArray(binding.type) ? binding.type : [binding.type];
+			return {
+				slotKey,
+				label: binding.label ?? this.humanize(slotKey),
+				acceptedTypes: types.map((entry) => this.resolveTypeId(entry)),
+				optional: binding.optional,
+				helpText: binding.helpText,
+				helpUrl: binding.helpUrl
+			};
+		});
+	},
+	isCredentialType(value) {
+		return Boolean(value) && typeof value === "object" && "definition" in value && typeof value.definition?.typeId === "string";
+	},
+	resolveTypeId(type) {
+		return typeof type === "string" ? type : type.definition.typeId;
+	},
+	humanize(key) {
+		return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim().replace(/^./, (character) => character.toUpperCase());
 	}
 };
+const definedNodeCredentialAccessorFactory = { create(bindings, ctx) {
+	if (!bindings) return {};
+	const entries = Object.keys(bindings).map((slotKey) => [slotKey, () => ctx.getCredential(slotKey)]);
+	return Object.fromEntries(entries);
+} };
 
 //#endregion
-//#region src/ai/AgentConfigInspectorFactory.ts
-var AgentConfigInspector = class {
-	static isAgentNodeConfig(config) {
-		if (!config) return false;
-		const candidate = config;
-		return !!candidate.chatModel && this.hasCompatibleMessageConfiguration(candidate);
-	}
-	static hasCompatibleMessageConfiguration(candidate) {
-		const messages = candidate.messages;
-		if (messages === void 0 || messages === null) return false;
-		if (Array.isArray(messages)) return messages.length > 0;
-		if (typeof messages === "object") {
-			if (require_runtime.isItemExpr(messages)) return true;
-			const o = messages;
-			return Array.isArray(o.prompt) && o.prompt.length > 0 || typeof o.buildMessages === "function";
-		}
-		return false;
+//#region src/authoring/definePollingTrigger.types.ts
+/**
+* TriggerNodeConfig produced by `DefinedPollingTrigger.create(...)`.
+* Holds user configuration and credential requirements for the engine.
+* The setup state type is opaque `JsonValue | undefined` — the runtime
+* uses an internal wrapped shape that plugin authors never see.
+*/
+var DefinedPollingTriggerConfig = class {
+	kind = "trigger";
+	type;
+	icon;
+	constructor(name, cfg, typeToken, icon, credentialRequirements, id) {
+		this.name = name;
+		this.cfg = cfg;
+		this.credentialRequirements = credentialRequirements;
+		this.id = id;
+		this.type = typeToken;
+		this.icon = icon;
+	}
+	getCredentialRequirements() {
+		return this.credentialRequirements;
 	}
 };
+function isWrappedState(value) {
+	return value !== null && typeof value === "object" && "seenKeys" in value && Array.isArray(value.seenKeys);
+}
+/**
+* Declarative helper for authoring polling triggers.
+*
+* ```ts
+* export const onNewMail = definePollingTrigger({
+*   key: "my-plugin.on-new-mail",
+*   title: "On new mail",
+*   configSchema: z.object({ folder: z.string() }),
+*   credentials: { auth: myOAuthCredentialType },
+*   initialState: () => ({ lastSeenId: undefined }),
+*   pollIntervalMs: 60_000,
+*   async poll({ config, state, credentials }) {
+*     const session = await credentials.auth();
+*     const messages = await fetchMessages(session, config.folder, state.lastSeenId);
+*     return {
+*       items: messages.map(m => ({ json: m, dedupKey: m.id })),
+*       nextState: { lastSeenId: messages[0]?.id ?? state.lastSeenId },
+*     };
+*   },
+* });
+* ```
+*/
+function definePollingTrigger(options) {
+	const credentialRequirements = definedNodeCredentialRequirementFactory.create(options.credentials);
+	const DEFAULT_INTERVAL_MS = 6e4;
+	const DefinedPollingTriggerRuntime = class {
+		kind = "trigger";
+		outputPorts = ["main"];
+		async setup(ctx) {
+			const cfg = ctx.config.cfg;
+			const intervalMs = cfg.pollIntervalMs ?? options.pollIntervalMs ?? DEFAULT_INTERVAL_MS;
+			const persisted = ctx.previousState;
+			const seedWrapped = (isWrappedState(persisted) ? persisted : void 0) ?? {
+				userState: options.initialState ? options.initialState() : void 0,
+				seenKeys: []
+			};
+			return await ctx.polling.start({
+				intervalMs,
+				seedState: seedWrapped,
+				runCycle: async ({ previousState }) => {
+					const wrapped = previousState ?? seedWrapped;
+					const seenSet = new Set(wrapped.seenKeys);
+					const credentialAccessors = definedNodeCredentialAccessorFactory.create(options.credentials, ctx);
+					const pollResult = await options.poll({
+						config: cfg,
+						state: wrapped.userState,
+						credentials: credentialAccessors
+					});
+					const newItems = [];
+					const newKeys = [];
+					for (const item of pollResult.items) {
+						if (item.dedupKey !== void 0) {
+							if (seenSet.has(item.dedupKey)) continue;
+							newKeys.push(item.dedupKey);
+						}
+						newItems.push({ json: item.json });
+					}
+					const allKeys = [...wrapped.seenKeys, ...newKeys];
+					const cappedKeys = allKeys.length > 2e3 ? allKeys.slice(allKeys.length - 2e3) : allKeys;
+					return {
+						items: newItems,
+						nextState: {
+							userState: pollResult.nextState,
+							seenKeys: cappedKeys
+						}
+					};
+				}
+			});
+		}
+		async execute(items, ctx) {
+			if (options.execute) return await options.execute(items, ctx);
+			return { main: items };
+		}
+		async getTestItems(ctx) {
+			if (options.testItems) return await options.testItems(ctx);
+			return [];
+		}
+	};
+	require_runtime.node({ name: options.key })(DefinedPollingTriggerRuntime);
+	return {
+		kind: "defined-polling-trigger",
+		key: options.key,
+		title: options.title,
+		description: options.description,
+		create(cfg, name = options.title, id) {
+			return new DefinedPollingTriggerConfig(name, cfg, DefinedPollingTriggerRuntime, options.icon, credentialRequirements, id);
+		},
+		poll(pollCtx) {
+			return options.poll({
+				config: pollCtx.config,
+				state: pollCtx.state,
+				credentials: pollCtx.credentials ?? {}
+			});
+		},
+		register(context) {
+			context.registerNode(DefinedPollingTriggerRuntime);
+		}
+	};
+}
 
 //#endregion
 //#region src/ai/AgentToolFactory.ts
 var AgentToolFactoryImpl = class {
 	asTool(node$1, options) {
-		return new NodeBackedToolConfig(options.name ?? node$1.name ?? "tool", node$1, this.withDefaultAgentInputMapper(node$1, options));
+		return new require_runtime.NodeBackedToolConfig(options.name ?? node$1.name ?? "tool", node$1, this.withDefaultAgentInputMapper(node$1, options));
 	}
 	withDefaultAgentInputMapper(node$1, options) {
-		if (options.mapInput || !AgentConfigInspector.isAgentNodeConfig(node$1)) return options;
+		if (options.mapInput || !require_runtime.AgentConfigInspector.isAgentNodeConfig(node$1)) return options;
 		return {
 			...options,
 			mapInput: ({ input, item }) => this.mergeAgentToolInputWithCurrentItem(input, item)
@@ -493,103 +702,6 @@ const AgentGuardrailDefaults = {
 	onTurnLimitReached: "error"
 };
 
-//#endregion
-//#region src/ai/AgentConnectionNodeCollector.ts
-const AgentConnectionNodeCollector = new class {
-	collect(parentNodeId, agentConfig) {
-		const collected = [];
-		this.collectInto(parentNodeId, agentConfig, collected);
-		return collected;
-	}
-	collectInto(parentNodeId, agentConfig, collected) {
-		collected.push({
-			nodeId: require_runtime.ConnectionNodeIdFactory.languageModelConnectionNodeId(parentNodeId),
-			parentNodeId,
-			connectionName: "llm",
-			role: "languageModel",
-			name: agentConfig.chatModel.presentation?.label ?? agentConfig.chatModel.name,
-			typeName: agentConfig.chatModel.name,
-			icon: agentConfig.chatModel.presentation?.icon,
-			credentialSource: agentConfig.chatModel
-		});
-		for (const tool$1 of agentConfig.tools ?? []) {
-			const toolNodeId = require_runtime.ConnectionNodeIdFactory.toolConnectionNodeId(parentNodeId, tool$1.name);
-			const isNestedAgent = this.isNodeBackedAgentTool(tool$1);
-			collected.push({
-				nodeId: toolNodeId,
-				parentNodeId,
-				connectionName: "tools",
-				role: isNestedAgent ? "nestedAgent" : "tool",
-				name: tool$1.presentation?.label ?? tool$1.name,
-				typeName: tool$1.name,
-				icon: tool$1.presentation?.icon,
-				credentialSource: tool$1
-			});
-			this.collectNestedAgentTools(toolNodeId, tool$1, collected);
-		}
-	}
-	collectNestedAgentTools(toolNodeId, tool$1, collected) {
-		if (!this.isNodeBackedAgentTool(tool$1)) return;
-		const innerAgent = tool$1 instanceof NodeBackedToolConfig ? tool$1.node : tool$1.node;
-		this.collectInto(toolNodeId, innerAgent, collected);
-	}
-	/**
-	* After JSON round-trip (persisted snapshots), tools are plain objects — `instanceof NodeBackedToolConfig` fails.
-	* Detect node-backed tools structurally via {@link NodeBackedToolConfig#toolKind}.
-	*/
-	isNodeBackedAgentTool(tool$1) {
-		if (tool$1 instanceof NodeBackedToolConfig) return AgentConfigInspector.isAgentNodeConfig(tool$1.node);
-		if (!tool$1 || typeof tool$1 !== "object") return false;
-		const t = tool$1;
-		if (t.toolKind !== "nodeBacked") return false;
-		return AgentConfigInspector.isAgentNodeConfig(t.node);
-	}
-}();
-
-//#endregion
-//#region src/workflow/definition/ConnectionInvocationIdFactory.ts
-/**
-* Unique ids for persisted connection invocation history rows (LLM/tool calls under an owning node).
-*/
-var ConnectionInvocationIdFactory = class {
-	static create() {
-		return `cinv_${(0, node_crypto.randomUUID)()}`;
-	}
-	/** Deterministic id for tests when a stable sequence is needed. */
-	static createForTest(runId, connectionNodeId, sequence) {
-		return `cinv_${runId}_${connectionNodeId}_${sequence}`;
-	}
-};
-
-//#endregion
-//#region src/workflow/graph/ExecutableGraph.ts
-var ExecutableGraph = class {
-	outgoingByNodeAndPort = /* @__PURE__ */ new Map();
-	constructor(def) {
-		for (const e of def.edges) {
-			const byPort = this.outgoingByNodeAndPort.get(e.from.nodeId) ?? /* @__PURE__ */ new Map();
-			const next = byPort.get(e.from.output) ?? [];
-			next.push({
-				nodeId: e.to.nodeId,
-				input: e.to.input
-			});
-			byPort.set(e.from.output, next);
-			this.outgoingByNodeAndPort.set(e.from.nodeId, byPort);
-		}
-	}
-	next(nodeId, output) {
-		return this.outgoingByNodeAndPort.get(nodeId)?.get(output) ?? [];
-	}
-};
-
-//#endregion
-//#region src/workflow/graph/DefaultWorkflowGraphFactory.ts
-var DefaultWorkflowGraphFactory = class {
-	create(def) {
-		return new ExecutableGraph(def);
-	}
-};
-
 //#endregion
 //#region src/events/EventPublishingWorkflowExecutionRepository.ts
 var EventPublishingWorkflowExecutionRepository = class {
@@ -641,6 +753,15 @@ var EventPublishingWorkflowExecutionRepository = class {
 	}
 };
 
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c$1 = arguments.length, r = c$1 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c$1 < 3 ? d(r) : c$1 > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c$1 > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
 //#endregion
 //#region src/serialization/ItemsInputNormalizer.ts
 let ItemsInputNormalizer = class ItemsInputNormalizer$1 {
@@ -662,11 +783,31 @@ let ItemsInputNormalizer = class ItemsInputNormalizer$1 {
 		return typeof raw === "object" && raw !== null && Object.prototype.hasOwnProperty.call(raw, "json");
 	}
 };
-ItemsInputNormalizer = require_runtime.__decorate([(0, tsyringe.injectable)()], ItemsInputNormalizer);
+ItemsInputNormalizer = __decorate([(0, tsyringe.injectable)()], ItemsInputNormalizer);
 
 //#endregion
-exports.AgentConfigInspector = AgentConfigInspector;
-exports.AgentConnectionNodeCollector = AgentConnectionNodeCollector;
+//#region src/contracts/assertionTypes.ts
+/**
+* Default {@link AssertionResult.passThreshold} when authors omit it. Boolean-style assertions
+* (assertEqual / contains / etc.) emit `score: 1` or `score: 0` so this default works for them;
+* AI-judge assertions are expected to set their own threshold.
+*/
+const DEFAULT_ASSERTION_PASS_THRESHOLD = .5;
+/**
+* Derive whether an assertion result is considered "passing" using the score-based contract:
+* `errored` always fails, otherwise `score >= (passThreshold ?? 0.5)`. This is the canonical
+* derivation — UI and rollup code should call it rather than inlining the comparison so future
+* tweaks (e.g. NaN handling) land in one place.
+*/
+function deriveAssertionPassed(result) {
+	if (result.errored === true) return false;
+	const threshold = result.passThreshold ?? DEFAULT_ASSERTION_PASS_THRESHOLD;
+	return result.score >= threshold;
+}
+
+//#endregion
+exports.AgentConfigInspector = require_runtime.AgentConfigInspector;
+exports.AgentConnectionNodeCollector = require_runtime.AgentConnectionNodeCollector;
 exports.AgentGuardrailDefaults = AgentGuardrailDefaults;
 exports.AgentMessageConfigNormalizer = AgentMessageConfigNormalizer;
 exports.AgentToolFactory = AgentToolFactory;
@@ -674,28 +815,26 @@ exports.AllWorkflowsActiveWorkflowActivationPolicy = require_runtime.AllWorkflow
 exports.CallableToolConfig = CallableToolConfig;
 exports.CallableToolFactory = CallableToolFactory;
 exports.CallableToolKindToken = CallableToolKindToken;
-exports.ChainCursor = require_InMemoryRunEventBusRegistry.ChainCursor;
-Object.defineProperty(exports, 'ChildExecutionScopeFactory', {
-  enumerable: true,
-  get: function () {
-    return require_runtime.ChildExecutionScopeFactory;
-  }
-});
+exports.ChainCursor = require_runtime.ChainCursor;
+exports.ChildExecutionScopeFactory = require_runtime.ChildExecutionScopeFactory;
 exports.CodemationTelemetryAttributeNames = require_runtime.CodemationTelemetryAttributeNames;
 exports.CodemationTelemetryMetricNames = require_runtime.CodemationTelemetryMetricNames;
 exports.ConnectionInvocationEventPublisher = require_runtime.ConnectionInvocationEventPublisher;
-exports.ConnectionInvocationIdFactory = ConnectionInvocationIdFactory;
+exports.ConnectionInvocationIdFactory = require_runtime.ConnectionInvocationIdFactory;
 exports.ConnectionNodeIdFactory = require_runtime.ConnectionNodeIdFactory;
 exports.CoreTokens = require_runtime.CoreTokens;
 exports.CostTrackingTelemetryAttributeNames = require_runtime.CostTrackingTelemetryAttributeNames;
 exports.CostTrackingTelemetryMetricNames = require_runtime.CostTrackingTelemetryMetricNames;
 exports.CredentialResolverFactory = require_runtime.CredentialResolverFactory;
 exports.CredentialUnboundError = require_runtime.CredentialUnboundError;
+exports.DEFAULT_ASSERTION_PASS_THRESHOLD = DEFAULT_ASSERTION_PASS_THRESHOLD;
 exports.DefaultAsyncSleeper = require_runtime.DefaultAsyncSleeper;
 exports.DefaultExecutionBinaryService = require_runtime.DefaultExecutionBinaryService;
 exports.DefaultExecutionContextFactory = require_runtime.DefaultExecutionContextFactory;
-exports.DefaultWorkflowGraphFactory = DefaultWorkflowGraphFactory;
+exports.DefaultWorkflowGraphFactory = require_runtime.DefaultWorkflowGraphFactory;
+exports.DefinedCollectionRegistry = DefinedCollectionRegistry;
 exports.DefinedNodeRegistry = DefinedNodeRegistry;
+exports.DefinedPollingTriggerConfig = DefinedPollingTriggerConfig;
 exports.EngineExecutionLimitsPolicy = require_runtime.EngineExecutionLimitsPolicy;
 exports.EventPublishingWorkflowExecutionRepository = EventPublishingWorkflowExecutionRepository;
 exports.ExpRetryPolicy = require_runtime.ExpRetryPolicy;
@@ -718,15 +857,19 @@ exports.NoOpCostTrackingTelemetryFactory = require_runtime.NoOpCostTrackingTelem
 exports.NoOpExecutionTelemetry = require_runtime.NoOpExecutionTelemetry;
 exports.NoOpExecutionTelemetryFactory = require_runtime.NoOpExecutionTelemetryFactory;
 exports.NoOpNodeExecutionTelemetry = require_runtime.NoOpNodeExecutionTelemetry;
+exports.NoOpPollingTriggerLogger = require_runtime.NoOpPollingTriggerLogger;
 exports.NoOpTelemetryArtifactReference = require_runtime.NoOpTelemetryArtifactReference;
 exports.NoOpTelemetrySpanScope = require_runtime.NoOpTelemetrySpanScope;
 exports.NoRetryPolicy = require_runtime.NoRetryPolicy;
-exports.NodeBackedToolConfig = NodeBackedToolConfig;
+exports.NodeBackedToolConfig = require_runtime.NodeBackedToolConfig;
 exports.NodeEventPublisher = require_runtime.NodeEventPublisher;
+exports.NodeIdSlugifier = require_runtime.NodeIdSlugifier;
 exports.NodeIterationIdFactory = require_runtime.NodeIterationIdFactory;
 exports.NodeOutputNormalizer = require_runtime.NodeOutputNormalizer;
 exports.PersistedRuntimeTypeMetadataStore = require_runtime.PersistedRuntimeTypeMetadataStore;
 exports.PersistedRuntimeTypeNameResolver = require_runtime.PersistedRuntimeTypeNameResolver;
+exports.PollingTriggerDedupWindow = require_runtime.PollingTriggerDedupWindow;
+exports.PollingTriggerRuntime = require_runtime.PollingTriggerRuntime;
 exports.RetryPolicy = require_runtime.RetryPolicy;
 exports.RunFinishedAtFactory = require_runtime.RunFinishedAtFactory;
 exports.RunIntentService = require_runtime.RunIntentService;
@@ -734,11 +877,13 @@ exports.RunnableOutputBehaviorResolver = require_runtime.RunnableOutputBehaviorR
 exports.StackTraceCallSitePathResolver = require_runtime.StackTraceCallSitePathResolver;
 exports.SystemClock = SystemClock;
 exports.UnavailableBinaryStorage = require_runtime.UnavailableBinaryStorage;
-exports.WhenBuilder = require_InMemoryRunEventBusRegistry.WhenBuilder;
-exports.WorkflowBuilder = require_InMemoryRunEventBusRegistry.WorkflowBuilder;
+exports.WhenBuilder = require_runtime.WhenBuilder;
+exports.WorkflowBuilder = require_runtime.WorkflowBuilder;
+exports.WorkflowDefinitionError = require_runtime.WorkflowDefinitionError;
 exports.WorkflowExecutableNodeClassifier = require_runtime.WorkflowExecutableNodeClassifier;
 exports.WorkflowExecutableNodeClassifierFactory = require_runtime.WorkflowExecutableNodeClassifierFactory;
 exports.branchRef = require_runtime.branchRef;
+exports.c = c;
 exports.callableTool = callableTool;
 exports.chatModel = require_runtime.chatModel;
 Object.defineProperty(exports, 'container', {
@@ -748,14 +893,17 @@ Object.defineProperty(exports, 'container', {
   }
 });
 exports.defineBatchNode = defineBatchNode;
+exports.defineCollection = defineCollection;
 exports.defineCredential = defineCredential;
 exports.defineNode = defineNode;
+exports.definePollingTrigger = definePollingTrigger;
 Object.defineProperty(exports, 'delay', {
   enumerable: true,
   get: function () {
     return tsyringe.delay;
   }
 });
+exports.deriveAssertionPassed = deriveAssertionPassed;
 exports.emitPorts = require_runtime.emitPorts;
 exports.getOriginIndexFromItem = require_runtime.getOriginIndexFromItem;
 exports.getPersistedRuntimeTypeMetadata = require_runtime.getPersistedRuntimeTypeMetadata;