@codemation/core 0.0.19 → 0.2.0

package/src/testing/RegistrarEngineTestKitFactory.ts

@@ -0,0 +1,154 @@
+import type { DependencyContainer, InjectionToken } from "tsyringe";
+import { container as tsyringeContainer } from "tsyringe";
+
+import type { WorkflowRunnerService } from "../contracts/runtimeTypes";
+import { CoreTokens } from "../di";
+import { InMemoryRunEventBus } from "../events/InMemoryRunEventBusRegistry";
+import { AllWorkflowsActiveWorkflowActivationPolicy } from "../contracts/workflowActivationPolicy";
+import { RunIntentService } from "../runtime/RunIntentService";
+import {
+  DefaultDrivingScheduler,
+  DefaultAsyncSleeper,
+  DefaultExecutionContextFactory,
+  Engine,
+  EngineRuntimeRegistrar,
+  EngineWorkflowRunnerService,
+  HintOnlyOffloadPolicy,
+  InProcessRetryRunner,
+  InMemoryRunDataFactory,
+  InMemoryWorkflowExecutionRepository,
+  InlineDrivingScheduler,
+  NodeExecutor,
+  NodeInstanceFactory,
+  PersistedWorkflowTokenRegistry,
+} from "../bootstrap/index";
+import { InMemoryLiveWorkflowRepository } from "../runtime/InMemoryLiveWorkflowRepository";
+import { EngineTestKitRunIdFactory } from "./EngineTestKitRunIdFactory";
+import { InMemoryTriggerSetupStateRepository } from "./InMemoryTriggerSetupStateRepository";
+import { RejectingCredentialSessionService } from "./RejectingCredentialSessionService";
+import { CapturingScheduler } from "./CapturingScheduler";
+import { PrefixedSequentialIdGenerator } from "./PrefixedSequentialIdGenerator";
+import type { RegistrarEngineTestKitHandle, RegistrarEngineTestKitOptions } from "./RegistrarEngineTestKit.types";
+import { SubWorkflowRunnerNode } from "./SubWorkflowRunnerTestNode";
+import { WorkflowTestHarnessManualTriggerNode } from "./WorkflowTestHarnessManualTrigger";
+
+export class RegistrarEngineTestKitFactory {
+  static create(options: RegistrarEngineTestKitOptions = {}): RegistrarEngineTestKitHandle {
+    const runStore = options.runStore ?? new InMemoryWorkflowExecutionRepository();
+    const scheduler = options.scheduler ?? new CapturingScheduler();
+    const offloadPolicy = options.offloadPolicy ?? new HintOnlyOffloadPolicy();
+    const runIdGen = new PrefixedSequentialIdGenerator("run_");
+    const activationIdGen = new PrefixedSequentialIdGenerator("act_");
+    const makeRunId = options.makeRunId ?? runIdGen.asFn();
+    const makeActivationId = options.makeActivationId ?? activationIdGen.asFn();
+    const credentialSessions = options.credentialSessions ?? new RejectingCredentialSessionService();
+    const eventBus = options.eventBus ?? new InMemoryRunEventBus();
+    const triggerSetupStateRepository =
+      options.triggerSetupStateRepository ?? new InMemoryTriggerSetupStateRepository();
+    const liveWorkflowRepository = new InMemoryLiveWorkflowRepository();
+    const runDataFactory = options.runDataFactory ?? new InMemoryRunDataFactory();
+    const executionContextFactory = options.executionContextFactory ?? new DefaultExecutionContextFactory();
+    const container = options.container ?? tsyringeContainer.createChildContainer();
+    const dependencyContainer = container as DependencyContainer;
+    const nodeResolver = container;
+    const nodeExecutor = new NodeExecutor(
+      new NodeInstanceFactory(nodeResolver),
+      new InProcessRetryRunner(new DefaultAsyncSleeper()),
+    );
+    const activationScheduler = new DefaultDrivingScheduler(
+      offloadPolicy,
+      scheduler,
+      new InlineDrivingScheduler(nodeExecutor),
+    );
+
+    for (const [token, value] of options.providers ?? new Map<InjectionToken<unknown>, unknown>()) {
+      dependencyContainer.registerInstance(token, value);
+    }
+
+    dependencyContainer.registerInstance(CoreTokens.CredentialSessionService, credentialSessions);
+    dependencyContainer.registerInstance(CoreTokens.LiveWorkflowRepository, liveWorkflowRepository);
+    dependencyContainer.registerInstance(CoreTokens.WorkflowRepository, liveWorkflowRepository);
+    dependencyContainer.registerInstance(CoreTokens.NodeResolver, nodeResolver);
+    dependencyContainer.registerInstance(
+      CoreTokens.RunIdFactory,
+      new EngineTestKitRunIdFactory(makeRunId, makeActivationId),
+    );
+    dependencyContainer.registerInstance(
+      CoreTokens.ActivationIdFactory,
+      new EngineTestKitRunIdFactory(makeRunId, makeActivationId),
+    );
+    dependencyContainer.registerInstance(CoreTokens.WebhookBasePath, options.webhookBasePath ?? "/webhooks");
+    dependencyContainer.registerInstance(CoreTokens.WorkflowExecutionRepository, runStore);
+    dependencyContainer.registerInstance(CoreTokens.TriggerSetupStateRepository, triggerSetupStateRepository);
+    dependencyContainer.registerInstance(CoreTokens.NodeActivationScheduler, activationScheduler);
+    dependencyContainer.registerInstance(CoreTokens.RunDataFactory, runDataFactory);
+    dependencyContainer.registerInstance(CoreTokens.ExecutionContextFactory, executionContextFactory);
+    dependencyContainer.registerInstance(CoreTokens.RunEventBus, eventBus);
+    dependencyContainer.registerInstance(
+      CoreTokens.PersistedWorkflowTokenRegistry,
+      new PersistedWorkflowTokenRegistry(),
+    );
+    dependencyContainer.registerInstance(
+      CoreTokens.WorkflowActivationPolicy,
+      new AllWorkflowsActiveWorkflowActivationPolicy(),
+    );
+
+    if (options.executionLimitsPolicy !== undefined) {
+      dependencyContainer.registerInstance(CoreTokens.EngineExecutionLimitsPolicy, options.executionLimitsPolicy);
+    }
+
+    new EngineRuntimeRegistrar().register(dependencyContainer, options.registrarOptions ?? {});
+
+    const engine = dependencyContainer.resolve(Engine);
+    const runIntent = dependencyContainer.resolve(RunIntentService);
+    const workflowRunner =
+      options.workflowRunner ??
+      (dependencyContainer.resolve(CoreTokens.WorkflowRunnerService) as EngineWorkflowRunnerService);
+    dependencyContainer.registerInstance(
+      SubWorkflowRunnerNode,
+      new SubWorkflowRunnerNode(workflowRunner as WorkflowRunnerService),
+    );
+    dependencyContainer.registerInstance(
+      WorkflowTestHarnessManualTriggerNode,
+      new WorkflowTestHarnessManualTriggerNode(),
+    );
+
+    const start = async (workflows: ReadonlyArray<import("../types").WorkflowDefinition>): Promise<void> => {
+      await engine.start([...workflows]);
+    };
+
+    const runToCompletion: RegistrarEngineTestKitHandle["runToCompletion"] = async (args) => {
+      const r0 = await engine.runWorkflow(args.wf, args.startAt, args.items, args.parent);
+      if (r0.status !== "pending") return r0;
+      return await engine.waitForCompletion(r0.runId);
+    };
+
+    const runIntentStartToCompletion: RegistrarEngineTestKitHandle["runIntentStartToCompletion"] = async (args) => {
+      const r0 = await runIntent.startWorkflow({
+        workflow: args.wf,
+        startAt: args.startAt,
+        items: args.items,
+        parent: args.parent,
+      });
+      if (r0.status !== "pending") return r0;
+      return await engine.waitForCompletion(r0.runId);
+    };
+
+    return {
+      engine,
+      runIntent,
+      liveWorkflowRepository,
+      runStore,
+      triggerSetupStateRepository,
+      scheduler: scheduler as CapturingScheduler | import("../types").NodeExecutionScheduler,
+      offloadPolicy,
+      workflowRunner,
+      dependencyContainer,
+      start,
+      runToCompletion,
+      runIntentStartToCompletion,
+      makeRunId,
+      makeActivationId,
+    };
+  }
+}

