@codemation/core 0.8.0 → 0.10.0

package/src/testing/WorkflowTestKitNodeRegistrationContextFactory.ts

@@ -8,9 +8,7 @@ export class WorkflowTestKitNodeRegistrationContextFactory {
   create(dependencyContainer: DependencyContainer): DefinedNodeRegistrationContext {
     return {
       registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>) {
-        dependencyContainer.register(token, {
-          useClass: (implementation ?? token) as never,
-        });
+        dependencyContainer.registerSingleton(token as never, (implementation ?? token) as never);
       },
     };
   }

package/src/triggers/polling/PollingTriggerDedupWindow.ts

@@ -0,0 +1,23 @@
+/**
+ * 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}.
+ */
+export class PollingTriggerDedupWindow {
+  static readonly defaultCapN = 2000;
+
+  merge(
+    previous: ReadonlyArray<string>,
+    incoming: ReadonlyArray<string>,
+    capN: number = PollingTriggerDedupWindow.defaultCapN,
+  ): ReadonlyArray<string> {
+    const merged = new Set(previous);
+    for (const id of incoming) {
+      merged.add(id);
+    }
+    const result = [...merged];
+    if (result.length <= capN) {
+      return result;
+    }
+    return result.slice(result.length - capN);
+  }
+}

package/src/triggers/polling/PollingTriggerLogger.ts

@@ -0,0 +1,18 @@
+/**
+ * Minimal logger surface for the polling-trigger runtime.
+ * Hosts supply this via {@link EngineDeps.pollingTriggerLogger};
+ * when absent the runtime is silent.
+ */
+export interface PollingTriggerLogger {
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string, exception?: Error): void;
+  debug(message: string): void;
+}
+
+export class NoOpPollingTriggerLogger implements PollingTriggerLogger {
+  info(): void {}
+  warn(): void {}
+  error(): void {}
+  debug(): void {}
+}

package/src/triggers/polling/PollingTriggerRuntime.ts

