@lssm/lib.contracts 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217072406

package/dist/workflow/adapters/db-adapter.js

@@ -1 +1,83 @@
-var e=class{constructor(e){this.prisma=e}async create(e){await this.prisma.workflowState.create({data:{id:e.workflowId,name:e.workflowName,version:e.workflowVersion,status:e.status,currentStep:e.currentStep,data:e.data,history:e.history,retryCounts:e.retryCounts??{},createdAt:e.createdAt,updatedAt:e.updatedAt}})}async get(e){let t=await this.prisma.workflowState.findUnique({where:{id:e}});if(t)return{workflowId:t.id,workflowName:t.name,workflowVersion:t.version,currentStep:t.currentStep,data:t.data,history:t.history,retryCounts:t.retryCounts,status:t.status,createdAt:t.createdAt,updatedAt:t.updatedAt}}async update(e,t){let n=await this.get(e);if(!n)throw Error(`Workflow ${e} not found`);let r=t(n),i=await this.prisma.workflowState.update({where:{id:e},data:{status:r.status,currentStep:r.currentStep,data:r.data,history:r.history,retryCounts:r.retryCounts,updatedAt:r.updatedAt}});return{workflowId:i.id,workflowName:i.name,workflowVersion:i.version,currentStep:i.currentStep,data:i.data,history:i.history,retryCounts:i.retryCounts,status:i.status,createdAt:i.createdAt,updatedAt:i.updatedAt}}async list(e){let t={};return e?.status&&(t.status=e.status),(await this.prisma.workflowState.findMany({where:t})).map(e=>({workflowId:e.id,workflowName:e.name,workflowVersion:e.version,currentStep:e.currentStep,data:e.data,history:e.history,retryCounts:e.retryCounts,status:e.status,createdAt:e.createdAt,updatedAt:e.updatedAt}))}};export{e as PrismaStateStore};
+//#region src/workflow/adapters/db-adapter.ts
+var PrismaStateStore = class {
+	constructor(prisma) {
+		this.prisma = prisma;
+	}
+	async create(state) {
+		await this.prisma.workflowState.create({ data: {
+			id: state.workflowId,
+			name: state.workflowName,
+			version: state.workflowVersion,
+			status: state.status,
+			currentStep: state.currentStep,
+			data: state.data,
+			history: state.history,
+			retryCounts: state.retryCounts ?? {},
+			createdAt: state.createdAt,
+			updatedAt: state.updatedAt
+		} });
+	}
+	async get(workflowId) {
+		const record = await this.prisma.workflowState.findUnique({ where: { id: workflowId } });
+		if (!record) return void 0;
+		return {
+			workflowId: record.id,
+			workflowName: record.name,
+			workflowVersion: record.version,
+			currentStep: record.currentStep,
+			data: record.data,
+			history: record.history,
+			retryCounts: record.retryCounts,
+			status: record.status,
+			createdAt: record.createdAt,
+			updatedAt: record.updatedAt
+		};
+	}
+	async update(workflowId, updater) {
+		const current = await this.get(workflowId);
+		if (!current) throw new Error(`Workflow ${workflowId} not found`);
+		const next = updater(current);
+		const updated = await this.prisma.workflowState.update({
+			where: { id: workflowId },
+			data: {
+				status: next.status,
+				currentStep: next.currentStep,
+				data: next.data,
+				history: next.history,
+				retryCounts: next.retryCounts,
+				updatedAt: next.updatedAt
+			}
+		});
+		return {
+			workflowId: updated.id,
+			workflowName: updated.name,
+			workflowVersion: updated.version,
+			currentStep: updated.currentStep,
+			data: updated.data,
+			history: updated.history,
+			retryCounts: updated.retryCounts,
+			status: updated.status,
+			createdAt: updated.createdAt,
+			updatedAt: updated.updatedAt
+		};
+	}
+	async list(filters) {
+		const where = {};
+		if (filters?.status) where.status = filters.status;
+		return (await this.prisma.workflowState.findMany({ where })).map((record) => ({
+			workflowId: record.id,
+			workflowName: record.name,
+			workflowVersion: record.version,
+			currentStep: record.currentStep,
+			data: record.data,
+			history: record.history,
+			retryCounts: record.retryCounts,
+			status: record.status,
+			createdAt: record.createdAt,
+			updatedAt: record.updatedAt
+		}));
+	}
+};
+
+//#endregion
+export { PrismaStateStore };

package/dist/workflow/adapters/file-adapter.js

@@ -1 +1,11 @@
-function e(e){throw Error(`File-backed state store adapter not implemented. Provide a custom adapter that satisfies StateStore.`)}export{e as createFileStateStore};
+//#region src/workflow/adapters/file-adapter.ts
+/**
+* Placeholder for a file-backed state store adapter.
+* Implementations should manage locking/concurrency and JSON serialization.
+*/
+function createFileStateStore(_options) {
+	throw new Error("File-backed state store adapter not implemented. Provide a custom adapter that satisfies StateStore.");
+}
+
+//#endregion
+export { createFileStateStore };