package/src/testing/SubWorkflowRunnerTestNode.ts

@@ -0,0 +1,83 @@
+/* eslint-disable codemation/single-class-per-file -- Runnable config and implementation share a TypeToken pairing. */
+import type { WorkflowRunnerService } from "../contracts/runtimeTypes";
+import type { TypeToken } from "../di";
+import type {
+  Item,
+  Items,
+  NodeExecutionContext,
+  NodeId,
+  NodeOutputs,
+  Node,
+  RunnableNodeConfig,
+  WorkflowId,
+} from "../types";
+
+/**
+ * Test harness subworkflow runner (mirrors integration patterns; lives under {@link "@codemation/core/testing"}).
+ */
+export class SubWorkflowRunnerConfig<TInputJson = unknown, TOutputJson = unknown> implements RunnableNodeConfig<
+  TInputJson,
+  TOutputJson
+> {
+  readonly kind = "node" as const;
+  readonly type: TypeToken<unknown> = SubWorkflowRunnerNode;
+
+  constructor(
+    public readonly name: string,
+    public readonly args: Readonly<{
+      workflowId: WorkflowId;
+      startAt?: NodeId;
+      id?: string;
+      execution?: Readonly<{ hint?: "local" | "worker"; queue?: string }>;
+    }>,
+  ) {}
+
+  get id(): string | undefined {
+    return this.args.id;
+  }
+
+  get execution(): Readonly<{ hint?: "local" | "worker"; queue?: string }> | undefined {
+    return this.args.execution;
+  }
+
+  get workflowId(): WorkflowId {
+    return this.args.workflowId;
+  }
+
+  get startAt(): NodeId | undefined {
+    return this.args.startAt;
+  }
+}
+
+export class SubWorkflowRunnerNode implements Node<SubWorkflowRunnerConfig<any, any>> {
+  readonly kind = "node" as const;
+  readonly outputPorts = ["main"] as const;
+
+  constructor(private readonly workflows: WorkflowRunnerService) {}
+
+  async execute(items: Items, ctx: NodeExecutionContext<SubWorkflowRunnerConfig<any, any>>): Promise<NodeOutputs> {
+    const out: Item[] = [];
+    for (let i = 0; i < items.length; i++) {
+      const current = items[i]!;
+      const result = await this.workflows.runById({
+        workflowId: ctx.config.workflowId,
+        startAt: ctx.config.startAt,
+        items: [current],
+        parent: {
+          runId: ctx.runId,
+          workflowId: ctx.workflowId,
+          nodeId: ctx.nodeId,
+          subworkflowDepth: ctx.subworkflowDepth,
+          engineMaxNodeActivations: ctx.engineMaxNodeActivations,
+          engineMaxSubworkflowDepth: ctx.engineMaxSubworkflowDepth,
+        },
+      });
+      if (result.status !== "completed") {
+        throw new Error(`Subworkflow ${ctx.config.workflowId} did not complete (status=${result.status})`);
+      }
+      out.push(...result.outputs);
+    }
+
+    return { main: out };
+  }
+}