@@ -0,0 +1,122 @@
+import type { Items, TriggerInstanceId, TriggerSetupStateRepository } from "../../types";
+import type { PollingTriggerLogger } from "./PollingTriggerLogger";
+
+export interface PollingRunCycleArgs<TState> {
+  previousState: TState | undefined;
+  signal: AbortSignal;
+}
+
+export interface PollingRunCycleResult<TState, TItem> {
+  items: Items<TItem>;
+  nextState: TState;
+}
+
+export interface PollingTriggerStartArgs<TState, TItem> {
+  trigger: TriggerInstanceId;
+  intervalMs: number;
+  seedState?: TState;
+  runCycle: (cycleCtx: PollingRunCycleArgs<TState>) => Promise<PollingRunCycleResult<TState, TItem>>;
+  emit: (items: Items) => Promise<void>;
+}
+
+/**
+ * Generic polling-trigger runtime. Owns the set-interval loop, overlap guard, and persistence.
+ * Constructed by {@link import("../../runtime/EngineFactory").EngineFactory} and exposed to plugin
+ * authors via {@link import("../../contracts/runtimeTypes").TriggerSetupContext}.polling.
+ */
+export class PollingTriggerRuntime {
+  private readonly activeTriggers = new Set<string>();
+  private readonly intervalsByTrigger = new Map<string, ReturnType<typeof setInterval>>();
+  private readonly busyTriggers = new Set<string>();
+
+  constructor(
+    private readonly triggerSetupStateRepository: TriggerSetupStateRepository,
+    private readonly logger: PollingTriggerLogger,
+  ) {}
+
+  async start<TState, TItem>(args: PollingTriggerStartArgs<TState, TItem>): Promise<TState | undefined> {
+    let first: TState | undefined;
+    try {
+      first = await this.runCycle(args, { seedState: args.seedState });
+    } catch (err: unknown) {
+      this.logError(`Polling trigger initial cycle failed for ${this.describe(args.trigger)}`, err);
+    }
+    this.ensureLoop(args);
+    return first;
+  }
+
+  async stop(trigger: TriggerInstanceId): Promise<void> {
+    const key = this.toKey(trigger);
+    const interval = this.intervalsByTrigger.get(key);
+    if (interval !== undefined) {
+      clearInterval(interval);
+      this.intervalsByTrigger.delete(key);
+    }
+    this.busyTriggers.delete(key);
+    this.activeTriggers.delete(key);
+    this.logger.debug(`Polling trigger stopped for ${this.describe(trigger)}`);
+  }
+
+  private ensureLoop<TState, TItem>(args: PollingTriggerStartArgs<TState, TItem>): void {
+    const key = this.toKey(args.trigger);
+    if (this.activeTriggers.has(key)) {
+      this.logger.debug(`Polling trigger already active for ${this.describe(args.trigger)}`);
+      return;
+    }
+    this.activeTriggers.add(key);
+    const intervalMs = Math.max(args.intervalMs, 25);
+    const interval = setInterval(() => {
+      void this.runCycle(args, { seedState: undefined }).catch((err: unknown) => {
+        this.logError(`Polling trigger cycle failed for ${this.describe(args.trigger)}`, err);
+      });
+    }, intervalMs);
+    this.intervalsByTrigger.set(key, interval);
+    this.logger.info(`Polling trigger started for ${this.describe(args.trigger)} (interval ${intervalMs}ms)`);
+  }
+
+  private async runCycle<TState, TItem>(
+    args: PollingTriggerStartArgs<TState, TItem>,
+    opts: { seedState: TState | undefined },
+  ): Promise<TState | undefined> {
+    const key = this.toKey(args.trigger);
+    if (this.busyTriggers.has(key)) {
+      this.logger.debug(`Polling trigger skipping overlapping tick for ${this.describe(args.trigger)}`);
+      return undefined;
+    }
+    this.busyTriggers.add(key);
+    try {
+      const loaded = await this.triggerSetupStateRepository.load(args.trigger);
+      const previousState = loaded !== undefined ? (loaded.state as TState | undefined) : opts.seedState;
+      const controller = new AbortController();
+      const { items, nextState } = await args.runCycle({ previousState, signal: controller.signal });
+      await this.triggerSetupStateRepository.save({
+        trigger: args.trigger,
+        updatedAt: new Date().toISOString(),
+        state: nextState as never,
+      });
+      if (items.length > 0) {
+        this.logger.info(`Polling trigger emitting ${items.length} item(s) for ${this.describe(args.trigger)}`);
+        await args.emit(items);
+      }
+      return nextState;
+    } finally {
+      this.busyTriggers.delete(key);
+    }
+  }
+
+  private toKey(trigger: TriggerInstanceId): string {
+    return `${trigger.workflowId}:${trigger.nodeId}`;
+  }
+
+  private describe(trigger: TriggerInstanceId): string {
+    return `${trigger.workflowId}.${trigger.nodeId}`;
+  }
+
+  private logError(message: string, error: unknown): void {
+    if (error instanceof Error) {
+      this.logger.error(message, error);
+      return;
+    }
+    this.logger.error(`${message}: ${String(error)}`);
+  }
+}

package/src/triggers/polling/index.ts

@@ -0,0 +1,5 @@
+export { PollingTriggerDedupWindow } from "./PollingTriggerDedupWindow";
+export { PollingTriggerRuntime } from "./PollingTriggerRuntime";
+export type { PollingTriggerLogger } from "./PollingTriggerLogger";
+export { NoOpPollingTriggerLogger } from "./PollingTriggerLogger";
+export type { PollingRunCycleArgs, PollingRunCycleResult, PollingTriggerStartArgs } from "./PollingTriggerRuntime";

package/src/types/index.ts

@@ -1,22 +1,25 @@
+// Re-export pure-type contracts first (available via @codemation/core/contracts subpath)
+export * from "../contracts";
+export type { CollectionStore, CollectionsContext } from "../contracts/collectionTypes";
+
+// Additional runtime exports not included in contracts (factory classes, DSL builders, etc.)
 export * from "../contracts/emitPorts";
 export * from "../contracts/itemMeta";
