workflowskill 0.2.1 → 0.3.1

package/dist/runtime-CD81H1bx.mjs

@@ -1,1977 +0,0 @@
-import { parse } from "yaml";
-import { z } from "zod";
-import Anthropic from "@anthropic-ai/sdk";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-//#region src/parser/extract.ts
-/**
-* Extract YAML frontmatter from SKILL.md content.
-* Frontmatter is delimited by --- at the start of the file.
-*/
-function extractFrontmatter(content) {
-	return content.replace(/\r\n/g, "\n").match(/^---\n([\s\S]*?)\n---/)?.[1] ?? null;
-}
-/**
-* Extract the ```workflow fenced code block from SKILL.md content.
-* Returns the YAML content inside the block.
-* Throws if no workflow block is found.
-*/
-function extractWorkflowBlock(content) {
-	const match = content.replace(/\r\n/g, "\n").match(/```workflow\s*\n([\s\S]*?)\n```/);
-	if (!match?.[1]) throw new ExtractError("No ```workflow fenced code block found in SKILL.md. WorkflowSkill definitions must be wrapped in a ```workflow block.");
-	return match[1];
-}
-/**
-* Extract both frontmatter and workflow block from SKILL.md content.
-*/
-function extract(content) {
-	return {
-		frontmatter: extractFrontmatter(content),
-		workflowYaml: extractWorkflowBlock(content)
-	};
-}
-/** Error thrown during extraction. */
-var ExtractError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "ExtractError";
-	}
-};
-
-//#endregion
-//#region src/parser/schema.ts
-const schemaTypeEnum = z.enum([
-	"string",
-	"int",
-	"float",
-	"boolean",
-	"array",
-	"object"
-]);
-const nestedFieldSchema = z.object({
-	type: schemaTypeEnum,
-	value: z.unknown().optional(),
-	items: z.record(z.string(), z.unknown()).optional(),
-	properties: z.record(z.string(), z.unknown()).optional()
-});
-const fieldSchema = z.object({
-	type: schemaTypeEnum,
-	value: z.unknown().optional(),
-	default: z.unknown().optional(),
-	items: nestedFieldSchema.optional(),
-	properties: z.record(z.string(), z.union([z.string(), nestedFieldSchema])).optional()
-}).transform((obj) => {
-	const { default: legacy, ...rest } = obj;
-	if (rest.value === void 0 && legacy !== void 0) rest.value = legacy;
-	return rest;
-});
-const workflowInputSchema = z.object({
-	type: schemaTypeEnum,
-	default: z.unknown().optional(),
-	value: z.unknown().optional(),
-	items: nestedFieldSchema.optional(),
-	properties: z.record(z.string(), z.union([z.string(), nestedFieldSchema])).optional()
-}).transform((obj) => {
-	const { value: legacy, ...rest } = obj;
-	if (rest.default === void 0 && legacy !== void 0) rest.default = legacy;
-	return rest;
-});
-const workflowOutputBaseSchema = z.object({
-	type: schemaTypeEnum,
-	value: z.unknown().optional(),
-	default: z.unknown().optional(),
-	source: z.string().optional(),
-	items: nestedFieldSchema.optional(),
-	properties: z.record(z.string(), z.union([z.string(), nestedFieldSchema])).optional()
-}).transform((obj) => {
-	const { source, default: legacy, ...rest } = obj;
-	if (rest.value === void 0 && source !== void 0) rest.value = source;
-	if (rest.value === void 0 && legacy !== void 0) rest.value = legacy;
-	return rest;
-});
-const workflowOutputSchema = workflowOutputBaseSchema;
-const stepInputBaseSchema = z.object({
-	type: schemaTypeEnum,
-	value: z.unknown().optional(),
-	default: z.unknown().optional(),
-	source: z.string().optional(),
-	items: nestedFieldSchema.optional(),
-	properties: z.record(z.string(), z.union([z.string(), nestedFieldSchema])).optional()
-}).transform((obj) => {
-	const { source, default: legacy, ...rest } = obj;
-	if (rest.value === void 0 && source !== void 0) rest.value = source;
-	if (rest.value === void 0 && legacy !== void 0) rest.value = legacy;
-	return rest;
-});
-const stepInputSchema = stepInputBaseSchema;
-const stepOutputBaseSchema = z.object({
-	type: schemaTypeEnum,
-	value: z.unknown().optional(),
-	default: z.unknown().optional(),
-	source: z.string().optional(),
-	items: nestedFieldSchema.optional(),
-	properties: z.record(z.string(), z.union([z.string(), nestedFieldSchema])).optional()
-}).transform((obj) => {
-	const { source, default: legacy, ...rest } = obj;
-	if (rest.value === void 0 && source !== void 0) rest.value = source;
-	if (rest.value === void 0 && legacy !== void 0) rest.value = legacy;
-	return rest;
-});
-const stepOutputSchema = stepOutputBaseSchema;
-const retryPolicySchema = z.object({
-	max: z.number().int().positive(),
-	delay: z.string(),
-	backoff: z.number().positive()
-});
-const stepBaseSchema = z.object({
-	id: z.string().min(1),
-	type: z.enum([
-		"tool",
-		"llm",
-		"transform",
-		"conditional",
-		"exit"
-	]),
-	description: z.string().optional(),
-	inputs: z.record(z.string(), stepInputSchema).default({}),
-	outputs: z.record(z.string(), stepOutputSchema).default({}),
-	condition: z.string().optional(),
-	each: z.string().optional(),
-	delay: z.string().optional(),
-	on_error: z.enum(["fail", "ignore"]).optional(),
-	retry: retryPolicySchema.optional()
-});
-const toolStepSchema = stepBaseSchema.extend({
-	type: z.literal("tool"),
-	tool: z.string().min(1)
-});
-const llmStepSchema = stepBaseSchema.extend({
-	type: z.literal("llm"),
-	model: z.string().optional(),
-	prompt: z.string().min(1),
-	response_format: z.record(z.string(), z.unknown()).optional()
-});
-const transformFilterStepSchema = stepBaseSchema.extend({
-	type: z.literal("transform"),
-	operation: z.literal("filter"),
-	where: z.string().min(1)
-});
-const transformMapStepSchema = stepBaseSchema.extend({
-	type: z.literal("transform"),
-	operation: z.literal("map"),
-	expression: z.record(z.string(), z.unknown())
-});
-const transformSortStepSchema = stepBaseSchema.extend({
-	type: z.literal("transform"),
-	operation: z.literal("sort"),
-	field: z.string().min(1),
-	direction: z.enum(["asc", "desc"]).optional()
-});
-const conditionalStepSchema = stepBaseSchema.extend({
-	type: z.literal("conditional"),
-	condition: z.string().min(1),
-	then: z.array(z.string()).min(1),
-	else: z.array(z.string()).optional()
-});
-const exitStepSchema = stepBaseSchema.extend({
-	type: z.literal("exit"),
-	status: z.enum(["success", "failed"]),
-	output: z.union([z.string(), z.record(z.string(), z.unknown())]).optional()
-});
-const transformStepSchema = z.discriminatedUnion("operation", [
-	transformFilterStepSchema,
-	transformMapStepSchema,
-	transformSortStepSchema
-]);
-const stepSchema = z.union([
-	toolStepSchema,
-	llmStepSchema,
-	transformStepSchema,
-	conditionalStepSchema,
-	exitStepSchema
-]);
-const workflowDefinitionSchema = z.object({
-	inputs: z.record(z.string(), workflowInputSchema).default({}),
-	outputs: z.record(z.string(), workflowOutputSchema).default({}),
-	steps: z.array(stepSchema).min(1, "Workflow must have at least one step")
-});
-const skillFrontmatterSchema = z.object({
-	name: z.string().min(1),
-	description: z.string().min(1)
-}).passthrough();
-
-//#endregion
-//#region src/parser/index.ts
-/** Error thrown when parsing fails. Includes structured details. */
-var ParseError = class extends Error {
-	constructor(message, details = []) {
-		super(message);
-		this.details = details;
-		this.name = "ParseError";
-	}
-};
-/**
-* Convert Zod errors to our ParseErrorDetail format.
-*/
-function zodToDetails(err) {
-	return err.issues.map((issue) => ({
-		path: issue.path.join("."),
-		message: issue.message
-	}));
-}
-/**
-* Parse a raw YAML string into a validated WorkflowDefinition.
-* Use this when you already have the YAML content (e.g., from extractWorkflowBlock).
-*/
-function parseWorkflowYaml(yaml) {
-	let raw;
-	try {
-		raw = parse(yaml);
-	} catch (err) {
-		throw new ParseError(`Invalid YAML: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	const result = workflowDefinitionSchema.safeParse(raw);
-	if (!result.success) throw new ParseError("Workflow validation failed", zodToDetails(result.error));
-	return result.data;
-}
-/**
-* Parse a SKILL.md file content into a fully typed ParsedSkill.
-* Extracts frontmatter and workflow block, validates both.
-*/
-function parseSkillMd(content) {
-	let extracted;
-	try {
-		extracted = extract(content);
-	} catch (err) {
-		if (err instanceof ExtractError) throw new ParseError(err.message);
-		throw err;
-	}
-	let frontmatter;
-	if (extracted.frontmatter) {
-		let rawFrontmatter;
-		try {
-			rawFrontmatter = parse(extracted.frontmatter);
-		} catch (err) {
-			throw new ParseError(`Invalid frontmatter YAML: ${err instanceof Error ? err.message : String(err)}`);
-		}
-		const fmResult = skillFrontmatterSchema.safeParse(rawFrontmatter);
-		if (!fmResult.success) throw new ParseError("Frontmatter validation failed", zodToDetails(fmResult.error));
-		frontmatter = fmResult.data;
-	} else throw new ParseError("SKILL.md must have YAML frontmatter with name and description");
-	const workflow = parseWorkflowYaml(extracted.workflowYaml);
-	return {
-		frontmatter,
-		workflow
-	};
-}
-/**
-* Parse just the workflow block from SKILL.md content.
-* Useful when you only need the workflow definition without frontmatter.
-*/
-function parseWorkflowFromMd(content) {
-	let yaml;
-	try {
-		yaml = extractWorkflowBlock(content);
-	} catch (err) {
-		if (err instanceof ExtractError) throw new ParseError(err.message);
-		throw err;
-	}
-	return parseWorkflowYaml(yaml);
-}
-
-//#endregion
-//#region src/expression/lexer.ts
-var LexError = class extends Error {
-	constructor(message, position) {
-		super(message);
-		this.position = position;
-		this.name = "LexError";
-	}
-};
-function lex(input) {
-	const tokens = [];
-	let pos = 0;
-	while (pos < input.length) {
-		if (/\s/.test(input[pos])) {
-			pos++;
-			continue;
-		}
-		const ch = input[pos];
-		if (ch === "$") {
-			const start = pos;
-			pos++;
-			let name = "";
-			while (pos < input.length && /[a-zA-Z_]/.test(input[pos])) {
-				name += input[pos];
-				pos++;
-			}
-			if (!name) throw new LexError(`Expected identifier after $`, start);
-			tokens.push({
-				type: "DOLLAR_REF",
-				value: name,
-				position: start
-			});
-			continue;
-		}
-		if (ch === ".") {
-			tokens.push({
-				type: "DOT",
-				value: ".",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (ch === "(") {
-			tokens.push({
-				type: "LPAREN",
-				value: "(",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (ch === ")") {
-			tokens.push({
-				type: "RPAREN",
-				value: ")",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (ch === "[") {
-			tokens.push({
-				type: "LBRACKET",
-				value: "[",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (ch === "]") {
-			tokens.push({
-				type: "RBRACKET",
-				value: "]",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (pos + 1 < input.length) {
-			const twoChar = input[pos] + input[pos + 1];
-			if (twoChar === "==") {
-				tokens.push({
-					type: "EQ",
-					value: "==",
-					position: pos
-				});
-				pos += 2;
-				continue;
-			}
-			if (twoChar === "!=") {
-				tokens.push({
-					type: "NEQ",
-					value: "!=",
-					position: pos
-				});
-				pos += 2;
-				continue;
-			}
-			if (twoChar === ">=") {
-				tokens.push({
-					type: "GTE",
-					value: ">=",
-					position: pos
-				});
-				pos += 2;
-				continue;
-			}
-			if (twoChar === "<=") {
-				tokens.push({
-					type: "LTE",
-					value: "<=",
-					position: pos
-				});
-				pos += 2;
-				continue;
-			}
-			if (twoChar === "&&") {
-				tokens.push({
-					type: "AND",
-					value: "&&",
-					position: pos
-				});
-				pos += 2;
-				continue;
-			}
-			if (twoChar === "||") {
-				tokens.push({
-					type: "OR",
-					value: "||",
-					position: pos
-				});
-				pos += 2;
-				continue;
-			}
-		}
-		if (ch === ">") {
-			tokens.push({
-				type: "GT",
-				value: ">",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (ch === "<") {
-			tokens.push({
-				type: "LT",
-				value: "<",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (ch === "!") {
-			tokens.push({
-				type: "NOT",
-				value: "!",
-				position: pos
-			});
-			pos++;
-			continue;
-		}
-		if (/[0-9]/.test(ch) || ch === "-" && pos + 1 < input.length && /[0-9]/.test(input[pos + 1])) {
-			const start = pos;
-			if (ch === "-") pos++;
-			while (pos < input.length && /[0-9]/.test(input[pos])) pos++;
-			if (pos < input.length && input[pos] === ".") {
-				pos++;
-				while (pos < input.length && /[0-9]/.test(input[pos])) pos++;
-			}
-			tokens.push({
-				type: "NUMBER",
-				value: input.slice(start, pos),
-				position: start
-			});
-			continue;
-		}
-		if (ch === "\"" || ch === "'") {
-			const quote = ch;
-			const start = pos;
-			pos++;
-			let str = "";
-			while (pos < input.length && input[pos] !== quote) {
-				if (input[pos] === "\\" && pos + 1 < input.length) pos++;
-				str += input[pos];
-				pos++;
-			}
-			if (pos >= input.length) throw new LexError(`Unterminated string literal`, start);
-			pos++;
-			tokens.push({
-				type: "STRING",
-				value: str,
-				position: start
-			});
-			continue;
-		}
-		if (/[a-zA-Z_]/.test(ch)) {
-			const start = pos;
-			while (pos < input.length && /[a-zA-Z0-9_]/.test(input[pos])) pos++;
-			const word = input.slice(start, pos);
-			if (word === "true" || word === "false") tokens.push({
-				type: "BOOLEAN",
-				value: word,
-				position: start
-			});
-			else if (word === "null") tokens.push({
-				type: "NULL",
-				value: word,
-				position: start
-			});
-			else if (word === "contains") tokens.push({
-				type: "CONTAINS",
-				value: word,
-				position: start
-			});
-			else tokens.push({
-				type: "IDENTIFIER",
-				value: word,
-				position: start
-			});
-			continue;
-		}
-		throw new LexError(`Unexpected character: ${ch}`, pos);
-	}
-	tokens.push({
-		type: "EOF",
-		value: "",
-		position: pos
-	});
-	return tokens;
-}
-
-//#endregion
-//#region src/expression/parser.ts
-var ParseExprError = class extends Error {
-	constructor(message, position) {
-		super(message);
-		this.position = position;
-		this.name = "ParseExprError";
-	}
-};
-function parseExpression(tokens) {
-	let pos = 0;
-	function current() {
-		return tokens[pos];
-	}
-	function expect(type) {
-		const tok = current();
-		if (tok.type !== type) throw new ParseExprError(`Expected ${type} but got ${tok.type} ("${tok.value}")`, tok.position);
-		pos++;
-		return tok;
-	}
-	function peek() {
-		return tokens[pos];
-	}
-	function parseOr() {
-		let left = parseAnd();
-		while (peek().type === "OR") {
-			const op = current().value;
-			pos++;
-			const right = parseAnd();
-			left = {
-				kind: "binary",
-				operator: op,
-				left,
-				right
-			};
-		}
-		return left;
-	}
-	function parseAnd() {
-		let left = parseComparison();
-		while (peek().type === "AND") {
-			const op = current().value;
-			pos++;
-			const right = parseComparison();
-			left = {
-				kind: "binary",
-				operator: op,
-				left,
-				right
-			};
-		}
-		return left;
-	}
-	function parseComparison() {
-		let left = parseUnary();
-		const t = peek().type;
-		if (t === "EQ" || t === "NEQ" || t === "GT" || t === "GTE" || t === "LT" || t === "LTE" || t === "CONTAINS") {
-			const op = current().value;
-			pos++;
-			const right = parseUnary();
-			left = {
-				kind: "binary",
-				operator: op,
-				left,
-				right
-			};
-		}
-		return left;
-	}
-	function parseUnary() {
-		if (peek().type === "NOT") {
-			const op = current().value;
-			pos++;
-			return {
-				kind: "unary",
-				operator: op,
-				operand: parseUnary()
-			};
-		}
-		return parsePrimary();
-	}
-	function parsePrimary() {
-		const tok = peek();
-		if (tok.type === "LPAREN") {
-			pos++;
-			const expr = parseOr();
-			expect("RPAREN");
-			return expr;
-		}
-		if (tok.type === "DOLLAR_REF") {
-			pos++;
-			let node = {
-				kind: "reference",
-				name: tok.value
-			};
-			while (peek().type === "DOT" || peek().type === "LBRACKET") if (peek().type === "DOT") {
-				pos++;
-				const prop = current();
-				if (prop.type === "IDENTIFIER" || prop.type === "DOLLAR_REF") {
-					pos++;
-					node = {
-						kind: "property_access",
-						object: node,
-						property: prop.value
-					};
-				} else if (prop.type === "NUMBER") {
-					pos++;
-					node = {
-						kind: "property_access",
-						object: node,
-						property: prop.value
-					};
-				} else throw new ParseExprError(`Expected property name after '.', got ${prop.type}`, prop.position);
-			} else {
-				pos++;
-				const indexExpr = parseOr();
-				expect("RBRACKET");
-				node = {
-					kind: "index_access",
-					object: node,
-					index: indexExpr
-				};
-			}
-			return node;
-		}
-		if (tok.type === "NUMBER") {
-			pos++;
-			return {
-				kind: "literal",
-				value: tok.value.includes(".") ? parseFloat(tok.value) : parseInt(tok.value, 10)
-			};
-		}
-		if (tok.type === "STRING") {
-			pos++;
-			return {
-				kind: "literal",
-				value: tok.value
-			};
-		}
-		if (tok.type === "BOOLEAN") {
-			pos++;
-			return {
-				kind: "literal",
-				value: tok.value === "true"
-			};
-		}
-		if (tok.type === "NULL") {
-			pos++;
-			return {
-				kind: "literal",
-				value: null
-			};
-		}
-		throw new ParseExprError(`Unexpected token: ${tok.type} ("${tok.value}")`, tok.position);
-	}
-	const ast = parseOr();
-	if (peek().type !== "EOF") {
-		const leftover = peek();
-		throw new ParseExprError(`Unexpected token after expression: ${leftover.type} ("${leftover.value}")`, leftover.position);
-	}
-	return ast;
-}
-
-//#endregion
-//#region src/expression/evaluator.ts
-var EvalError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "EvalError";
-	}
-};
-/**
-* Evaluate an AST node against a runtime context.
-* Returns the resolved value (primitive, object, array, or null).
-*/
-function evaluate(node, context) {
-	switch (node.kind) {
-		case "reference": return resolveReference(node.name, context);
-		case "property_access": return resolvePropertyAccess(node, context);
-		case "index_access": return resolveIndexAccess(node, context);
-		case "literal": return node.value;
-		case "binary": return evaluateBinary(node.operator, node.left, node.right, context);
-		case "unary": return evaluateUnary(node.operator, node.operand, context);
-	}
-}
-function resolveReference(name, context) {
-	switch (name) {
-		case "inputs": return context.inputs;
-		case "steps": return context.steps;
-		case "item": return context.item;
-		case "index": return context.index;
-		case "result": return context.result;
-		default: throw new EvalError(`Unknown reference: $${name}`);
-	}
-}
-function resolvePropertyAccess(node, context) {
-	const obj = evaluate(node.object, context);
-	if (obj === null || obj === void 0) return;
-	if (node.property === "length" && Array.isArray(obj)) return obj.length;
-	if (typeof obj === "object") return obj[node.property];
-}
-function resolveIndexAccess(node, context) {
-	const obj = evaluate(node.object, context);
-	const idx = evaluate(node.index, context);
-	if (obj === null || obj === void 0) return;
-	if (Array.isArray(obj) && typeof idx === "number") return obj[idx];
-	if (typeof obj === "object") {
-		const key = typeof idx === "number" ? String(idx) : idx;
-		if (typeof key === "string") return obj[key];
-	}
-}
-function evaluateBinary(op, left, right, context) {
-	const lval = evaluate(left, context);
-	const rval = evaluate(right, context);
-	switch (op) {
-		case "==": return lval === rval;
-		case "!=": return lval !== rval;
-		case ">": return toNumber(lval) > toNumber(rval);
-		case "<": return toNumber(lval) < toNumber(rval);
-		case ">=": return toNumber(lval) >= toNumber(rval);
-		case "<=": return toNumber(lval) <= toNumber(rval);
-		case "&&": return isTruthy(lval) && isTruthy(rval);
-		case "||": return isTruthy(lval) || isTruthy(rval);
-		case "contains":
-			if (Array.isArray(lval)) return lval.includes(rval);
-			return String(lval ?? "").includes(String(rval ?? ""));
-		default: throw new EvalError(`Unknown operator: ${op}`);
-	}
-}
-function evaluateUnary(op, operand, context) {
-	const val = evaluate(operand, context);
-	switch (op) {
-		case "!": return !isTruthy(val);
-		default: throw new EvalError(`Unknown unary operator: ${op}`);
-	}
-}
-function toNumber(val) {
-	if (typeof val === "number") return val;
-	if (typeof val === "string") {
-		const n = Number(val);
-		if (!isNaN(n)) return n;
-	}
-	if (typeof val === "boolean") return val ? 1 : 0;
-	return 0;
-}
-function isTruthy(val) {
-	if (val === null || val === void 0) return false;
-	if (typeof val === "boolean") return val;
-	if (typeof val === "number") return val !== 0;
-	if (typeof val === "string") return val.length > 0;
-	if (Array.isArray(val)) return val.length > 0;
-	return true;
-}
-
-//#endregion
-//#region src/expression/index.ts
-/**
-* Resolve a single expression string against a runtime context.
-* Used for source, condition, where, each, and output fields.
-* Example: "$steps.fetch.output.messages.length >= 5"
-*/
-function resolveExpression(expr, context) {
-	return evaluate(parseExpression(lex(expr)), context);
-}
-/**
-* Interpolate $-references in a prompt template string.
-* Only resolves references and property access (no operators).
-* Objects/arrays are serialized as JSON. Null → empty string.
-*
-* Example: "Score this email: $steps.fetch.output.subject"
-*/
-function interpolatePrompt(template, context) {
-	return template.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)(\.[a-zA-Z_][a-zA-Z0-9_]*|\[[^\]]*\])*/g, (match) => {
-		try {
-			return stringify(resolveExpression(match, context));
-		} catch {
-			return match;
-		}
-	});
-}
-/**
-* Returns true if the string contains at least one ${...} template block.
-*/
-function containsTemplate(value) {
-	return /\$\{[^}]+\}/.test(value);
-}
-/**
-* Resolve a ${...} template string against a runtime context.
-*
-* Two modes:
-* - Whole-value `${ref}` (nothing else) — type is preserved (not coerced to string).
-* - Multi-block — each `${ref}` is evaluated and spliced into the surrounding string.
-*   Use `$${` to produce a literal `${` inside a template.
-*
-* Inside `${...}`, references omit the leading `$` (the `$` is part of the delimiter).
-* Example: `"https://example.com?q=${inputs.query}"` → resolves `$inputs.query`.
-*/
-function resolveTemplate(template, context) {
-	const single = template.match(/^\$\{([^}]+)\}$/);
-	if (single) return resolveExpression("$" + single[1], context);
-	return template.replace(/\$\$\{|\$\{([^}]+)\}/g, (match, expr) => {
-		if (match === "$${") return "${";
-		return stringify(resolveExpression("$" + expr, context));
-	});
-}
-/**
-* Coerce a value to its string representation for prompt interpolation.
-* Per the spec: objects/arrays → JSON, null → empty string.
-*/
-function stringify(value) {
-	if (value === null || value === void 0) return "";
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	return JSON.stringify(value);
-}
-
-//#endregion
-//#region src/parser/parse-content.ts
-/**
-* Parse content that is either a full SKILL.md or a bare workflow YAML block.
-* Never throws — failures are encoded in the returned union.
-*/
-function parseContent(content) {
-	if (!content.trim()) return {
-		ok: false,
-		message: "Content is empty"
-	};
-	try {
-		const skill = parseSkillMd(content);
-		return {
-			ok: true,
-			workflow: skill.workflow,
-			name: skill.frontmatter.name
-		};
-	} catch {}
-	try {
-		return {
-			ok: true,
-			workflow: parseWorkflowFromMd(content),
-			name: void 0
-		};
-	} catch (err) {
-		let message;
-		let details;
-		if (err instanceof ParseError) {
-			message = err.message;
-			details = err.details.length > 0 ? err.details : void 0;
-		} else message = err instanceof Error ? err.message : String(err);
-		return {
-			ok: false,
-			message,
-			details
-		};
-	}
-}
-
-//#endregion
-//#region src/validator/index.ts
-/**
-* Validate a workflow definition before execution.
-* Checks structural correctness, reference graph, type compatibility, and tool availability.
-* Returns all errors found — does not fail fast.
-*/
-function validateWorkflow(workflow, toolAdapter) {
-	const errors = [];
-	const stepMap = /* @__PURE__ */ new Map();
-	const stepOrder = /* @__PURE__ */ new Map();
-	for (let i = 0; i < workflow.steps.length; i++) {
-		const step = workflow.steps[i];
-		stepOrder.set(step.id, i);
-		if (stepMap.has(step.id)) errors.push({
-			path: `steps[${i}].id`,
-			message: `Duplicate step ID "${step.id}"`
-		});
-		stepMap.set(step.id, step);
-	}
-	const branchStepIds = /* @__PURE__ */ new Set();
-	for (const step of workflow.steps) if (step.type === "conditional") {
-		for (const id of step.then) branchStepIds.add(id);
-		if (step.else) for (const id of step.else) branchStepIds.add(id);
-	}
-	for (let i = 0; i < workflow.steps.length; i++) {
-		const step = workflow.steps[i];
-		const path = `steps[${i}]`;
-		if (step.each && step.type === "exit") errors.push({
-			path: `${path}.each`,
-			message: `"each" is not valid on exit steps`
-		});
-		if (step.each && step.type === "conditional") errors.push({
-			path: `${path}.each`,
-			message: `"each" is not valid on conditional steps`
-		});
-		if (step.delay && !step.each) errors.push({
-			path: `${path}.delay`,
-			message: `"delay" requires "each" to be present`
-		});
-		if (step.type === "tool" && toolAdapter && !toolAdapter.has(step.tool)) errors.push({
-			path: `${path}.tool`,
-			message: `Tool "${step.tool}" is not registered`
-		});
-		for (const [inputName, input] of Object.entries(step.inputs)) if (typeof input.value === "string" && hasStepReferences(input.value)) validateSourceReference(input.value, step.id, `${path}.inputs.${inputName}.value`, stepMap, stepOrder, branchStepIds, errors);
-		if (step.condition) validateExpressionReferences(step.condition, step.id, `${path}.condition`, stepMap, stepOrder, branchStepIds, errors);
-		if (step.each) validateExpressionReferences(step.each, step.id, `${path}.each`, stepMap, stepOrder, branchStepIds, errors);
-		if (step.type === "conditional") validateBranchReferences(step, i, stepMap, errors);
-		if (step.type === "exit" && step.output) {
-			if (typeof step.output === "string") validateExpressionReferences(step.output, step.id, `${path}.output`, stepMap, stepOrder, branchStepIds, errors);
-			else for (const [key, val] of Object.entries(step.output)) if (typeof val === "string" && val.startsWith("$")) validateExpressionReferences(val, step.id, `${path}.output.${key}`, stepMap, stepOrder, branchStepIds, errors);
-		}
-	}
-	for (const [outputName, outputDef] of Object.entries(workflow.outputs)) if (typeof outputDef.value === "string" && hasStepReferences(outputDef.value)) {
-		const refs = extractStepReferences(outputDef.value);
-		for (const refId of refs) if (!stepMap.has(refId)) errors.push({
-			path: `outputs.${outputName}.value`,
-			message: `References undefined step "${refId}"`
-		});
-	}
-	const cycleErrors = detectCycles(workflow.steps, stepMap);
-	errors.push(...cycleErrors);
-	return {
-		valid: errors.length === 0,
-		errors
-	};
-}
-/**
-* Extract step IDs referenced from an expression or template string.
-* Handles both expression form ($steps.<id>) and template form (${steps.<id>...}).
-*/
-function extractStepReferences(expr) {
-	const refs = [];
-	const exprRegex = /\$steps\.([a-zA-Z_][a-zA-Z0-9_]*)/g;
-	const tmplRegex = /\$\{steps\.([a-zA-Z_][a-zA-Z0-9_]*)/g;
-	let match;
-	while ((match = exprRegex.exec(expr)) !== null) refs.push(match[1]);
-	while ((match = tmplRegex.exec(expr)) !== null) refs.push(match[1]);
-	return [...new Set(refs)];
-}
-/** Returns true if the string contains $steps references in either expression or template form. */
-function hasStepReferences(value) {
-	return value.startsWith("$steps.") || /\$\{steps\./.test(value);
-}
-/**
-* Validate that a source expression references valid, earlier-defined steps.
-*/
-function validateSourceReference(source, currentStepId, path, stepMap, stepOrder, branchStepIds, errors) {
-	const refs = extractStepReferences(source);
-	const currentOrder = stepOrder.get(currentStepId) ?? -1;
-	for (const refId of refs) if (!stepMap.has(refId)) errors.push({
-		path,
-		message: `References undefined step "${refId}"`
-	});
-	else if ((stepOrder.get(refId) ?? -1) >= currentOrder && !branchStepIds.has(currentStepId)) errors.push({
-		path,
-		message: `Step "${currentStepId}" references step "${refId}" which is not declared before it`
-	});
-}
-/**
-* Validate expression references (condition, each, output).
-*/
-function validateExpressionReferences(expr, currentStepId, path, stepMap, stepOrder, branchStepIds, errors) {
-	const refs = extractStepReferences(expr);
-	const currentOrder = stepOrder.get(currentStepId) ?? -1;
-	for (const refId of refs) if (!stepMap.has(refId)) errors.push({
-		path,
-		message: `References undefined step "${refId}"`
-	});
-	else if ((stepOrder.get(refId) ?? -1) >= currentOrder && !branchStepIds.has(currentStepId)) errors.push({
-		path,
-		message: `Step "${currentStepId}" references step "${refId}" which is not declared before it`
-	});
-}
-/**
-* Validate conditional step branch references.
-*/
-function validateBranchReferences(step, stepIndex, stepMap, errors) {
-	const path = `steps[${stepIndex}]`;
-	for (const id of step.then) if (!stepMap.has(id)) errors.push({
-		path: `${path}.then`,
-		message: `Branch references undefined step "${id}"`
-	});
-	if (step.else) {
-		for (const id of step.else) if (!stepMap.has(id)) errors.push({
-			path: `${path}.else`,
-			message: `Branch references undefined step "${id}"`
-		});
-	}
-}
-/**
-* Detect cycles in the step reference graph.
-* Steps form a DAG through $steps references. Cycles would cause infinite loops.
-*/
-function detectCycles(steps, stepMap) {
-	const errors = [];
-	const deps = /* @__PURE__ */ new Map();
-	for (const step of steps) {
-		const stepDeps = /* @__PURE__ */ new Set();
-		for (const input of Object.values(step.inputs)) if (typeof input.value === "string") for (const ref of extractStepReferences(input.value)) stepDeps.add(ref);
-		if (step.condition) for (const ref of extractStepReferences(step.condition)) stepDeps.add(ref);
-		if (step.each) for (const ref of extractStepReferences(step.each)) stepDeps.add(ref);
-		deps.set(step.id, stepDeps);
-	}
-	const visited = /* @__PURE__ */ new Set();
-	const inStack = /* @__PURE__ */ new Set();
-	function dfs(nodeId, pathStack) {
-		if (inStack.has(nodeId)) {
-			const cycleStart = pathStack.indexOf(nodeId);
-			const cycle = pathStack.slice(cycleStart).concat(nodeId);
-			errors.push({
-				path: `steps`,
-				message: `Cycle detected: ${cycle.join(" → ")}`
-			});
-			return true;
-		}
-		if (visited.has(nodeId)) return false;
-		visited.add(nodeId);
-		inStack.add(nodeId);
-		pathStack.push(nodeId);
-		const nodeDeps = deps.get(nodeId) ?? /* @__PURE__ */ new Set();
-		for (const dep of nodeDeps) if (stepMap.has(dep)) dfs(dep, pathStack);
-		pathStack.pop();
-		inStack.delete(nodeId);
-		return false;
-	}
-	for (const step of steps) if (!visited.has(step.id)) dfs(step.id, []);
-	return errors;
-}
-/**
-* Parse content and validate the workflow in one synchronous call.
-* Matches the shape of the plugin's ValidateResult exactly.
-*/
-function validateWorkflowSkill(options) {
-	const { content, toolAdapter } = options;
-	const parsed = parseContent(content);
-	if (!parsed.ok) return {
-		valid: false,
-		errors: parsed.details ?? [{
-			path: "parse",
-			message: parsed.message
-		}]
-	};
-	const result = validateWorkflow(parsed.workflow, toolAdapter);
-	if (!result.valid) return {
-		valid: false,
-		errors: result.errors
-	};
-	const stepTypes = [...new Set(parsed.workflow.steps.map((s) => s.type))];
-	return {
-		valid: true,
-		errors: [],
-		name: parsed.name,
-		stepCount: parsed.workflow.steps.length,
-		stepTypes
-	};
-}
-
-//#endregion
-//#region src/adapters/anthropic-llm-adapter.ts
-/** Model alias map: short names → full model IDs. */
-const MODEL_ALIASES = {
-	haiku: "claude-haiku-4-5-20251001",
-	sonnet: "claude-sonnet-4-6",
-	opus: "claude-opus-4-6"
-};
-const DEFAULT_MODEL = "claude-haiku-4-5-20251001";
-function resolveModel(model, fallback = DEFAULT_MODEL) {
-	if (!model) return fallback;
-	return MODEL_ALIASES[model] ?? model;
-}
-var AnthropicLLMAdapter = class {
-	client;
-	constructor(apiKey) {
-		this.client = new Anthropic({
-			apiKey,
-			timeout: 12e4,
-			maxRetries: 1
-		});
-	}
-	async call(model, prompt, responseFormat) {
-		let fullPrompt = prompt;
-		if (responseFormat && Object.keys(responseFormat).length > 0) fullPrompt += `\n\nRespond with valid JSON matching this schema: ${JSON.stringify(responseFormat)}`;
-		const response = await this.client.messages.create({
-			model: resolveModel(model),
-			max_tokens: 4096,
-			messages: [{
-				role: "user",
-				content: fullPrompt
-			}]
-		});
-		const textBlock = response.content.find((block) => block.type === "text");
-		return {
-			text: textBlock && "text" in textBlock ? textBlock.text : "",
-			tokens: {
-				input: response.usage.input_tokens,
-				output: response.usage.output_tokens
-			}
-		};
-	}
-};
-
-//#endregion
-//#region src/tools/builtin-tool-adapter.ts
-var BuiltinToolAdapter = class BuiltinToolAdapter {
-	tools = /* @__PURE__ */ new Map();
-	register(descriptor, handler) {
-		this.tools.set(descriptor.name, {
-			handler,
-			descriptor
-		});
-	}
-	has(toolName) {
-		return this.tools.has(toolName);
-	}
-	list() {
-		return [...this.tools.values()].map((t) => t.descriptor);
-	}
-	async invoke(toolName, args) {
-		const entry = this.tools.get(toolName);
-		if (!entry) return {
-			output: null,
-			error: `Tool "${toolName}" not registered`
-		};
-		return entry.handler(args);
-	}
-	/**
-	* Create a BuiltinToolAdapter with all bundled tools registered.
-	*/
-	static async create() {
-		const adapter = new BuiltinToolAdapter();
-		const scrapeMod = await import("./web-scrape-GeEM_JNl.mjs");
-		adapter.register(scrapeMod.descriptor, scrapeMod.handler);
-		return adapter;
-	}
-};
-
-//#endregion
-//#region src/config/index.ts
-/**
-* Parse a .env file into key-value pairs.
-* Supports KEY=VALUE format, blank lines, and # comments.
-* Values may be optionally quoted with single or double quotes.
-*/
-function parseDotenv(content) {
-	const vars = {};
-	for (const line of content.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const eqIdx = trimmed.indexOf("=");
-		if (eqIdx === -1) continue;
-		const key = trimmed.slice(0, eqIdx).trim();
-		let value = trimmed.slice(eqIdx + 1).trim();
-		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
-		vars[key] = value;
-	}
-	return vars;
-}
-/**
-* Find the package root by walking up from this module's directory
-* until we find a directory containing package.json.
-*/
-function findPackageRoot() {
-	let dir = dirname(fileURLToPath(import.meta.url));
-	while (true) {
-		if (existsSync(join(dir, "package.json"))) return dir;
-		const parent = dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-}
-/**
-* Load configuration from environment variables, with .env fallback.
-* Environment variables take precedence over .env file values.
-*
-* .env search order:
-* 1. Explicit `cwd` parameter (for tests)
-* 2. Package root (found by walking up from this module)
-* 3. process.cwd()
-*/
-function loadConfig(cwd) {
-	let dotenvVars = {};
-	const searchDirs = cwd ? [cwd] : [findPackageRoot(), process.cwd()].filter((d) => d !== void 0);
-	for (const dir of searchDirs) try {
-		dotenvVars = parseDotenv(readFileSync(join(dir, ".env"), "utf-8"));
-		break;
-	} catch {}
-	const get = (key) => process.env[key] ?? dotenvVars[key];
-	const config = {};
-	const anthropicKey = get("ANTHROPIC_API_KEY");
-	if (anthropicKey) config.anthropicApiKey = anthropicKey;
-	return config;
-}
-
-//#endregion
-//#region src/executor/transform.ts
-/**
-* Execute a transform step.
-* Returns an object with the first declared output key mapped to the transformed array.
-*/
-function executeTransform(step, resolvedInputs, context) {
-	const items = getInputArray(resolvedInputs);
-	let result;
-	switch (step.operation) {
-		case "filter":
-			result = executeFilter(step, items, context);
-			break;
-		case "map":
-			result = executeMap(step, items, context);
-			break;
-		case "sort":
-			result = executeSort(step, items);
-			break;
-	}
-	return { [Object.keys(step.outputs)[0] ?? "items"]: result };
-}
-/** Find the array to transform from resolved inputs. */
-function getInputArray(inputs) {
-	if ("items" in inputs && Array.isArray(inputs.items)) return inputs.items;
-	for (const val of Object.values(inputs)) if (Array.isArray(val)) return val;
-	const first = Object.values(inputs)[0];
-	return first != null ? [first] : [];
-}
-/** Filter: keep items where the `where` expression is truthy. */
-function executeFilter(step, items, context) {
-	return items.filter((item, index) => {
-		const itemCtx = {
-			...context,
-			item,
-			index
-		};
-		return Boolean(resolveExpression(step.where, itemCtx));
-	});
-}
-/** Map: project each item into a new shape using the `expression` object. */
-function executeMap(step, items, context) {
-	return items.map((item, index) => {
-		const itemCtx = {
-			...context,
-			item,
-			index
-		};
-		const result = {};
-		for (const [key, expr] of Object.entries(step.expression)) result[key] = resolveMapValue(expr, itemCtx);
-		return result;
-	});
-}
-/**
-* Resolve a map expression value.
-* - String starting with `$` → expression reference
-* - Non-string primitive (number, boolean, null) → pass through as literal
-* - Object (non-array) → recurse, applying same rules to each value
-* - String not starting with `$` → literal string
-*/
-function resolveMapValue(value, context) {
-	if (typeof value === "string") {
-		if (value.startsWith("$")) return resolveExpression(value, context);
-		return value;
-	}
-	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-		const result = {};
-		for (const [k, v] of Object.entries(value)) result[k] = resolveMapValue(v, context);
-		return result;
-	}
-	return value;
-}
-/** Sort: order items by a field path in the given direction (default: asc). */
-function executeSort(step, items) {
-	const direction = step.direction ?? "asc";
-	return [...items].sort((a, b) => {
-		const aVal = getNestedField(a, step.field);
-		const bVal = getNestedField(b, step.field);
-		if (aVal == null && bVal == null) return 0;
-		if (aVal == null) return 1;
-		if (bVal == null) return -1;
-		if (aVal < bVal) return direction === "asc" ? -1 : 1;
-		if (aVal > bVal) return direction === "asc" ? 1 : -1;
-		return 0;
-	});
-}
-/** Access a nested field by dot-notation path (e.g., "user.name"). */
-function getNestedField(obj, path) {
-	const parts = path.split(".");
-	let current = obj;
-	for (const part of parts) {
-		if (current == null || typeof current !== "object") return void 0;
-		current = current[part];
-	}
-	return current;
-}
-
-//#endregion
-//#region src/executor/conditional.ts
-/**
-* Execute a conditional step.
-* Evaluates the condition expression and returns the branch to execute.
-* The runtime is responsible for executing the branch steps.
-*/
-function executeConditional(step, context) {
-	const conditionResult = resolveExpression(step.condition, context);
-	if (Boolean(conditionResult)) return {
-		branch: "then",
-		stepIds: step.then
-	};
-	else if (step.else) return {
-		branch: "else",
-		stepIds: step.else
-	};
-	else return {
-		branch: null,
-		stepIds: []
-	};
-}
-
-//#endregion
-//#region src/executor/exit.ts
-/**
-* Execute an exit step.
-* Output can be:
-* - A string expression: resolved against context
-* - An object literal: each string value starting with $ is resolved, others kept as-is
-* - Undefined: null output
-*/
-function executeExit(step, context) {
-	let output = null;
-	if (step.output) if (typeof step.output === "string") output = resolveExpression(step.output, context);
-	else output = resolveOutputObject(step.output, context);
-	return {
-		status: step.status,
-		output
-	};
-}
-function resolveOutputObject(obj, context) {
-	const result = {};
-	for (const [key, val] of Object.entries(obj)) if (typeof val === "string") if (val.startsWith("$$")) result[key] = val.slice(1);
-	else if (containsTemplate(val)) result[key] = resolveTemplate(val, context);
-	else if (val.startsWith("$")) result[key] = resolveExpression(val, context);
-	else result[key] = val;
-	else result[key] = val;
-	return result;
-}
-
-//#endregion
-//#region src/executor/types.ts
-/** Error thrown by step executors. */
-var StepExecutionError = class extends Error {
-	constructor(message, retriable = false, context) {
-		super(message);
-		this.retriable = retriable;
-		this.context = context;
-		this.name = "StepExecutionError";
-	}
-};
-
-//#endregion
-//#region src/executor/tool.ts
-/**
-* Execute a tool step.
-* Passes resolved inputs as the tool's arguments. Returns the tool's response.
-* The runtime does not interpret the response (per spec).
-*/
-async function executeTool(step, resolvedInputs, toolAdapter) {
-	const result = await toolAdapter.invoke(step.tool, resolvedInputs);
-	if (result.error) throw new StepExecutionError(result.error, true, { tool: step.tool });
-	return { output: result.output };
-}
-
-//#endregion
-//#region src/executor/llm.ts
-/**
-* Execute an LLM step.
-* Interpolates $-references in the prompt, calls the model, and returns the response.
-* The response_format field is passed as a hint but not enforced (per spec).
-* If the response is valid JSON, it's parsed; otherwise returned as text.
-*/
-async function executeLLM(step, _resolvedInputs, context, llmAdapter) {
-	const prompt = interpolatePrompt(step.prompt, context);
-	let result;
-	try {
-		result = await llmAdapter.call(step.model, prompt, step.response_format);
-	} catch (err) {
-		throw new StepExecutionError(err instanceof Error ? err.message : String(err), true);
-	}
-	let output = result.text;
-	try {
-		output = JSON.parse(result.text);
-	} catch {}
-	return {
-		output,
-		tokens: result.tokens
-	};
-}
-
-//#endregion
-//#region src/executor/index.ts
-/**
-* Dispatch a step to the appropriate executor.
-* The runtime calls this for each step in the execution loop.
-*/
-async function dispatch(step, resolvedInputs, context, toolAdapter, llmAdapter) {
-	switch (step.type) {
-		case "tool": return {
-			kind: "output",
-			...await executeTool(step, resolvedInputs, toolAdapter)
-		};
-		case "llm": return {
-			kind: "output",
-			...await executeLLM(step, resolvedInputs, context, llmAdapter)
-		};
-		case "transform": return {
-			kind: "output",
-			output: executeTransform(step, resolvedInputs, context)
-		};
-		case "conditional": return {
-			kind: "branch",
-			...executeConditional(step, context)
-		};
-		case "exit": return {
-			kind: "exit",
-			...executeExit(step, context)
-		};
-	}
-}
-
-//#endregion
-//#region src/runtime/index.ts
-/** Resolve a value field:
-* 1. starts with $$ → strip one $ (literal escape)
-* 2. contains ${...} → template interpolation
-* 3. starts with $ → whole expression
-* 4. otherwise → literal
-*/
-function resolveValue(value, context) {
-	if (typeof value !== "string") return value;
-	if (value.startsWith("$$")) return value.slice(1);
-	if (containsTemplate(value)) return resolveTemplate(value, context);
-	if (value.startsWith("$")) return resolveExpression(value, context);
-	return value;
-}
-/** Emit a runtime event if a callback is registered. */
-function emit(onEvent, event) {
-	onEvent?.(event);
-}
-var WorkflowExecutionError = class extends Error {
-	constructor(message, validationErrors) {
-		super(message);
-		this.validationErrors = validationErrors;
-		this.name = "WorkflowExecutionError";
-	}
-};
-/**
-* Build a minimal RunLog for a pre-execution failure (parse or validate phase).
-* Every run attempt — even those that fail before execution begins — produces a structured artifact.
-*/
-function buildFailedRunLog(workflowName, error, startedAt) {
-	const now = /* @__PURE__ */ new Date();
-	const start = startedAt ?? now;
-	const durationMs = now.getTime() - start.getTime();
-	return {
-		id: crypto.randomUUID(),
-		workflow: workflowName,
-		status: "failed",
-		summary: {
-			steps_executed: 0,
-			steps_skipped: 0,
-			total_tokens: 0,
-			total_duration_ms: durationMs
-		},
-		started_at: start.toISOString(),
-		completed_at: now.toISOString(),
-		duration_ms: durationMs,
-		inputs: {},
-		steps: [],
-		outputs: {},
-		error
-	};
-}
-/**
-* Execute a workflow and produce a run log.
-* Phase 1: Validate the workflow definition.
-* Phase 2: Execute steps in declaration order following the 8-step lifecycle.
-*/
-async function runWorkflow(options) {
-	const { onEvent } = options;
-	const startedAt = /* @__PURE__ */ new Date();
-	const validation = validateWorkflow(options.workflow, options.toolAdapter);
-	if (!validation.valid) {
-		const message = `Workflow validation failed: ${validation.errors.map((e) => e.message).join("; ")}`;
-		return buildFailedRunLog(options.workflowName ?? "unnamed", {
-			phase: "validate",
-			message,
-			details: validation.errors
-		}, startedAt);
-	}
-	const workflowName = options.workflowName ?? "unnamed";
-	emit(onEvent, {
-		type: "workflow_start",
-		workflow: workflowName,
-		totalSteps: options.workflow.steps.length
-	});
-	const inputs = applyDefaults(options.workflow.inputs, options.inputs ?? {});
-	const context = {
-		inputs,
-		steps: {}
-	};
-	const stepRecords = [];
-	const branchStepIds = collectBranchStepIds(options.workflow.steps);
-	const stepMap = new Map(options.workflow.steps.map((s) => [s.id, s]));
-	let workflowStatus = "success";
-	let workflowOutput = null;
-	let exitFired = false;
-	let halted = false;
-	for (const step of options.workflow.steps) {
-		if (halted) break;
-		if (branchStepIds.has(step.id)) continue;
-		const result = await executeStepLifecycle(step, context, stepMap, branchStepIds, options.toolAdapter, options.llmAdapter, onEvent);
-		stepRecords.push(...result.records);
-		if (result.exit) {
-			halted = true;
-			exitFired = true;
-			workflowStatus = result.exit.status === "failed" ? "failed" : "success";
-			workflowOutput = result.exit.output;
-		} else if (result.failed) {
-			halted = true;
-			workflowStatus = "failed";
-		} else workflowOutput = context.steps[step.id]?.output ?? null;
-	}
-	const recordedIds = new Set(stepRecords.map((r) => r.id));
-	for (const step of options.workflow.steps) if (!recordedIds.has(step.id)) {
-		const reason = branchStepIds.has(step.id) ? "Branch not selected" : "Workflow halted";
-		emit(onEvent, {
-			type: "step_skip",
-			stepId: step.id,
-			reason
-		});
-		stepRecords.push({
-			id: step.id,
-			executor: step.type,
-			status: "skipped",
-			reason,
-			duration_ms: 0
-		});
-	}
-	const outputs = buildWorkflowOutputs(options.workflow, workflowOutput, context, exitFired);
-	const completedAt = /* @__PURE__ */ new Date();
-	const durationMs = completedAt.getTime() - startedAt.getTime();
-	let stepsExecuted = 0;
-	let stepsSkipped = 0;
-	let totalTokens = 0;
-	for (const rec of stepRecords) {
-		if (rec.status === "skipped") stepsSkipped++;
-		else stepsExecuted++;
-		if (rec.tokens) totalTokens += rec.tokens.input + rec.tokens.output;
-	}
-	const summary = {
-		steps_executed: stepsExecuted,
-		steps_skipped: stepsSkipped,
-		total_tokens: totalTokens,
-		total_duration_ms: durationMs
-	};
-	emit(onEvent, {
-		type: "workflow_complete",
-		status: workflowStatus,
-		duration_ms: durationMs,
-		summary
-	});
-	return {
-		id: crypto.randomUUID(),
-		workflow: workflowName,
-		status: workflowStatus,
-		summary,
-		started_at: startedAt.toISOString(),
-		completed_at: completedAt.toISOString(),
-		duration_ms: durationMs,
-		inputs,
-		steps: stepRecords,
-		outputs
-	};
-}
-/**
-* Parse content and execute the workflow in one call. Never throws.
-* Empty or unparseable content → failed RunLog (phase: 'parse').
-* Unexpected execution exception → failed RunLog (phase: 'execute').
-* Validation failures are handled internally by runWorkflow.
-*/
-async function runWorkflowSkill(options) {
-	const { content, inputs, toolAdapter, llmAdapter, workflowName = "inline", onEvent } = options;
-	const startedAt = /* @__PURE__ */ new Date();
-	const parsed = parseContent(content);
-	if (!parsed.ok) return buildFailedRunLog(workflowName, {
-		phase: "parse",
-		message: parsed.message,
-		details: parsed.details
-	}, startedAt);
-	const resolvedName = parsed.name ?? workflowName;
-	try {
-		return await runWorkflow({
-			workflow: parsed.workflow,
-			inputs,
-			toolAdapter,
-			llmAdapter,
-			workflowName: resolvedName,
-			onEvent
-		});
-	} catch (err) {
-		return buildFailedRunLog(resolvedName, {
-			phase: "execute",
-			message: err instanceof Error ? err.message : String(err)
-		}, startedAt);
-	}
-}
-/**
-* Execute one step through the 9-step lifecycle:
-* 1. Guard  2. Resolve inputs  3. Iterate (each)  4. Dispatch
-* 5. Map outputs  6. Validate output  7. Retry  8. Handle errors  9. Record
-*/
-async function executeStepLifecycle(step, context, stepMap, branchStepIds, toolAdapter, llmAdapter, onEvent) {
-	const startTime = performance.now();
-	const records = [];
-	if (step.condition && step.type !== "conditional") {
-		if (!resolveExpression(step.condition, context)) {
-			context.steps[step.id] = { output: null };
-			emit(onEvent, {
-				type: "step_skip",
-				stepId: step.id,
-				reason: "Guard condition evaluated to false"
-			});
-			records.push({
-				id: step.id,
-				executor: step.type,
-				status: "skipped",
-				reason: "Guard condition evaluated to false",
-				duration_ms: Math.round(performance.now() - startTime)
-			});
-			return { records };
-		}
-	}
-	emit(onEvent, {
-		type: "step_start",
-		stepId: step.id,
-		stepType: step.type,
-		tool: step.type === "tool" ? step.tool : void 0
-	});
-	if (step.each) return executeWithEach(step, context, stepMap, branchStepIds, toolAdapter, llmAdapter, startTime, onEvent);
-	const resolvedInputs = resolveInputs(step.inputs, context, step.id);
-	try {
-		const { result, retries } = await dispatchWithRetry(step, resolvedInputs, context, toolAdapter, llmAdapter, onEvent);
-		if (result.kind === "exit") {
-			context.steps[step.id] = { output: result.output };
-			const durationMs = Math.round(performance.now() - startTime);
-			emit(onEvent, {
-				type: "step_complete",
-				stepId: step.id,
-				status: "success",
-				duration_ms: durationMs
-			});
-			records.push({
-				id: step.id,
-				executor: "exit",
-				status: "success",
-				duration_ms: durationMs,
-				inputs: resolvedInputs,
-				output: result.output,
-				retries
-			});
-			return {
-				records,
-				exit: {
-					status: result.status,
-					output: result.output
-				}
-			};
-		}
-		if (result.kind === "branch") {
-			const branchRecords = await executeBranch(result.stepIds, context, stepMap, branchStepIds, toolAdapter, llmAdapter, onEvent);
-			const lastBranchStepId = result.stepIds[result.stepIds.length - 1];
-			const conditionalOutput = lastBranchStepId ? context.steps[lastBranchStepId]?.output ?? null : null;
-			context.steps[step.id] = { output: conditionalOutput };
-			const durationMs = Math.round(performance.now() - startTime);
-			emit(onEvent, {
-				type: "step_complete",
-				stepId: step.id,
-				status: "success",
-				duration_ms: durationMs
-			});
-			records.push({
-				id: step.id,
-				executor: "conditional",
-				status: "success",
-				duration_ms: durationMs,
-				inputs: resolvedInputs,
-				output: conditionalOutput,
-				retries
-			});
-			records.push(...branchRecords.records);
-			return {
-				records,
-				exit: branchRecords.exit,
-				failed: branchRecords.failed
-			};
-		}
-		const mappedOutput = applyStepOutputMapping(step.outputs, result.output, context);
-		context.steps[step.id] = { output: mappedOutput };
-		const durationMs = Math.round(performance.now() - startTime);
-		emit(onEvent, {
-			type: "step_complete",
-			stepId: step.id,
-			status: "success",
-			duration_ms: durationMs,
-			tokens: result.tokens
-		});
-		records.push({
-			id: step.id,
-			executor: step.type,
-			status: "success",
-			duration_ms: durationMs,
-			inputs: resolvedInputs,
-			output: mappedOutput,
-			tokens: result.tokens,
-			retries
-		});
-		return { records };
-	} catch (err) {
-		return handleStepError(step, err, context, startTime, resolvedInputs, void 0, onEvent);
-	}
-}
-async function executeWithEach(step, context, _stepMap, _branchStepIds, toolAdapter, llmAdapter, startTime, onEvent) {
-	const records = [];
-	const eachArray = resolveExpression(step.each, context);
-	if (!Array.isArray(eachArray)) return handleStepError(step, new StepExecutionError(`each expression must resolve to an array, got ${typeof eachArray}`), context, startTime, void 0, void 0, onEvent);
-	const baseResolvedInputs = resolveInputs(step.inputs, context, step.id);
-	const results = [];
-	let totalTokens;
-	let totalRetries;
-	try {
-		for (let i = 0; i < eachArray.length; i++) {
-			const itemContext = {
-				...context,
-				item: eachArray[i],
-				index: i
-			};
-			const { result, retries } = await dispatchWithRetry(step, resolveInputs(step.inputs, itemContext, step.id), itemContext, toolAdapter, llmAdapter, onEvent);
-			if (retries) {
-				totalRetries = totalRetries ?? {
-					attempts: 0,
-					errors: []
-				};
-				totalRetries.attempts += retries.attempts;
-				totalRetries.errors.push(...retries.errors);
-			}
-			if (result.kind === "output") {
-				const mappedIterOutput = applyStepOutputMapping(step.outputs, result.output, itemContext);
-				results.push(mappedIterOutput);
-				if (result.tokens) {
-					totalTokens = totalTokens ?? {
-						input: 0,
-						output: 0
-					};
-					totalTokens.input += result.tokens.input;
-					totalTokens.output += result.tokens.output;
-				}
-			}
-			emit(onEvent, {
-				type: "each_progress",
-				stepId: step.id,
-				current: i + 1,
-				total: eachArray.length
-			});
-			if (step.delay && i < eachArray.length - 1) await sleep(parseDelay(step.delay));
-		}
-	} catch (err) {
-		return handleStepError(step, err, context, startTime, baseResolvedInputs, totalRetries, onEvent);
-	}
-	context.steps[step.id] = { output: results };
-	const durationMs = Math.round(performance.now() - startTime);
-	emit(onEvent, {
-		type: "step_complete",
-		stepId: step.id,
-		status: "success",
-		duration_ms: durationMs,
-		tokens: totalTokens,
-		iterations: eachArray.length
-	});
-	records.push({
-		id: step.id,
-		executor: step.type,
-		status: "success",
-		duration_ms: durationMs,
-		inputs: baseResolvedInputs,
-		iterations: eachArray.length,
-		tokens: totalTokens,
-		output: results,
-		retries: totalRetries
-	});
-	return { records };
-}
-async function executeBranch(stepIds, context, stepMap, branchStepIds, toolAdapter, llmAdapter, onEvent) {
-	const records = [];
-	for (const stepId of stepIds) {
-		const branchStep = stepMap.get(stepId);
-		if (!branchStep) continue;
-		const result = await executeStepLifecycle(branchStep, context, stepMap, branchStepIds, toolAdapter, llmAdapter, onEvent);
-		records.push(...result.records);
-		if (result.exit) return {
-			records,
-			exit: result.exit
-		};
-		if (result.failed) return {
-			records,
-			failed: true
-		};
-	}
-	return { records };
-}
-async function dispatchWithRetry(step, resolvedInputs, context, toolAdapter, llmAdapter, onEvent) {
-	const retryPolicy = "retry" in step ? step.retry : void 0;
-	const maxRetries = retryPolicy?.max ?? 0;
-	const baseDelay = retryPolicy ? parseDelay(retryPolicy.delay) : 0;
-	const backoff = retryPolicy?.backoff ?? 1;
-	let attempts = 0;
-	const retryErrors = [];
-	for (;;) try {
-		return {
-			result: await dispatch(step, resolvedInputs, context, toolAdapter, llmAdapter),
-			retries: attempts > 0 ? {
-				attempts,
-				errors: retryErrors
-			} : void 0
-		};
-	} catch (err) {
-		if (!(err instanceof StepExecutionError && err.retriable && attempts < maxRetries)) {
-			if (attempts > 0 && err instanceof Error) err.__retries = {
-				attempts,
-				errors: retryErrors
-			};
-			throw err;
-		}
-		const errorMessage = err instanceof Error ? err.message : String(err);
-		retryErrors.push(errorMessage);
-		attempts++;
-		emit(onEvent, {
-			type: "step_retry",
-			stepId: step.id,
-			attempt: attempts,
-			error: errorMessage
-		});
-		await sleep(baseDelay * Math.pow(backoff, attempts - 1));
-	}
-}
-function handleStepError(step, err, context, startTime, resolvedInputs, retries, onEvent) {
-	let errorMessage = err instanceof Error ? err.message : String(err);
-	if (err instanceof StepExecutionError && err.context?.tool) errorMessage = `Tool "${err.context.tool}": ${errorMessage}`;
-	const effectiveRetries = retries ?? (err instanceof Error ? err.__retries : void 0);
-	const onError = step.on_error ?? "fail";
-	const durationMs = Math.round(performance.now() - startTime);
-	context.steps[step.id] = { output: null };
-	const record = {
-		id: step.id,
-		executor: step.type,
-		status: "failed",
-		duration_ms: durationMs,
-		inputs: resolvedInputs,
-		error: errorMessage,
-		retries: effectiveRetries
-	};
-	emit(onEvent, {
-		type: "step_error",
-		stepId: step.id,
-		error: errorMessage,
-		onError
-	});
-	emit(onEvent, {
-		type: "step_complete",
-		stepId: step.id,
-		status: "failed",
-		duration_ms: durationMs
-	});
-	if (onError === "ignore") return { records: [record] };
-	return {
-		records: [record],
-		failed: true
-	};
-}
-function resolveInputs(stepInputs, context, stepId) {
-	const resolved = {};
-	for (const [key, input] of Object.entries(stepInputs)) if (input.value !== void 0) try {
-		resolved[key] = resolveValue(input.value, context);
-	} catch (err) {
-		const expr = typeof input.value === "string" ? input.value : JSON.stringify(input.value);
-		throw new StepExecutionError(`${stepId ? `Step "${stepId}" input "${key}"` : `Input "${key}"`}: failed to resolve expression ${expr}: ${err instanceof Error ? err.message : String(err)}`, false, { expression: typeof input.value === "string" ? input.value : void 0 });
-	}
-	return resolved;
-}
-function applyDefaults(schema, provided) {
-	const result = { ...provided };
-	for (const [key, def] of Object.entries(schema)) if (!(key in result) && def.default !== void 0) result[key] = def.default;
-	return result;
-}
-function collectBranchStepIds(steps) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const step of steps) if (step.type === "conditional") {
-		for (const id of step.then) ids.add(id);
-		if (step.else) for (const id of step.else) ids.add(id);
-	}
-	return ids;
-}
-/**
-* Apply step output value mapping.
-* For each declared output with a `value` expression, resolve against the raw executor result.
-* Outputs without `value` pass through from raw output by key name (backwards compatible).
-*/
-function applyStepOutputMapping(stepOutputs, rawOutput, context) {
-	if (!Object.values(stepOutputs).some((o) => o.value !== void 0)) return rawOutput;
-	const tempContext = {
-		...context,
-		result: rawOutput
-	};
-	const mapped = {};
-	for (const [key, outputDef] of Object.entries(stepOutputs)) if (outputDef.value !== void 0) mapped[key] = resolveValue(outputDef.value, tempContext);
-	else if (rawOutput !== null && typeof rawOutput === "object" && !Array.isArray(rawOutput)) mapped[key] = rawOutput[key] ?? null;
-	else mapped[key] = null;
-	return mapped;
-}
-function buildWorkflowOutputs(workflow, finalOutput, context, exitFired) {
-	const outputKeys = Object.keys(workflow.outputs);
-	if (outputKeys.length === 0) return {};
-	if (exitFired) {
-		if (finalOutput !== null && typeof finalOutput === "object" && !Array.isArray(finalOutput)) {
-			const outputObj = finalOutput;
-			const result = {};
-			for (const key of outputKeys) result[key] = outputObj[key] ?? null;
-			return result;
-		}
-		if (outputKeys.length === 1) return { [outputKeys[0]]: finalOutput };
-		return { [outputKeys[0]]: finalOutput };
-	}
-	if (Object.values(workflow.outputs).some((o) => o.value !== void 0)) {
-		const result = {};
-		for (const [key, outputDef] of Object.entries(workflow.outputs)) if (outputDef.value !== void 0) result[key] = resolveValue(outputDef.value, context);
-		else if (finalOutput !== null && typeof finalOutput === "object" && !Array.isArray(finalOutput)) result[key] = finalOutput[key] ?? null;
-		else result[key] = null;
-		return result;
-	}
-	if (finalOutput !== null && typeof finalOutput === "object" && !Array.isArray(finalOutput)) {
-		const outputObj = finalOutput;
-		const result = {};
-		for (const key of outputKeys) result[key] = outputObj[key] ?? null;
-		return result;
-	}
-	if (outputKeys.length === 1) return { [outputKeys[0]]: finalOutput };
-	return { [outputKeys[0]]: finalOutput };
-}
-function parseDelay(delay) {
-	const match = delay.match(/^(\d+)(ms|s)$/);
-	if (!match) return 0;
-	const value = parseInt(match[1], 10);
-	return match[2] === "s" ? value * 1e3 : value;
-}
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-//#endregion
-export { parseSkillMd as C, ParseError as S, parseWorkflowYaml as T, interpolatePrompt as _, dispatch as a, ParseExprError as b, StepExecutionError as c, executeTransform as d, loadConfig as f, validateWorkflowSkill as g, validateWorkflow as h, runWorkflowSkill as i, executeExit as l, AnthropicLLMAdapter as m, buildFailedRunLog as n, executeLLM as o, BuiltinToolAdapter as p, runWorkflow as r, executeTool as s, WorkflowExecutionError as t, executeConditional as u, resolveExpression as v, parseWorkflowFromMd as w, LexError as x, EvalError as y };
-//# sourceMappingURL=runtime-CD81H1bx.mjs.map