package/src/testing/WorkflowTestHarnessManualTrigger.ts

@@ -0,0 +1,39 @@
+/* eslint-disable codemation/single-class-per-file -- Trigger config and implementation share a TypeToken pairing. */
+import type { TypeToken } from "../di";
+import type {
+  Items,
+  NodeExecutionContext,
+  NodeOutputs,
+  TriggerNode,
+  TriggerNodeConfig,
+  TriggerSetupContext,
+} from "../types";
+
+/**
+ * Minimal pass-through manual trigger for {@link WorkflowTestKit.runNode}; emits input items unchanged.
+ */
+export class WorkflowTestHarnessManualTriggerConfig implements TriggerNodeConfig<unknown> {
+  readonly kind = "trigger" as const;
+  readonly type: TypeToken<unknown> = WorkflowTestHarnessManualTriggerNode;
+
+  constructor(
+    public readonly name: string,
+    public readonly id?: string,
+  ) {}
+}
+
+export class WorkflowTestHarnessManualTriggerNode implements TriggerNode<WorkflowTestHarnessManualTriggerConfig> {
+  readonly kind = "trigger" as const;
+  readonly outputPorts = ["main"] as const;
+
+  async setup(_ctx: TriggerSetupContext<WorkflowTestHarnessManualTriggerConfig>): Promise<undefined> {
+    return undefined;
+  }
+
+  async execute(
+    items: Items,
+    _ctx: NodeExecutionContext<WorkflowTestHarnessManualTriggerConfig>,
+  ): Promise<NodeOutputs> {
+    return { main: items };
+  }
+}