package/dist/workflow/adapters/index.js

@@ -1 +1,5 @@
-import{InMemoryStateStore as e}from"./memory-store.js";import{PrismaStateStore as t}from"./db-adapter.js";import{createFileStateStore as n}from"./file-adapter.js";export{e as InMemoryStateStore,t as PrismaStateStore,n as createFileStateStore};
+import { InMemoryStateStore } from "./memory-store.js";
+import { PrismaStateStore } from "./db-adapter.js";
+import { createFileStateStore } from "./file-adapter.js";
+
+export { InMemoryStateStore, PrismaStateStore, createFileStateStore };

package/dist/workflow/adapters/memory-store.js

@@ -1 +1,58 @@
-function e(e){return{...e,data:n(e.data),history:e.history.map(e=>({...e,input:n(e.input),output:n(e.output),startedAt:new Date(e.startedAt),completedAt:e.completedAt?new Date(e.completedAt):void 0})),createdAt:new Date(e.createdAt),updatedAt:new Date(e.updatedAt)}}var t=class{items=new Map;async create(t){if(this.items.has(t.workflowId))throw Error(`Workflow state already exists: ${t.workflowId}`);this.items.set(t.workflowId,e(t))}async get(t){let n=this.items.get(t);return n?e(n):void 0}async update(t,n){let r=this.items.get(t);if(!r)throw Error(`Workflow state not found for ${t}`);let i=e(n(e(r)));return this.items.set(t,i),e(i)}async list(t){let n=[...this.items.values()];return(t?.status?n.filter(e=>e.status===t.status):n).map(e)}clear(){this.items.clear()}};function n(e){if(e instanceof Date)return new Date(e.getTime());if(Array.isArray(e))return e.map(e=>n(e));if(e&&typeof e==`object`){let t={};for(let[r,i]of Object.entries(e))t[r]=n(i);return t}return e}export{t as InMemoryStateStore};
+//#region src/workflow/adapters/memory-store.ts
+function cloneState(state) {
+	return {
+		...state,
+		data: deepCopy(state.data),
+		history: state.history.map((execution) => ({
+			...execution,
+			input: deepCopy(execution.input),
+			output: deepCopy(execution.output),
+			startedAt: new Date(execution.startedAt),
+			completedAt: execution.completedAt ? new Date(execution.completedAt) : void 0
+		})),
+		createdAt: new Date(state.createdAt),
+		updatedAt: new Date(state.updatedAt)
+	};
+}
+/**
+* Naive in-memory state store. Suitable for tests and single-node development
+* environments. Swap with a database-backed adapter in production.
+*/
+var InMemoryStateStore = class {
+	items = /* @__PURE__ */ new Map();
+	async create(state) {
+		if (this.items.has(state.workflowId)) throw new Error(`Workflow state already exists: ${state.workflowId}`);
+		this.items.set(state.workflowId, cloneState(state));
+	}
+	async get(workflowId) {
+		const state = this.items.get(workflowId);
+		return state ? cloneState(state) : void 0;
+	}
+	async update(workflowId, updater) {
+		const current = this.items.get(workflowId);
+		if (!current) throw new Error(`Workflow state not found for ${workflowId}`);
+		const next = cloneState(updater(cloneState(current)));
+		this.items.set(workflowId, next);
+		return cloneState(next);
+	}
+	async list(filters) {
+		const all = [...this.items.values()];
+		return (filters?.status ? all.filter((state) => state.status === filters.status) : all).map(cloneState);
+	}
+	clear() {
+		this.items.clear();
+	}
+};
+function deepCopy(value) {
+	if (value instanceof Date) return new Date(value.getTime());
+	if (Array.isArray(value)) return value.map((item) => deepCopy(item));
+	if (value && typeof value === "object") {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) result[key] = deepCopy(val);
+		return result;
+	}
+	return value;
+}
+
+//#endregion
+export { InMemoryStateStore };

package/dist/workflow/expression.js

