@aigne/ash 0.0.1

package/dist/parser.mjs

@@ -0,0 +1,734 @@
+//#region src/parser.ts
+/** Annotation names that are script-level: propagate to all jobs when declared before any statement. */
+const SCRIPT_LEVEL_ANNOTATIONS = new Set(["caps", "budget"]);
+/** Merge script-level annotations with job-specific ones. Job overrides script-level by name. */
+function mergeAnnotations(script, job) {
+	if (script.length === 0) return job;
+	if (job.length === 0) return [...script];
+	const jobNames = new Set(job.map((a) => a.name));
+	return [...script.filter((a) => !jobNames.has(a.name)), ...job];
+}
+var AshParser = class AshParser {
+	tokens = [];
+	pos = 0;
+	letNames = /* @__PURE__ */ new Set();
+	paramNames = /* @__PURE__ */ new Set();
+	static RESERVED_KEYWORDS = new Set([
+		"job",
+		"find",
+		"where",
+		"map",
+		"save",
+		"publish",
+		"tee",
+		"fanout",
+		"input",
+		"output",
+		"let",
+		"action",
+		"route",
+		"lookup",
+		"param",
+		"on"
+	]);
+	parse(tokens) {
+		this.tokens = tokens;
+		this.pos = 0;
+		this.letNames = /* @__PURE__ */ new Set();
+		this.paramNames = /* @__PURE__ */ new Set();
+		const statements = [];
+		this.skipNewlines();
+		const initialAnnotations = this.parseAnnotations();
+		const scriptAnnotations = initialAnnotations.filter((a) => SCRIPT_LEVEL_ANNOTATIONS.has(a.name));
+		const firstJobOnly = initialAnnotations.filter((a) => !SCRIPT_LEVEL_ANNOTATIONS.has(a.name));
+		let firstStatement = true;
+		while (!this.isAtEnd()) {
+			const jobAnnotations = this.parseAnnotations();
+			if (this.isAtEnd()) break;
+			const t = this.peek();
+			if (t.type === "JOB") {
+				const merged = mergeAnnotations(scriptAnnotations, firstStatement ? [...firstJobOnly, ...jobAnnotations] : jobAnnotations);
+				firstStatement = false;
+				statements.push(this.parseJob(merged));
+			} else if (t.type === "OUTPUT" && jobAnnotations.length === 0) {
+				firstStatement = false;
+				this.advance();
+				const msg = this.expect("STRING", "Expected string after 'output'");
+				statements.push({
+					kind: "output",
+					message: msg.value
+				});
+			} else if (t.type === "LET" && jobAnnotations.length === 0) {
+				firstStatement = false;
+				statements.push(this.parseLet());
+			} else if (t.type === "PARAM" && jobAnnotations.length === 0) {
+				firstStatement = false;
+				statements.push(this.parseParam());
+			} else throw new Error(`Expected 'job', 'output', 'let', or 'param' at top level, got ${t.type} at line ${t.line}, column ${t.column}`);
+			this.skipNewlines();
+		}
+		return {
+			statements,
+			jobs: statements.filter((s) => s.kind === "job")
+		};
+	}
+	parseParam() {
+		const paramToken = this.advance();
+		if (this.isAtEnd()) throw new Error(`Expected parameter name after 'param' at line ${paramToken.line}, column ${paramToken.column}`);
+		const nameToken = this.peek();
+		if (nameToken.type !== "IDENTIFIER") throw new Error(`Cannot use reserved keyword '${nameToken.value}' as param name at line ${nameToken.line}, column ${nameToken.column}`);
+		this.advance();
+		if (AshParser.RESERVED_KEYWORDS.has(nameToken.value)) throw new Error(`Cannot use reserved keyword '${nameToken.value}' as param name at line ${nameToken.line}, column ${nameToken.column}`);
+		if (this.paramNames.has(nameToken.value)) throw new Error(`Duplicate param name '${nameToken.value}' at line ${nameToken.line}, column ${nameToken.column}`);
+		if (this.letNames.has(nameToken.value)) throw new Error(`Param '${nameToken.value}' conflicts with existing let variable at line ${nameToken.line}, column ${nameToken.column}`);
+		this.expect("ASSIGN", "Expected '=' after param name");
+		const valToken = this.advance();
+		let defaultValue;
+		if (valToken.type === "NUMBER") defaultValue = parseFloat(valToken.value);
+		else if (valToken.type === "STRING") defaultValue = valToken.value;
+		else if (valToken.type === "PATH") defaultValue = valToken.value;
+		else if (valToken.type === "IDENTIFIER") defaultValue = valToken.value;
+		else throw new Error(`Expected default value after '=' at line ${valToken.line}, column ${valToken.column}`);
+		this.paramNames.add(nameToken.value);
+		return {
+			kind: "param",
+			name: nameToken.value,
+			defaultValue
+		};
+	}
+	static PIPELINE_STARTERS = new Set([
+		"FIND",
+		"ACTION",
+		"LOOKUP",
+		"INPUT"
+	]);
+	parseLet() {
+		const letToken = this.advance();
+		if (this.isAtEnd() || this.peek().type !== "IDENTIFIER") throw new Error(`Expected variable name after 'let' at line ${letToken.line}, column ${letToken.column}`);
+		const nameToken = this.advance();
+		if (AshParser.RESERVED_KEYWORDS.has(nameToken.value)) throw new Error(`Cannot use reserved keyword '${nameToken.value}' as variable name at line ${nameToken.line}, column ${nameToken.column}`);
+		if (this.letNames.has(nameToken.value)) throw new Error(`Duplicate variable name '${nameToken.value}' at line ${nameToken.line}, column ${nameToken.column}`);
+		if (this.paramNames.has(nameToken.value)) throw new Error(`Let variable '${nameToken.value}' conflicts with existing param at line ${nameToken.line}, column ${nameToken.column}`);
+		this.expect("ASSIGN", "Expected '=' after variable name");
+		if (!this.isAtEnd() && AshParser.PIPELINE_STARTERS.has(this.peek().type)) {
+			const pipeline = this.parseLetPipeline();
+			this.letNames.add(nameToken.value);
+			return {
+				kind: "let",
+				name: nameToken.value,
+				value: 0,
+				pipeline
+			};
+		}
+		const valToken = this.advance();
+		let value;
+		if (valToken.type === "NUMBER") value = parseFloat(valToken.value);
+		else if (valToken.type === "STRING") value = valToken.value;
+		else if (valToken.type === "IDENTIFIER") value = valToken.value;
+		else throw new Error(`Expected value after '=' at line ${valToken.line}, column ${valToken.column}`);
+		this.letNames.add(nameToken.value);
+		return {
+			kind: "let",
+			name: nameToken.value,
+			value
+		};
+	}
+	parseLetPipeline() {
+		const stages = [];
+		while (!this.isAtEnd()) {
+			const t = this.peek();
+			if (t.type === "NEWLINE" || t.type === "JOB" || t.type === "LET" || t.type === "OUTPUT" || t.type === "AT") break;
+			if (t.type === "PIPE") {
+				this.advance();
+				continue;
+			}
+			stages.push(this.parseStage());
+		}
+		return stages;
+	}
+	parseAnnotations() {
+		const annotations = [];
+		while (!this.isAtEnd() && this.peek().type === "AT") {
+			const at = this.advance();
+			if (this.isAtEnd() || this.peek().type !== "IDENTIFIER") throw new Error(`Expected annotation name after '@' at line ${at.line}, column ${at.column}`);
+			const nameToken = this.advance();
+			const args = [];
+			if (!this.isAtEnd() && this.peek().type === "LPAREN") {
+				this.advance();
+				while (!this.isAtEnd() && this.peek().type !== "RPAREN") {
+					const arg = this.advance();
+					args.push(arg.value);
+					if (!this.isAtEnd() && this.peek().type === "COMMA") this.advance();
+				}
+				if (this.isAtEnd()) throw new Error(`Unclosed annotation parenthesis at line ${at.line}, column ${at.column}`);
+				this.advance();
+			}
+			annotations.push({
+				name: nameToken.value,
+				args,
+				line: at.line,
+				column: at.column
+			});
+			this.skipNewlines();
+		}
+		return annotations;
+	}
+	parseJob(annotations) {
+		this.advance();
+		this.skipNewlines();
+		if (this.isAtEnd()) throw new Error("Expected job name");
+		const nameToken = this.advance();
+		if (AshParser.RESERVED_KEYWORDS.has(nameToken.value)) throw new Error(`Cannot use reserved keyword '${nameToken.value}' as job name at line ${nameToken.line}, column ${nameToken.column}`);
+		this.skipNewlines();
+		let trigger;
+		if (!this.isAtEnd() && this.peek().type === "ON") {
+			const onToken = this.advance();
+			if (!this.isAtEnd() && this.peek().type === "IDENTIFIER" && this.peek().value === "cron") {
+				this.advance();
+				if (this.isAtEnd() || this.peek().type !== "LPAREN") throw new Error(`Expected '(' after 'cron' at line ${onToken.line}, column ${onToken.column}`);
+				this.advance();
+				if (this.isAtEnd() || this.peek().type !== "STRING") throw new Error(`Expected cron expression string after 'cron(' at line ${onToken.line}, column ${onToken.column}`);
+				const exprToken = this.advance();
+				if (this.isAtEnd() || this.peek().type !== "RPAREN") throw new Error(`Expected ')' after cron expression at line ${onToken.line}, column ${onToken.column}`);
+				this.advance();
+				trigger = {
+					kind: "cron",
+					expression: exprToken.value
+				};
+			} else {
+				if (this.isAtEnd() || this.peek().type !== "PATH") throw new Error(`Expected path after 'on' at line ${onToken.line}, column ${onToken.column}`);
+				const pathToken = this.advance();
+				if (this.isAtEnd() || this.peek().type !== "COLON") throw new Error(`Expected ':event' after trigger path at line ${pathToken.line}, column ${pathToken.column}`);
+				this.advance();
+				if (this.isAtEnd() || this.peek().type !== "IDENTIFIER") throw new Error(`Expected event name after ':' at line ${pathToken.line}, column ${pathToken.column}`);
+				const eventToken = this.advance();
+				trigger = {
+					kind: "event",
+					path: pathToken.value,
+					event: eventToken.value
+				};
+			}
+			this.skipNewlines();
+		}
+		if (this.isAtEnd() || this.peek().type !== "LBRACE") {
+			const t = this.isAtEnd() ? nameToken : this.peek();
+			throw new Error(`Expected '{' after job name at line ${t.line}, column ${t.column}`);
+		}
+		this.advance();
+		this.skipNewlines();
+		const pipeline = this.parsePipeline();
+		this.skipNewlines();
+		if (this.isAtEnd() || this.peek().type !== "RBRACE") throw new Error("Expected '}' to close job body");
+		this.advance();
+		return {
+			kind: "job",
+			name: nameToken.value,
+			annotations,
+			pipeline,
+			trigger
+		};
+	}
+	parsePipeline() {
+		const stages = [];
+		while (!this.isAtEnd() && this.peek().type !== "RBRACE") {
+			if (this.peek().type === "PIPE") {
+				if (stages.length === 0) {
+					const t = this.peek();
+					throw new Error(`Unexpected PIPE at line ${t.line}, column ${t.column}`);
+				}
+				this.advance();
+				this.skipNewlines();
+				if (this.isAtEnd() || this.peek().type === "RBRACE") throw new Error("Unexpected end after pipe operator");
+			}
+			this.skipNewlines();
+			if (this.isAtEnd() || this.peek().type === "RBRACE") break;
+			const stage = this.parseStage();
+			stages.push(stage);
+			this.skipNewlines();
+		}
+		return stages;
+	}
+	parseStage() {
+		const t = this.peek();
+		switch (t.type) {
+			case "FIND": {
+				this.advance();
+				const path = this.expect("PATH", "Expected path after 'find'");
+				let query;
+				if (!this.isAtEnd() && this.peek().type === "WHERE") {
+					this.advance();
+					const where = this.parseWhere();
+					query = {
+						field: where.left,
+						op: where.op,
+						value: where.right
+					};
+				}
+				return {
+					kind: "find",
+					path: path.value,
+					query
+				};
+			}
+			case "WHERE":
+				this.advance();
+				return this.parseWhere();
+			case "MAP":
+				this.advance();
+				return this.parseMapBody();
+			case "SAVE":
+				this.advance();
+				return {
+					kind: "save",
+					path: this.expect("PATH", "Expected path after 'save'").value
+				};
+			case "PUBLISH":
+				this.advance();
+				return {
+					kind: "publish",
+					path: this.expect("PATH", "Expected path after 'publish'").value
+				};
+			case "TEE":
+				this.advance();
+				return {
+					kind: "tee",
+					path: this.expect("PATH", "Expected path after 'tee'").value
+				};
+			case "FANOUT":
+				this.advance();
+				return this.parseFanout();
+			case "OUTPUT": {
+				this.advance();
+				const expr = this.parseExpression();
+				if (expr.kind === "literal" && typeof expr.value === "string") return {
+					kind: "output",
+					message: expr.value
+				};
+				return {
+					kind: "output",
+					message: "",
+					expression: expr
+				};
+			}
+			case "INPUT":
+				this.advance();
+				return {
+					kind: "input",
+					prompt: this.expect("STRING", "Expected string after 'input'").value
+				};
+			case "COUNT":
+				this.advance();
+				return { kind: "count" };
+			case "GROUP_BY":
+				this.advance();
+				if (this.isAtEnd() || this.peek().type === "PIPE" || this.peek().type === "RBRACE" || this.peek().type === "NEWLINE") throw new Error("Expected field name after 'group-by'");
+				return {
+					kind: "group-by",
+					field: this.parseFieldAccess()
+				};
+			case "ACTION": return this.parseAction();
+			case "ROUTE": return this.parseRoute();
+			case "LOOKUP": return this.parseLookup();
+			default: throw new Error(`Unexpected token ${t.type} "${t.value}" at line ${t.line}, column ${t.column}`);
+		}
+	}
+	parseWhere() {
+		const left = this.parseFieldAccess();
+		const opToken = this.advance();
+		const op = {
+			"==": "==",
+			"!=": "!=",
+			">": ">",
+			"<": "<",
+			">=": ">=",
+			"<=": "<="
+		}[opToken.value];
+		if (!op) throw new Error(`Expected comparison operator, got ${opToken.type} at line ${opToken.line}, column ${opToken.column}`);
+		let right;
+		if (!this.isAtEnd() && this.peek().type === "DOLLAR") {
+			this.advance();
+			right = "$" + this.advance().value;
+		} else {
+			const rightToken = this.advance();
+			if (rightToken.type === "NUMBER") right = parseFloat(rightToken.value);
+			else if (rightToken.type === "STRING") right = rightToken.value;
+			else if (rightToken.type === "IDENTIFIER" || rightToken.type === "PATH") {
+				let val = rightToken.value;
+				while (!this.isAtEnd() && this.peek().type === "DOT") {
+					this.advance();
+					const next = this.advance();
+					val += "." + next.value;
+				}
+				right = val;
+			} else right = rightToken.value;
+		}
+		return {
+			kind: "where",
+			left,
+			op,
+			right
+		};
+	}
+	parseFieldAccess() {
+		let field = this.advance().value;
+		while (!this.isAtEnd() && this.peek().type === "DOT") {
+			this.advance();
+			const next = this.advance();
+			field += "." + next.value;
+		}
+		return field;
+	}
+	parseMapBody() {
+		if (this.isAtEnd() || this.peek().type === "PIPE" || this.peek().type === "RBRACE" || this.peek().type === "NEWLINE") throw new Error("Expected field or expression after 'map'");
+		if (this.peek().type !== "LBRACE") {
+			const expr = this.parseExpression();
+			if (expr.kind === "field_access") return {
+				kind: "map",
+				field: expr.path
+			};
+			return {
+				kind: "map",
+				field: "",
+				expression: expr
+			};
+		}
+		this.advance();
+		this.skipNewlines();
+		if (this.isAtEnd() || this.peek().type === "RBRACE") {
+			this.advance();
+			return {
+				kind: "map",
+				field: ""
+			};
+		}
+		const savedPos = this.pos;
+		this.advance();
+		const hasColon = !this.isAtEnd() && this.peek().type === "COLON";
+		this.pos = savedPos;
+		if (hasColon) {
+			const exprMappings = Object.create(null);
+			const seenExprKeys = /* @__PURE__ */ new Set();
+			while (!this.isAtEnd() && this.peek().type !== "RBRACE") {
+				const keyToken = this.expect("IDENTIFIER", "Expected key in map expression");
+				if (seenExprKeys.has(keyToken.value)) throw new Error(`Duplicate map key '${keyToken.value}' at line ${keyToken.line}, column ${keyToken.column}`);
+				seenExprKeys.add(keyToken.value);
+				this.expect("COLON", "Expected ':' after key in map expression");
+				const expr = this.parseExpression();
+				exprMappings[keyToken.value] = expr;
+				this.skipNewlines();
+				if (!this.isAtEnd() && this.peek().type === "COMMA") {
+					this.advance();
+					this.skipNewlines();
+				}
+			}
+			if (this.isAtEnd()) throw new Error("Expected '}' to close map expression");
+			this.advance();
+			return {
+				kind: "map",
+				field: "",
+				exprMappings
+			};
+		}
+		const mappings = Object.create(null);
+		const seenMapKeys = /* @__PURE__ */ new Set();
+		while (!this.isAtEnd() && this.peek().type !== "RBRACE") {
+			const key = this.advance();
+			if (seenMapKeys.has(key.value)) throw new Error(`Duplicate map key '${key.value}' at line ${key.line}, column ${key.column}`);
+			seenMapKeys.add(key.value);
+			const field = this.advance();
+			mappings[key.value] = field.value;
+			this.skipNewlines();
+			if (!this.isAtEnd() && this.peek().type === "COMMA") {
+				this.advance();
+				this.skipNewlines();
+			}
+		}
+		if (this.isAtEnd()) throw new Error("Expected '}' to close map object");
+		this.advance();
+		return {
+			kind: "map",
+			field: Object.keys(mappings)[0] ?? "",
+			mappings
+		};
+	}
+	parseExpression() {
+		let left = this.parseTerm();
+		while (!this.isAtEnd() && (this.peek().type === "PLUS" || this.peek().type === "MINUS")) {
+			const opToken = this.advance();
+			const right = this.parseTerm();
+			left = {
+				kind: "binary",
+				op: opToken.value,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseTerm() {
+		let left = this.parseFactor();
+		while (!this.isAtEnd() && (this.peek().type === "STAR" || this.peek().type === "SLASH")) {
+			const opToken = this.advance();
+			const right = this.parseFactor();
+			left = {
+				kind: "binary",
+				op: opToken.value,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseFactor() {
+		if (this.isAtEnd()) throw new Error("Expected expression");
+		const t = this.peek();
+		if (t.type === "LPAREN") {
+			this.advance();
+			const expr = this.parseExpression();
+			this.expect("RPAREN", "Expected ')' after expression");
+			return expr;
+		}
+		if (t.type === "DOLLAR") {
+			this.advance();
+			return {
+				kind: "var_ref",
+				name: this.expect("IDENTIFIER", "Expected variable name after '$'").value
+			};
+		}
+		if (t.type === "STRING") {
+			this.advance();
+			return {
+				kind: "literal",
+				value: t.value
+			};
+		}
+		if (t.type === "NUMBER") {
+			this.advance();
+			return {
+				kind: "literal",
+				value: parseFloat(t.value)
+			};
+		}
+		if (t.type === "IDENTIFIER") {
+			let field = this.advance().value;
+			while (!this.isAtEnd() && this.peek().type === "DOT") {
+				this.advance();
+				const next = this.advance();
+				field += "." + next.value;
+			}
+			return {
+				kind: "field_access",
+				path: field
+			};
+		}
+		throw new Error(`Unexpected token in expression: ${t.type} "${t.value}" at line ${t.line}, column ${t.column}`);
+	}
+	parseAction() {
+		const actionToken = this.advance();
+		if (this.isAtEnd()) throw new Error(`Expected path or action name after 'action' at line ${actionToken.line}, column ${actionToken.column}`);
+		const nextToken = this.peek();
+		let path;
+		let relative;
+		if (nextToken.type === "PATH") path = this.advance().value;
+		else if (nextToken.type === "IDENTIFIER") {
+			path = this.advance().value;
+			relative = true;
+		} else throw new Error(`Expected path or action name after 'action' at line ${actionToken.line}, column ${actionToken.column}`);
+		let params;
+		if (!this.isAtEnd() && this.peek().type === "LBRACE") {
+			this.advance();
+			params = {};
+			this.skipNewlines();
+			while (!this.isAtEnd() && this.peek().type !== "RBRACE") {
+				const keyToken = this.expect("IDENTIFIER", "Expected parameter name in action params");
+				this.expect("COLON", "Expected ':' after parameter name");
+				if (this.isAtEnd()) throw new Error(`Expected value after ':' at line ${keyToken.line}, column ${keyToken.column}`);
+				if (this.peek().type === "IDENTIFIER" && this.peek().value === "json") {
+					const jsonToken = this.advance();
+					this.expect("LPAREN", `Expected '(' after json at line ${jsonToken.line}, column ${jsonToken.column}`);
+					params[keyToken.value] = this.parseJsonValue();
+					this.expect("RPAREN", "Expected ')' to close json()");
+				} else {
+					const valToken = this.advance();
+					if (valToken.type === "STRING") params[keyToken.value] = valToken.value;
+					else if (valToken.type === "NUMBER") params[keyToken.value] = parseFloat(valToken.value);
+					else throw new Error(`Expected string or number value for parameter '${keyToken.value}' at line ${valToken.line}, column ${valToken.column}`);
+				}
+				this.skipNewlines();
+				if (!this.isAtEnd() && this.peek().type === "COMMA") {
+					this.advance();
+					this.skipNewlines();
+				}
+			}
+			if (this.isAtEnd()) throw new Error("Expected '}' to close action params");
+			this.advance();
+		}
+		return {
+			kind: "action",
+			path,
+			relative,
+			params
+		};
+	}
+	parseRoute() {
+		const routeToken = this.advance();
+		if (this.isAtEnd() || this.peek().type !== "IDENTIFIER" && this.peek().type !== "DOT") throw new Error(`Expected field name after 'route' at line ${routeToken.line}, column ${routeToken.column}`);
+		const field = this.parseFieldAccess();
+		this.expect("LBRACE", "Expected '{' after route field");
+		this.skipNewlines();
+		const branches = [];
+		let fallback;
+		while (!this.isAtEnd() && this.peek().type !== "RBRACE") {
+			let value;
+			if (this.peek().type === "STRING") value = this.advance().value;
+			else if (this.peek().type === "IDENTIFIER" && this.peek().value === "_") {
+				value = "_";
+				this.advance();
+			} else throw new Error(`Expected string value or '_' in route branch at line ${this.peek().line}, column ${this.peek().column}`);
+			this.expect("ARROW", "Expected '->' in route branch");
+			this.expect("JOB", "Expected 'job' keyword in route branch target");
+			const targetToken = this.advance();
+			if (value === "_") fallback = targetToken.value;
+			else branches.push({
+				value,
+				targetJob: targetToken.value
+			});
+			this.skipNewlines();
+			if (!this.isAtEnd() && this.peek().type === "COMMA") {
+				this.advance();
+				this.skipNewlines();
+			}
+		}
+		if (branches.length === 0 && !fallback) throw new Error(`Route must have at least one branch at line ${routeToken.line}, column ${routeToken.column}`);
+		if (this.isAtEnd()) throw new Error("Expected '}' to close route");
+		this.advance();
+		return {
+			kind: "route",
+			field,
+			branches,
+			fallback
+		};
+	}
+	parseLookup() {
+		const lookupToken = this.advance();
+		if (this.isAtEnd() || this.peek().type !== "PATH") throw new Error(`Expected path after 'lookup' at line ${lookupToken.line}, column ${lookupToken.column}`);
+		const pathToken = this.advance();
+		if (this.isAtEnd() || this.peek().type !== "ON") throw new Error(`Expected 'on' keyword after lookup path at line ${lookupToken.line}, column ${lookupToken.column}`);
+		this.advance();
+		const joinKey = this.parseFieldAccess();
+		return {
+			kind: "lookup",
+			path: pathToken.value,
+			joinKey
+		};
+	}
+	parseFanout() {
+		this.expect("LBRACE", "Expected '{' after 'fanout'");
+		const branches = [];
+		this.skipNewlines();
+		while (!this.isAtEnd() && this.peek().type !== "RBRACE") {
+			const branch = [];
+			while (!this.isAtEnd() && this.peek().type !== "COMMA" && this.peek().type !== "RBRACE" && this.peek().type !== "NEWLINE") {
+				if (this.peek().type === "PIPE") this.advance();
+				branch.push(this.parseStage());
+			}
+			branches.push(branch);
+			this.skipNewlines();
+			if (!this.isAtEnd() && this.peek().type === "COMMA") {
+				this.advance();
+				this.skipNewlines();
+			}
+		}
+		if (this.isAtEnd()) throw new Error("Expected '}' to close fanout");
+		this.advance();
+		return {
+			kind: "fanout",
+			branches
+		};
+	}
+	/** Recursive descent JSON value parser using existing lexer tokens. */
+	parseJsonValue() {
+		if (this.isAtEnd()) throw new Error("Expected JSON value (unexpected EOF)");
+		const t = this.peek();
+		if (t.type === "LBRACE") {
+			this.advance();
+			const obj = {};
+			this.skipNewlines();
+			while (!this.isAtEnd() && this.peek().type !== "RBRACE") {
+				const keyToken = this.advance();
+				if (keyToken.type !== "STRING" && keyToken.type !== "IDENTIFIER") throw new Error(`Expected string key in JSON object at line ${keyToken.line}, column ${keyToken.column}`);
+				this.expect("COLON", "Expected ':' after key in JSON object");
+				obj[keyToken.value] = this.parseJsonValue();
+				this.skipNewlines();
+				if (!this.isAtEnd() && this.peek().type === "COMMA") {
+					this.advance();
+					this.skipNewlines();
+				}
+			}
+			if (this.isAtEnd()) throw new Error("Expected '}' to close JSON object");
+			this.advance();
+			return obj;
+		}
+		if (t.type === "LBRACKET") {
+			this.advance();
+			const arr = [];
+			this.skipNewlines();
+			while (!this.isAtEnd() && this.peek().type !== "RBRACKET") {
+				arr.push(this.parseJsonValue());
+				this.skipNewlines();
+				if (!this.isAtEnd() && this.peek().type === "COMMA") {
+					this.advance();
+					this.skipNewlines();
+				}
+			}
+			if (this.isAtEnd()) throw new Error("Expected ']' to close JSON array");
+			this.advance();
+			return arr;
+		}
+		if (t.type === "STRING") {
+			this.advance();
+			return t.value;
+		}
+		if (t.type === "NUMBER") {
+			this.advance();
+			return parseFloat(t.value);
+		}
+		if (t.type === "IDENTIFIER") {
+			if (t.value === "true") {
+				this.advance();
+				return true;
+			}
+			if (t.value === "false") {
+				this.advance();
+				return false;
+			}
+			if (t.value === "null") {
+				this.advance();
+				return null;
+			}
+		}
+		throw new Error(`Unexpected token in json(): ${t.type} "${t.value}" at line ${t.line}, column ${t.column}`);
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	advance() {
+		return this.tokens[this.pos++];
+	}
+	expect(type, message) {
+		if (this.isAtEnd()) throw new Error(message + " (unexpected EOF)");
+		const t = this.peek();
+		if (t.type !== type) throw new Error(`${message}, got ${t.type} at line ${t.line}, column ${t.column}`);
+		return this.advance();
+	}
+	isAtEnd() {
+		return this.pos >= this.tokens.length || this.tokens[this.pos].type === "EOF";
+	}
+	skipNewlines() {
+		while (!this.isAtEnd() && this.peek().type === "NEWLINE") this.pos++;
+	}
+};
+
+//#endregion
+export { AshParser };
+//# sourceMappingURL=parser.mjs.map