package/src/testing/WorkflowTestKit.types.ts

@@ -0,0 +1,9 @@
+import type { TypeToken } from "../di";
+
+export type DefinedNodeRegistrationContext = {
+  registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
+};
+
+export type DefinedNodeRegistration = {
+  register(context: DefinedNodeRegistrationContext): void;
+};

package/src/testing/WorkflowTestKitBuilder.ts

@@ -0,0 +1,77 @@
+import type { DependencyContainer } from "tsyringe";
+
+import type { Items, NodeId, RunnableNodeConfig, RunResult, WorkflowDefinition, WorkflowId } from "../types";
+
+import { RegistrarEngineTestKitFactory } from "./RegistrarEngineTestKitFactory";
+import type { EngineTestKitOptions, RegistrarEngineTestKitHandle } from "./RegistrarEngineTestKit.types";
+import { WorkflowTestKitNodeRegistrationContextFactory } from "./WorkflowTestKitNodeRegistrationContextFactory";
+import type { DefinedNodeRegistration } from "./WorkflowTestKit.types";
+import { WorkflowTestKitRunNodeWorkflowFactory } from "./WorkflowTestKitRunNodeWorkflowFactory";
+
+export type { DefinedNodeRegistration, DefinedNodeRegistrationContext } from "./WorkflowTestKit.types";
+
+export type WorkflowTestKitOptions = EngineTestKitOptions;
+
+export class WorkflowTestKit {
+  private readonly handle: RegistrarEngineTestKitHandle;
+  private readonly runNodeWorkflowFactory = new WorkflowTestKitRunNodeWorkflowFactory();
+  private readonly nodeRegistrationContextFactory = new WorkflowTestKitNodeRegistrationContextFactory();
+
+  constructor(options: WorkflowTestKitOptions = {}) {
+    this.handle = RegistrarEngineTestKitFactory.create(options);
+  }
+
+  get dependencyContainer(): DependencyContainer {
+    return this.handle.dependencyContainer;
+  }
+
+  get engine(): RegistrarEngineTestKitHandle["engine"] {
+    return this.handle.engine;
+  }
+
+  get workflowRunner(): RegistrarEngineTestKitHandle["workflowRunner"] {
+    return this.handle.workflowRunner;
+  }
+
+  get liveWorkflowRepository(): RegistrarEngineTestKitHandle["liveWorkflowRepository"] {
+    return this.handle.liveWorkflowRepository;
+  }
+
+  get runStore(): RegistrarEngineTestKitHandle["runStore"] {
+    return this.handle.runStore;
+  }
+
+  /**
+   * Registers {@link import("../authoring/defineNode.types").DefinedNode} implementations on the same DI container used by the engine
+   * (same pattern as `plugin.register({ registerNode })` in the host).
+   */
+  registerDefinedNodes(definitions: ReadonlyArray<DefinedNodeRegistration>): void {
+    const ctx = this.nodeRegistrationContextFactory.create(this.handle.dependencyContainer);
+    for (const def of definitions) {
+      def.register(ctx);
+    }
+  }
+
+  async run(args: { workflow: WorkflowDefinition; items: Items; startAt?: NodeId }): Promise<RunResult> {
+    await this.handle.start([args.workflow]);
+    return await this.handle.workflowRunner.runById({
+      workflowId: args.workflow.id,
+      startAt: args.startAt,
+      items: args.items,
+    });
+  }
+
+  async runNode(args: {
+    node: RunnableNodeConfig;
+    items: Items;
+    workflowId?: WorkflowId;
+    workflowName?: string;
+  }): Promise<RunResult> {
+    const wf = this.runNodeWorkflowFactory.build(args);
+    return await this.run({
+      workflow: wf,
+      items: args.items,
+      startAt: this.runNodeWorkflowFactory.defaultStartNodeId(),
+    });
+  }
+}