@@ -1 +1,98 @@
-function e(n,r){if(!n)return!0;let i=n.trim();if(!i)return!0;let a=o(i,`||`);if(a.length>1)return a.some(t=>e(t,r));let s=o(i,`&&`);return s.length>1?s.every(t=>e(t,r)):t(i,r)}function t(e,a){let o=e.trim();if(!o)return!0;if(o.startsWith(`!`))return!t(o.slice(1),a);let s=o.match(/^(data|input|output)\.([A-Za-z0-9_.\[\]]+)\s*(===|==|!==|!=|>=|<=|>|<)\s*(.+)$/);if(s){let[,e,t,o,c]=s;return n(i(e,a,t),r(c),o)}let c=o.match(/^(data|input|output)\.([A-Za-z0-9_.\[\]]+)$/);if(c){let[,e,t]=c;return!!i(e,a,t)}return!!r(o)}function n(e,t,n){switch(n){case`===`:case`==`:return e===t;case`!==`:case`!=`:return e!==t;case`>`:return Number(e)>Number(t);case`>=`:return Number(e)>=Number(t);case`<`:return Number(e)<Number(t);case`<=`:return Number(e)<=Number(t);default:return!1}}function r(e){let t=(e??``).trim();if(t.startsWith(`"`)&&t.endsWith(`"`)||t.startsWith(`'`)&&t.endsWith(`'`))return t.slice(1,-1);if(/^-?\d+(\.\d+)?$/.test(t))return Number(t);if(/^true$/i.test(t))return!0;if(/^false$/i.test(t))return!1;if(/^null$/i.test(t))return null;if(!/^undefined$/i.test(t))return t}function i(e,t,n){return a(e===`data`?t.data:e===`input`?t.input:t.output,n)}function a(e,t){if(e==null)return;if(!t)return e;let n=t.replace(/\[(\d+)\]/g,`.$1`).split(`.`).filter(Boolean),r=e;for(let e of n){if(r==null)return;r=r[e]}return r}function o(e,t){let n=[],r=``,i=!1,a=!1;for(let o=0;o<e.length;o++){let s=e[o],c=e.slice(o,o+t.length);if(s===`'`&&!a){i=!i,r+=s;continue}if(s===`"`&&!i){a=!a,r+=s;continue}if(!i&&!a&&c===t){n.push(r.trim()),r=``,o+=t.length-1;continue}r+=s}return r.trim().length&&n.push(r.trim()),n}export{e as evaluateExpression};
+//#region src/workflow/expression.ts
+function evaluateExpression(expression, ctx) {
+	if (!expression) return true;
+	const trimmed = expression.trim();
+	if (!trimmed) return true;
+	const orParts = splitByOperator(trimmed, "||");
+	if (orParts.length > 1) return orParts.some((part) => evaluateExpression(part, ctx));
+	const andParts = splitByOperator(trimmed, "&&");
+	if (andParts.length > 1) return andParts.every((part) => evaluateExpression(part, ctx));
+	return evaluateSingle(trimmed, ctx);
+}
+function evaluateSingle(expr, ctx) {
+	const trimmed = expr.trim();
+	if (!trimmed) return true;
+	if (trimmed.startsWith("!")) return !evaluateSingle(trimmed.slice(1), ctx);
+	const comparisonMatch = trimmed.match(/^(data|input|output)\.([A-Za-z0-9_.\[\]]+)\s*(===|==|!==|!=|>=|<=|>|<)\s*(.+)$/);
+	if (comparisonMatch) {
+		const [, root, path, operator, rawRight] = comparisonMatch;
+		return compare(resolveRoot(root, ctx, path), parseLiteral(rawRight), operator);
+	}
+	const truthyMatch = trimmed.match(/^(data|input|output)\.([A-Za-z0-9_.\[\]]+)$/);
+	if (truthyMatch) {
+		const [, root, path] = truthyMatch;
+		const value = resolveRoot(root, ctx, path);
+		return Boolean(value);
+	}
+	const literal = parseLiteral(trimmed);
+	return Boolean(literal);
+}
+function compare(left, right, operator) {
+	switch (operator) {
+		case "===":
+		case "==": return left === right;
+		case "!==":
+		case "!=": return left !== right;
+		case ">": return Number(left) > Number(right);
+		case ">=": return Number(left) >= Number(right);
+		case "<": return Number(left) < Number(right);
+		case "<=": return Number(left) <= Number(right);
+		default: return false;
+	}
+}
+function parseLiteral(value) {
+	const trimmed = (value ?? "").trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+	if (/^true$/i.test(trimmed)) return true;
+	if (/^false$/i.test(trimmed)) return false;
+	if (/^null$/i.test(trimmed)) return null;
+	if (/^undefined$/i.test(trimmed)) return void 0;
+	return trimmed;
+}
+function resolveRoot(root, ctx, path) {
+	return resolvePath(root === "data" ? ctx.data : root === "input" ? ctx.input : ctx.output, path);
+}
+function resolvePath(source, path) {
+	if (source == null) return void 0;
+	if (!path) return source;
+	const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+	let current = source;
+	for (const segment of segments) {
+		if (current == null) return void 0;
+		current = current[segment];
+	}
+	return current;
+}
+function splitByOperator(expr, operator) {
+	const parts = [];
+	let buffer = "";
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	for (let i = 0; i < expr.length; i++) {
+		const char = expr[i];
+		const next = expr.slice(i, i + operator.length);
+		if (char === "'" && !inDoubleQuote) {
+			inSingleQuote = !inSingleQuote;
+			buffer += char;
+			continue;
+		}
+		if (char === "\"" && !inSingleQuote) {
+			inDoubleQuote = !inDoubleQuote;
+			buffer += char;
+			continue;
+		}
+		if (!inSingleQuote && !inDoubleQuote && next === operator) {
+			parts.push(buffer.trim());
+			buffer = "";
+			i += operator.length - 1;
+			continue;
+		}
+		buffer += char;
+	}
+	if (buffer.trim().length) parts.push(buffer.trim());
+	return parts;
+}
+
+//#endregion
+export { evaluateExpression };