-export * from "../contracts/params";
 export * from "../contracts/itemExpr";
-export * from "../contracts/retryPolicySpec.types";
 export * from "../contracts/NoRetryPolicy";
 export * from "../contracts/RetryPolicy";
 export * from "../contracts/ExpRetryPolicy";
 export * from "../contracts/credentialTypes";
-export * from "../contracts/CostCatalogContract";
 export * from "../contracts/CostTrackingTelemetryContract";
 export * from "../contracts/NoOpCostTrackingTelemetry";
 export * from "../contracts/NoOpCostTrackingTelemetryFactory";
-export * from "../contracts/executionPersistenceContracts";
-export * from "../contracts/runtimeTypes";
-export * from "../contracts/telemetryTypes";
+export * from "../contracts/NoOpExecutionTelemetryFactory";
 export * from "../contracts/runFinishedAtFactory";
-export * from "../contracts/runTypes";
-export * from "../contracts/webhookTypes";
-export * from "../contracts/workflowTypes";
 export * from "../contracts/workflowActivationPolicy";
+// telemetryTypes and workflowTypes also have runtime exports (No-Op telemetry classes,
+// attribute-name registries, `nodeRef` factory, unique-symbol type tags) — `contracts.ts`
+// already re-exports them with `export type *` for the slim subpath; re-export with the
+// full `export *` here so back-compat for `@codemation/core` (root) consumers is preserved.
+export * from "../contracts/telemetryTypes";
+export * from "../contracts/workflowTypes";
 export * from "../workflow";

package/src/workflow/definition/NodeIterationIdFactory.ts

@@ -0,0 +1,26 @@
+import { randomUUID } from "node:crypto";
+
+import type { NodeId } from "../../types";
+
+/**
+ * Unique ids for one per-item iteration of a runnable node's execute loop.
+ *
+ * Activations are per-batch (one scheduled execution of a node, possibly with N items).
+ * Iterations refine that to one identifier per item-index inside the batch loop, so per-item
+ * connection invocations and telemetry can be grouped without time-window heuristics.
+ */
+export class NodeIterationIdFactory {
+  static create(): string {
+    return `iter_${randomUUID()}`;
+  }
+
+  /** Deterministic id for tests when a stable sequence is needed. */
+  static createForTest(seed: string, sequence: number): string {
+    return `iter_${seed}_${sequence}`;
+  }
+
+  /** Deterministic id derived from a connection node id (for sub-agent / tool-call scopes). */
+  static createForConnection(connectionNodeId: NodeId, sequence: number): string {
+    return `iter_${connectionNodeId}_${sequence}`;
+  }
+}

package/src/workflow/dsl/NodeIdSlugifier.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+export const NodeIdSlugifier = {
+  slugify(label: string): string {
+    if (!label) return "";
+    return label
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "");
+  },
+};

package/src/workflow/dsl/WorkflowBuilder.ts

@@ -10,13 +10,22 @@ import type {
   WorkflowId,
 } from "../../types";
 
+import { AgentConfigInspector } from "../../ai/AgentConfigInspectorFactory";
+import { AgentConnectionNodeCollector } from "../../ai/AgentConnectionNodeCollector";
 import { ChainCursor } from "./ChainCursorResolver";
+import { NodeIdSlugifier } from "./NodeIdSlugifier";
+import { WorkflowDefinitionError } from "./WorkflowDefinitionError";
 import type { AnyRunnableNodeConfig, AnyTriggerNodeConfig } from "./workflowBuilderTypes";
 
