@aigne/ash 0.0.1

package/dist/template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.mjs","names":[],"sources":["../src/template.ts"],"sourcesContent":["/**\n * ASH Template Parameter Resolution\n *\n * Resolves ${field} references in action parameters and paths\n * against the current stream record.\n */\n\nconst MAX_RESOLVED_SIZE = 65536; // 64KB\n\n// Match ${identifier.path} but not \\${...}\nconst TEMPLATE_RE = /(?<!\\\\)\\$\\{([^}]+)\\}/g;\n// Match whole-value template: entire string is a single ${field}\nconst WHOLE_VALUE_RE = /^\\$\\{([^}]+)\\}$/;\n\n/**\n * Access a nested value via dot-separated path.\n * Supports object fields and array indices (numeric keys).\n *\n * getNestedValue({data: {id: 42}}, \"data.id\") → 42\n * getNestedValue({items: [{name: \"a\"}]}, \"items.0.name\") → \"a\"\n */\nexport function getNestedValue(obj: unknown, path: string): unknown {\n  const keys = path.split(\".\");\n  let current: unknown = obj;\n  for (const key of keys) {\n    if (current === null || current === undefined) return undefined;\n    if (typeof current !== \"object\") return undefined;\n    current = (current as Record<string, unknown>)[key];\n  }\n  return current;\n}\n\n/**\n * Resolve a single template value against a stream record.\n *\n * - Non-string values pass through unchanged\n * - Whole-value \"${field}\" preserves the field's type\n * - Mixed \"text ${field}\" stringifies substitutions (JSON.stringify for objects)\n * - Escaped \\${...} produces literal ${...}\n * - Missing fields resolve to \"\"\n * - Resolved strings > 64KB throw\n */\nexport function resolveTemplate(value: unknown, record: Record<string, unknown>): unknown {\n  if (typeof value !== \"string\") return value;\n\n  // Whole-value: single ${field} with nothing else → preserve type\n  const wholeMatch = value.match(WHOLE_VALUE_RE);\n  if (wholeMatch) {\n    const resolved = getNestedValue(record, wholeMatch[1]);\n    if (resolved === undefined || resolved === null) return \"\";\n    // Size check for string values\n    if (typeof resolved === \"string\" && resolved.length > MAX_RESOLVED_SIZE) {\n      throw new Error(\n        `Template resolution error: resolved value exceeds 64KB limit (${resolved.length} bytes)`,\n      );\n    }\n    return resolved;\n  }\n\n  // Mixed template: replace ${...} with stringified values\n  const result = value.replace(TEMPLATE_RE, (_, field: string) => {\n    const val = getNestedValue(record, field);\n    if (val === undefined || val === null) return \"\";\n    if (typeof val === \"object\") return JSON.stringify(val);\n    return String(val);\n  });\n\n  // Strip escape: \\${ → ${\n  const final = result.replace(/\\\\\\$/g, \"$\");\n\n  // Size check\n  if (final.length > MAX_RESOLVED_SIZE) {\n    throw new Error(\n      `Template resolution error: resolved value exceeds 64KB limit (${final.length} bytes)`,\n    );\n  }\n\n  return final;\n}\n\n/**\n * Resolve all template references in an action's parameters.\n */\nexport function resolveActionParams(\n  params: Record<string, unknown>,\n  record: Record<string, unknown>,\n): Record<string, unknown> {\n  const resolved: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(params)) {\n    resolved[key] = resolveTemplate(value, record);\n  }\n  return resolved;\n}\n\n/**\n * Resolve template references in a path string.\n * Always returns a string. Validates the resolved path:\n * - No empty segments (//)\n * - No path traversal (..)\n */\nexport function resolveTemplatePath(\n  path: string,\n  record: Record<string, unknown>,\n): string {\n  if (!path.includes(\"${\")) return path;\n\n  const resolved = path.replace(TEMPLATE_RE, (_, field: string) => {\n    const val = getNestedValue(record, field);\n    if (val === undefined || val === null) return \"\";\n    return String(val);\n  });\n\n  // Strip escape: \\${ → ${\n  const final = resolved.replace(/\\\\\\$/g, \"$\");\n\n  // Validate resolved path\n  if (final.includes(\"//\")) {\n    throw new Error(\n      `Template path resolution error: resolved path '${final}' contains empty segment (//). Check that template fields are not empty.`,\n    );\n  }\n  if (final.split(\"/\").some((seg) => seg === \"..\")) {\n    throw new Error(\n      `Template path resolution error: resolved path '${final}' contains path traversal (..)`,\n    );\n  }\n\n  return final;\n}\n\n/**\n * Check if a value contains any unescaped ${...} template references.\n */\nexport function hasTemplates(value: unknown): boolean {\n  if (typeof value !== \"string\") return false;\n  // Reset regex lastIndex since it's global\n  TEMPLATE_RE.lastIndex = 0;\n  return TEMPLATE_RE.test(value);\n}\n"],"mappings":";;;;;;;AAOA,MAAM,oBAAoB;AAG1B,MAAM,cAAc;AAEpB,MAAM,iBAAiB;;;;;;;;AASvB,SAAgB,eAAe,KAAc,MAAuB;CAClE,MAAM,OAAO,KAAK,MAAM,IAAI;CAC5B,IAAI,UAAmB;AACvB,MAAK,MAAM,OAAO,MAAM;AACtB,MAAI,YAAY,QAAQ,YAAY,OAAW,QAAO;AACtD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,YAAW,QAAoC;;AAEjD,QAAO;;;;;;;;;;;;AAaT,SAAgB,gBAAgB,OAAgB,QAA0C;AACxF,KAAI,OAAO,UAAU,SAAU,QAAO;CAGtC,MAAM,aAAa,MAAM,MAAM,eAAe;AAC9C,KAAI,YAAY;EACd,MAAM,WAAW,eAAe,QAAQ,WAAW,GAAG;AACtD,MAAI,aAAa,UAAa,aAAa,KAAM,QAAO;AAExD,MAAI,OAAO,aAAa,YAAY,SAAS,SAAS,kBACpD,OAAM,IAAI,MACR,iEAAiE,SAAS,OAAO,SAClF;AAEH,SAAO;;CAYT,MAAM,QARS,MAAM,QAAQ,cAAc,GAAG,UAAkB;EAC9D,MAAM,MAAM,eAAe,QAAQ,MAAM;AACzC,MAAI,QAAQ,UAAa,QAAQ,KAAM,QAAO;AAC9C,MAAI,OAAO,QAAQ,SAAU,QAAO,KAAK,UAAU,IAAI;AACvD,SAAO,OAAO,IAAI;GAClB,CAGmB,QAAQ,SAAS,IAAI;AAG1C,KAAI,MAAM,SAAS,kBACjB,OAAM,IAAI,MACR,iEAAiE,MAAM,OAAO,SAC/E;AAGH,QAAO;;;;;AAMT,SAAgB,oBACd,QACA,QACyB;CACzB,MAAM,WAAoC,EAAE;AAC5C,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAC/C,UAAS,OAAO,gBAAgB,OAAO,OAAO;AAEhD,QAAO;;;;;;;;AAST,SAAgB,oBACd,MACA,QACQ;AACR,KAAI,CAAC,KAAK,SAAS,KAAK,CAAE,QAAO;CASjC,MAAM,QAPW,KAAK,QAAQ,cAAc,GAAG,UAAkB;EAC/D,MAAM,MAAM,eAAe,QAAQ,MAAM;AACzC,MAAI,QAAQ,UAAa,QAAQ,KAAM,QAAO;AAC9C,SAAO,OAAO,IAAI;GAClB,CAGqB,QAAQ,SAAS,IAAI;AAG5C,KAAI,MAAM,SAAS,KAAK,CACtB,OAAM,IAAI,MACR,kDAAkD,MAAM,0EACzD;AAEH,KAAI,MAAM,MAAM,IAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,CAC9C,OAAM,IAAI,MACR,kDAAkD,MAAM,gCACzD;AAGH,QAAO"}