package/dist/workflow/index.js

@@ -1 +1,9 @@
-import{WorkflowRegistry as e}from"./spec.js";import{WorkflowValidationError as t,assertWorkflowSpecValid as n,validateWorkflowSpec as r}from"./validation.js";import{evaluateExpression as i}from"./expression.js";import{WorkflowPreFlightError as a,WorkflowRunner as o}from"./runner.js";import{InMemoryStateStore as s}from"./adapters/memory-store.js";import{PrismaStateStore as c}from"./adapters/db-adapter.js";import{createFileStateStore as l}from"./adapters/file-adapter.js";export{s as InMemoryStateStore,c as PrismaStateStore,a as WorkflowPreFlightError,e as WorkflowRegistry,o as WorkflowRunner,t as WorkflowValidationError,n as assertWorkflowSpecValid,l as createFileStateStore,i as evaluateExpression,r as validateWorkflowSpec};
+import { WorkflowRegistry } from "./spec.js";
+import { WorkflowValidationError, assertWorkflowSpecValid, validateWorkflowSpec } from "./validation.js";
+import { evaluateExpression } from "./expression.js";
+import { WorkflowPreFlightError, WorkflowRunner } from "./runner.js";
+import { InMemoryStateStore } from "./adapters/memory-store.js";
+import { PrismaStateStore } from "./adapters/db-adapter.js";
+import { createFileStateStore } from "./adapters/file-adapter.js";
+
+export { InMemoryStateStore, PrismaStateStore, WorkflowPreFlightError, WorkflowRegistry, WorkflowRunner, WorkflowValidationError, assertWorkflowSpecValid, createFileStateStore, evaluateExpression, validateWorkflowSpec };

package/dist/workflow/runner.js