+type NodeIdEntry = Readonly<{
+  nodeId: string;
+  tokenName: string;
+  label: string;
+}>;
+
 export class WorkflowBuilder {
   private readonly nodes: NodeDefinition[] = [];
   private readonly edges: WorkflowDefinition["edges"] = [];
-  private seq = 0;
 
   constructor(
     private readonly meta: { id: WorkflowId; name: string },
@@ -24,8 +33,7 @@ export class WorkflowBuilder {
   ) {}
 
   private add(config: NodeConfigBase): NodeRef {
-    const tokenName = typeof config.type === "function" ? config.type.name : String(config.type);
-    const id = config.id ?? `${tokenName}:${++this.seq}`;
+    const id = config.id ?? NodeIdSlugifier.slugify(config.name ?? "");
     this.nodes.push({ id, kind: config.kind, type: config.type, name: config.name, config });
     return { id, kind: config.kind, name: config.name };
   }
@@ -45,8 +53,68 @@ export class WorkflowBuilder {
   }
 
   build(): WorkflowDefinition {
+    this.validateNodeIds();
     return { ...this.meta, nodes: this.nodes, edges: this.edges };
   }
+
+  private validateNodeIds(): void {
+    const entries: NodeIdEntry[] = [];
+
+    for (const node of this.nodes) {
+      const tokenName = typeof node.type === "function" ? node.type.name : String(node.type);
+      entries.push({ nodeId: node.id, tokenName, label: node.name ?? "" });
+
+      if (AgentConfigInspector.isAgentNodeConfig(node.config)) {
+        for (const child of AgentConnectionNodeCollector.collect(node.id, node.config)) {
+          entries.push({ nodeId: child.nodeId, tokenName: child.typeName, label: child.name });
+        }
+      }
+    }
+
+    const emptyIds: NodeIdEntry[] = [];
+    const seenIds = new Map<string, NodeIdEntry>();
+    const duplicateIds: NodeIdEntry[] = [];
+
+    for (const entry of entries) {
+      if (!entry.nodeId) {
+        emptyIds.push(entry);
+        continue;
+      }
+      const existing = seenIds.get(entry.nodeId);
+      if (existing) {
+        if (!duplicateIds.includes(existing)) {
+          duplicateIds.push(existing);
+        }
+        duplicateIds.push(entry);
+      } else {
+        seenIds.set(entry.nodeId, entry);
+      }
+    }
+
+    if (emptyIds.length === 0 && duplicateIds.length === 0) {
+      return;
+    }
+
+    const lines: string[] = ["WorkflowBuilder.build() found invalid node ids:"];
+
+    if (emptyIds.length > 0) {
+      lines.push("  Empty ids (label is blank and no explicit id was given):");
+      for (const e of emptyIds) {
+        lines.push(`    - type "${e.tokenName}" label "${e.label}"`);
+      }
+    }
+
+    if (duplicateIds.length > 0) {
+      lines.push("  Duplicate ids:");
+      for (const e of duplicateIds) {
+        lines.push(`    - id "${e.nodeId}" type "${e.tokenName}" label "${e.label}"`);
+      }
+    }
+
+    lines.push("  Fix: set an explicit `id:` on each offending node config.");
+
+    throw new WorkflowDefinitionError(lines.join("\n"));
+  }
 }
 
 export { ChainCursor } from "./ChainCursorResolver";

package/src/workflow/dsl/WorkflowDefinitionError.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+export class WorkflowDefinitionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WorkflowDefinitionError";
+  }
+}

package/src/workflow/index.ts

@@ -1,10 +1,13 @@
 export { WorkflowBuilder } from "./dsl/WorkflowBuilder";
+export { WorkflowDefinitionError } from "./dsl/WorkflowDefinitionError";
+export { NodeIdSlugifier } from "./dsl/NodeIdSlugifier";
 export { ChainCursor } from "./dsl/ChainCursorResolver";
 export { WhenBuilder } from "./dsl/WhenBuilder";
 export * from "./dsl/workflowBuilderTypes";
 
 export { ConnectionInvocationIdFactory } from "./definition/ConnectionInvocationIdFactory";
 export { ConnectionNodeIdFactory } from "./definition/ConnectionNodeIdFactory";
+export { NodeIterationIdFactory } from "./definition/NodeIterationIdFactory";
 export { WorkflowExecutableNodeClassifier } from "./definition/WorkflowExecutableNodeClassifier";
 export * from "./definition/WorkflowExecutableNodeClassifierFactory";
 

package/dist/InMemoryRunEventBusRegistry-B0_C4OnP.cjs