package/src/testing/WorkflowTestKitNodeRegistrationContextFactory.ts

@@ -0,0 +1,17 @@
+import type { DependencyContainer } from "tsyringe";
+
+import type { TypeToken } from "../di";
+
+import type { DefinedNodeRegistrationContext } from "./WorkflowTestKit.types";
+
+export class WorkflowTestKitNodeRegistrationContextFactory {
+  create(dependencyContainer: DependencyContainer): DefinedNodeRegistrationContext {
+    return {
+      registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>) {
+        dependencyContainer.register(token, {
+          useClass: (implementation ?? token) as never,
+        });
+      },
+    };
+  }
+}

package/src/testing/WorkflowTestKitRunNodeWorkflowFactory.ts

@@ -0,0 +1,26 @@
+import type { RunnableNodeConfig, WorkflowDefinition, WorkflowId } from "../types";
+import { WorkflowBuilder } from "../workflow/dsl/WorkflowBuilder";
+
+import { WorkflowTestHarnessManualTriggerConfig } from "./WorkflowTestHarnessManualTrigger";
+
+const defaultInlineWorkflowId = "codemation.testing.workflowkit.inline" as WorkflowId;
+const defaultInlineWorkflowName = "WorkflowTestKit inline";
+
+/**
+ * Builds the minimal trigger → runnable workflow used by {@link import("./WorkflowTestKit").WorkflowTestKit.runNode}.
+ */
+export class WorkflowTestKitRunNodeWorkflowFactory {
+  build(args: { node: RunnableNodeConfig; workflowId?: WorkflowId; workflowName?: string }): WorkflowDefinition {
+    const workflowId = args.workflowId ?? defaultInlineWorkflowId;
+    const workflowName = args.workflowName ?? defaultInlineWorkflowName;
+    const trigger = new WorkflowTestHarnessManualTriggerConfig(
+      "WorkflowTestKit trigger",
+      "workflowkit.harness.trigger",
+    );
+    return new WorkflowBuilder({ id: workflowId, name: workflowName }).trigger(trigger).then(args.node).build();
+  }
+
+  defaultStartNodeId(): string {
+    return "workflowkit.harness.trigger";
+  }
+}

package/src/testing.ts

@@ -4,3 +4,22 @@
 export { InMemoryLiveWorkflowRepository } from "./runtime/InMemoryLiveWorkflowRepository";
 export { WorkflowSnapshotCodec as PersistedWorkflowSnapshotFactory } from "./workflowSnapshots/WorkflowSnapshotCodec";
 export { RejectingCredentialSessionService } from "./testing/RejectingCredentialSessionService";
+export { CapturingScheduler } from "./testing/CapturingScheduler";
+export { PrefixedSequentialIdGenerator } from "./testing/PrefixedSequentialIdGenerator";
+export {
+  type EngineTestKitOptions,
+  type RegistrarEngineTestKitHandle,
+  type RegistrarEngineTestKitOptions,
+} from "./testing/RegistrarEngineTestKit.types";
+export { RegistrarEngineTestKitFactory } from "./testing/RegistrarEngineTestKitFactory";
+export { SubWorkflowRunnerConfig, SubWorkflowRunnerNode } from "./testing/SubWorkflowRunnerTestNode";
+export {
+  WorkflowTestHarnessManualTriggerConfig,
+  WorkflowTestHarnessManualTriggerNode,
+} from "./testing/WorkflowTestHarnessManualTrigger";
+export {
+  type DefinedNodeRegistration,
+  type DefinedNodeRegistrationContext,
+  WorkflowTestKit,
+  type WorkflowTestKitOptions,
+} from "./testing/WorkflowTestKitBuilder";