@@ -1 +1,337 @@
-import{evaluateExpression as e}from"./expression.js";import{randomUUID as t}from"node:crypto";var n=class{constructor(e){this.config=e}async preFlightCheck(e,t,n){let r=this.getSpec(e,t);return this.performPreFlight(r,n)}async start(e,n,i){let a=this.getSpec(e,n),o=r(a),s=new Date,l=t(),u={workflowId:l,workflowName:a.meta.name,workflowVersion:a.meta.version,currentStep:o,data:{...i??{}},retryCounts:{},history:[],status:`running`,createdAt:s,updatedAt:s},d=this.config.appConfigProvider?await this.config.appConfigProvider(u):void 0,f=await this.performPreFlight(a,d);if(!f.canStart)throw new c(f.issues);return await this.config.stateStore.create(u),this.emit(`workflow.started`,{workflowId:l,workflowName:a.meta.name,workflowVersion:a.meta.version,currentStep:o}),l}async executeStep(e,t){let n=await this.getStateOrThrow(e);if(s(n.status))throw Error(`Workflow ${e} is in terminal status "${n.status}".`);let r=this.getSpec(n.workflowName,n.workflowVersion),c=i(r,n.currentStep);if(!await this.evaluateGuard(c,n,t))throw Error(`GuardRejected: ${n.workflowName} -> ${c.id}`);let l={stepId:c.id,startedAt:new Date,status:`running`,input:t},u={...n,data:{...n.data},history:[...n.history]};try{let i=await this.runStepAction(c,u,t);l.output=i,l.status=`completed`,l.completedAt=new Date,u.history.push(l),u.updatedAt=new Date,o(t)&&(u.data={...u.data,...t}),o(i)&&(u.data={...u.data,...i});let s=this.pickNextStepId(r,u,c,t,i);if(s)u.currentStep=s,u.status=`running`;else if(!a(r,c.id))u.status=`completed`;else throw Error(`No transition matched after executing step "${c.id}".`);await this.config.stateStore.update(e,()=>u),this.emit(`workflow.step_completed`,{workflowId:e,workflowName:n.workflowName,stepId:c.id,status:u.status})}catch(i){if(l.status=`failed`,l.completedAt=new Date,l.error=i instanceof Error?i.message:String(i),u.history.push(l),u.updatedAt=new Date,c.retry){let r=n.retryCounts?.[c.id]??0;if(r<c.retry.maxAttempts){let i=c.retry.backoff??`exponential`,a=c.retry.delayMs??1e3,o=i===`exponential`?a*2**r:a,s=Math.min(o,c.retry.maxDelayMs??1/0);return u.retryCounts={...n.retryCounts??{},[c.id]:r+1},u.status=`running`,await this.config.stateStore.update(e,()=>u),this.emit(`workflow.step_retrying`,{workflowId:e,workflowName:n.workflowName,stepId:c.id,attempt:r+1,delay:s,error:l.error}),await new Promise(e=>setTimeout(e,s)),this.executeStep(e,t)}}throw u.status=`failed`,await this.config.stateStore.update(e,()=>u),this.emit(`workflow.step_failed`,{workflowId:e,workflowName:n.workflowName,stepId:c.id,error:l.error??`unknown`}),r.definition.compensation?.trigger===`on_failure`&&await this.rollback(e),i}}async rollback(e){let t=await this.getStateOrThrow(e),n=this.getSpec(t.workflowName,t.workflowVersion);if(!n.definition.compensation)return;this.emit(`workflow.rollback_started`,{workflowId:e});let r=t.history.filter(e=>e.status===`completed`).reverse();for(let a of r){let r=n.definition.compensation.steps.find(e=>e.stepId===a.stepId);if(r){let o={stepId:a.stepId,originalInput:a.input,originalOutput:a.output,workflowData:t.data};try{let s=i(n,a.stepId),c=this.config.appConfigProvider?await this.config.appConfigProvider(t):void 0,l={workflow:t,step:s,resolvedAppConfig:c,integrations:c?.integrations??[],knowledge:c?.knowledge??[],branding:c?.branding,translation:c?.translation,translationResolver:this.config.translationResolver,secretProvider:this.config.secretProvider};await this.config.opExecutor(r.operation,o,l),this.emit(`workflow.compensation_step_completed`,{workflowId:e,stepId:a.stepId,compensationOp:r.operation.name})}catch(t){let n=t instanceof Error?t.message:String(t);this.emit(`workflow.compensation_step_failed`,{workflowId:e,stepId:a.stepId,compensationOp:r.operation.name,error:n})}}}this.emit(`workflow.rollback_completed`,{workflowId:e})}async getState(e){return this.getStateOrThrow(e)}async cancel(e){let t=await this.getStateOrThrow(e);if(t.status===`cancelled`)return;let n={...t,status:`cancelled`,updatedAt:new Date};await this.config.stateStore.update(e,()=>n),this.emit(`workflow.cancelled`,{workflowId:e,workflowName:t.workflowName})}async performPreFlight(e,t){if(!t)return{canStart:!0,issues:[]};let n=[],r=new Map;for(let e of t.integrations)r.set(e.slot.slotId,e);for(let t of e.definition.steps)for(let e of t.requiredIntegrations??[]){let i=r.get(e);if(!i){n.push({stepId:t.id,type:`integration`,identifier:e,severity:`error`,reason:`Integration slot "${e}" is not bound in the resolved app config.`});continue}let a=i.connection.status;a===`disconnected`||a===`error`?n.push({stepId:t.id,type:`integration`,identifier:e,severity:`error`,reason:`Integration slot "${e}" is in status "${a}".`}):a===`unknown`&&n.push({stepId:t.id,type:`integration`,identifier:e,severity:`warning`,reason:`Integration slot "${e}" reports unknown health status.`})}let i=new Set(t.capabilities.enabled.map(l));for(let t of e.definition.steps)for(let e of t.requiredCapabilities??[])i.has(l(e))||n.push({stepId:t.id,type:`capability`,identifier:l(e),severity:`error`,reason:`Capability "${e.key}@${e.version}" is not enabled.`});return{canStart:n.every(e=>e.severity!==`error`),issues:n}}async evaluateGuard(t,n,r){return t.guard?this.config.guardEvaluator?this.config.guardEvaluator(t.guard,{workflow:n,step:t,input:r}):t.guard.type===`expression`?e(t.guard.value,{data:n.data,input:r}):!0:!0}async runStepAction(e,t,n){if(e.type===`automation`){let r=e.action?.operation;if(!r)throw Error(`Automation step "${e.id}" requires an operation.`);let i=this.config.appConfigProvider?await this.config.appConfigProvider(t):void 0,a={workflow:t,step:e,resolvedAppConfig:i,integrations:i?.integrations??[],knowledge:i?.knowledge??[],branding:i?.branding,translation:i?.translation,translationResolver:this.config.translationResolver,secretProvider:this.config.secretProvider};return this.config.enforceCapabilities&&await this.config.enforceCapabilities(r,a),this.config.opExecutor(r,n,a)}return e.type,n}pickNextStepId(t,n,r,i,a){let o=t.definition.transitions.filter(e=>e.from===r.id);for(let r of o)if(e(r.condition,{data:n.data,input:i,output:a})){let e=t.definition.steps.find(e=>e.id===r.to);if(!e)throw Error(`Transition ${r.from} -> ${r.to} points to missing step.`);return e.id}return null}getSpec(e,t){let n=this.config.registry.get(e,t);if(!n)throw Error(`Workflow spec not found for ${e}${t?`.v${t}`:``}`);return n}async getStateOrThrow(e){let t=await this.config.stateStore.get(e);if(!t)throw Error(`Workflow state not found for ${e}`);return t}emit(e,t){this.config.eventEmitter?.(e,t)}};function r(e){let t=e.definition.entryStepId??e.definition.steps[0]?.id??null;if(!t)throw Error(`Workflow ${e.meta.name}.v${e.meta.version} has no entry step.`);return t}function i(e,t){let n=e.definition.steps.find(e=>e.id===t);if(!n)throw Error(`Step "${t}" not found in workflow ${e.meta.name}.v${e.meta.version}.`);return n}function a(e,t){return e.definition.transitions.some(e=>e.from===t)}function o(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function s(e){return e===`completed`||e===`failed`||e===`cancelled`}var c=class extends Error{constructor(e){super(`Workflow pre-flight failed: ${e.filter(e=>e.severity===`error`).map(e=>`${e.type}:${e.identifier}`).join(`, `)}`),this.issues=e,this.name=`WorkflowPreFlightError`}};function l(e){return`${e.key}@${e.version}`}export{c as WorkflowPreFlightError,n as WorkflowRunner};
+import { evaluateExpression } from "./expression.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/workflow/runner.ts
+var WorkflowRunner = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async preFlightCheck(workflowName, version, resolvedConfig) {
+		const spec = this.getSpec(workflowName, version);
+		return this.performPreFlight(spec, resolvedConfig);
+	}
+	async start(workflowName, version, initialData) {
+		const spec = this.getSpec(workflowName, version);
+		const entryStepId = resolveEntryStepId(spec);
+		const now = /* @__PURE__ */ new Date();
+		const workflowId = randomUUID();
+		const state = {
+			workflowId,
+			workflowName: spec.meta.name,
+			workflowVersion: spec.meta.version,
+			currentStep: entryStepId,
+			data: { ...initialData ?? {} },
+			retryCounts: {},
+			history: [],
+			status: "running",
+			createdAt: now,
+			updatedAt: now
+		};
+		const resolvedAppConfig = this.config.appConfigProvider ? await this.config.appConfigProvider(state) : void 0;
+		const preFlightResult = await this.performPreFlight(spec, resolvedAppConfig);
+		if (!preFlightResult.canStart) throw new WorkflowPreFlightError(preFlightResult.issues);
+		await this.config.stateStore.create(state);
+		this.emit("workflow.started", {
+			workflowId,
+			workflowName: spec.meta.name,
+			workflowVersion: spec.meta.version,
+			currentStep: entryStepId
+		});
+		return workflowId;
+	}
+	async executeStep(workflowId, input) {
+		const state = await this.getStateOrThrow(workflowId);
+		if (isTerminalStatus(state.status)) throw new Error(`Workflow ${workflowId} is in terminal status "${state.status}".`);
+		const spec = this.getSpec(state.workflowName, state.workflowVersion);
+		const step = getCurrentStep(spec, state.currentStep);
+		if (!await this.evaluateGuard(step, state, input)) throw new Error(`GuardRejected: ${state.workflowName} -> ${step.id}`);
+		const execution = {
+			stepId: step.id,
+			startedAt: /* @__PURE__ */ new Date(),
+			status: "running",
+			input
+		};
+		const workingState = {
+			...state,
+			data: { ...state.data },
+			history: [...state.history]
+		};
+		try {
+			const output = await this.runStepAction(step, workingState, input);
+			execution.output = output;
+			execution.status = "completed";
+			execution.completedAt = /* @__PURE__ */ new Date();
+			workingState.history.push(execution);
+			workingState.updatedAt = /* @__PURE__ */ new Date();
+			if (isRecord(input)) workingState.data = {
+				...workingState.data,
+				...input
+			};
+			if (isRecord(output)) workingState.data = {
+				...workingState.data,
+				...output
+			};
+			const nextStepId = this.pickNextStepId(spec, workingState, step, input, output);
+			if (nextStepId) {
+				workingState.currentStep = nextStepId;
+				workingState.status = "running";
+			} else if (!hasOutgoing(spec, step.id)) workingState.status = "completed";
+			else throw new Error(`No transition matched after executing step "${step.id}".`);
+			await this.config.stateStore.update(workflowId, () => workingState);
+			this.emit("workflow.step_completed", {
+				workflowId,
+				workflowName: state.workflowName,
+				stepId: step.id,
+				status: workingState.status
+			});
+		} catch (error) {
+			execution.status = "failed";
+			execution.completedAt = /* @__PURE__ */ new Date();
+			execution.error = error instanceof Error ? error.message : String(error);
+			workingState.history.push(execution);
+			workingState.updatedAt = /* @__PURE__ */ new Date();
+			if (step.retry) {
+				const retries = state.retryCounts?.[step.id] ?? 0;
+				if (retries < step.retry.maxAttempts) {
+					const backoff = step.retry.backoff ?? "exponential";
+					const baseDelay = step.retry.delayMs ?? 1e3;
+					const delay = backoff === "exponential" ? baseDelay * Math.pow(2, retries) : baseDelay;
+					const cappedDelay = Math.min(delay, step.retry.maxDelayMs ?? Infinity);
+					workingState.retryCounts = {
+						...state.retryCounts ?? {},
+						[step.id]: retries + 1
+					};
+					workingState.status = "running";
+					await this.config.stateStore.update(workflowId, () => workingState);
+					this.emit("workflow.step_retrying", {
+						workflowId,
+						workflowName: state.workflowName,
+						stepId: step.id,
+						attempt: retries + 1,
+						delay: cappedDelay,
+						error: execution.error
+					});
+					await new Promise((resolve) => setTimeout(resolve, cappedDelay));
+					return this.executeStep(workflowId, input);
+				}
+			}
+			workingState.status = "failed";
+			await this.config.stateStore.update(workflowId, () => workingState);
+			this.emit("workflow.step_failed", {
+				workflowId,
+				workflowName: state.workflowName,
+				stepId: step.id,
+				error: execution.error ?? "unknown"
+			});
+			if (spec.definition.compensation?.trigger === "on_failure") await this.rollback(workflowId);
+			throw error;
+		}
+	}
+	async rollback(workflowId) {
+		const state = await this.getStateOrThrow(workflowId);
+		const spec = this.getSpec(state.workflowName, state.workflowVersion);
+		if (!spec.definition.compensation) return;
+		this.emit("workflow.rollback_started", { workflowId });
+		const completedSteps = state.history.filter((h) => h.status === "completed").reverse();
+		for (const execution of completedSteps) {
+			const compStep = spec.definition.compensation.steps.find((s) => s.stepId === execution.stepId);
+			if (compStep) {
+				const input = {
+					stepId: execution.stepId,
+					originalInput: execution.input,
+					originalOutput: execution.output,
+					workflowData: state.data
+				};
+				try {
+					const step = getCurrentStep(spec, execution.stepId);
+					const resolvedAppConfig = this.config.appConfigProvider ? await this.config.appConfigProvider(state) : void 0;
+					const executorContext = {
+						workflow: state,
+						step,
+						resolvedAppConfig,
+						integrations: resolvedAppConfig?.integrations ?? [],
+						knowledge: resolvedAppConfig?.knowledge ?? [],
+						branding: resolvedAppConfig?.branding,
+						translation: resolvedAppConfig?.translation,
+						translationResolver: this.config.translationResolver,
+						secretProvider: this.config.secretProvider
+					};
+					await this.config.opExecutor(compStep.operation, input, executorContext);
+					this.emit("workflow.compensation_step_completed", {
+						workflowId,
+						stepId: execution.stepId,
+						compensationOp: compStep.operation.name
+					});
+				} catch (error) {
+					const errorMessage = error instanceof Error ? error.message : String(error);
+					this.emit("workflow.compensation_step_failed", {
+						workflowId,
+						stepId: execution.stepId,
+						compensationOp: compStep.operation.name,
+						error: errorMessage
+					});
+				}
+			}
+		}
+		this.emit("workflow.rollback_completed", { workflowId });
+	}
+	async getState(workflowId) {
+		return this.getStateOrThrow(workflowId);
+	}
+	async cancel(workflowId) {
+		const state = await this.getStateOrThrow(workflowId);
+		if (state.status === "cancelled") return;
+		const nextState = {
+			...state,
+			status: "cancelled",
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		await this.config.stateStore.update(workflowId, () => nextState);
+		this.emit("workflow.cancelled", {
+			workflowId,
+			workflowName: state.workflowName
+		});
+	}
+	async performPreFlight(spec, resolvedConfig) {
+		if (!resolvedConfig) return {
+			canStart: true,
+			issues: []
+		};
+		const issues = [];
+		const integrationBySlot = /* @__PURE__ */ new Map();
+		for (const integration of resolvedConfig.integrations) integrationBySlot.set(integration.slot.slotId, integration);
+		for (const step of spec.definition.steps) for (const slotId of step.requiredIntegrations ?? []) {
+			const integration = integrationBySlot.get(slotId);
+			if (!integration) {
+				issues.push({
+					stepId: step.id,
+					type: "integration",
+					identifier: slotId,
+					severity: "error",
+					reason: `Integration slot "${slotId}" is not bound in the resolved app config.`
+				});
+				continue;
+			}
+			const status = integration.connection.status;
+			if (status === "disconnected" || status === "error") issues.push({
+				stepId: step.id,
+				type: "integration",
+				identifier: slotId,
+				severity: "error",
+				reason: `Integration slot "${slotId}" is in status "${status}".`
+			});
+			else if (status === "unknown") issues.push({
+				stepId: step.id,
+				type: "integration",
+				identifier: slotId,
+				severity: "warning",
+				reason: `Integration slot "${slotId}" reports unknown health status.`
+			});
+		}
+		const enabledCapabilities = new Set(resolvedConfig.capabilities.enabled.map(capabilityKey));
+		for (const step of spec.definition.steps) for (const required of step.requiredCapabilities ?? []) if (!enabledCapabilities.has(capabilityKey(required))) issues.push({
+			stepId: step.id,
+			type: "capability",
+			identifier: capabilityKey(required),
+			severity: "error",
+			reason: `Capability "${required.key}@${required.version}" is not enabled.`
+		});
+		return {
+			canStart: issues.every((issue) => issue.severity !== "error"),
+			issues
+		};
+	}
+	async evaluateGuard(step, state, input) {
+		if (!step.guard) return true;
+		if (this.config.guardEvaluator) return this.config.guardEvaluator(step.guard, {
+			workflow: state,
+			step,
+			input
+		});
+		if (step.guard.type === "expression") return evaluateExpression(step.guard.value, {
+			data: state.data,
+			input
+		});
+		return true;
+	}
+	async runStepAction(step, state, input) {
+		if (step.type === "automation") {
+			const op = step.action?.operation;
+			if (!op) throw new Error(`Automation step "${step.id}" requires an operation.`);
+			const resolvedAppConfig = this.config.appConfigProvider ? await this.config.appConfigProvider(state) : void 0;
+			const executorContext = {
+				workflow: state,
+				step,
+				resolvedAppConfig,
+				integrations: resolvedAppConfig?.integrations ?? [],
+				knowledge: resolvedAppConfig?.knowledge ?? [],
+				branding: resolvedAppConfig?.branding,
+				translation: resolvedAppConfig?.translation,
+				translationResolver: this.config.translationResolver,
+				secretProvider: this.config.secretProvider
+			};
+			if (this.config.enforceCapabilities) await this.config.enforceCapabilities(op, executorContext);
+			return this.config.opExecutor(op, input, executorContext);
+		}
+		if (step.type === "human") return input;
+		return input;
+	}
+	pickNextStepId(spec, state, step, input, output) {
+		const transitions = spec.definition.transitions.filter((t) => t.from === step.id);
+		for (const transition of transitions) if (evaluateExpression(transition.condition, {
+			data: state.data,
+			input,
+			output
+		})) {
+			const target = spec.definition.steps.find((s) => s.id === transition.to);
+			if (!target) throw new Error(`Transition ${transition.from} -> ${transition.to} points to missing step.`);
+			return target.id;
+		}
+		return null;
+	}
+	getSpec(name, version) {
+		const spec = this.config.registry.get(name, version);
+		if (!spec) throw new Error(`Workflow spec not found for ${name}${version ? `.v${version}` : ""}`);
+		return spec;
+	}
+	async getStateOrThrow(workflowId) {
+		const state = await this.config.stateStore.get(workflowId);
+		if (!state) throw new Error(`Workflow state not found for ${workflowId}`);
+		return state;
+	}
+	emit(event, payload) {
+		this.config.eventEmitter?.(event, payload);
+	}
+};
+function resolveEntryStepId(spec) {
+	const entry = spec.definition.entryStepId ?? spec.definition.steps[0]?.id ?? null;
+	if (!entry) throw new Error(`Workflow ${spec.meta.name}.v${spec.meta.version} has no entry step.`);
+	return entry;
+}
+function getCurrentStep(spec, stepId) {
+	const step = spec.definition.steps.find((s) => s.id === stepId);
+	if (!step) throw new Error(`Step "${stepId}" not found in workflow ${spec.meta.name}.v${spec.meta.version}.`);
+	return step;
+}
+function hasOutgoing(spec, stepId) {
+	return spec.definition.transitions.some((t) => t.from === stepId);
+}
+function isRecord(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isTerminalStatus(status) {
+	return status === "completed" || status === "failed" || status === "cancelled";
+}
+var WorkflowPreFlightError = class extends Error {
+	constructor(issues) {
+		super(`Workflow pre-flight failed: ${issues.filter((issue) => issue.severity === "error").map((issue) => `${issue.type}:${issue.identifier}`).join(", ")}`);
+		this.issues = issues;
+		this.name = "WorkflowPreFlightError";
+	}
+};
+function capabilityKey(ref) {
+	return `${ref.key}@${ref.version}`;
+}
+
+//#endregion
+export { WorkflowPreFlightError, WorkflowRunner };