@orkestrel/workflow 0.0.3 → 0.0.5

package/dist/src/core/index.cjs

@@ -1844,6 +1844,91 @@ var Workflow = class {
 	}
 };
 //#endregion
+//#region src/core/WorkflowManager.ts
+/**
+* The store-backed registry of {@link WorkflowInterface}s keyed by `id`, in insertion order —
+* the additive manager tier mirroring the `@orkestrel/agent` line's `ConversationManager` /
+* `WorkspaceManager`. Event-free (a registry, like its twins); the observability lives on each
+* {@link WorkflowInterface}.
+*
+* @remarks
+* - **Registry.** Workflows live in an insertion-ordered `Map` keyed by `id`. `add(definition)`
+*   mints a live {@link WorkflowInterface} through {@link createWorkflow} (flowing the manager's
+*   `functions` registry in) and stores it under `definition.id` — an already-present id
+*   OVERWRITES (last write wins). `count` is the map size, `workflow(id)` looks one up,
+*   `workflows()` lists them in insertion order.
+* - **Durable open / save.** `open(id)` returns an already-registered workflow directly; on a
+*   registry MISS with a `store` set it rehydrates through {@link restoreWorkflow} (flowing the
+*   manager's `functions` registry in so the rehydrated tree is RUNNABLE), registers it, and
+*   returns it — lenient (`undefined`) with no store or a store miss. `save(id)` persists a
+*   registered workflow's `snapshot()` to the `store` — lenient (`false`) with no store or an
+*   unknown id.
+* - **Removal.** `remove` drops one by id, or a batch (§9.2, array overload FIRST) — `true` when
+*   any was removed. `clear` empties the registry.
+* - **No active pointer.** Unlike its `ConversationManager` / `WorkspaceManager` twins, there is
+*   no `active` / `switch` — nothing in the workflow domain renders "the current workflow".
+*
+* @example
+* ```ts
+* const manager = new WorkflowManager({
+* 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+* })
+* const workflow = manager.add(definition) // minted, registered, RUNNABLE
+* manager.workflow(workflow.id) // the same workflow
+* manager.count // 1
+* ```
+*/
+var WorkflowManager = class {
+	#workflows = /* @__PURE__ */ new Map();
+	#functions;
+	#store;
+	constructor(options) {
+		this.#functions = options?.functions;
+		this.#store = options?.store;
+	}
+	get count() {
+		return this.#workflows.size;
+	}
+	workflow(id) {
+		return this.#workflows.get(id);
+	}
+	workflows() {
+		return [...this.#workflows.values()];
+	}
+	add(definition) {
+		const workflow = createWorkflow(definition, { functions: this.#functions });
+		this.#workflows.set(workflow.id, workflow);
+		return workflow;
+	}
+	async open(id) {
+		const existing = this.#workflows.get(id);
+		if (existing !== void 0) return existing;
+		if (this.#store === void 0) return void 0;
+		const snapshot = await this.#store.get(id);
+		if (snapshot === void 0) return void 0;
+		const workflow = restoreWorkflow(snapshot, { functions: this.#functions });
+		this.#workflows.set(workflow.id, workflow);
+		return workflow;
+	}
+	async save(id) {
+		const workflow = this.#workflows.get(id);
+		if (this.#store === void 0 || workflow === void 0) return false;
+		await this.#store.set(workflow.snapshot());
+		return true;
+	}
+	remove(ids) {
+		if ((0, _orkestrel_contract.isArray)(ids)) {
+			let removed = false;
+			for (const id of ids) if (this.#workflows.delete(id)) removed = true;
+			return removed;
+		}
+		return this.#workflows.delete(ids);
+	}
+	clear() {
+		this.#workflows.clear();
+	}
+};
+//#endregion
 //#region src/core/Controller.ts
 /**
 * The per-unit handle a runner handler receives — wraps the unit's identity,
@@ -2805,6 +2890,40 @@ function createWorkflowRunner(options) {
 	return new WorkflowRunner(options?.scheduler ?? createScheduler());
 }
 /**
+* Create a {@link WorkflowManagerInterface} — the store-backed registry of
+* {@link WorkflowInterface}s, the additive manager tier mirroring the `@orkestrel/agent`
+* line's `createConversationManager` / `createWorkspaceManager`.
+*
+* @remarks
+* `options.functions` flows into every workflow the manager mints (`add`, via
+* {@link createWorkflow}) or hydrates (`open`'s registry-miss path, via
+* {@link restoreWorkflow}), so a hydrated workflow is RUNNABLE rather than a dead snapshot
+* mirror. `options.store` is the EXACT analogue of the twins' `store` seam — omitted ⇒ the
+* manager is registry-only (`open` resolves only what is registered, `save` is a no-op). This
+* is PURELY ADDITIVE: direct {@link WorkflowStoreInterface} use and
+* {@link restoreWorkflow} remain valid — the manager is one more caller-driven persistence
+* seam, not a replacement.
+*
+* @param options - The optional `store` seam and the `functions` registry threaded into every mint/hydrate
+* @returns A working {@link WorkflowManagerInterface}
+*
+* @example
+* ```ts
+* import { createMemoryWorkflowStore, createWorkflowManager } from '@src/core'
+*
+* const manager = createWorkflowManager({
+* 	store: createMemoryWorkflowStore(),
+* 	functions: { compile: async (controller) => `built ${controller.task.id}` },
+* })
+* const workflow = manager.add(definition) // minted, registered, RUNNABLE
+* await manager.save(workflow.id)          // persisted to the store
+* const reopened = await manager.open(workflow.id) // already registered — no store hit
+* ```
+*/
+function createWorkflowManager(options) {
+	return new WorkflowManager(options);
+}
+/**
 * Create the safe cross-environment cooperative-yield default — a
 * {@link SchedulerInterface} built on `setTimeout` / `clearTimeout` alone, so it
 * runs unchanged in both the browser and Node.
@@ -2915,6 +3034,7 @@ exports.TaskManager = TaskManager;
 exports.WORKFLOW_STATUSES = WORKFLOW_STATUSES;
 exports.Workflow = Workflow;
 exports.WorkflowError = WorkflowError;
+exports.WorkflowManager = WorkflowManager;
 exports.WorkflowRunner = WorkflowRunner;
 exports.assertSnapshot = assertSnapshot;
 exports.buildPhaseContext = buildPhaseContext;
@@ -2929,6 +3049,7 @@ exports.createRunner = createRunner;
 exports.createScheduler = createScheduler;
 exports.createWorkflow = createWorkflow;
 exports.createWorkflowContract = createWorkflowContract;
+exports.createWorkflowManager = createWorkflowManager;
 exports.createWorkflowRunner = createWorkflowRunner;
 exports.definitionToSnapshot = definitionToSnapshot;
 exports.deriveBoundary = deriveBoundary;