package/src/types/index.ts

@@ -3,6 +3,7 @@ export * from "../contracts/NoRetryPolicy";
 export * from "../contracts/RetryPolicy";
 export * from "../contracts/ExpRetryPolicy";
 export * from "../contracts/credentialTypes";
+export * from "../contracts/executionPersistenceContracts";
 export * from "../contracts/runtimeTypes";
 export * from "../contracts/runFinishedAtFactory";
 export * from "../contracts/runTypes";

package/src/workflow/definition/ConnectionNodeIdFactory.ts

@@ -24,6 +24,34 @@ export class ConnectionNodeIdFactory {
     return nodeId.includes(`${this.connectionSegment}tool${this.connectionSegment}`);
   }
 
+  static parseLanguageModelConnectionNodeId(nodeId: NodeId): Readonly<{ parentNodeId: NodeId }> | undefined {
+    if (!this.isLanguageModelConnectionNodeId(nodeId)) {
+      return undefined;
+    }
+    const suffix = `${this.connectionSegment}llm`;
+    const parentNodeId = nodeId.slice(0, -suffix.length);
+    return parentNodeId ? { parentNodeId } : undefined;
+  }
+
+  static parseToolConnectionNodeId(
+    nodeId: NodeId,
+  ): Readonly<{ parentNodeId: NodeId; normalizedToolName: string }> | undefined {
+    if (!this.isToolConnectionNodeId(nodeId)) {
+      return undefined;
+    }
+    const marker = `${this.connectionSegment}tool${this.connectionSegment}`;
+    const idx = nodeId.lastIndexOf(marker);
+    if (idx < 0) {
+      return undefined;
+    }
+    const parentNodeId = nodeId.slice(0, idx);
+    const normalizedToolName = nodeId.slice(idx + marker.length);
+    if (!parentNodeId || !normalizedToolName) {
+      return undefined;
+    }
+    return { parentNodeId, normalizedToolName };
+  }
+
   /** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
   static isConnectionOwnedDescendantOf(parentNodeId: NodeId, nodeId: NodeId): boolean {
     return nodeId.startsWith(`${parentNodeId}${this.connectionSegment}`);

package/dist/InMemoryLiveWorkflowRepository-BTzHpQ6e.cjs

@@ -1,151 +0,0 @@
-
-//#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) => ({
-				id: node.id,
-				kind: node.kind,
-				name: node.name,
-				nodeTokenId: this.resolveTokenId(node.type),
-				configTokenId: this.resolveTokenId(node.config.type),
-				tokenName: this.resolveTokenName(node.type),
-				configTokenName: this.resolveTokenName(node.config.type),
-				config: this.serializeConfig(node.config)
-			})),
-			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;
-		}
-	}
-	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;
-	}
-	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 {};
-		return { ...value };
-	}
-};
-
-//#endregion
-//#region src/runtime/InMemoryLiveWorkflowRepository.ts
-var InMemoryLiveWorkflowRepository = class {
-	workflowsById = /* @__PURE__ */ new Map();
-	setWorkflows(workflows) {
-		this.workflowsById.clear();
-		for (const workflow of workflows) this.workflowsById.set(workflow.id, workflow);
-	}
-	list() {
-		return [...this.workflowsById.values()];
-	}
-	get(workflowId) {
-		return this.workflowsById.get(workflowId);
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'InMemoryLiveWorkflowRepository', {
-  enumerable: true,
-  get: function () {
-    return InMemoryLiveWorkflowRepository;
-  }
-});
-Object.defineProperty(exports, 'WorkflowSnapshotCodec', {
-  enumerable: true,
-  get: function () {
-    return WorkflowSnapshotCodec;
-  }
-});
-//# sourceMappingURL=InMemoryLiveWorkflowRepository-BTzHpQ6e.cjs.map

