@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/test-runner/event-types.js

@@ -0,0 +1,330 @@
+import "../chunk-gOLHoazu.js";
+//#region src/test-runner/event-types.ts
+/**
+* Parse CLI event argument to EventType.
+* Supports all trigger types and common action shortcuts.
+*/
+function parseEventArg(arg) {
+	const normalized = arg.toLowerCase().trim();
+	switch (normalized) {
+		case "pr:open":
+		case "pr:opened": return {
+			type: "pull_request",
+			action: "opened"
+		};
+		case "pr:sync":
+		case "pr:synchronize": return {
+			type: "pull_request",
+			action: "synchronize"
+		};
+		case "pr:close":
+		case "pr:closed": return {
+			type: "pull_request",
+			action: "closed"
+		};
+		case "pr:reopen":
+		case "pr:reopened": return {
+			type: "pull_request",
+			action: "reopened"
+		};
+		case "push": return { type: "push" };
+		case "tag": return { type: "tag" };
+		case "comment":
+		case "comment:created": return {
+			type: "comment",
+			action: "created"
+		};
+		case "comment:edited": return {
+			type: "comment",
+			action: "edited"
+		};
+		case "comment:deleted": return {
+			type: "comment",
+			action: "deleted"
+		};
+		case "review":
+		case "review:submitted": return {
+			type: "review",
+			action: "submitted"
+		};
+		case "review:edited": return {
+			type: "review",
+			action: "edited"
+		};
+		case "review:dismissed": return {
+			type: "review",
+			action: "dismissed"
+		};
+		case "review_comment":
+		case "review_comment:created": return {
+			type: "review_comment",
+			action: "created"
+		};
+		case "review_comment:edited": return {
+			type: "review_comment",
+			action: "edited"
+		};
+		case "review_comment:deleted": return {
+			type: "review_comment",
+			action: "deleted"
+		};
+		case "release":
+		case "release:published": return {
+			type: "release",
+			action: "published"
+		};
+		case "release:unpublished": return {
+			type: "release",
+			action: "unpublished"
+		};
+		case "release:created": return {
+			type: "release",
+			action: "created"
+		};
+		case "release:edited": return {
+			type: "release",
+			action: "edited"
+		};
+		case "release:deleted": return {
+			type: "release",
+			action: "deleted"
+		};
+		case "release:prereleased": return {
+			type: "release",
+			action: "prereleased"
+		};
+		case "release:released": return {
+			type: "release",
+			action: "released"
+		};
+		case "dispatch": return { type: "dispatch" };
+		case "create": return { type: "create" };
+		case "create:branch": return {
+			type: "create",
+			refType: "branch"
+		};
+		case "create:tag": return {
+			type: "create",
+			refType: "tag"
+		};
+		case "delete": return { type: "delete" };
+		case "delete:branch": return {
+			type: "delete",
+			refType: "branch"
+		};
+		case "delete:tag": return {
+			type: "delete",
+			refType: "tag"
+		};
+		case "status": return { type: "status" };
+		case "workflow_run":
+		case "workflow_run:completed": return {
+			type: "workflow_run",
+			action: "completed"
+		};
+		case "workflow_run:requested": return {
+			type: "workflow_run",
+			action: "requested"
+		};
+		case "workflow_run:in_progress": return {
+			type: "workflow_run",
+			action: "in_progress"
+		};
+		case "fork": return { type: "fork" };
+		case "star":
+		case "star:created": return {
+			type: "star",
+			action: "created"
+		};
+		case "star:deleted": return {
+			type: "star",
+			action: "deleted"
+		};
+		case "watch":
+		case "watch:started": return {
+			type: "watch",
+			action: "started"
+		};
+		case "kici_event": return {
+			type: "kici_event",
+			eventName: "test-event"
+		};
+		case "workflow_complete": return {
+			type: "workflow_complete",
+			workflowName: "test",
+			status: "success"
+		};
+		case "workflow_complete:success": return {
+			type: "workflow_complete",
+			workflowName: "test",
+			status: "success"
+		};
+		case "workflow_complete:failed": return {
+			type: "workflow_complete",
+			workflowName: "test",
+			status: "failed"
+		};
+		case "workflow_complete:cancelled": return {
+			type: "workflow_complete",
+			workflowName: "test",
+			status: "cancelled"
+		};
+		case "job_complete": return {
+			type: "job_complete",
+			workflowName: "test",
+			jobName: "test",
+			status: "success"
+		};
+		case "generic_webhook": return { type: "generic_webhook" };
+		case "schedule": return { type: "schedule" };
+		case "lifecycle": return {
+			type: "lifecycle",
+			lifecycleEvent: "workflow_complete"
+		};
+		default:
+			if (normalized.startsWith("kici_event:")) return {
+				type: "kici_event",
+				eventName: normalized.slice(11)
+			};
+			if (normalized.startsWith("workflow_complete:")) return {
+				type: "workflow_complete",
+				workflowName: "test",
+				status: normalized.slice(18)
+			};
+			if (normalized.startsWith("job_complete:")) return {
+				type: "job_complete",
+				workflowName: "test",
+				jobName: "test",
+				status: normalized.slice(13)
+			};
+			if (normalized.startsWith("generic_webhook:")) return {
+				type: "generic_webhook",
+				source: normalized.slice(16)
+			};
+			if (normalized.startsWith("webhook:")) return {
+				type: "generic_webhook",
+				source: normalized.slice(8)
+			};
+			if (normalized.startsWith("lifecycle:")) return {
+				type: "lifecycle",
+				lifecycleEvent: normalized.slice(10)
+			};
+			if (normalized.startsWith("schedule:")) return {
+				type: "schedule",
+				cronExpression: normalized.slice(9)
+			};
+			throw new Error(`Unknown event name: ${arg}\nAvailable events: pr:open, pr:sync, pr:close, pr:reopen, push, tag, comment, comment:created, comment:edited, comment:deleted, review, review:submitted, review:edited, review:dismissed, review_comment, review_comment:created, release, release:published, release:created, release:prereleased, dispatch, create, create:branch, create:tag, delete, delete:branch, delete:tag, status, workflow_run, workflow_run:completed, fork, star, star:created, watch, kici_event, kici_event:<name>, workflow_complete, workflow_complete:<status>, job_complete, generic_webhook, generic_webhook:<source>, webhook:<source>, schedule, lifecycle, lifecycle:<event>`);
+	}
+}
+function assertNever(x) {
+	throw new Error(`Unhandled trigger type: ${JSON.stringify(x)}`);
+}
+/**
+* Derive an event-arg string from a `LockTrigger` that `parseEventArg` can accept.
+* Inverse of `parseEventArg` for picker-driven flows: pick a trigger, feed the
+* derived event arg back through the standard pipeline.
+*/
+function triggerToEventArg(trigger) {
+	switch (trigger._type) {
+		case "pr": return `pr:${trigger.events[0] ?? "opened"}`;
+		case "push": return "push";
+		case "tag": return "tag";
+		case "comment": return `comment:${trigger.actions[0] ?? "created"}`;
+		case "review": return `review:${trigger.actions[0] ?? "submitted"}`;
+		case "review_comment": return `review_comment:${trigger.actions[0] ?? "created"}`;
+		case "release": return `release:${trigger.actions[0] ?? "published"}`;
+		case "dispatch": return "dispatch";
+		case "create": {
+			const refType = trigger.refTypes[0];
+			return refType ? `create:${refType}` : "create";
+		}
+		case "delete": {
+			const refType = trigger.refTypes[0];
+			return refType ? `delete:${refType}` : "delete";
+		}
+		case "status": return "status";
+		case "workflow_run": return `workflow_run:${trigger.actions[0] ?? "completed"}`;
+		case "fork": return "fork";
+		case "star": return `star:${trigger.actions[0] ?? "created"}`;
+		case "watch": return `watch:${trigger.actions[0] ?? "started"}`;
+		case "webhook": {
+			const event = trigger.events[0];
+			return event ? `webhook:${event}` : "generic_webhook";
+		}
+		case "kici_event": return `kici_event:${trigger.eventName}`;
+		case "workflow_complete": {
+			const status = trigger.status?.[0];
+			return status ? `workflow_complete:${status}` : "workflow_complete";
+		}
+		case "job_complete": {
+			const status = trigger.status?.[0];
+			return status ? `job_complete:${status}` : "job_complete";
+		}
+		case "generic_webhook": return `webhook:${trigger.source}`;
+		case "schedule": return "schedule";
+		case "lifecycle": return `lifecycle:${trigger.events[0] ?? "workflow_complete"}`;
+		default: return assertNever(trigger);
+	}
+}
+function joinList(values, max = 3) {
+	if (values.length === 0) return "";
+	if (values.length <= max) return values.join(",");
+	return `${values.slice(0, max).join(",")}…`;
+}
+function patternSummary(patterns, max = 3) {
+	return joinList(patterns.map((p) => p.pattern), max);
+}
+/**
+* One-line label for a `LockTrigger`, suitable for interactive picker rows.
+* Keeps output compact and human-readable.
+*/
+function triggerSummary(trigger) {
+	switch (trigger._type) {
+		case "pr": {
+			const events = joinList(trigger.events);
+			const targets = patternSummary(trigger.targetBranches);
+			return `pr(${events}${targets ? ` on ${targets}` : ""})`;
+		}
+		case "push": {
+			const branches = patternSummary(trigger.branches);
+			return branches ? `push(${branches})` : "push";
+		}
+		case "tag": {
+			const patterns = patternSummary(trigger.patterns);
+			return patterns ? `tag(${patterns})` : "tag";
+		}
+		case "comment": return `comment(${joinList(trigger.actions)}${trigger.source ? ` ${trigger.source}` : ""})`;
+		case "review": return `review(${joinList(trigger.actions)})`;
+		case "review_comment": return `review_comment(${joinList(trigger.actions)})`;
+		case "release": return `release(${joinList(trigger.actions)})`;
+		case "dispatch": {
+			const types = joinList(trigger.types);
+			return types ? `dispatch(${types})` : "dispatch";
+		}
+		case "create": {
+			const refTypes = joinList(trigger.refTypes);
+			return refTypes ? `create(${refTypes})` : "create";
+		}
+		case "delete": {
+			const refTypes = joinList(trigger.refTypes);
+			return refTypes ? `delete(${refTypes})` : "delete";
+		}
+		case "status": return `status(${joinList(trigger.states)})`;
+		case "workflow_run": return `workflow_run(${joinList(trigger.actions)})`;
+		case "fork": return "fork";
+		case "star": return `star(${joinList(trigger.actions)})`;
+		case "watch": return `watch(${joinList(trigger.actions)})`;
+		case "webhook": return `webhook(${joinList(trigger.events)})`;
+		case "kici_event": return `kici_event(${trigger.eventName})`;
+		case "workflow_complete": return `workflow_complete(${trigger.name ? `${trigger.name}` : "*"}${trigger.status?.length ? `, ${joinList(trigger.status)}` : ""})`;
+		case "job_complete": return `job_complete(${trigger.workflow ?? "*"}${trigger.job ? `.${trigger.job}` : ""}${trigger.status?.length ? `, ${joinList(trigger.status)}` : ""})`;
+		case "generic_webhook": return `webhook(${trigger.source})`;
+		case "schedule": return `schedule('${trigger.cronExpression}')`;
+		case "lifecycle": return `lifecycle(${joinList(trigger.events)})`;
+		default: return assertNever(trigger);
+	}
+}
+//#endregion
+export { parseEventArg, triggerSummary, triggerToEventArg };
+
+//# sourceMappingURL=event-types.js.map