package/dist/type-checker.cjs

@@ -0,0 +1,582 @@
+
+//#region src/type-checker.ts
+const BUILTIN_MANIFESTS = {
+	find: {
+		name: "find",
+		stdin: "none",
+		stdout: "object_stream"
+	},
+	where: {
+		name: "where",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	map: {
+		name: "map",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	save: {
+		name: "save",
+		stdin: "object_stream",
+		stdout: "none"
+	},
+	publish: {
+		name: "publish",
+		stdin: "object_stream",
+		stdout: "none"
+	},
+	tee: {
+		name: "tee",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	fanout: {
+		name: "fanout",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	output: {
+		name: "output",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	input: {
+		name: "input",
+		stdin: "none",
+		stdout: "object_stream"
+	},
+	count: {
+		name: "count",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	"group-by": {
+		name: "group-by",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	action: {
+		name: "action",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	},
+	route: {
+		name: "route",
+		stdin: "object_stream",
+		stdout: "none"
+	},
+	lookup: {
+		name: "lookup",
+		stdin: "object_stream",
+		stdout: "object_stream"
+	}
+};
+function checkPipelineTypes(stages) {
+	const errors = [];
+	if (stages.length <= 1) return errors;
+	for (let i = 1; i < stages.length; i++) {
+		const prev = stages[i - 1];
+		const curr = stages[i];
+		const prevManifest = BUILTIN_MANIFESTS[prev.kind];
+		const currManifest = BUILTIN_MANIFESTS[curr.kind];
+		if (!prevManifest || !currManifest) {
+			errors.push({
+				message: `Unknown command at stage ${i}`,
+				stage: i,
+				kind: "unknown_command"
+			});
+			continue;
+		}
+		if (prevManifest.stdout === "none" && currManifest.stdin === "object_stream") errors.push({
+			message: `Type mismatch at stage ${i}: ${prev.kind} outputs 'none' but ${curr.kind} expects 'object_stream'`,
+			stage: i,
+			expected: currManifest.stdin,
+			actual: prevManifest.stdout
+		});
+	}
+	return errors;
+}
+function checkProhibitedPatterns(program) {
+	const errors = [];
+	const jobNames = new Set(program.jobs.map((j) => j.name));
+	const seenJobs = /* @__PURE__ */ new Set();
+	for (const job of program.jobs) {
+		if (seenJobs.has(job.name)) errors.push({
+			message: `Duplicate job name '${job.name}' — each job must have a unique name`,
+			kind: "prohibited"
+		});
+		if (job.name.length > 64) errors.push({
+			message: `Job name '${job.name.slice(0, 20)}...' exceeds 64 characters — keep job names concise`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+		seenJobs.add(job.name);
+	}
+	if (program.jobs.length > 50) errors.push({
+		message: `Program has ${program.jobs.length} jobs — programs with over 50 jobs may indicate over-complexity`,
+		kind: "prohibited",
+		severity: "warning"
+	});
+	for (const job of program.jobs) {
+		if (job.pipeline.length === 0) errors.push({
+			message: `Job '${job.name}' has empty pipeline — did you forget to add stages?`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+		if (job.pipeline.length > 30) errors.push({
+			message: `Job '${job.name}' has ${job.pipeline.length} stages — pipelines over 30 stages may indicate over-complexity`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+		for (const stage of job.pipeline) {
+			if (!Object.hasOwn(BUILTIN_MANIFESTS, stage.kind)) errors.push({
+				message: `Unknown command '${stage.kind}' — not registered in manifest`,
+				kind: "unknown_command"
+			});
+			if ("path" in stage && typeof stage.path === "string") {
+				const path = stage.path;
+				if (path.includes("..")) errors.push({
+					message: `Path '${path}' contains '..' — path traversal is not allowed`,
+					kind: "prohibited"
+				});
+				if (path.replace(/\$\{[a-zA-Z_][a-zA-Z0-9_.]*\}/g, "").includes("$")) errors.push({
+					message: `Path '${path}' contains '$' — variable interpolation in paths is not allowed`,
+					kind: "prohibited",
+					severity: "warning"
+				});
+			}
+			checkExpressionDivZero(stage, errors);
+			if (stage.kind === "route") {
+				for (const branch of stage.branches) if (!jobNames.has(branch.targetJob)) errors.push({
+					message: `Route target job '${branch.targetJob}' not found in program`,
+					kind: "prohibited"
+				});
+				if (stage.fallback && !jobNames.has(stage.fallback)) errors.push({
+					message: `Route fallback job '${stage.fallback}' not found in program`,
+					kind: "prohibited"
+				});
+				if (!stage.fallback) errors.push({
+					message: `Job '${job.name}': route has no default branch — unmatched items are silently dropped, add '_ -> fallback_job' to handle unexpected values`,
+					kind: "prohibited",
+					severity: "warning"
+				});
+			}
+		}
+	}
+	for (const job of program.jobs) {
+		checkFanoutDepth(job.pipeline, 0, errors);
+		checkFanoutDuplicateWrites(job, errors);
+	}
+	for (const job of program.jobs) {
+		const teeCount = job.pipeline.filter((s) => s.kind === "tee").length;
+		if (teeCount > 5) errors.push({
+			message: `Job '${job.name}' has ${teeCount} tee stages — more than 5 tee stages risks data amplification`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+	}
+	checkRouteDag(program, errors);
+	for (const job of program.jobs) if (job.trigger) {
+		if (job.trigger.kind === "event") {
+			if (!job.trigger.path || !job.trigger.event) errors.push({
+				message: `Job '${job.name}' has incomplete trigger declaration`,
+				kind: "prohibited"
+			});
+		} else if (job.trigger.kind === "cron") if (!job.trigger.expression) errors.push({
+			message: `Job '${job.name}' has empty cron expression`,
+			kind: "prohibited"
+		});
+		else {
+			const fields = job.trigger.expression.trim().split(/\s+/);
+			if (fields.length < 5 || fields.length > 7) errors.push({
+				message: `Job '${job.name}' has invalid cron expression "${job.trigger.expression}" — expected 5-7 fields, got ${fields.length}`,
+				kind: "prohibited"
+			});
+		}
+	}
+	for (const job of program.jobs) if (job.trigger?.kind === "event") {
+		const triggerPath = job.trigger.path;
+		for (const stage of job.pipeline) if ((stage.kind === "save" || stage.kind === "tee") && stage.path === triggerPath) errors.push({
+			message: `Job '${job.name}' writes to its own trigger path '${triggerPath}' — this creates an event loop`,
+			kind: "prohibited"
+		});
+	}
+	const SELF_EXEC_BLOCKED = new Set(["/.actions/run", "/.actions/exec"]);
+	for (const job of program.jobs) for (const stage of job.pipeline) if (stage.kind === "action" && SELF_EXEC_BLOCKED.has(stage.path)) errors.push({
+		message: `Job '${job.name}' calls action '${stage.path}' — self-referencing ASH execution risks recursion and bypasses compile-time checks`,
+		kind: "prohibited"
+	});
+	const PROTO_POLLUTION_FIELDS = new Set([
+		"constructor",
+		"__proto__",
+		"prototype",
+		"__defineGetter__",
+		"__defineSetter__"
+	]);
+	const JS_RESERVED_FIELDS = new Set([
+		...PROTO_POLLUTION_FIELDS,
+		"toString",
+		"valueOf",
+		"hasOwnProperty",
+		"class",
+		"return",
+		"delete",
+		"void",
+		"typeof",
+		"new"
+	]);
+	for (const job of program.jobs) for (const stage of job.pipeline) {
+		const protoFields = [];
+		const jsFields = [];
+		if (stage.kind === "map") {
+			if (stage.field) classifyField(stage.field, PROTO_POLLUTION_FIELDS, JS_RESERVED_FIELDS, protoFields, jsFields);
+			if (stage.expression) collectJsReservedFields(stage.expression, JS_RESERVED_FIELDS, jsFields);
+			if (stage.exprMappings) {
+				for (const key of Object.keys(stage.exprMappings)) classifyField(key, PROTO_POLLUTION_FIELDS, JS_RESERVED_FIELDS, protoFields, jsFields);
+				for (const expr of Object.values(stage.exprMappings)) collectJsReservedFields(expr, JS_RESERVED_FIELDS, jsFields);
+			}
+			if (stage.mappings) for (const key of Object.keys(stage.mappings)) classifyField(key, PROTO_POLLUTION_FIELDS, JS_RESERVED_FIELDS, protoFields, jsFields);
+			if (stage.exprMappings) checkMapDuplicateKeys(stage.exprMappings, job.name, errors);
+			if (stage.mappings) checkMapDuplicateKeys(stage.mappings, job.name, errors);
+		}
+		if (stage.kind === "where" && JS_RESERVED_FIELDS.has(stage.left)) classifyField(stage.left, PROTO_POLLUTION_FIELDS, JS_RESERVED_FIELDS, protoFields, jsFields);
+		for (const field of protoFields) errors.push({
+			message: `Job '${job.name}': field '${field}' is a prototype pollution vector — not allowed as map key or field name`,
+			kind: "prohibited"
+		});
+		for (const field of jsFields) errors.push({
+			message: `Job '${job.name}': field '${field}' is a JavaScript reserved identifier — may expose runtime internals`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+	}
+	for (const job of program.jobs) for (const stage of job.pipeline) if (stage.kind === "map") {
+		if (stage.expression) checkDivisionRisk(stage.expression, job.name, errors);
+		if (stage.exprMappings) for (const expr of Object.values(stage.exprMappings)) checkDivisionRisk(expr, job.name, errors);
+	}
+	return errors;
+}
+function checkDivisionRisk(expr, jobName, errors) {
+	if (expr.kind === "binary" && expr.op === "/") {
+		if (expr.right.kind === "field_access") errors.push({
+			message: `Job '${jobName}': division by field '${expr.right.path}' may produce NaN/Infinity if zero — consider adding a where clause to filter`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+	}
+	if (expr.kind === "binary") {
+		checkDivisionRisk(expr.left, jobName, errors);
+		checkDivisionRisk(expr.right, jobName, errors);
+	}
+}
+function collectJsReservedFields(expr, reserved, out) {
+	if (expr.kind === "field_access" && reserved.has(expr.path)) out.push(expr.path);
+	if (expr.kind === "binary") {
+		collectJsReservedFields(expr.left, reserved, out);
+		collectJsReservedFields(expr.right, reserved, out);
+	}
+}
+function classifyField(field, proto, jsReserved, protoOut, jsOut) {
+	if (proto.has(field)) protoOut.push(field);
+	else if (jsReserved.has(field)) jsOut.push(field);
+}
+function checkMapDuplicateKeys(obj, jobName, errors) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(obj)) {
+		if (seen.has(key)) errors.push({
+			message: `Job '${jobName}': map has duplicate key '${key}' — last value wins silently, potential data confusion`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+		seen.add(key);
+	}
+}
+function checkFanoutDepth(stages, depth, errors) {
+	for (const stage of stages) if (stage.kind === "fanout") {
+		if (stage.branches.length > 10) errors.push({
+			message: `Fanout has ${stage.branches.length} branches — more than 10 branches may cause excessive parallelism`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+		if (depth + 1 > 3) {
+			errors.push({
+				message: `Fanout nesting depth exceeds 3 levels — deeply nested fanout may indicate over-complexity`,
+				kind: "prohibited",
+				severity: "warning"
+			});
+			return;
+		}
+		for (const branch of stage.branches) checkFanoutDepth(branch, depth + 1, errors);
+	}
+}
+function checkFanoutDuplicateWrites(job, errors) {
+	for (const stage of job.pipeline) {
+		if (stage.kind !== "fanout") continue;
+		const writePaths = /* @__PURE__ */ new Map();
+		for (const branch of stage.branches) for (const s of branch) if ((s.kind === "save" || s.kind === "tee") && "path" in s) {
+			const path = s.path;
+			writePaths.set(path, (writePaths.get(path) ?? 0) + 1);
+		}
+		for (const [path, count] of writePaths) if (count > 1) errors.push({
+			message: `Job '${job.name}': fanout has ${count} branches writing to '${path}' — last write wins silently, audit trail lost`,
+			kind: "prohibited",
+			severity: "warning"
+		});
+	}
+}
+function checkExpressionDivZero(stage, errors) {
+	if (stage.kind !== "map") return;
+	if (stage.exprMappings) {
+		for (const expr of Object.values(stage.exprMappings)) if (hasLiteralDivByZero(expr)) errors.push({
+			message: "Expression contains literal division by zero",
+			kind: "prohibited",
+			severity: "warning"
+		});
+	}
+	if (stage.expression && hasLiteralDivByZero(stage.expression)) errors.push({
+		message: "Expression contains literal division by zero",
+		kind: "prohibited",
+		severity: "warning"
+	});
+}
+function hasLiteralDivByZero(expr) {
+	if (expr.kind === "binary" && expr.op === "/" && expr.right.kind === "literal" && expr.right.value === 0) return true;
+	if (expr.kind === "binary") return hasLiteralDivByZero(expr.left) || hasLiteralDivByZero(expr.right);
+	return false;
+}
+function checkRouteDag(program, errors) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const job of program.jobs) {
+		const targets = /* @__PURE__ */ new Set();
+		for (const stage of job.pipeline) if (stage.kind === "route") {
+			for (const branch of stage.branches) targets.add(branch.targetJob);
+			if (stage.fallback) targets.add(stage.fallback);
+		}
+		if (targets.size > 0) graph.set(job.name, targets);
+	}
+	const visited = /* @__PURE__ */ new Set();
+	const inStack = /* @__PURE__ */ new Set();
+	function dfs(node) {
+		if (inStack.has(node)) return true;
+		if (visited.has(node)) return false;
+		visited.add(node);
+		inStack.add(node);
+		const neighbors = graph.get(node);
+		if (neighbors) {
+			for (const n of neighbors) if (dfs(n)) {
+				errors.push({
+					message: `Route cycle detected: job '${node}' → job '${n}' forms a cycle`,
+					kind: "prohibited"
+				});
+				return true;
+			}
+		}
+		inStack.delete(node);
+		return false;
+	}
+	for (const node of graph.keys()) dfs(node);
+}
+const ANNOTATION_VALIDATORS = {
+	approval: (args) => {
+		if (args.length === 0) return null;
+		if (!new Set(["human", "auto"]).has(args[0])) return `@approval accepts 'human' or 'auto', got '${args[0]}'`;
+		return null;
+	},
+	readonly: () => null,
+	retry: (args) => {
+		if (args.length === 0) return null;
+		const n = Number(args[0]);
+		if (isNaN(n) || !Number.isInteger(n) || n < 0) return `@retry requires a non-negative integer, got '${args[0]}'`;
+		return null;
+	},
+	timeout: (args) => {
+		if (args.length === 0) return null;
+		const n = Number(args[0]);
+		if (isNaN(n) || n <= 0) return `@timeout requires a positive number, got '${args[0]}'`;
+		if (n > 36e5) return `@timeout(${args[0]}) exceeds hard limit of 3600000ms (1 hour) — reduce timeout`;
+		return null;
+	},
+	on_error: (args) => {
+		if (args.length === 0) return `@on_error requires a strategy: skip, fail, or save <path>`;
+		if (!new Set([
+			"skip",
+			"fail",
+			"save"
+		]).has(args[0])) return `@on_error accepts 'skip', 'fail', or 'save', got '${args[0]}'`;
+		return null;
+	},
+	budget: (args) => {
+		if (args.length === 0) return `@budget requires at least one limit: @budget(actions 50, records 10000)`;
+		if (args.length % 2 !== 0) return `@budget requires dimension/value pairs — got odd number of args`;
+		const validDims = new Set([
+			"actions",
+			"writes",
+			"records",
+			"tokens",
+			"cost"
+		]);
+		for (let i = 0; i < args.length; i += 2) {
+			if (!validDims.has(args[i])) return `@budget dimension must be one of: ${[...validDims].join(", ")} — got '${args[i]}'`;
+			const n = Number(args[i + 1]);
+			if (isNaN(n) || n <= 0) return `@budget value must be a positive number, got '${args[i + 1]}'`;
+		}
+		return null;
+	},
+	caps: (args) => {
+		if (args.length === 0) return `@caps requires at least one capability: @caps(read /path/*, write /out/*)`;
+		if (args.length % 2 !== 0) return `@caps requires operation/path pairs — got odd number of args`;
+		const validOps = new Set([
+			"read",
+			"write",
+			"exec"
+		]);
+		for (let i = 0; i < args.length; i += 2) {
+			if (!validOps.has(args[i])) return `@caps operation must be 'read', 'write', or 'exec', got '${args[i]}'`;
+			if (!args[i + 1].startsWith("/")) return `@caps path must start with '/', got '${args[i + 1]}'`;
+		}
+		return null;
+	}
+};
+const BUILTIN_COMMAND_NAMES = Object.keys(BUILTIN_MANIFESTS);
+function typeErrorsToDiagnostics(errors) {
+	return errors.map((e) => ({
+		code: "ASH_TYPE_MISMATCH",
+		message: e.message,
+		stage: e.stage
+	}));
+}
+function compileErrorsToDiagnostics(errors) {
+	return errors.map((e) => ({
+		code: e.kind === "unknown_command" ? "ASH_UNKNOWN_COMMAND" : "ASH_ANNOTATION_INVALID",
+		severity: e.severity,
+		message: e.message,
+		suggestion: e.kind === "unknown_command" ? BUILTIN_COMMAND_NAMES : void 0
+	}));
+}
+function annotationErrorsToDiagnostics(errors) {
+	return errors.map((e) => ({
+		code: "ASH_ANNOTATION_INVALID",
+		severity: e.severity,
+		message: e.message
+	}));
+}
+function parseSyntaxError(errorMessage) {
+	const isUnterminated = /unterminated/i.test(errorMessage);
+	const isDuplicate = /duplicate variable/i.test(errorMessage);
+	const lineMatch = errorMessage.match(/line\s+(\d+)/i);
+	const colMatch = errorMessage.match(/column\s+(\d+)/i);
+	const cleanMsg = errorMessage.replace(/^Error:\s*/i, "");
+	return {
+		code: isDuplicate ? "ASH_DUPLICATE_VAR" : isUnterminated ? "ASH_SYNTAX_UNTERMINATED" : "ASH_SYNTAX_UNEXPECTED",
+		message: cleanMsg,
+		line: lineMatch ? Number(lineMatch[1]) : void 0,
+		column: colMatch ? Number(colMatch[1]) : void 0
+	};
+}
+function checkAnnotations(job) {
+	const errors = [];
+	for (const ann of job.annotations) {
+		const validator = Object.hasOwn(ANNOTATION_VALIDATORS, ann.name) ? ANNOTATION_VALIDATORS[ann.name] : void 0;
+		if (!validator) {
+			errors.push({
+				message: `Unknown annotation '@${ann.name}' — not in allowed set`,
+				kind: "prohibited"
+			});
+			continue;
+		}
+		const err = validator(ann.args);
+		if (err) errors.push({
+			message: err,
+			kind: "prohibited"
+		});
+	}
+	const annCounts = /* @__PURE__ */ new Map();
+	for (const ann of job.annotations) annCounts.set(ann.name, (annCounts.get(ann.name) ?? 0) + 1);
+	for (const [name, count] of annCounts) if (count > 1) errors.push({
+		message: `Job '${job.name}': @${name} appears ${count} times — last value wins silently, potential audit deception`,
+		kind: "prohibited"
+	});
+	const retryAnns = job.annotations.filter((a) => a.name === "retry");
+	for (const ann of retryAnns) if (ann.args.length > 0) {
+		const n = Number(ann.args[0]);
+		if (!isNaN(n) && n > 100) errors.push({
+			message: `@retry(${n}) exceeds hard limit of 100 — reduce retry count`,
+			kind: "prohibited"
+		});
+	}
+	const approvalAnns = job.annotations.filter((a) => a.name === "approval");
+	if (approvalAnns.length > 1) {
+		const values = approvalAnns.map((a) => a.args[0]).filter(Boolean);
+		if (values.includes("human") && values.includes("auto")) errors.push({
+			message: `@approval conflict: 'human' and 'auto' cannot both be set on job '${job.name}'`,
+			kind: "prohibited"
+		});
+	}
+	return errors;
+}
+function parseCaps(ann) {
+	const caps = [];
+	for (let i = 0; i < ann.args.length; i += 2) caps.push({
+		op: ann.args[i],
+		pathGlob: ann.args[i + 1]
+	});
+	return caps;
+}
+function capMatches(pathGlob, actual) {
+	if (pathGlob === actual) return true;
+	if (pathGlob.endsWith("/*")) {
+		const prefix = pathGlob.slice(0, -1);
+		return actual.startsWith(prefix) || actual === pathGlob.slice(0, -2);
+	}
+	if (pathGlob.endsWith("*")) return actual.startsWith(pathGlob.slice(0, -1));
+	return false;
+}
+function hasCapFor(caps, op, path) {
+	return caps.some((c) => c.op === op && capMatches(c.pathGlob, path));
+}
+const STAGE_OP_MAP = {
+	find: "read",
+	lookup: "read",
+	save: "write",
+	publish: "write",
+	tee: "write",
+	action: "exec"
+};
+function checkStagesCaps(stages, caps, diagnostics) {
+	for (const stage of stages) {
+		if (stage.kind === "action" && stage.relative) continue;
+		if ("path" in stage && typeof stage.path === "string" && stage.path.includes("${")) continue;
+		const op = Object.hasOwn(STAGE_OP_MAP, stage.kind) ? STAGE_OP_MAP[stage.kind] : void 0;
+		if (op && "path" in stage && typeof stage.path === "string") {
+			const path = stage.path;
+			if (!hasCapFor(caps, op, path)) diagnostics.push({
+				code: "ASH_CAP_DENIED",
+				message: `@caps denied: '${stage.kind} ${path}' requires '${op}' capability for '${path}'`
+			});
+		}
+		if (stage.kind === "fanout") for (const branch of stage.branches) checkStagesCaps(branch, caps, diagnostics);
+	}
+}
+function checkJobCaps(job) {
+	const capsAnns = job.annotations.filter((a) => a.name === "caps");
+	if (capsAnns.length === 0) return [];
+	const diagnostics = [];
+	const allCaps = [];
+	for (const ann of capsAnns) if (ann.args.length > 0 && ann.args.length % 2 === 0) allCaps.push(...parseCaps(ann));
+	if (allCaps.length === 0) return diagnostics;
+	checkStagesCaps(job.pipeline, allCaps, diagnostics);
+	return diagnostics;
+}
+
+//#endregion
+exports.annotationErrorsToDiagnostics = annotationErrorsToDiagnostics;
+exports.checkAnnotations = checkAnnotations;
+exports.checkJobCaps = checkJobCaps;
+exports.checkPipelineTypes = checkPipelineTypes;
+exports.checkProhibitedPatterns = checkProhibitedPatterns;
+exports.compileErrorsToDiagnostics = compileErrorsToDiagnostics;
+exports.hasCapFor = hasCapFor;
+exports.parseCaps = parseCaps;
+exports.parseSyntaxError = parseSyntaxError;
+exports.typeErrorsToDiagnostics = typeErrorsToDiagnostics;

package/dist/type-checker.d.cts

@@ -0,0 +1,31 @@
+import { JobDeclaration, PipelineStage, Program } from "./ast.cjs";
+
+//#region src/type-checker.d.ts
+type DiagnosticCode = "ASH_SYNTAX_UNTERMINATED" | "ASH_SYNTAX_UNEXPECTED" | "ASH_UNKNOWN_COMMAND" | "ASH_TYPE_MISMATCH" | "ASH_UNDEFINED_VAR" | "ASH_DUPLICATE_VAR" | "ASH_DUPLICATE_JOB" | "ASH_ANNOTATION_INVALID" | "ASH_ANNOTATION_CONFLICT" | "ASH_READONLY_VIOLATION" | "ASH_CAP_DENIED" | "ASH_PATH_TRAVERSAL" | "ASH_EMPTY_JOB" | "ASH_DIV_ZERO" | "ASH_EXCESSIVE_RETRY" | "ASH_EVENT_LOOP" | "ASH_SELF_RECURSION" | "ASH_DIVISION_RISK" | "ASH_MIXED_SECURITY" | "ASH_JS_GLOBAL_FIELD" | "ASH_LET_WRITE" | "ASH_LET_PRE_APPROVAL" | "ASH_PARAM_WRITE_GATE" | "ASH_UNCAPPED_ACTION" | "ASH_ACTION_AMPLIFICATION" | "ASH_CROSS_PROVIDER_ACTION" | "ASH_RELATIVE_ACTION_NO_FIND" | "ASH_UNCAPPED_WRITE" | "ASH_BUDGET_EXCESSIVE";
+interface AshDiagnostic {
+  code: DiagnosticCode;
+  severity?: "error" | "warning";
+  message: string;
+  line?: number;
+  column?: number;
+  stage?: number;
+  suggestion?: string[];
+}
+type StreamType = "object_stream" | "single_object" | "none";
+interface TypeError {
+  message: string;
+  stage: number;
+  expected?: StreamType;
+  actual?: StreamType;
+}
+interface CompileError {
+  message: string;
+  kind: "prohibited" | "unknown_command";
+  severity?: "error" | "warning";
+}
+declare function checkPipelineTypes(stages: PipelineStage[]): TypeError[];
+declare function checkProhibitedPatterns(program: Program): CompileError[];
+declare function checkAnnotations(job: JobDeclaration): CompileError[];
+//#endregion
+export { AshDiagnostic, DiagnosticCode, checkAnnotations, checkPipelineTypes, checkProhibitedPatterns };
+//# sourceMappingURL=type-checker.d.cts.map

package/dist/type-checker.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checker.d.cts","names":[],"sources":["../src/type-checker.ts"],"mappings":";;;KAIY,cAAA;AAAA,UAgCK,aAAA;EACf,IAAA,EAAM,cAAA;EACN,QAAA;EACA,OAAA;EACA,IAAA;EACA,MAAA;EACA,KAAA;EACA,UAAA;AAAA;AAAA,KAGU,UAAA;AAAA,UAQK,SAAA;EACf,OAAA;EACA,KAAA;EACA,QAAA,GAAW,UAAA;EACX,MAAA,GAAS,UAAA;AAAA;AAAA,UAGM,YAAA;EACf,OAAA;EACA,IAAA;EACA,QAAA;AAAA;AAAA,iBAoBc,kBAAA,CAAmB,MAAA,EAAQ,aAAA,KAAkB,SAAA;AAAA,iBA4B7C,uBAAA,CAAwB,OAAA,EAAS,OAAA,GAAU,YAAA;AAAA,iBAwhB3C,gBAAA,CAAiB,GAAA,EAAK,cAAA,GAAiB,YAAA"}

package/dist/type-checker.d.mts

@@ -0,0 +1,31 @@
+import { JobDeclaration, PipelineStage, Program } from "./ast.mjs";
+
+//#region src/type-checker.d.ts
+type DiagnosticCode = "ASH_SYNTAX_UNTERMINATED" | "ASH_SYNTAX_UNEXPECTED" | "ASH_UNKNOWN_COMMAND" | "ASH_TYPE_MISMATCH" | "ASH_UNDEFINED_VAR" | "ASH_DUPLICATE_VAR" | "ASH_DUPLICATE_JOB" | "ASH_ANNOTATION_INVALID" | "ASH_ANNOTATION_CONFLICT" | "ASH_READONLY_VIOLATION" | "ASH_CAP_DENIED" | "ASH_PATH_TRAVERSAL" | "ASH_EMPTY_JOB" | "ASH_DIV_ZERO" | "ASH_EXCESSIVE_RETRY" | "ASH_EVENT_LOOP" | "ASH_SELF_RECURSION" | "ASH_DIVISION_RISK" | "ASH_MIXED_SECURITY" | "ASH_JS_GLOBAL_FIELD" | "ASH_LET_WRITE" | "ASH_LET_PRE_APPROVAL" | "ASH_PARAM_WRITE_GATE" | "ASH_UNCAPPED_ACTION" | "ASH_ACTION_AMPLIFICATION" | "ASH_CROSS_PROVIDER_ACTION" | "ASH_RELATIVE_ACTION_NO_FIND" | "ASH_UNCAPPED_WRITE" | "ASH_BUDGET_EXCESSIVE";
+interface AshDiagnostic {
+  code: DiagnosticCode;
+  severity?: "error" | "warning";
+  message: string;
+  line?: number;
+  column?: number;
+  stage?: number;
+  suggestion?: string[];
+}
+type StreamType = "object_stream" | "single_object" | "none";
+interface TypeError {
+  message: string;
+  stage: number;
+  expected?: StreamType;
+  actual?: StreamType;
+}
+interface CompileError {
+  message: string;
+  kind: "prohibited" | "unknown_command";
+  severity?: "error" | "warning";
+}
+declare function checkPipelineTypes(stages: PipelineStage[]): TypeError[];
+declare function checkProhibitedPatterns(program: Program): CompileError[];
+declare function checkAnnotations(job: JobDeclaration): CompileError[];
+//#endregion
+export { AshDiagnostic, DiagnosticCode, checkAnnotations, checkPipelineTypes, checkProhibitedPatterns };
+//# sourceMappingURL=type-checker.d.mts.map

package/dist/type-checker.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checker.d.mts","names":[],"sources":["../src/type-checker.ts"],"mappings":";;;KAIY,cAAA;AAAA,UAgCK,aAAA;EACf,IAAA,EAAM,cAAA;EACN,QAAA;EACA,OAAA;EACA,IAAA;EACA,MAAA;EACA,KAAA;EACA,UAAA;AAAA;AAAA,KAGU,UAAA;AAAA,UAQK,SAAA;EACf,OAAA;EACA,KAAA;EACA,QAAA,GAAW,UAAA;EACX,MAAA,GAAS,UAAA;AAAA;AAAA,UAGM,YAAA;EACf,OAAA;EACA,IAAA;EACA,QAAA;AAAA;AAAA,iBAoBc,kBAAA,CAAmB,MAAA,EAAQ,aAAA,KAAkB,SAAA;AAAA,iBA4B7C,uBAAA,CAAwB,OAAA,EAAS,OAAA,GAAU,YAAA;AAAA,iBAwhB3C,gBAAA,CAAiB,GAAA,EAAK,cAAA,GAAiB,YAAA"}