package/dist/InMemoryLiveWorkflowRepository-BTzHpQ6e.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"InMemoryLiveWorkflowRepository-BTzHpQ6e.cjs","names":["tokenRegistry: PersistedWorkflowTokenRegistryLike","fallback: Record<string, unknown>"],"sources":["../src/workflowSnapshots/WorkflowSnapshotCodec.ts","../src/runtime/InMemoryLiveWorkflowRepository.ts"],"sourcesContent":["import type { TypeToken } from \"../di\";\nimport type {\n  NodeConfigBase,\n  PersistedTokenId,\n  PersistedWorkflowSnapshot,\n  PersistedWorkflowSnapshotNode,\n  PersistedWorkflowTokenRegistryLike,\n  WorkflowDefinition,\n} from \"../types\";\n\nexport class WorkflowSnapshotCodec {\n  constructor(private readonly tokenRegistry: PersistedWorkflowTokenRegistryLike) {}\n\n  create(workflow: WorkflowDefinition): PersistedWorkflowSnapshot {\n    return {\n      id: workflow.id,\n      name: workflow.name,\n      workflowErrorHandlerConfigured: workflow.workflowErrorHandler !== undefined,\n      ...(workflow.connections !== undefined && workflow.connections.length > 0\n        ? { connections: workflow.connections }\n        : {}),\n      nodes: workflow.nodes.map((node) => ({\n        id: node.id,\n        kind: node.kind,\n        name: node.name,\n        nodeTokenId: this.resolveTokenId(node.type),\n        configTokenId: this.resolveTokenId(node.config.type),\n        tokenName: this.resolveTokenName(node.type),\n        configTokenName: this.resolveTokenName(node.config.type),\n        config: this.serializeConfig(node.config),\n      })),\n      edges: workflow.edges.map((edge) => ({\n        from: { nodeId: edge.from.nodeId, output: edge.from.output },\n        to: { nodeId: edge.to.nodeId, input: edge.to.input },\n      })),\n    };\n  }\n\n  hydrate(snapshotNode: PersistedWorkflowSnapshotNode, liveConfig: NodeConfigBase): NodeConfigBase {\n    const hydrated = this.mergeValue(liveConfig, snapshotNode.config);\n    const configToken = this.tokenRegistry.resolve(snapshotNode.configTokenId);\n    Object.assign(hydrated, {\n      type: configToken ?? liveConfig.type,\n      kind: snapshotNode.kind,\n    });\n    if (snapshotNode.name && !(\"name\" in hydrated && hydrated.name)) {\n      Object.assign(hydrated, { name: snapshotNode.name });\n    }\n    return hydrated as unknown as NodeConfigBase;\n  }\n\n  private serializeConfig(config: NodeConfigBase): unknown {\n    try {\n      const cloned = JSON.parse(JSON.stringify(config)) as Record<string, unknown>;\n      this.injectTokenIds(cloned, config as unknown as Record<string, unknown>);\n      return cloned;\n    } catch {\n      const fallback: Record<string, unknown> = {\n        kind: config.kind,\n        name: config.name,\n        id: config.id,\n        icon: config.icon,\n        execution: config.execution,\n      };\n      this.injectTokenIds(fallback, config as unknown as Record<string, unknown>);\n      return fallback;\n    }\n  }\n\n  private injectTokenIds(target: Record<string, unknown>, source: Record<string, unknown>): void {\n    const type = this.asTypeToken(source.type);\n    if (type) {\n      target.tokenId = this.tokenRegistry.getTokenId(type) ?? this.resolveTokenName(type) ?? \"unknown\";\n    }\n    for (const [key, value] of Object.entries(source)) {\n      if (key === \"type\" || value == null) {\n        continue;\n      }\n      if (Array.isArray(value)) {\n        const targetArray = target[key];\n        if (Array.isArray(targetArray)) {\n          value.forEach((item, index) => {\n            if (item && typeof item === \"object\" && targetArray[index] && typeof targetArray[index] === \"object\") {\n              this.injectTokenIds(targetArray[index] as Record<string, unknown>, item as Record<string, unknown>);\n            }\n          });\n        }\n        continue;\n      }\n      if (typeof value === \"object\") {\n        const targetValue = target[key];\n        if (targetValue && typeof targetValue === \"object\") {\n          this.injectTokenIds(targetValue as Record<string, unknown>, value as Record<string, unknown>);\n        }\n      }\n    }\n  }\n\n  private mergeValue(liveValue: unknown, snapshotValue: unknown): Record<string, unknown> {\n    const liveRecord = this.asRecord(liveValue);\n    const snapshotRecord = this.asRecord(snapshotValue);\n    const hydrated = Object.create(\n      liveValue && typeof liveValue === \"object\"\n        ? (Object.getPrototypeOf(liveValue) ?? Object.prototype)\n        : Object.prototype,\n    ) as Record<string, unknown>;\n\n    for (const [key, value] of Object.entries(snapshotRecord)) {\n      hydrated[key] = this.mergeNestedValue(liveRecord[key], value);\n    }\n\n    this.restoreNonSerializableProperties(liveRecord, hydrated);\n    this.restoreTypeProperty(hydrated);\n    return hydrated;\n  }\n\n  private mergeNestedValue(liveValue: unknown, snapshotValue: unknown): unknown {\n    if (Array.isArray(snapshotValue)) {\n      const liveArray = Array.isArray(liveValue) ? liveValue : [];\n      return snapshotValue.map((entry, index) => this.mergeNestedValue(liveArray[index], entry));\n    }\n    if (snapshotValue && typeof snapshotValue === \"object\") {\n      return this.mergeValue(liveValue, snapshotValue);\n    }\n    return snapshotValue;\n  }\n\n  private restoreNonSerializableProperties(\n    liveRecord: Record<string, unknown>,\n    hydrated: Record<string, unknown>,\n  ): void {\n    for (const [key, value] of Object.entries(liveRecord)) {\n      if (typeof value === \"function\" || typeof value === \"symbol\") {\n        hydrated[key] = value;\n      }\n    }\n  }\n\n  private restoreTypeProperty(record: Record<string, unknown>): void {\n    const tokenId = typeof record.tokenId === \"string\" ? record.tokenId : undefined;\n    if (!tokenId) {\n      return;\n    }\n    const type = this.tokenRegistry.resolve(tokenId as PersistedTokenId);\n    if (type) {\n      record.type = type;\n    }\n  }\n\n  private resolveTokenId(token: TypeToken<unknown>): PersistedTokenId {\n    return (this.tokenRegistry.getTokenId(token) ?? this.resolveTokenName(token) ?? \"unknown\") as PersistedTokenId;\n  }\n\n  private resolveTokenName(token: TypeToken<unknown>): string | undefined {\n    if (typeof token === \"function\" && token.name) {\n      return token.name;\n    }\n    if (typeof token === \"string\") {\n      return token;\n    }\n    return undefined;\n  }\n\n  private asTypeToken(value: unknown): TypeToken<unknown> | undefined {\n    if (typeof value === \"function\" || typeof value === \"string\" || typeof value === \"symbol\") {\n      return value as TypeToken<unknown>;\n    }\n    return undefined;\n  }\n\n  private asRecord(value: unknown): Record<string, unknown> {\n    if (!value || typeof value !== \"object\" || Array.isArray(value)) {\n      return {};\n    }\n    return { ...(value as Record<string, unknown>) };\n  }\n}\n","import type { LiveWorkflowRepository, WorkflowDefinition, WorkflowId } from \"../types\";\n\nexport class InMemoryLiveWorkflowRepository implements LiveWorkflowRepository {\n  private readonly workflowsById = new Map<WorkflowId, WorkflowDefinition>();\n\n  setWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void {\n    this.workflowsById.clear();\n    for (const workflow of workflows) {\n      this.workflowsById.set(workflow.id, workflow);\n    }\n  }\n\n  list(): ReadonlyArray<WorkflowDefinition> {\n    return [...this.workflowsById.values()];\n  }\n\n  get(workflowId: WorkflowId): WorkflowDefinition | undefined {\n    return this.workflowsById.get(workflowId);\n  }\n}\n"],"mappings":"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"}