@@ -1,262 +0,0 @@
-
-//#region src/workflow/dsl/WhenBuilder.ts
-var WhenBuilder = class WhenBuilder {
-	constructor(wf, from, branchPort) {
-		this.wf = wf;
-		this.from = from;
-		this.branchPort = branchPort;
-	}
-	addBranch(steps) {
-		const created = [];
-		let prev = null;
-		for (const cfg of steps) {
-			const ref = this.wf.add(cfg);
-			created.push(ref);
-			if (!prev) this.wf.connect(this.from, ref, this.branchPort, "in");
-			else this.wf.connect(prev, ref, "main", "in");
-			prev = ref;
-		}
-		for (const cfg of steps) {
-			const maybe = cfg;
-			if (!Array.isArray(maybe.upstreamRefs) || maybe.upstreamRefs.length === 0) continue;
-			maybe.upstreamRefs = maybe.upstreamRefs.map((r) => {
-				if (typeof r !== "string") return r;
-				const nodeId = created[parseInt(r.slice(1), 10)]?.id;
-				return nodeId ? { nodeId } : { nodeId: r };
-			});
-		}
-		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);
-		b.addBranch(list);
-		return b;
-	};
-	build() {
-		return this.wf.build();
-	}
-};
-
-//#endregion
-//#region src/workflow/dsl/ChainCursorResolver.ts
-var ChainCursor = class ChainCursor {
-	constructor(wf, endpoints) {
-		this.wf = wf;
-		this.endpoints = endpoints;
-	}
-	then(config) {
-		const next = this.wf.add(config);
-		const inputPortHint = this.resolveSharedInputPortHint();
-		for (const e of this.endpoints) this.wf.connect(e.node, next, e.output);
-		return new ChainCursor(this.wf, [{
-			node: next,
-			output: "main",
-			...inputPortHint ? { inputPortHint } : {}
-		}]);
-	}
-	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");
-		return new ChainCursor(this.wf, [{
-			node: next,
-			output: "main"
-		}]);
-	}
-	when = ((arg1, steps, ...more) => {
-		if (this.endpoints.length !== 1) throw new Error("ChainCursor.when(...) is only supported from a single cursor endpoint");
-		const cursor = this.endpoints[0].node;
-		if (typeof arg1 === "boolean") {
-			const list = Array.isArray(steps) ? steps : steps ? [steps, ...more] : more;
-			const port = arg1 ? "true" : "false";
-			const b = new WhenBuilder(this.wf, cursor, port);
-			b.addBranch(list);
-			return b;
-		}
-		const branches = arg1;
-		const wfAny = this.wf;
-		const buildBranch = (port, branchSteps) => {
-			const list = branchSteps ?? [];
-			let prev = null;
-			for (const cfg of list) {
-				const ref = wfAny.add(cfg);
-				if (!prev) wfAny.connect(cursor, ref, port, "in");
-				else wfAny.connect(prev, ref, "main", "in");
-				prev = ref;
-			}
-			if (!prev) return {
-				end: cursor,
-				endOutput: port,
-				inputPortHint: port
-			};
-			return {
-				end: prev,
-				endOutput: "main",
-				inputPortHint: port
-			};
-		};
-		const t = buildBranch("true", branches.true);
-		const f = buildBranch("false", branches.false);
-		return new ChainCursor(this.wf, [{
-			node: t.end,
-			output: t.endOutput,
-			inputPortHint: t.inputPortHint
-		}, {
-			node: f.end,
-			output: f.endOutput,
-			inputPortHint: f.inputPortHint
-		}]);
-	});
-	route(branches) {
-		if (this.endpoints.length !== 1) throw new Error("ChainCursor.route(...) is only supported from a single cursor endpoint");
-		const cursor = this.endpoints[0];
-		const nextEndpoints = [];
-		for (const [port, branchFactory] of Object.entries(branches)) {
-			if (!branchFactory) continue;
-			const builtBranch = branchFactory(new ChainCursor(this.wf, [{
-				node: cursor.node,
-				output: port,
-				inputPortHint: port
-			}]));
-			if (!builtBranch) continue;
-			nextEndpoints.push(...builtBranch.endpoints);
-		}
-		return new ChainCursor(this.wf, nextEndpoints);
-	}
-	build() {
-		return this.wf.build();
-	}
-	resolveSharedInputPortHint() {
-		const first = this.endpoints[0]?.inputPortHint;
-		if (!first) return;
-		return this.endpoints.every((endpoint) => endpoint.inputPortHint === first) ? first : void 0;
-	}
-};
-
-//#endregion
-//#region src/workflow/dsl/WorkflowBuilder.ts
-var WorkflowBuilder = class {
-	nodes = [];
-	edges = [];
-	seq = 0;
-	constructor(meta, options) {
-		this.meta = meta;
-		this.options = options;
-	}
-	add(config) {
-		const tokenName = typeof config.type === "function" ? config.type.name : String(config.type);
-		const id = config.id ?? `${tokenName}:${++this.seq}`;
-		this.nodes.push({
-			id,
-			kind: config.kind,
-			type: config.type,
-			name: config.name,
-			config
-		});
-		return {
-			id,
-			kind: config.kind,
-			name: config.name
-		};
-	}
-	connect(from, to, fromOutput = "main", toInput = "in") {
-		this.edges.push({
-			from: {
-				nodeId: from.id,
-				output: fromOutput
-			},
-			to: {
-				nodeId: to.id,
-				input: toInput
-			}
-		});
-	}
-	trigger(config) {
-		const ref = this.add(config);
-		return new ChainCursor(this, [{
-			node: ref,
-			output: "main"
-		}]);
-	}
-	start(config) {
-		const ref = this.add(config);
-		return new ChainCursor(this, [{
-			node: ref,
-			output: "main"
-		}]);
-	}
-	build() {
-		return {
-			...this.meta,
-			nodes: this.nodes,
-			edges: this.edges
-		};
-	}
-};
-
-//#endregion
-//#region src/events/InMemoryRunEventSubscription.ts
-var InMemoryRunEventSubscription = class {
-	constructor(onClose) {
-		this.onClose = onClose;
-	}
-	async close() {
-		this.onClose();
-	}
-};
-
-//#endregion
-//#region src/events/InMemoryRunEventBusRegistry.ts
-var InMemoryRunEventBus = class {
-	globalListeners = /* @__PURE__ */ new Set();
-	listenersByWorkflowId = /* @__PURE__ */ new Map();
-	async publish(event) {
-		for (const listener of this.globalListeners) listener(event);
-		for (const listener of this.listenersByWorkflowId.get(event.workflowId) ?? []) listener(event);
-	}
-	async subscribe(onEvent) {
-		this.globalListeners.add(onEvent);
-		return new InMemoryRunEventSubscription(() => {
-			this.globalListeners.delete(onEvent);
-		});
-	}
-	async subscribeToWorkflow(workflowId, onEvent) {
-		const existing = this.listenersByWorkflowId.get(workflowId) ?? /* @__PURE__ */ new Set();
-		existing.add(onEvent);
-		this.listenersByWorkflowId.set(workflowId, existing);
-		return new InMemoryRunEventSubscription(() => {
-			const listeners = this.listenersByWorkflowId.get(workflowId);
-			if (!listeners) return;
-			listeners.delete(onEvent);
-			if (listeners.size === 0) this.listenersByWorkflowId.delete(workflowId);
-		});
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'ChainCursor', {
-  enumerable: true,
-  get: function () {
-    return ChainCursor;
-  }
-});
-Object.defineProperty(exports, 'InMemoryRunEventBus', {
-  enumerable: true,
-  get: function () {
-    return InMemoryRunEventBus;
-  }
-});
-Object.defineProperty(exports, 'WhenBuilder', {
-  enumerable: true,
-  get: function () {
-    return WhenBuilder;
-  }
-});
-Object.defineProperty(exports, 'WorkflowBuilder', {
-  enumerable: true,
-  get: function () {
-    return WorkflowBuilder;
-  }
-});
-//# sourceMappingURL=InMemoryRunEventBusRegistry-B0_C4OnP.cjs.map