package/dist/test-runner/git-detector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Auto-detect repository information from .git/config
+ */
+interface RepoInfo {
+    owner: string;
+    name: string;
+}
+/**
+ * Detect repository owner and name from .git/config
+ * @param cwd - Working directory to search for .git/config
+ * @returns Repository info or null if not a git repo or no origin
+ */
+export declare function detectRepoFromGit(cwd?: string): Promise<RepoInfo | null>;
+export {};
+//# sourceMappingURL=git-detector.d.ts.map

package/dist/test-runner/git-detector.js

@@ -0,0 +1,30 @@
+import "../chunk-gOLHoazu.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/test-runner/git-detector.ts
+/**
+* Auto-detect repository information from .git/config
+*/
+/**
+* Detect repository owner and name from .git/config
+* @param cwd - Working directory to search for .git/config
+* @returns Repository info or null if not a git repo or no origin
+*/
+async function detectRepoFromGit(cwd = process.cwd()) {
+	try {
+		const remoteMatch = (await readFile(path.join(cwd, ".git", "config"), "utf-8")).match(/\[remote "origin"\][^[]*url\s*=\s*(.+)/m);
+		if (!remoteMatch) return null;
+		const match = remoteMatch[1].trim().match(/github\.com[:/]([^/]+)\/([^/\s]+?)(\.git)?$/);
+		if (!match) return null;
+		return {
+			owner: match[1],
+			name: match[2]
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { detectRepoFromGit };
+
+//# sourceMappingURL=git-detector.js.map

package/dist/test-runner/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Test runner utilities and exports
+ */
+export * from './event-types.js';
+export * from './git-detector.js';
+export * from './step-context.js';
+export * from './rule-evaluator.js';
+export * from './job-executor.js';
+export * from './output-formatter.js';
+export * from './payload-builder.js';
+export * from './dry-run.js';
+export { getDefaultFixture, listAvailableEvents } from '../fixtures/defaults/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test-runner/index.js

@@ -0,0 +1,11 @@
+import "../chunk-gOLHoazu.js";
+import { getDefaultFixture, listAvailableEvents } from "../fixtures/defaults/index.js";
+import { detectRepoFromGit } from "./git-detector.js";
+import { parseEventArg, triggerSummary, triggerToEventArg } from "./event-types.js";
+import { buildEventPayload } from "./payload-builder.js";
+import { displayDryRun } from "./dry-run.js";
+import { formatter } from "./output-formatter.js";
+import { createStepContext } from "./step-context.js";
+import { createRuleContext, evaluateRules as evaluateRulesWithFormatting } from "./rule-evaluator.js";
+import { executeJob, executeWorkflow } from "./job-executor.js";
+export { buildEventPayload, createRuleContext, createStepContext, detectRepoFromGit, displayDryRun, evaluateRulesWithFormatting as evaluateRules, executeJob, executeWorkflow, formatter, getDefaultFixture, listAvailableEvents, parseEventArg, triggerSummary, triggerToEventArg };

package/dist/test-runner/job-executor.d.ts

@@ -0,0 +1,48 @@
+import type { Job, Workflow } from '@kici-dev/sdk';
+import type { OutputsMap, StepRefMap } from '@kici-dev/sdk';
+import type { SimulatedEvent } from '@kici-dev/engine';
+import type { RuleResult } from '@kici-dev/sdk';
+import type { ParsedSecrets } from './secrets-file.js';
+/**
+ * SDK output setters resolved from the workflow's module instance.
+ * When the SDK is externalized in rolldown, the workflow shares the same
+ * module instance. We use these to set up output infrastructure.
+ */
+interface SdkOutputSetters {
+    setStepOutputsMap: (map: OutputsMap) => void;
+    setStepRefMap: (map: StepRefMap) => void;
+    setJobOutputsMap: (map: OutputsMap) => void;
+}
+export interface StepResult {
+    name: string;
+    status: 'success' | 'failure';
+    durationMs: number;
+    error?: Error;
+    outputs?: Record<string, unknown>;
+}
+export interface JobResult {
+    name: string;
+    status: 'success' | 'failure' | 'skipped';
+    durationMs: number;
+    steps: StepResult[];
+    ruleResults?: RuleResult[];
+    error?: Error;
+}
+interface WorkflowResult {
+    name: string;
+    status: 'success' | 'failure' | 'skipped';
+    durationMs: number;
+    jobs: JobResult[];
+    ruleResults?: RuleResult[];
+}
+/**
+ * Execute a job sequentially (steps run in order).
+ */
+export declare function executeJob(job: Job, workflowName: string, event: SimulatedEvent, repoRoot: string, testSecrets?: ParsedSecrets, sdkSetters?: SdkOutputSetters): Promise<JobResult>;
+/**
+ * Execute a workflow with parallel job execution.
+ * Jobs run in parallel where dependencies allow (respecting needs).
+ */
+export declare function executeWorkflow(workflow: Workflow, event: SimulatedEvent, repoRoot: string, testSecrets?: ParsedSecrets, kiciDir?: string): Promise<WorkflowResult>;
+export {};
+//# sourceMappingURL=job-executor.d.ts.map

package/dist/test-runner/job-executor.js

@@ -0,0 +1,245 @@
+import "../chunk-gOLHoazu.js";
+import { formatter } from "./output-formatter.js";
+import { createStepContext } from "./step-context.js";
+import { createRuleContext, evaluateRules as evaluateRulesWithFormatting } from "./rule-evaluator.js";
+import pc from "picocolors";
+import path from "node:path";
+import { logger } from "@kici-dev/shared";
+import { pathToFileURL } from "node:url";
+import { setJobOutputsMap, setStepOutputsMap, setStepRefMap } from "@kici-dev/sdk";
+//#region src/test-runner/job-executor.ts
+/**
+* Resolve SDK output setter functions from the workflow's module instance.
+* This ensures the output maps are set on the same SDK module that the
+* workflow code uses for .result proxy resolution and ctx.outputsOf().
+*
+* Falls back to the compiler's own SDK import if dynamic resolution fails.
+*/
+async function resolveSdkSetters(kiciDir) {
+	if (kiciDir) try {
+		const sdk = await import(pathToFileURL(path.join(kiciDir, "node_modules", "@kici-dev", "sdk", "dist", "index.js")).href);
+		return {
+			setStepOutputsMap: sdk.setStepOutputsMap,
+			setStepRefMap: sdk.setStepRefMap,
+			setJobOutputsMap: sdk.setJobOutputsMap
+		};
+	} catch {}
+	return {
+		setStepOutputsMap,
+		setStepRefMap,
+		setJobOutputsMap
+	};
+}
+/**
+* Execute a single step.
+*/
+async function executeStep(step, ctx, jobName) {
+	formatter.logStepStart(jobName, step.name);
+	const startTime = Date.now();
+	try {
+		const outputs = await step.run(ctx);
+		const durationMs = Date.now() - startTime;
+		formatter.logStepComplete(jobName, step.name, durationMs);
+		return {
+			name: step.name,
+			status: "success",
+			durationMs,
+			outputs
+		};
+	} catch (e) {
+		const durationMs = Date.now() - startTime;
+		const error = e instanceof Error ? e : new Error(String(e));
+		formatter.logStepError(jobName, step.name, error);
+		return {
+			name: step.name,
+			status: "failure",
+			durationMs,
+			error
+		};
+	}
+}
+/**
+* Execute a job sequentially (steps run in order).
+*/
+async function executeJob(job, workflowName, event, repoRoot, testSecrets, sdkSetters) {
+	const setters = sdkSetters ?? {
+		setStepOutputsMap,
+		setStepRefMap,
+		setJobOutputsMap
+	};
+	formatter.logJobStart(job.name);
+	const startTime = Date.now();
+	const stepResults = [];
+	let ruleResults;
+	if (job.rules && job.rules.length > 0) {
+		const ruleContext = createRuleContext(event, event.changedFiles);
+		const ruleEval = await evaluateRulesWithFormatting(job.rules, ruleContext, job.name);
+		ruleResults = ruleEval.results;
+		if (!ruleEval.allPassed) {
+			const durationMs = Date.now() - startTime;
+			return {
+				name: job.name,
+				status: "skipped",
+				durationMs,
+				steps: [],
+				ruleResults
+			};
+		}
+	}
+	const outputsMap = /* @__PURE__ */ new Map();
+	const refMap = /* @__PURE__ */ new WeakMap();
+	setters.setStepOutputsMap(outputsMap);
+	setters.setStepRefMap(refMap);
+	setStepOutputsMap(outputsMap);
+	setStepRefMap(refMap);
+	const ctx = createStepContext({ name: workflowName }, {
+		name: job.name,
+		runsOn: typeof job.runsOn === "string" ? job.runsOn : Array.isArray(job.runsOn) ? job.runsOn.join(",") : (Array.isArray(job.runsOn.labels) ? job.runsOn.labels : [job.runsOn.labels]).join(",")
+	}, repoRoot, void 0, void 0, testSecrets, void 0, event.payload, event.provider);
+	let stepCounter = 0;
+	for (const stepOrFn of job.steps) {
+		let normalizedStep;
+		if (typeof stepOrFn === "function") {
+			stepCounter++;
+			const name = `step-${stepCounter}`;
+			refMap.set(stepOrFn, name);
+			normalizedStep = {
+				_tag: "Step",
+				name,
+				run: stepOrFn
+			};
+		} else {
+			normalizedStep = stepOrFn;
+			if (!normalizedStep.name) stepCounter++;
+		}
+		const result = await executeStep(normalizedStep, ctx, job.name);
+		if (result.status === "success" && result.outputs != null) outputsMap.set(normalizedStep.name, result.outputs);
+		stepResults.push(result);
+		if (result.status === "failure") {
+			const durationMs = Date.now() - startTime;
+			formatter.logJobFailure(job.name, durationMs, result.error);
+			return {
+				name: job.name,
+				status: "failure",
+				durationMs,
+				steps: stepResults,
+				ruleResults,
+				error: result.error
+			};
+		}
+	}
+	const durationMs = Date.now() - startTime;
+	formatter.logJobComplete(job.name, durationMs);
+	return {
+		name: job.name,
+		status: "success",
+		durationMs,
+		steps: stepResults,
+		ruleResults
+	};
+}
+/**
+* Execute a workflow with parallel job execution.
+* Jobs run in parallel where dependencies allow (respecting needs).
+*/
+async function executeWorkflow(workflow, event, repoRoot, testSecrets, kiciDir) {
+	logger.info(`\n${pc.bold("▶ Running workflow:")} ${workflow.name}\n`);
+	const startTime = Date.now();
+	const sdkSetters = await resolveSdkSetters(kiciDir);
+	let ruleResults;
+	if (workflow.rules && workflow.rules.length > 0) {
+		const ruleContext = createRuleContext(event, event.changedFiles);
+		const ruleEval = await evaluateRulesWithFormatting(workflow.rules, ruleContext, workflow.name);
+		ruleResults = ruleEval.results;
+		if (!ruleEval.allPassed) {
+			const durationMs = Date.now() - startTime;
+			logger.info(pc.yellow(`\n⚠ Workflow skipped due to rule failure\n`));
+			return {
+				name: workflow.name,
+				status: "skipped",
+				durationMs,
+				jobs: [],
+				ruleResults
+			};
+		}
+	}
+	const staticJobs = workflow.jobs.filter((j) => typeof j !== "function");
+	const jobMap = new Map(staticJobs.map((j) => [j.name, j]));
+	const completed = /* @__PURE__ */ new Map();
+	const pending = new Set(staticJobs.map((j) => j.name));
+	const jobOutputsMap = /* @__PURE__ */ new Map();
+	sdkSetters.setJobOutputsMap(jobOutputsMap);
+	setJobOutputsMap(jobOutputsMap);
+	while (pending.size > 0) {
+		const ready = [...pending].filter((jobName) => {
+			const job = jobMap.get(jobName);
+			if (!job.needs || job.needs.length === 0) return true;
+			return job.needs.every((need) => {
+				let needName;
+				if (typeof need === "string") needName = need;
+				else if ("name" in need) needName = need.name;
+				else if ("group" in need) return true;
+				else needName = need.name;
+				const result = completed.get(needName);
+				return result && result.status === "success";
+			});
+		});
+		if (ready.length === 0 && pending.size > 0) {
+			const remaining = [...pending];
+			logger.info(pc.yellow(`\n⚠ Skipping jobs with failed dependencies: ${remaining.join(", ")}\n`));
+			break;
+		}
+		const results = await Promise.allSettled(ready.map((jobName) => {
+			const job = jobMap.get(jobName);
+			pending.delete(jobName);
+			return executeJob(job, workflow.name, event, repoRoot, testSecrets, sdkSetters);
+		}));
+		for (let i = 0; i < ready.length; i++) {
+			const result = results[i];
+			const jobName = ready[i];
+			if (result.status === "fulfilled") {
+				completed.set(jobName, result.value);
+				if (result.value.status === "success") {
+					const jobResult = result.value;
+					const stepsWithOutputs = jobResult.steps.filter((s) => s.outputs != null);
+					if (stepsWithOutputs.length === 1 && jobResult.steps.length === 1) jobOutputsMap.set(jobName, stepsWithOutputs[0].outputs);
+					else if (stepsWithOutputs.length > 0) {
+						const aggregated = {};
+						for (const stepResult of stepsWithOutputs) aggregated[stepResult.name] = stepResult.outputs;
+						jobOutputsMap.set(jobName, aggregated);
+					}
+				}
+				if (result.value.status === "failure") {
+					const durationMs = Date.now() - startTime;
+					logger.info(pc.red(`\n✗ Workflow failed\n`));
+					return {
+						name: workflow.name,
+						status: "failure",
+						durationMs,
+						jobs: [...completed.values()],
+						ruleResults
+					};
+				}
+			} else completed.set(jobName, {
+				name: jobName,
+				status: "failure",
+				durationMs: 0,
+				steps: [],
+				error: result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+			});
+		}
+	}
+	const durationMs = Date.now() - startTime;
+	logger.info(pc.green(`\n✓ Workflow complete`) + pc.gray(` (${durationMs}ms)\n`));
+	return {
+		name: workflow.name,
+		status: "success",
+		durationMs,
+		jobs: [...completed.values()],
+		ruleResults
+	};
+}
+//#endregion
+export { executeJob, executeWorkflow };
+
+//# sourceMappingURL=job-executor.js.map