@kumikijs/compiler 0.1.0

package/dist/index.js

@@ -0,0 +1,3400 @@
+//#region src/codegen.ts
+function codegen(program, opts) {
+	const types = new Map(program.defs.filter((d) => d.kind === "TypeDef").map((d) => [d.name, d]));
+	const slots = program.defs.filter((d) => d.kind === "SlotDef");
+	const effects = program.defs.filter((d) => d.kind === "EffectDef");
+	const reducers = program.defs.filter((d) => d.kind === "ReducerDef");
+	const fns = program.defs.filter((d) => d.kind === "FnDef");
+	const tiles = program.defs.filter((d) => d.kind === "TileDef");
+	const apps = program.defs.filter((d) => d.kind === "AppDef");
+	const themes = program.defs.filter((d) => d.kind === "ThemeDef");
+	const app = apps[0];
+	if (!app) throw new Error("No app definition found");
+	const ctx = {
+		slots,
+		fns,
+		tiles,
+		reducers,
+		effects,
+		types
+	};
+	const lines = [];
+	lines.push(`import { mount, _stdlib, builtinEffects } from "${opts.runtimeSpecifier}";`);
+	lines.push("");
+	lines.push("const _s = _stdlib;");
+	lines.push("");
+	for (const fn of fns) lines.push(genFn(fn, ctx));
+	lines.push("const _effects = {");
+	for (const eff of effects) lines.push(`  ${JSON.stringify(eff.name)}: ${genEffect(eff, ctx)},`);
+	lines.push("};");
+	lines.push("");
+	lines.push("const _slots = {");
+	for (const s of slots) {
+		const refine = refinementJs(s.type, ctx);
+		const init = jsOfExpr(s.init, makeEvalCtx(ctx, /* @__PURE__ */ new Set()));
+		lines.push(`  ${JSON.stringify(s.name)}: { value: ${init}${refine ? `, refine: ${refine}` : ""} },`);
+	}
+	lines.push("};");
+	lines.push("");
+	lines.push("const _live = {};");
+	lines.push("for (const [k, v] of Object.entries(_slots)) _live[k] = v.value;");
+	lines.push("");
+	lines.push("const _reducers = [");
+	for (const r of reducers) lines.push(genReducer(r, ctx));
+	lines.push("];");
+	lines.push("");
+	lines.push("const _routes = [");
+	for (const r of app.routes) if (r.tile.startsWith(">>")) {
+		const target = r.tile.slice(2);
+		lines.push(`  { pattern: ${JSON.stringify(r.path)}, redirectTo: ${JSON.stringify(target)} },`);
+	} else {
+		const tile = tiles.find((t) => t.name === r.tile);
+		if (!tile) throw new Error(`Route ${r.path} targets undefined tile "${r.tile}"`);
+		lines.push(`  { pattern: ${JSON.stringify(r.path)}, tile: () => ${genTile(tile, ctx)} },`);
+	}
+	lines.push("];");
+	lines.push("");
+	lines.push("const _themes = {");
+	for (const t of themes) lines.push(`  ${JSON.stringify(t.name)}: ${JSON.stringify(t.body)},`);
+	lines.push("};");
+	const themeRef = app.theme ? JSON.stringify(app.theme) : "null";
+	lines.push("");
+	lines.push("const App = {");
+	lines.push("  slots: _slots,");
+	lines.push(`  caps: ${JSON.stringify(app.caps)},`);
+	lines.push("  reducers: _reducers,");
+	lines.push("  effects: _effects,");
+	lines.push(`  init: [${app.init.map((e) => emitFromInitExpr(e)).join(", ")}],`);
+	lines.push("  routes: _routes,");
+	lines.push("  live: _live,");
+	lines.push("  themes: _themes,");
+	lines.push(`  themeName: ${themeRef},`);
+	lines.push("};");
+	lines.push("");
+	lines.push("globalThis.__kumikiApp = App;");
+	lines.push(`mount(App, document.getElementById("root"));`);
+	return lines.join("\n");
+}
+function makeEvalCtx(gen, locals, reducerScope = false) {
+	return {
+		gen,
+		localBinds: new Set(locals),
+		reducerScope
+	};
+}
+function genFn(fn, gen) {
+	const params = fn.params.map((p) => p.name).join(", ");
+	const ctx = makeEvalCtx(gen, new Set([
+		...fn.params.map((p) => p.name),
+		"$1",
+		"$2"
+	]));
+	return `function ${jsName(fn.name)}(${params}) { return ${jsOfExpr(fn.body, ctx)}; }`;
+}
+function genEffect(eff, gen) {
+	let invokeBody;
+	if (eff.cap === "storage.read") if (eff.mapRequest) {
+		const mapJs = jsOfExpr(eff.mapRequest, makeEvalCtx(gen, new Set(["$1"])));
+		invokeBody = `async (${jsName("$1")}, _caps) => { const req = ${mapJs}; return builtinEffects.storageRead({ key: req.key }); }`;
+	} else invokeBody = `async (input) => builtinEffects.storageRead(input)`;
+	else if (eff.cap === "storage.write") if (eff.mapRequest) {
+		const mapJs = jsOfExpr(eff.mapRequest, makeEvalCtx(gen, new Set(["$1"])));
+		invokeBody = `async (${jsName("$1")}, _caps) => { const req = ${mapJs}; return builtinEffects.storageWrite({ key: req.key, value: req.value }); }`;
+	} else invokeBody = `async (input) => builtinEffects.storageWrite(input)`;
+	else if (eff.cap.startsWith("http.")) {
+		const method = eff.cap.slice(5).toUpperCase();
+		if (eff.mapRequest) {
+			const mapJs = jsOfExpr(eff.mapRequest, makeEvalCtx(gen, new Set(["$1"])));
+			invokeBody = `async (${jsName("$1")}, _caps) => { const req = ${mapJs}; return builtinEffects.httpFetch(${JSON.stringify(method)}, req, ""); }`;
+		} else invokeBody = `async (input) => builtinEffects.httpFetch(${JSON.stringify(method)}, input, "")`;
+	} else invokeBody = `async () => ({ kind: "err", value: { message: "Capability ${eff.cap} not implemented" } })`;
+	return `{
+    name: ${JSON.stringify(eff.name)},
+    cap: ${JSON.stringify(eff.cap)},
+    policy: ${policyJs(eff.policy)},
+    invoke: ${invokeBody},
+  }`;
+}
+function policyJs(p) {
+	if (!p) return "undefined";
+	switch (p.kind) {
+		case "PolLatest": return `{ kind: "latest" }`;
+		case "PolLatestKey": return `{ kind: "latest-per-key", keyOf: ((${jsName("$1")}) => String(${jsOfExpr(p.key, {
+			gen: {},
+			localBinds: new Set(["$1"])
+		})})) }`;
+		case "PolQueue": return `{ kind: "queue" }`;
+		case "PolDebounce": return `{ kind: "debounce", ms: ${p.ms} }`;
+		case "PolThrottle": return `{ kind: "throttle", ms: ${p.ms} }`;
+		case "PolOnce": return `{ kind: "once" }`;
+	}
+}
+function genReducer(r, gen) {
+	const locals = new Set([
+		"$el",
+		"$event",
+		"$route"
+	]);
+	if (r.on.kind === "EffectEvent") {
+		for (const b of r.on.binds) if (b !== "_") locals.add(b);
+	}
+	const ctx = makeEvalCtx(gen, locals, true);
+	let eventJs;
+	let selectorJs = "undefined";
+	if (r.on.kind === "UiEvent") {
+		eventJs = `{ kind: "ui", ev: ${JSON.stringify(r.on.ev)} }`;
+		selectorJs = `{ tile: ${JSON.stringify(r.on.selector.tile)}${r.on.selector.id ? `, id: ${JSON.stringify(r.on.selector.id)}` : ""} }`;
+	} else if (r.on.kind === "EffectEvent") eventJs = `{ kind: "effect", effect: ${JSON.stringify(r.on.effect)}, outcome: ${JSON.stringify(r.on.outcome)} }`;
+	else if (r.on.kind === "TimerEvent") eventJs = `{ kind: "timer", intervalMs: ${r.on.intervalMs} }`;
+	else eventJs = `{ kind: "lifecycle", name: ${JSON.stringify(r.on.name)} }`;
+	const stmtLines = [];
+	stmtLines.push(`const _next = {};`);
+	stmtLines.push(`const _emits = [];`);
+	if (r.on.kind === "EffectEvent") for (let i = 0; i < r.on.binds.length; i++) {
+		const name = r.on.binds[i];
+		if (name === "_") continue;
+		stmtLines.push(`const ${jsName(name)} = _payload[${JSON.stringify(`$${i + 1}`)}];`);
+	}
+	stmtLines.push(`const ${jsName("$el")} = _payload.$el || {};`);
+	stmtLines.push(`const ${jsName("$event")} = _payload.$event || _payload || {};`);
+	stmtLines.push(`const ${jsName("$route")} = _payload.$route || {};`);
+	for (const st of r.do) stmtLines.push(genStatement(st, ctx));
+	stmtLines.push(`return { slots: _next, emits: _emits };`);
+	return `  {
+    name: ${JSON.stringify(r.name)},
+    selector: ${selectorJs},
+    event: ${eventJs},
+    apply: (_slotsLive, _payload) => {
+      ${stmtLines.join("\n      ")}
+    },
+  },`;
+}
+function genStatement(s, ctx) {
+	if (s.kind === "ForStmt") {
+		const iter = jsOfExpr(s.iter, ctx);
+		const inner = makeEvalCtx(ctx.gen, ctx.localBinds, ctx.reducerScope);
+		inner.localBinds.add(s.bind);
+		const body = s.body.map((b) => genStatement(b, inner)).join("\n  ");
+		return `for (const ${jsName(s.bind)} of ((${iter}) || [])) {\n  ${body}\n}`;
+	}
+	if (s.kind === "IfStmt") return `if (${jsOfExpr(s.cond, ctx)}) {\n  ${s.consequent.map((b) => genStatement(b, ctx)).join("\n  ")}\n} else {\n  ${s.alternate.map((b) => genStatement(b, ctx)).join("\n  ")}\n}`;
+	if (s.kind === "MatchStmt") return `{ const _v = ${jsOfExpr(s.scrutinee, ctx)};\n  ${s.arms.map((arm) => {
+		if (arm.pattern.kind === "PVariant") {
+			const inner = makeEvalCtx(ctx.gen, ctx.localBinds, ctx.reducerScope);
+			for (const b of arm.pattern.binds) if (b !== "_") inner.localBinds.add(b);
+			const binds = arm.pattern.binds.map((b, i) => b !== "_" ? `const ${jsName(b)} = _v[${JSON.stringify(`_${i}`)}];` : "").join(" ");
+			const body = arm.body.map((b) => genStatement(b, inner)).join("\n  ");
+			return `if (_s.variantIs(_v, ${JSON.stringify(arm.pattern.name)})) { ${binds}\n  ${body}\n}`;
+		}
+		if (arm.pattern.kind === "PBind") {
+			const inner = makeEvalCtx(ctx.gen, ctx.localBinds, ctx.reducerScope);
+			inner.localBinds.add(arm.pattern.name);
+			const body = arm.body.map((b) => genStatement(b, inner)).join("\n  ");
+			return `if (true) { const ${jsName(arm.pattern.name)} = _v;\n  ${body}\n}`;
+		}
+		if (arm.pattern.kind === "PWildcard") return `if (true) {\n  ${arm.body.map((b) => genStatement(b, ctx)).join("\n  ")}\n}`;
+		const body = arm.body.map((b) => genStatement(b, ctx)).join("\n  ");
+		return `if (_v === ${JSON.stringify(arm.pattern.value)}) {\n  ${body}\n}`;
+	}).join(" else ")}\n}`;
+	if (s.kind === "NoopStmt") return `/* no-op */`;
+	if (s.kind === "LetStmt") {
+		const rhs = jsOfExpr(s.rhs, ctx);
+		ctx.localBinds.add(s.name);
+		return `const ${jsName(s.name)} = ${rhs};`;
+	}
+	if (s.kind === "Emit") {
+		const args = s.args.map((a) => jsOfExpr(a, ctx)).join(", ");
+		return `_emits.push({ effect: ${JSON.stringify(s.effect)}, args: [${args}] });`;
+	}
+	return genSlotAssign(s.lvalue, s.rhs, ctx);
+}
+function genSlotAssign(lv, rhs, ctx) {
+	const rhsJs = jsOfExpr(rhs, ctx);
+	if (lv.kind === "LSlot") return `_next[${JSON.stringify(lv.name)}] = ${rhsJs};`;
+	const root = lvalueRootName(lv);
+	const path = [];
+	let cur = lv;
+	while (cur.kind !== "LSlot") {
+		if (cur.kind === "LField") path.unshift({
+			kind: "field",
+			name: cur.field
+		});
+		else path.unshift({
+			kind: "index",
+			expr: cur.index
+		});
+		cur = cur.base;
+	}
+	const rootKey = JSON.stringify(root);
+	const baseJs = ctx.reducerScope ? `(((_next[${rootKey}] !== undefined) ? _next[${rootKey}] : _live[${rootKey}]) ?? {})` : `(_live[${rootKey}] ?? {})`;
+	let pathExpr = "";
+	for (const seg of path) if (seg.kind === "field") pathExpr += `, ${JSON.stringify(seg.name)}`;
+	else pathExpr += `, ${jsOfExpr(seg.expr, ctx)}`;
+	return `_next[${JSON.stringify(root)}] = _setPath(${baseJs}, [${pathExpr.replace(/^, /, "")}], ${rhsJs});`;
+}
+function lvalueRootName(lv) {
+	while (lv.kind !== "LSlot") lv = lv.base;
+	return lv.name;
+}
+function jsOfExpr(e, ctx) {
+	switch (e.kind) {
+		case "Num": return String(e.value);
+		case "Str": return JSON.stringify(e.value);
+		case "Bool": return e.value ? "true" : "false";
+		case "Unit": return "null";
+		case "Ref":
+			if (ctx.localBinds.has(e.name)) return jsName(e.name);
+			if (e.name === "now") return `_s.now()`;
+			if (e.name === "route") return ctx.reducerScope ? `((_next["route"] !== undefined) ? _next["route"] : _live["route"])` : `_live["route"]`;
+			if (ctx.gen.slots?.some((s) => s.name === e.name)) {
+				const key = JSON.stringify(e.name);
+				return ctx.reducerScope ? `((_next[${key}] !== undefined) ? _next[${key}] : _live[${key}])` : `_live[${key}]`;
+			}
+			return jsName(e.name);
+		case "BinOp": {
+			const l = jsOfExpr(e.lhs, ctx);
+			const r = jsOfExpr(e.rhs, ctx);
+			if (e.op === "+") return `_s.add(${l}, ${r})`;
+			if (e.op === "&") return `(${l} && ${r})`;
+			if (e.op === "|") return `(${l} || ${r})`;
+			if (e.op === "==") return `_s.eq(${l}, ${r})`;
+			if (e.op === "!=") return `(!_s.eq(${l}, ${r}))`;
+			return `(${l} ${e.op} ${r})`;
+		}
+		case "UnaryOp": return `(${e.op === "!" ? "!" : "-"}${jsOfExpr(e.rhs, ctx)})`;
+		case "FieldAccess": {
+			const baseJs = jsOfExpr(e.base, ctx);
+			if (e.field === "get") return `_s.unwrap(${baseJs})`;
+			if (e.field === "is-some") return `(_s.variantIs(${baseJs}, "Some"))`;
+			if (e.field === "is-none") return `(_s.variantIs(${baseJs}, "None"))`;
+			if (e.field === "is-ok") return `(_s.variantIs(${baseJs}, "Ok"))`;
+			if (e.field === "is-err") return `(_s.variantIs(${baseJs}, "Err"))`;
+			if (e.field === "keys") return `_s.mapKeys(${baseJs})`;
+			if (e.field === "values") return `_s.mapValues(${baseJs})`;
+			if (e.field === "entries") return `_s.mapEntries(${baseJs})`;
+			if (e.field === "size") return `_s.mapSize(${baseJs})`;
+			if (e.field === "to-ms" || e.field === "ms") return `(${baseJs})`;
+			if (e.field === "show") return `_s.show(${baseJs})`;
+			if (e.field === "length") return `((${baseJs}) ?? "").length`;
+			if (e.field === "is-empty") return `(((${baseJs}) ?? []).length === 0 || ((${baseJs}) ?? "") === "")`;
+			if (e.field === "lower") return `(String((${baseJs}) ?? "")).toLowerCase()`;
+			if (e.field === "upper") return `(String((${baseJs}) ?? "")).toUpperCase()`;
+			if (e.field === "trim") return `(String((${baseJs}) ?? "")).trim()`;
+			if (e.field === "unique") return `[...new Set((${baseJs}) ?? [])]`;
+			if (e.field === "reverse") return `[...((${baseJs}) ?? [])].reverse()`;
+			if (e.field === "sort") return `[...((${baseJs}) ?? [])].sort()`;
+			return `(${baseJs})[${JSON.stringify(e.field)}]`;
+		}
+		case "Index": return `(${jsOfExpr(e.base, ctx)})[${jsOfExpr(e.index, ctx)}]`;
+		case "Call": {
+			const cn = e.callee;
+			if (cn === "now") return `_s.now()`;
+			if (/^[A-Z][A-Za-z0-9_]*\.fresh$/.test(cn)) return `_s.freshId()`;
+			if (/^[A-Z][A-Za-z0-9_]*\.parse$/.test(cn)) {
+				const a = e.args[0] ? jsOfExpr(e.args[0], ctx) : "\"\"";
+				const qualifier = cn.split(".")[0];
+				if (qualifier === "Int") return `((_v) => { const _n = Number(_v); return (String(_v).trim() !== "" && Number.isFinite(_n)) ? _s.Some(Math.trunc(_n)) : _s.None; })(${a})`;
+				if (qualifier === "Float") return `((_v) => { const _n = Number(_v); return (String(_v).trim() !== "" && Number.isFinite(_n)) ? _s.Some(_n) : _s.None; })(${a})`;
+				return `((_v) => (typeof _v === "string" && _v.length > 0) ? _s.Some(_v) : _s.None)(${a})`;
+			}
+			if (/^[A-Z][A-Za-z0-9_]*\.show$/.test(cn)) return `_s.show(${e.args[0] ? jsOfExpr(e.args[0], ctx) : "\"\""})`;
+			if (cn === "Duration.ms") return `(${e.args[0] ? jsOfExpr(e.args[0], ctx) : "0"})`;
+			if (cn === "Duration.s") return `((${e.args[0] ? jsOfExpr(e.args[0], ctx) : "0"}) * 1000)`;
+			if (cn === "Duration.m" || cn === "Duration.min") return `((${e.args[0] ? jsOfExpr(e.args[0], ctx) : "0"}) * 60000)`;
+			if (cn === "Duration.h") return `((${e.args[0] ? jsOfExpr(e.args[0], ctx) : "0"}) * 3600000)`;
+			if (cn === "Duration.d" || cn === "Duration.days") return `((${e.args[0] ? jsOfExpr(e.args[0], ctx) : "0"}) * 86400000)`;
+			if (cn === "Decoder.Json") return `"json"`;
+			if (cn === "Decoder.Text") return `"text"`;
+			if (cn === "Decoder.Bytes") return `"bytes"`;
+			if (cn === "Decoder.None") return `"none"`;
+			if (cn === "fmt") {
+				const args = e.args.map((a) => jsOfExpr(a, ctx));
+				return `_s.fmt ? _s.fmt(${args.join(", ")}) : ${args[0] ?? "\"\""}`;
+			}
+			const args = e.args.map((a) => jsOfExpr(a, ctx)).join(", ");
+			return `${jsName(cn)}(${args})`;
+		}
+		case "MethodCall": return methodCallJs(e.receiver, e.method, e.args, ctx);
+		case "RecordLit": return `{ ${e.fields.map((f) => `${JSON.stringify(f.name)}: ${jsOfExpr(f.value, ctx)}`).join(", ")} }`;
+		case "ListLit": return `[${e.items.map((it) => jsOfExpr(it, ctx)).join(", ")}]`;
+		case "MapLit": return `{ ${e.entries.map((en) => `[${jsOfExpr(en.key, ctx)}]: ${jsOfExpr(en.value, ctx)}`).join(", ")} }`;
+		case "MatchExpr": return matchExprJs(e, ctx);
+		case "IfExpr": return `((${jsOfExpr(e.cond, ctx)}) ? (${jsOfExpr(e.consequent, ctx)}) : (${jsOfExpr(e.alternate, ctx)}))`;
+		case "LetIn": {
+			const inner = makeEvalCtx(ctx.gen, ctx.localBinds);
+			inner.localBinds.add(e.name);
+			return `(() => { const ${jsName(e.name)} = ${jsOfExpr(e.value, ctx)}; return ${jsOfExpr(e.body, inner)}; })()`;
+		}
+		case "Variant": return variantJs(e.name, e.payload, ctx);
+	}
+}
+/**
+* Methods the code generator actually implements (the `methodCallJs` switch
+* cases below). This is the single source of truth for what `obj.method(...)`
+* calls are runnable; the typechecker uses it to flag unimplemented methods
+* (E0801) at `check` time instead of letting them throw or misbehave at runtime.
+* Keep this in exact sync with the `switch (method)` cases.
+*/
+const KNOWN_METHODS = new Set([
+	"filter",
+	"map",
+	"flat-map",
+	"size",
+	"keys",
+	"has",
+	"toggle",
+	"get",
+	"get-or",
+	"remove",
+	"insert",
+	"sort-by",
+	"fold",
+	"show",
+	"is-some",
+	"is-none",
+	"is-empty",
+	"to-ms",
+	"copy",
+	"find",
+	"push",
+	"unique",
+	"reverse",
+	"join",
+	"split",
+	"contains",
+	"starts-with",
+	"ends-with",
+	"length",
+	"slice",
+	"trim",
+	"format",
+	"plus",
+	"minus",
+	"diff",
+	"concat",
+	"prepend",
+	"chunk",
+	"zip",
+	"merge",
+	"update",
+	"add",
+	"union",
+	"intersect",
+	"or",
+	"map-err",
+	"replace",
+	"min",
+	"max",
+	"clamp"
+]);
+function methodCallJs(recv, method, args, ctx) {
+	const inner = makeEvalCtx(ctx.gen, ctx.localBinds);
+	inner.localBinds.add("$1");
+	inner.localBinds.add("$2");
+	const recvJs = jsOfExpr(recv, ctx);
+	const argFnList = (a) => `((__x, __y) => { const _isPair = (Array.isArray(__x) && __x.length === 2); const ${jsName("$1")} = _isPair ? __x[0] : __x; const ${jsName("$2")} = _isPair ? __x[1] : (__y !== undefined ? __y : __x); return ${jsOfExpr(a, inner)}; })`;
+	const argRaw = (a) => jsOfExpr(a, ctx);
+	switch (method) {
+		case "filter": return `_s.filter(${recvJs}, ${argFnList(args[0])})`;
+		case "map": return `_s.mapOver(${recvJs}, ${argFnList(args[0])})`;
+		case "flat-map": return `_s.flatMapOption(${recvJs}, ((${jsName("$1")}) => ${jsOfExpr(args[0], inner)}))`;
+		case "size": return `_s.mapSize(${recvJs})`;
+		case "keys": return `_s.mapKeys(${recvJs})`;
+		case "has": return `_s.setHas(${recvJs}, ${argRaw(args[0])})`;
+		case "toggle": return `_s.setToggle(${recvJs}, ${argRaw(args[0])})`;
+		case "get": return `((_v) => _v === undefined ? _s.None : _s.Some(_v))(_s.mapGet(${recvJs}, ${argRaw(args[0])}))`;
+		case "get-or":
+			if (args.length === 1) return `_s.getOr(${recvJs}, ${argRaw(args[0])})`;
+			return `_s.mapGetOr(${recvJs}, ${argRaw(args[0])}, ${argRaw(args[1])})`;
+		case "remove": return `_s.mapRemove(${recvJs}, ${argRaw(args[0])})`;
+		case "insert": return `_s.mapInsert(${recvJs}, ${argRaw(args[0])}, ${argRaw(args[1])})`;
+		case "sort-by": return `_s.listSortBy(${recvJs}, ${argFnList(args[0])})`;
+		case "fold": return `_s.listFold(${recvJs}, ${argRaw(args[0])}, (${jsName("$1")}, ${jsName("$2")}) => ${jsOfExpr(args[1], inner)})`;
+		case "show": return `_s.show(${recvJs})`;
+		case "is-some": return `_s.variantIs(${recvJs}, "Some")`;
+		case "is-none": return `_s.variantIs(${recvJs}, "None")`;
+		case "is-empty": return `(_s.mapSize(${recvJs}) === 0)`;
+		case "to-ms": return `(${recvJs})`;
+		case "copy":
+			if (args[0] && args[0].kind === "RecordLit") return `_s.recordCopy(${recvJs}, ${jsOfExpr(args[0], ctx)})`;
+			return `_s.recordCopy(${recvJs}, {})`;
+		case "find": return `((${recvJs}) || []).find(${argFnList(args[0])})`;
+		case "push": return `[...(${recvJs} ?? []), ${argRaw(args[0])}]`;
+		case "unique": return `[...new Set((${recvJs} ?? []))]`;
+		case "reverse": return `[...(${recvJs} ?? [])].reverse()`;
+		case "join": return `((${recvJs}) ?? []).join(${argRaw(args[0])})`;
+		case "split": return `((${recvJs}) ?? "").split(${argRaw(args[0])})`;
+		case "contains": return `(typeof (${recvJs}) === "string" ? ((${recvJs}) ?? "").includes(${argRaw(args[0])}) : ((${recvJs}) ?? []).includes(${argRaw(args[0])}))`;
+		case "starts-with": return `((${recvJs}) ?? "").startsWith(${argRaw(args[0])})`;
+		case "ends-with": return `((${recvJs}) ?? "").endsWith(${argRaw(args[0])})`;
+		case "length": return `((${recvJs}) || "").length`;
+		case "slice": return `((${recvJs}) || "").slice(${args.map(argRaw).join(", ")})`;
+		case "trim": return `((${recvJs}) || "").trim()`;
+		case "format": return `(new Date(${recvJs})).toISOString().slice(0, 10)`;
+		case "plus": return `((${recvJs}) + (${argRaw(args[0])}))`;
+		case "minus": return `((${recvJs}) - (${argRaw(args[0])}))`;
+		case "diff": return `_s.diff(${recvJs}, ${argRaw(args[0])})`;
+		case "concat": return `[...((${recvJs}) ?? []), ...((${argRaw(args[0])}) ?? [])]`;
+		case "prepend": return `[${argRaw(args[0])}, ...((${recvJs}) ?? [])]`;
+		case "chunk": return `_s.listChunk(${recvJs}, ${argRaw(args[0])})`;
+		case "zip": return `_s.listZip(${recvJs}, ${argRaw(args[0])})`;
+		case "merge": return `({ ...((${recvJs}) ?? {}), ...((${argRaw(args[0])}) ?? {}) })`;
+		case "update": return `_s.mapUpdate(${recvJs}, ${argRaw(args[0])}, ((${jsName("$1")}) => (${jsOfExpr(args[1], inner)})))`;
+		case "add": return `_s.setAdd(${recvJs}, ${argRaw(args[0])})`;
+		case "union": return `_s.setUnion(${recvJs}, ${argRaw(args[0])})`;
+		case "intersect": return `_s.setIntersect(${recvJs}, ${argRaw(args[0])})`;
+		case "or": return `_s.or(${recvJs}, ${argRaw(args[0])})`;
+		case "map-err": return `_s.mapErr(${recvJs}, ((${jsName("$1")}) => (${jsOfExpr(args[0], inner)})))`;
+		case "replace": return `String((${recvJs}) ?? "").replaceAll(${argRaw(args[0])}, ${argRaw(args[1])})`;
+		case "min": return `Math.min((${recvJs}), (${argRaw(args[0])}))`;
+		case "max": return `Math.max((${recvJs}), (${argRaw(args[0])}))`;
+		case "clamp": return `Math.min(Math.max((${recvJs}), (${argRaw(args[0])})), (${argRaw(args[1])}))`;
+		default: return `(${recvJs}).${jsName(method)}(${args.map(argRaw).join(", ")})`;
+	}
+}
+function variantJs(name, payload, ctx) {
+	if (payload.length === 0) {
+		if (name === "None") return `_s.None`;
+		return `({ _tag: ${JSON.stringify(name)} })`;
+	}
+	if (name === "Some") return `_s.Some(${jsOfExpr(payload[0], ctx)})`;
+	if (name === "Ok") return `_s.Ok(${jsOfExpr(payload[0], ctx)})`;
+	if (name === "Err") return `_s.Err(${jsOfExpr(payload[0], ctx)})`;
+	return `_s.variant(${JSON.stringify(name)}, ${payload.map((p) => jsOfExpr(p, ctx)).join(", ")})`;
+}
+function matchExprJs(e, ctx) {
+	const sc = jsOfExpr(e.scrutinee, ctx);
+	return `((_v) => { ${e.arms.map((arm) => matchArmJs(arm.pattern, arm.body, ctx, "_v")).join(" else ")} else { return undefined; } })(${sc})`;
+}
+function matchArmJs(p, body, ctx, scVar) {
+	if (p.kind === "PWildcard") return `if (true) { return ${jsOfExpr(body, ctx)}; }`;
+	if (p.kind === "PBind") {
+		const inner = makeEvalCtx(ctx.gen, ctx.localBinds);
+		inner.localBinds.add(p.name);
+		return `if (true) { const ${jsName(p.name)} = ${scVar}; return ${jsOfExpr(body, inner)}; }`;
+	}
+	if (p.kind === "PLiteral") return `if (${scVar} === ${JSON.stringify(p.value)}) { return ${jsOfExpr(body, ctx)}; }`;
+	const tag = p.name;
+	const inner = makeEvalCtx(ctx.gen, ctx.localBinds);
+	const bindAssigns = [];
+	for (let i = 0; i < p.binds.length; i++) {
+		const name = p.binds[i];
+		if (name === "_") continue;
+		inner.localBinds.add(name);
+		bindAssigns.push(`const ${jsName(name)} = (${scVar})[${JSON.stringify(`_${i}`)}];`);
+	}
+	return `if (_s.variantIs(${scVar}, ${JSON.stringify(tag)})) { ${bindAssigns.join(" ")} return ${jsOfExpr(body, inner)}; }`;
+}
+function genTile(tile, gen) {
+	const ctx = makeEvalCtx(gen, new Set(tile.in ? ["$1"] : []));
+	return tileExprJs(tile.body, gen, ctx, tile.name);
+}
+function tileExprJs(t, gen, ctx, enclosingTile) {
+	switch (t.kind) {
+		case "TileFor": {
+			const iter = jsOfExpr(t.iter, ctx);
+			const inner = makeEvalCtx(gen, ctx.localBinds);
+			inner.localBinds.add(t.bind);
+			return `((${iter}) || []).map((${jsName(t.bind)}) => (${tileExprJs(t.body, gen, inner, enclosingTile)}))`;
+		}
+		case "TileWhen": return `((${jsOfExpr(t.cond, ctx)}) ? (${tileExprJs(t.body, gen, ctx, enclosingTile)}) : null)`;
+		case "TileIf": return `((${jsOfExpr(t.cond, ctx)}) ? (${tileExprJs(t.consequent, gen, ctx, enclosingTile)}) : (${tileExprJs(t.alternate, gen, ctx, enclosingTile)}))`;
+		case "TileMatch": {
+			const sc = jsOfExpr(t.scrutinee, ctx);
+			return `((_v) => { ${t.arms.map((arm) => {
+				if (arm.pattern.kind === "PVariant") {
+					const inner = makeEvalCtx(gen, ctx.localBinds);
+					for (const b of arm.pattern.binds) if (b !== "_") inner.localBinds.add(b);
+					const binds = arm.pattern.binds.map((b, i) => b !== "_" ? `const ${jsName(b)} = _v[${JSON.stringify(`_${i}`)}];` : "").join(" ");
+					return `if (_s.variantIs(_v, ${JSON.stringify(arm.pattern.name)})) { ${binds} return ${tileExprJs(arm.body, gen, inner, enclosingTile)}; }`;
+				}
+				if (arm.pattern.kind === "PBind") {
+					const inner = makeEvalCtx(gen, ctx.localBinds);
+					inner.localBinds.add(arm.pattern.name);
+					return `if (true) { const ${jsName(arm.pattern.name)} = _v; return ${tileExprJs(arm.body, gen, inner, enclosingTile)}; }`;
+				}
+				if (arm.pattern.kind === "PWildcard") return `if (true) { return ${tileExprJs(arm.body, gen, ctx, enclosingTile)}; }`;
+				return `if (_v === ${JSON.stringify(arm.pattern.value)}) { return ${tileExprJs(arm.body, gen, ctx, enclosingTile)}; }`;
+			}).join(" else ")} else { return { kind: "text", text: "" }; } })(${sc})`;
+		}
+		case "TileCall": return tileCallJs(t, gen, ctx, enclosingTile);
+	}
+}
+const BUILTIN_TILES$2 = new Set([
+	"page",
+	"row",
+	"column",
+	"card",
+	"box",
+	"panel",
+	"grid",
+	"stack",
+	"region",
+	"scroll",
+	"divider",
+	"fieldset",
+	"heading",
+	"text",
+	"button",
+	"form",
+	"input",
+	"textarea",
+	"label",
+	"check",
+	"spinner",
+	"select",
+	"radio",
+	"slider",
+	"switch",
+	"link",
+	"markdown",
+	"skeleton",
+	"image",
+	"icon"
+]);
+/**
+* For `bind=draft` or `bind=draft.title.deeper`, extract the root slot name,
+* the static path (string field names), and a JS expression to read the value.
+* Only static field-access paths are supported (no Index, no dynamic lookups).
+* Returns null if no `bind=` arg exists or the path isn't statically resolvable.
+*/
+function extractBindPath(args) {
+	const bindArg = args.find((a) => a.name === "bind");
+	if (!bindArg) return null;
+	let cur = bindArg.value;
+	const reverseSegments = [];
+	while (cur.kind === "FieldAccess") {
+		reverseSegments.push(cur.field);
+		cur = cur.base;
+	}
+	if (cur.kind !== "Ref") return null;
+	const root = cur.name;
+	const path = reverseSegments.reverse();
+	let readRaw = `_live[${JSON.stringify(root)}]`;
+	for (const seg of path) readRaw = `((${readRaw}) ?? {})[${JSON.stringify(seg)}]`;
+	return {
+		root,
+		path,
+		readJs: readRaw,
+		readJsRaw: readRaw
+	};
+}
+function tileCallJs(t, gen, ctx, enclosingTile) {
+	const name = t.name;
+	if (!BUILTIN_TILES$2.has(name)) {
+		const def = gen.tiles.find((x) => x.name === name);
+		if (!def) throw new Error(`Tile "${name}" not found`);
+		const inner = makeEvalCtx(gen, ctx.localBinds);
+		const arg1 = t.args[0];
+		const TILE_KINDS = new Set([
+			"TileCall",
+			"TileFor",
+			"TileWhen",
+			"TileIf",
+			"TileMatch"
+		]);
+		const wrapBoundary = (body) => {
+			if (!def.errorBoundary) return body;
+			const fb = gen.tiles.find((x) => x.name === def.errorBoundary);
+			if (!fb) return body;
+			const fbCtx = makeEvalCtx(gen, new Set(["$1"]));
+			const fbBody = tileExprJs(fb.body, gen, fbCtx, fb.name);
+			return `((() => { try { return ${body}; } catch (_err) { const ${jsName("$1")} = { message: String(_err && _err.message || _err), location: ${JSON.stringify(def.name)} }; return ${fbBody}; } })())`;
+		};
+		if (arg1) {
+			const v = arg1.value;
+			if (TILE_KINDS.has(v.kind ?? "")) return wrapBoundary(tileExprJs(v, gen, inner, def.name));
+			const oneJs = jsOfExpr(v, ctx);
+			const propsJs = propsFor(t, ctx);
+			const bodyJs = tileExprJs(def.body, gen, addBind(inner, "$1"), def.name);
+			return wrapBoundary(`((_arg, _propsOuter) => { const ${jsName("$1")} = _arg; return _attachProps(${bodyJs}, _propsOuter); })(${oneJs}, ${propsJs})`);
+		}
+		const propsJs = propsFor(t, ctx);
+		return wrapBoundary(`(_attachProps(${tileExprJs(def.body, gen, inner, def.name)}, ${propsJs}))`);
+	}
+	const propsObj = propsFor(t, ctx, enclosingTile);
+	switch (name) {
+		case "page":
+		case "row":
+		case "column":
+		case "card":
+		case "box":
+		case "grid":
+		case "stack":
+		case "region":
+		case "scroll":
+		case "divider":
+		case "fieldset":
+		case "panel": {
+			const children = collectChildren(t.args, gen, ctx, enclosingTile);
+			return `({ kind: ${JSON.stringify(name)}, children: [${children}], props: ${propsObj} })`;
+		}
+		case "heading": return `({ kind: "heading", text: _s.show(${t.args[0] ? jsOfExpr(asExpr(t.args[0].value), ctx) : "\"\""}), props: ${propsObj} })`;
+		case "text": return `({ kind: "text", text: _s.show(${t.args[0] ? jsOfExpr(asExpr(t.args[0].value), ctx) : "\"\""}), props: ${propsObj} })`;
+		case "button": {
+			const textArg = t.args.find((a) => a.name === "text");
+			return `({ kind: "button", text: _s.show(${textArg ? jsOfExpr(asExpr(textArg.value), ctx) : "\"\""}), props: ${propsObj} })`;
+		}
+		case "input": {
+			const fields = [`kind: "input"`];
+			const bindInfo = extractBindPath(t.args);
+			for (const arg of t.args) {
+				if (!arg.name || arg.name === "bind") continue;
+				const valJs = jsOfExpr(asExpr(arg.value), ctx);
+				if (arg.name === "value") fields.push(`value: _s.show(${valJs})`);
+				else if (arg.name === "placeholder") fields.push(`placeholder: ${valJs}`);
+				else if (arg.name === "type") fields.push(`type: ${valJs}`);
+				else if (arg.name === "id") fields.push(`id: ${valJs}`);
+				else if (arg.name === "auto-focus") fields.push(`autoFocus: ${valJs}`);
+				else if (arg.name === "required") fields.push(`required: ${valJs}`);
+			}
+			if (bindInfo) {
+				fields.push(`bind: ${JSON.stringify(bindInfo.root)}`);
+				if (bindInfo.path.length > 0) fields.push(`bindPath: ${JSON.stringify(bindInfo.path)}`);
+				fields.push(`value: _s.show(${bindInfo.readJs})`);
+			}
+			fields.push(`props: ${propsObj}`);
+			return `({ ${fields.join(", ")} })`;
+		}
+		case "textarea": {
+			const fields = [`kind: "textarea"`];
+			const bindInfo = extractBindPath(t.args);
+			for (const arg of t.args) {
+				if (!arg.name || arg.name === "bind") continue;
+				const valJs = jsOfExpr(asExpr(arg.value), ctx);
+				if (arg.name === "value") fields.push(`value: _s.show(${valJs})`);
+				else if (arg.name === "placeholder") fields.push(`placeholder: ${valJs}`);
+				else if (arg.name === "id") fields.push(`id: ${valJs}`);
+				else if (arg.name === "rows") fields.push(`rows: ${valJs}`);
+			}
+			if (bindInfo) {
+				fields.push(`bind: ${JSON.stringify(bindInfo.root)}`);
+				if (bindInfo.path.length > 0) fields.push(`bindPath: ${JSON.stringify(bindInfo.path)}`);
+				fields.push(`value: _s.show(${bindInfo.readJs})`);
+			}
+			fields.push(`props: ${propsObj}`);
+			return `({ ${fields.join(", ")} })`;
+		}
+		case "check": {
+			const valArg = t.args.find((a) => a.name === "value");
+			return `({ kind: "check", checked: !!(${valArg ? jsOfExpr(asExpr(valArg.value), ctx) : "false"}), props: ${propsObj} })`;
+		}
+		case "select": {
+			const fields = [`kind: "select"`];
+			const bindInfo = extractBindPath(t.args);
+			if (bindInfo) {
+				fields.push(`bind: ${JSON.stringify(bindInfo.root)}`);
+				if (bindInfo.path.length > 0) fields.push(`bindPath: ${JSON.stringify(bindInfo.path)}`);
+				fields.push(`value: ${bindInfo.readJsRaw}`);
+			} else {
+				const valArg = t.args.find((a) => a.name === "value");
+				if (valArg) fields.push(`value: ${jsOfExpr(asExpr(valArg.value), ctx)}`);
+			}
+			const optionsArg = t.args.find((a) => a.name === "options");
+			if (optionsArg) fields.push(`options: ${jsOfExpr(asExpr(optionsArg.value), ctx)}`);
+			else fields.push(`options: []`);
+			const placeholderArg = t.args.find((a) => a.name === "placeholder");
+			if (placeholderArg) fields.push(`placeholder: ${jsOfExpr(asExpr(placeholderArg.value), ctx)}`);
+			fields.push(`props: ${propsObj}`);
+			return `({ ${fields.join(", ")} })`;
+		}
+		case "radio": {
+			const fields = [`kind: "radio"`];
+			for (const arg of t.args) {
+				if (!arg.name) continue;
+				const valJs = jsOfExpr(asExpr(arg.value), ctx);
+				if (arg.name === "group") fields.push(`group: ${valJs}`);
+				else if (arg.name === "value") fields.push(`value: ${valJs}`);
+				else if (arg.name === "selected") fields.push(`selected: !!(${valJs})`);
+			}
+			fields.push(`props: ${propsObj}`);
+			return `({ ${fields.join(", ")} })`;
+		}
+		case "spinner": return `({ kind: "spinner", props: ${propsObj} })`;
+		case "form": return `({ kind: "form", children: [${collectChildren(t.args, gen, ctx, enclosingTile)}], props: ${propsObj} })`;
+		case "label": {
+			const text = t.args.find((a) => a.name === "text");
+			return `({ kind: "label", text: _s.show(${text ? jsOfExpr(asExpr(text.value), ctx) : "\"\""}), props: ${propsObj} })`;
+		}
+		case "link": {
+			const toArg = t.args.find((a) => a.name === "to");
+			const to = toArg ? jsOfExpr(asExpr(toArg.value), ctx) : "\"\"";
+			const textProp = t.props.find((p) => p.name === "text");
+			return `({ kind: "link", text: _s.show(${textProp ? jsOfExpr(textProp.value, ctx) : "\"\""}), to: _s.show(${to}), props: ${propsObj} })`;
+		}
+		case "markdown": return `({ kind: "markdown", text: _s.show(${t.args[0] ? jsOfExpr(asExpr(t.args[0].value), ctx) : "\"\""}), props: ${propsObj} })`;
+		case "skeleton": return `({ kind: "skeleton", props: ${propsObj} })`;
+		case "image": {
+			const src = t.args.find((a) => a.name === "src");
+			return `({ kind: "image", src: _s.show(${src ? jsOfExpr(asExpr(src.value), ctx) : "\"\""}), props: ${propsObj} })`;
+		}
+		case "icon": {
+			const name = t.args.find((a) => a.name === "name");
+			return `({ kind: "icon", name: _s.show(${name ? jsOfExpr(asExpr(name.value), ctx) : "\"\""}), props: ${propsObj} })`;
+		}
+	}
+	throw new Error(`Unsupported builtin tile "${name}"`);
+}
+function asExpr(v) {
+	return v;
+}
+function collectChildren(args, gen, ctx, enclosingTile) {
+	const parts = [];
+	for (const a of args) {
+		if (a.name) continue;
+		const v = a.value;
+		if (v.kind === "TileCall" || v.kind === "TileFor" || v.kind === "TileWhen" || v.kind === "TileIf" || v.kind === "TileMatch") parts.push(tileExprJs(v, gen, ctx, enclosingTile));
+		else if (v.kind === "Ref") {
+			const refName = v.name;
+			const def = gen.tiles.find((x) => x.name === refName);
+			if (def) parts.push(tileExprJs(def.body, gen, ctx, def.name));
+			else parts.push("null");
+		}
+	}
+	return `..._children(${parts.join(", ")})`;
+}
+function propsFor(t, ctx, enclosingTile) {
+	const entries = [];
+	for (const a of t.args) {
+		if (!a.name) continue;
+		if (a.name === "onClick" || a.name === "onSubmit" || a.name === "onChange" || a.name === "onInput") {
+			if (a.value.kind === "Ref") {
+				const reducerName = a.value.name;
+				entries.push(`${a.name}: (el) => globalThis.__kumikiApp._dispatch(${JSON.stringify(reducerName)}, el)`);
+			}
+		}
+	}
+	for (const p of t.props) {
+		if (p.name === "onClick" || p.name === "onSubmit" || p.name === "onChange" || p.name === "onInput") {
+			if (p.value.kind === "Ref") {
+				const reducerName = p.value.name;
+				entries.push(`${p.name}: (el) => globalThis.__kumikiApp._dispatch(${JSON.stringify(reducerName)}, el)`);
+			}
+			continue;
+		}
+		entries.push(`${jsName(p.name)}: ${jsOfExpr(p.value, ctx)}`);
+	}
+	if (t.name === "button" && enclosingTile) {
+		const r = ctx.gen.reducers.find((rr) => rr.on.kind === "UiEvent" && rr.on.ev === "click" && rr.on.selector.tile === enclosingTile);
+		if (r && !entries.some((e) => e.startsWith("onClick"))) entries.push(`onClick: (el) => globalThis.__kumikiApp._dispatch(${JSON.stringify(r.name)}, el)`);
+	}
+	if (t.name === "check" && enclosingTile) {
+		const r = ctx.gen.reducers.find((rr) => rr.on.kind === "UiEvent" && rr.on.ev === "click" && rr.on.selector.tile === enclosingTile);
+		if (r && !entries.some((e) => e.startsWith("onClick"))) entries.push(`onClick: (el) => globalThis.__kumikiApp._dispatch(${JSON.stringify(r.name)}, el)`);
+	}
+	if (t.name === "form" && enclosingTile) {
+		const r = ctx.gen.reducers.find((rr) => rr.on.kind === "UiEvent" && rr.on.ev === "submit" && rr.on.selector.tile === enclosingTile);
+		if (r) entries.push(`onSubmit: (el) => globalThis.__kumikiApp._dispatch(${JSON.stringify(r.name)}, el)`);
+	}
+	if ((t.name === "select" || t.name === "input" || t.name === "textarea") && enclosingTile) {
+		const r = ctx.gen.reducers.find((rr) => rr.on.kind === "UiEvent" && rr.on.ev === "change" && rr.on.selector.tile === enclosingTile);
+		if (r && !entries.some((e) => e.startsWith("onChange"))) entries.push(`onChange: (el) => globalThis.__kumikiApp._dispatch(${JSON.stringify(r.name)}, el)`);
+	}
+	if ((t.name === "input" || t.name === "textarea") && enclosingTile) {
+		const r = ctx.gen.reducers.find((rr) => rr.on.kind === "UiEvent" && rr.on.ev === "input" && rr.on.selector.tile === enclosingTile);
+		if (r && !entries.some((e) => e.startsWith("onInput"))) entries.push(`onInput: (el) => globalThis.__kumikiApp._dispatch(${JSON.stringify(r.name)}, el)`);
+	}
+	const elProps = [];
+	for (const p of t.props) {
+		if (p.name === "onClick" || p.name === "onSubmit" || p.name === "onChange" || p.name === "onInput") continue;
+		elProps.push(`${jsName(p.name)}: ${jsOfExpr(p.value, ctx)}`);
+	}
+	if (elProps.length > 0) entries.push(`el: { ${elProps.join(", ")} }`);
+	return `{ ${entries.join(", ")} }`;
+}
+function addBind(ctx, name) {
+	const out = makeEvalCtx(ctx.gen, ctx.localBinds);
+	out.localBinds.add(name);
+	return out;
+}
+function jsName(name) {
+	return name.replace(/^\$/, "_d_").replace(/-/g, "_").replace(/\./g, "_");
+}
+function refinementJs(t, gen) {
+	let target = t;
+	if (t.kind === "TypeRef") {
+		const def = gen.types.get(t.name);
+		if (!def) return void 0;
+		target = def.body;
+	}
+	if (target.kind === "TypeNominal" || target.kind === "TypeRefinement") {
+		const r = target.refinement;
+		if (r) return refinementToJs(r);
+	}
+}
+function refinementToJs(r) {
+	switch (r.pred) {
+		case "between": return `(v) => typeof v === "number" && v >= ${r.args[0]} && v <= ${r.args[1]}`;
+		case "nonempty": return `(v) => typeof v === "string" && v.length > 0`;
+		case "len-lt": return `(v) => typeof v === "string" && v.length < ${r.args[0]}`;
+		case "len-gt": return `(v) => typeof v === "string" && v.length > ${r.args[0]}`;
+		case "len-eq": return `(v) => typeof v === "string" && v.length === ${r.args[0]}`;
+		default: return `(_v) => true`;
+	}
+}
+function emitFromInitExpr(e) {
+	if (e.kind === "Call") return `{ effect: ${JSON.stringify(e.callee)}, args: [${e.args.map((a) => jsOfExpr(a, {
+		gen: {},
+		localBinds: /* @__PURE__ */ new Set()
+	})).join(", ")}] }`;
+	return "null";
+}
+const RUNTIME_HELPERS = `
+function _setPath(obj, path, value) {
+  if (path.length === 0) return value;
+  const [head, ...rest] = path;
+  const cur = obj ?? {};
+  return { ...cur, [head]: _setPath(cur[head], rest, value) };
+}
+function _children(...xs) {
+  const out = [];
+  for (const x of xs) {
+    if (x === null || x === undefined) continue;
+    if (Array.isArray(x)) {
+      for (const y of x) if (y !== null && y !== undefined) out.push(y);
+    } else {
+      out.push(x);
+    }
+  }
+  return out;
+}
+function _attachProps(node, props) {
+  if (!node || !props) return node;
+  return { ...node, props: { ...(node.props || {}), ...props } };
+}
+`;
+//#endregion
+//#region src/lexer.ts
+const KEYWORDS = new Set([
+	"type",
+	"slot",
+	"effect",
+	"reducer",
+	"tile",
+	"fn",
+	"app",
+	"nominal",
+	"where",
+	"when",
+	"for",
+	"in",
+	"let",
+	"if",
+	"then",
+	"else",
+	"match",
+	"with",
+	"on",
+	"do",
+	"emit",
+	"cap",
+	"out",
+	"policy",
+	"retry",
+	"true",
+	"false",
+	"fresh",
+	"self",
+	"now",
+	"null"
+]);
+const MULTI_CHAR_OPS = [
+	"->>",
+	":=",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"->",
+	"||",
+	"&&"
+];
+const SINGLE_CHAR_OPS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"<",
+	">",
+	"=",
+	"|",
+	"&",
+	"!",
+	"(",
+	")",
+	"{",
+	"}",
+	"[",
+	"]",
+	",",
+	";",
+	":",
+	".",
+	"#"
+]);
+const MAX_IDENT_LEN = 32;
+var LexError = class extends Error {
+	pos;
+	constructor(message, pos) {
+		super(`Lex error at ${pos.line}:${pos.col}: ${message}`);
+		this.pos = pos;
+	}
+};
+function lex(source) {
+	const tokens = [];
+	let i = 0;
+	let line = 1;
+	let col = 1;
+	const advance = (n = 1) => {
+		for (let k = 0; k < n; k++) {
+			if (source[i] === "\n") {
+				line++;
+				col = 1;
+			} else col++;
+			i++;
+		}
+	};
+	const pos = () => ({
+		line,
+		col
+	});
+	while (i < source.length) {
+		const c = source[i];
+		if (c === " " || c === "	" || c === "\n" || c === "\r") {
+			advance();
+			continue;
+		}
+		if (c === "#") {
+			const prev = i > 0 ? source[i - 1] : void 0;
+			if (prev !== void 0 && (isIdentCont(prev) || prev === ")" || prev === "]" || prev === "}")) {
+				tokens.push({
+					kind: "op",
+					value: "#",
+					pos: pos()
+				});
+				advance();
+				continue;
+			}
+			while (i < source.length && source[i] !== "\n") advance();
+			continue;
+		}
+		const startPos = pos();
+		if (c === "\"") {
+			let value = "";
+			advance();
+			while (i < source.length && source[i] !== "\"") {
+				const ch = source[i];
+				if (ch === "\\") {
+					advance();
+					const esc = source[i];
+					if (esc === void 0) throw new LexError("Unterminated string", startPos);
+					if (esc === "n") value += "\n";
+					else if (esc === "t") value += "	";
+					else if (esc === "r") value += "\r";
+					else if (esc === "\"") value += "\"";
+					else if (esc === "\\") value += "\\";
+					else throw new LexError(`Unknown escape \\${esc}`, pos());
+					advance();
+				} else {
+					value += ch;
+					advance();
+				}
+			}
+			if (source[i] !== "\"") throw new LexError("Unterminated string", startPos);
+			advance();
+			tokens.push({
+				kind: "str",
+				value,
+				pos: startPos
+			});
+			continue;
+		}
+		if (isDigit(c)) {
+			let raw = "";
+			while (i < source.length && isDigit(source[i])) {
+				raw += source[i];
+				advance();
+			}
+			if (source[i] === "." && isDigit(source[i + 1])) {
+				raw += ".";
+				advance();
+				while (i < source.length && isDigit(source[i])) {
+					raw += source[i];
+					advance();
+				}
+			}
+			tokens.push({
+				kind: "num",
+				value: Number(raw),
+				pos: startPos
+			});
+			continue;
+		}
+		if (c === "$") {
+			let raw = "$";
+			advance();
+			while (i < source.length && isIdentCont(source[i])) {
+				raw += source[i];
+				advance();
+			}
+			if (raw.length === 1) throw new LexError(`Bare "$" is not a token`, startPos);
+			tokens.push({
+				kind: "ident",
+				value: raw,
+				pos: startPos
+			});
+			continue;
+		}
+		if (isIdentStart(c)) {
+			let raw = "";
+			while (i < source.length && isIdentCont(source[i])) {
+				raw += source[i];
+				advance();
+			}
+			if (raw.length > MAX_IDENT_LEN) throw new LexError(`Identifier too long (max ${MAX_IDENT_LEN}): "${raw}"`, startPos);
+			if (KEYWORDS.has(raw)) tokens.push({
+				kind: "kw",
+				value: raw,
+				pos: startPos
+			});
+			else tokens.push({
+				kind: "ident",
+				value: raw,
+				pos: startPos
+			});
+			continue;
+		}
+		let matched;
+		for (const op of MULTI_CHAR_OPS) if (source.startsWith(op, i)) {
+			matched = op;
+			break;
+		}
+		if (matched !== void 0) {
+			tokens.push({
+				kind: "op",
+				value: matched,
+				pos: startPos
+			});
+			advance(matched.length);
+			continue;
+		}
+		if (SINGLE_CHAR_OPS.has(c)) {
+			tokens.push({
+				kind: "op",
+				value: c,
+				pos: startPos
+			});
+			advance();
+			continue;
+		}
+		throw new LexError(`Unexpected character "${c}"`, startPos);
+	}
+	tokens.push({
+		kind: "eof",
+		pos: pos()
+	});
+	return tokens;
+}
+function isDigit(c) {
+	return c >= "0" && c <= "9";
+}
+function isIdentStart(c) {
+	return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+}
+function isIdentCont(c) {
+	return isIdentStart(c) || isDigit(c) || c === "_" || c === "-";
+}
+//#endregion
+//#region src/parser.ts
+var ParseError = class extends Error {
+	pos;
+	constructor(message, pos) {
+		super(`Parse error at ${pos.line}:${pos.col}: ${message}`);
+		this.pos = pos;
+	}
+};
+const PRIM_TYPES = new Set([
+	"Int",
+	"Text",
+	"Bool",
+	"Unit",
+	"Float",
+	"Time",
+	"Bytes"
+]);
+const VALUE_ARG_BUILTINS = new Set([
+	"text",
+	"heading",
+	"markdown",
+	"label",
+	"link",
+	"image",
+	"icon"
+]);
+const VALUE_NAMED_ARGS = new Set([
+	"text",
+	"value",
+	"placeholder",
+	"to",
+	"src",
+	"id",
+	"key",
+	"name",
+	"label",
+	"title",
+	"type",
+	"color",
+	"bg",
+	"size",
+	"weight",
+	"variant",
+	"pad",
+	"gap",
+	"align",
+	"justify",
+	"wrap",
+	"w",
+	"h",
+	"min-w",
+	"min-h",
+	"max-w",
+	"max-h",
+	"radius",
+	"shadow",
+	"rows",
+	"cols",
+	"aspect"
+]);
+const BUILTIN_TILES$1 = new Set([
+	"page",
+	"region",
+	"row",
+	"column",
+	"stack",
+	"grid",
+	"box",
+	"card",
+	"panel",
+	"divider",
+	"scroll",
+	"text",
+	"heading",
+	"link",
+	"code",
+	"markdown",
+	"image",
+	"icon",
+	"video",
+	"button",
+	"input",
+	"textarea",
+	"check",
+	"radio",
+	"select",
+	"slider",
+	"switch",
+	"form",
+	"label",
+	"fieldset",
+	"error",
+	"list",
+	"list-item",
+	"table",
+	"table-head",
+	"table-body",
+	"table-row",
+	"table-cell",
+	"modal",
+	"drawer",
+	"tooltip",
+	"popover",
+	"toast",
+	"spinner",
+	"progress",
+	"skeleton",
+	"route-outlet"
+]);
+const REFINE_PREDS = new Set([
+	"between",
+	"nonempty",
+	"len-eq",
+	"len-lt",
+	"len-gt",
+	"positive",
+	"negative",
+	"email",
+	"url",
+	"uuid",
+	"regex",
+	"one-of"
+]);
+var Parser = class {
+	tokens;
+	i = 0;
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	peek(offset = 0) {
+		return this.tokens[this.i + offset] ?? this.tokens[this.tokens.length - 1];
+	}
+	next() {
+		return this.tokens[this.i++] ?? this.tokens[this.tokens.length - 1];
+	}
+	eat(kind, value) {
+		const t = this.peek();
+		if (t.kind !== kind || value !== void 0 && "value" in t && t.value !== value) {
+			const got = t.kind === "eof" ? "eof" : `${t.kind}(${t.value})`;
+			throw new ParseError(`Expected ${value !== void 0 ? `${kind}(${value})` : kind}, got ${got}`, t.pos);
+		}
+		this.next();
+		return t;
+	}
+	matchTAt(offset, kind, value) {
+		const t = this.peek(offset);
+		if (t.kind !== kind) return false;
+		if (value !== void 0 && "value" in t && t.value !== value) return false;
+		return true;
+	}
+	matchT(kind, value) {
+		return this.matchTAt(0, kind, value);
+	}
+	matchOp(value) {
+		return this.matchT("op", value);
+	}
+	matchKw(value) {
+		return this.matchT("kw", value);
+	}
+	parseProgram() {
+		const defs = [];
+		while (!this.matchT("eof")) {
+			if (this.matchT("ident", "theme")) {
+				defs.push(this.parseThemeDef());
+				continue;
+			}
+			defs.push(this.parseDef());
+		}
+		return {
+			kind: "Program",
+			defs
+		};
+	}
+	parseThemeDef() {
+		const start = this.eat("ident", "theme");
+		const name = this.eat("ident").value;
+		this.eat("op", "=");
+		return {
+			kind: "ThemeDef",
+			name,
+			body: this.parseThemeRecord(),
+			pos: start.pos
+		};
+	}
+	parseThemeRecord() {
+		this.eat("op", "{");
+		const out = {};
+		if (!this.matchOp("}")) {
+			this.parseThemeEntry(out);
+			while (this.matchOp(",")) {
+				this.next();
+				if (this.matchOp("}")) break;
+				this.parseThemeEntry(out);
+			}
+		}
+		this.eat("op", "}");
+		return out;
+	}
+	parseThemeEntry(out) {
+		const keyTok = this.peek();
+		if (keyTok.kind !== "ident" && keyTok.kind !== "kw" && keyTok.kind !== "str") throw new ParseError(`Expected theme key`, keyTok.pos);
+		this.next();
+		const key = keyTok.value;
+		this.eat("op", ":");
+		const v = this.peek();
+		if (v.kind === "op" && v.value === "{") out[key] = this.parseThemeRecord();
+		else if (v.kind === "str") {
+			this.next();
+			out[key] = v.value;
+		} else if (v.kind === "num") {
+			this.next();
+			out[key] = v.value;
+		} else throw new ParseError(`Theme values must be string, number, or nested record`, v.pos);
+	}
+	parseDef() {
+		const t = this.peek();
+		if (t.kind !== "kw") throw new ParseError("Expected a definition keyword", t.pos);
+		switch (t.value) {
+			case "type": return this.parseType();
+			case "slot": return this.parseSlot();
+			case "reducer": return this.parseReducer();
+			case "tile": return this.parseTile();
+			case "fn": return this.parseFn();
+			case "effect": return this.parseEffect();
+			case "app": return this.parseApp();
+			default: throw new ParseError(`Unsupported definition keyword "${t.value}"`, t.pos);
+		}
+	}
+	parseType() {
+		const start = this.eat("kw", "type");
+		const name = this.eat("ident").value;
+		const params = [];
+		if (this.matchOp("(")) {
+			this.next();
+			if (!this.matchOp(")")) {
+				params.push(this.eat("ident").value);
+				while (this.matchOp(",")) {
+					this.next();
+					params.push(this.eat("ident").value);
+				}
+			}
+			this.eat("op", ")");
+		}
+		this.eat("op", "=");
+		return {
+			kind: "TypeDef",
+			name,
+			params,
+			body: this.parseTypeExpr(),
+			pos: start.pos
+		};
+	}
+	parseTypeExpr() {
+		const first = this.parseTypeUnionAtom();
+		if (this.matchOp("|")) {
+			const variants = [this.typeAsVariant(first)];
+			while (this.matchOp("|")) {
+				this.next();
+				variants.push(this.typeAsVariant(this.parseTypeUnionAtom()));
+			}
+			return {
+				kind: "TypeUnion",
+				variants,
+				pos: first.pos
+			};
+		}
+		if (this.matchKw("where")) {
+			this.next();
+			return {
+				kind: "TypeRefinement",
+				inner: first,
+				refinement: this.parseRefinement(),
+				pos: first.pos
+			};
+		}
+		return first;
+	}
+	typeAsVariant(t) {
+		if (t.kind === "TypeRef") return {
+			name: t.name,
+			payloads: []
+		};
+		if (t.kind === "TypeApp") return {
+			name: t.name,
+			payloads: t.args
+		};
+		throw new ParseError(`Unsupported variant form`, t.pos);
+	}
+	parseTypeUnionAtom() {
+		if (this.matchKw("nominal")) {
+			const start = this.next();
+			const inner = this.parseTypeAtom();
+			let refinement;
+			if (this.matchKw("where")) {
+				this.next();
+				refinement = this.parseRefinement();
+			}
+			const node = {
+				kind: "TypeNominal",
+				inner,
+				pos: start.pos
+			};
+			if (refinement) node.refinement = refinement;
+			return node;
+		}
+		const atom = this.parseTypeAtom();
+		if (this.matchKw("where")) {
+			this.next();
+			return {
+				kind: "TypeRefinement",
+				inner: atom,
+				refinement: this.parseRefinement(),
+				pos: atom.pos
+			};
+		}
+		return atom;
+	}
+	parseTypeAtom() {
+		if (this.matchOp("{")) {
+			const start = this.next();
+			const fields = [];
+			if (!this.matchOp("}")) {
+				fields.push(this.parseTypeField());
+				while (this.matchOp(",")) {
+					this.next();
+					fields.push(this.parseTypeField());
+				}
+			}
+			this.eat("op", "}");
+			return {
+				kind: "TypeRecord",
+				fields,
+				pos: start.pos
+			};
+		}
+		const t = this.eat("ident");
+		const name = t.value;
+		if (this.matchOp("(")) {
+			this.next();
+			const args = [];
+			if (!this.matchOp(")")) {
+				args.push(this.parseTypeExpr());
+				while (this.matchOp(",")) {
+					this.next();
+					args.push(this.parseTypeExpr());
+				}
+			}
+			this.eat("op", ")");
+			return {
+				kind: "TypeApp",
+				name,
+				args,
+				pos: t.pos
+			};
+		}
+		if (PRIM_TYPES.has(name)) return {
+			kind: "TypePrim",
+			name,
+			pos: t.pos
+		};
+		return {
+			kind: "TypeRef",
+			name,
+			pos: t.pos
+		};
+	}
+	parseTypeField() {
+		const name = this.eat("ident").value;
+		this.eat("op", ":");
+		return {
+			name,
+			type: this.parseTypeExpr()
+		};
+	}
+	parseRefinement() {
+		const t = this.eat("ident");
+		const name = t.value;
+		if (!REFINE_PREDS.has(name)) throw new ParseError(`Unknown refinement predicate "${name}"`, t.pos);
+		const args = [];
+		if (this.matchOp("(")) {
+			this.next();
+			if (!this.matchOp(")")) {
+				args.push(this.parseRefinementArg());
+				while (this.matchOp(",")) {
+					this.next();
+					args.push(this.parseRefinementArg());
+				}
+			}
+			this.eat("op", ")");
+		}
+		return {
+			kind: "Refinement",
+			pred: name,
+			args,
+			pos: t.pos
+		};
+	}
+	parseRefinementArg() {
+		const t = this.peek();
+		if (t.kind === "num") {
+			this.next();
+			return t.value;
+		}
+		if (t.kind === "str") {
+			this.next();
+			return t.value;
+		}
+		throw new ParseError("Refinement argument must be a literal", t.pos);
+	}
+	parseSlot() {
+		const start = this.eat("kw", "slot");
+		const name = this.eat("ident").value;
+		this.eat("op", ":");
+		const type = this.parseTypeExpr();
+		let modifier;
+		if (this.matchT("ident", "transient")) {
+			this.next();
+			modifier = "transient";
+		} else if (this.matchT("ident", "volatile")) {
+			this.next();
+			modifier = "volatile";
+		}
+		this.eat("op", "=");
+		const def = {
+			kind: "SlotDef",
+			name,
+			type,
+			init: this.parseExpr(),
+			pos: start.pos
+		};
+		if (modifier) def.modifier = modifier;
+		return def;
+	}
+	parseReducer() {
+		const start = this.eat("kw", "reducer");
+		const name = this.eat("ident").value;
+		this.eat("kw", "on");
+		this.eat("op", "=");
+		const on = this.parseEventPattern();
+		this.eat("kw", "do");
+		this.eat("op", "=");
+		const stmts = [this.parseStatement()];
+		while (this.matchOp(";") || this.statementLookahead()) {
+			if (this.matchOp(";")) this.next();
+			stmts.push(this.parseStatement());
+		}
+		return {
+			kind: "ReducerDef",
+			name,
+			on,
+			do: stmts,
+			pos: start.pos
+		};
+	}
+	statementLookahead() {
+		if (this.matchKw("let") || this.matchKw("emit") || this.matchKw("for") || this.matchKw("if") || this.matchKw("match")) return true;
+		if (this.peek().kind === "ident") {
+			const j = this.i + 1;
+			while (j < this.tokens.length) {
+				const t = this.tokens[j];
+				if (t.kind === "op" && (t.value === ":=" || t.value === "[" || t.value === ".")) return true;
+				if (t.kind === "op" && (t.value === ":=" || t.value === "(")) return true;
+				if (t.kind === "kw") return false;
+				if (t.kind === "ident") return false;
+				if (t.kind === "eof") return false;
+				return false;
+			}
+		}
+		return false;
+	}
+	parseEventPattern() {
+		const t = this.peek();
+		if (t.kind === "ident" && t.value === "timer") {
+			this.next();
+			this.eat("op", "(");
+			const intervalMs = this.parseDuration();
+			this.eat("op", ")");
+			return {
+				kind: "TimerEvent",
+				intervalMs,
+				pos: t.pos
+			};
+		}
+		if (t.kind === "ident" || t.kind === "kw" && (t.value === "app" || t.value === "tile")) {
+			const name = t.value;
+			this.next();
+			this.eat("op", ".");
+			const sub = this.eat("ident").value;
+			if (name === "ui") {
+				if (sub !== "click" && sub !== "submit" && sub !== "change" && sub !== "input" && sub !== "focus" && sub !== "blur") throw new ParseError(`Unknown ui event "${sub}"`, t.pos);
+				this.eat("op", "(");
+				const tile = this.eat("ident").value;
+				let id;
+				if (this.matchOp("#")) {
+					this.next();
+					id = this.eat("ident").value;
+				}
+				this.eat("op", ")");
+				const sel = { tile };
+				if (id) sel.id = id;
+				return {
+					kind: "UiEvent",
+					ev: sub,
+					selector: sel,
+					pos: t.pos
+				};
+			}
+			if (name === "app") return {
+				kind: "LifecycleEvent",
+				name: `app.${sub}`,
+				pos: t.pos
+			};
+			if (name === "tile") {
+				if (this.matchOp("(")) {
+					this.next();
+					this.eat("ident");
+					this.eat("op", ")");
+				}
+				return {
+					kind: "LifecycleEvent",
+					name: `tile.${sub}`,
+					pos: t.pos
+				};
+			}
+			if (name === "route") {
+				if (this.matchOp("(")) {
+					this.next();
+					this.eat("str");
+					this.eat("op", ")");
+				}
+				return {
+					kind: "LifecycleEvent",
+					name: `route.${sub}`,
+					pos: t.pos
+				};
+			}
+			if (sub === "ok" || sub === "err") {
+				this.eat("op", "(");
+				const binds = [];
+				if (!this.matchOp(")")) {
+					binds.push(this.readBind());
+					while (this.matchOp(",")) {
+						this.next();
+						binds.push(this.readBind());
+					}
+				}
+				this.eat("op", ")");
+				return {
+					kind: "EffectEvent",
+					effect: name,
+					outcome: sub,
+					binds,
+					pos: t.pos
+				};
+			}
+			throw new ParseError(`Unsupported event pattern "${name}.${sub}"`, t.pos);
+		}
+		throw new ParseError("Expected event pattern", t.pos);
+	}
+	readBind() {
+		if (this.matchOp("_")) {
+			this.next();
+			return "_";
+		}
+		const t = this.peek();
+		if (t.kind === "op" && t.value === "$") {}
+		if (this.matchT("ident", "_")) {
+			this.next();
+			return "_";
+		}
+		return this.eat("ident").value;
+	}
+	parseStatement() {
+		if (this.matchKw("for")) {
+			const start = this.next();
+			const bindTok = this.eat("ident");
+			this.eat("kw", "in");
+			const iter = this.parseExpr();
+			const body = this.parseStatementBody();
+			return {
+				kind: "ForStmt",
+				bind: bindTok.value,
+				iter,
+				body,
+				pos: start.pos
+			};
+		}
+		if (this.matchKw("if")) {
+			const start = this.next();
+			const cond = this.parseExpr();
+			this.eat("kw", "then");
+			const thenBody = this.parseStatementBody();
+			let elseBody = [];
+			if (this.matchKw("else")) {
+				this.next();
+				elseBody = this.parseStatementBody();
+			}
+			return {
+				kind: "IfStmt",
+				cond,
+				consequent: thenBody,
+				alternate: elseBody,
+				pos: start.pos
+			};
+		}
+		if (this.matchKw("match")) {
+			const start = this.next();
+			const scrutinee = this.parseExpr();
+			this.eat("kw", "with");
+			const arms = [];
+			while (this.matchOp("|")) {
+				this.next();
+				const pattern = this.parsePattern();
+				this.eat("op", "->");
+				const body = this.parseStatementBody();
+				arms.push({
+					pattern,
+					body
+				});
+			}
+			return {
+				kind: "MatchStmt",
+				scrutinee,
+				arms,
+				pos: start.pos
+			};
+		}
+		if (this.matchOp("(") && this.matchTAt(1, "op", ")")) {
+			const tok = this.next();
+			this.eat("op", ")");
+			return {
+				kind: "NoopStmt",
+				pos: tok.pos
+			};
+		}
+		if (this.matchKw("let")) {
+			const start = this.next();
+			const name = this.eat("ident").value;
+			this.eat("op", "=");
+			return {
+				kind: "LetStmt",
+				name,
+				rhs: this.parseExpr(),
+				pos: start.pos
+			};
+		}
+		if (this.matchKw("emit")) {
+			const start = this.next();
+			const effect = this.eat("ident").value;
+			this.eat("op", "(");
+			const args = [];
+			if (!this.matchOp(")")) {
+				args.push(this.parseExpr());
+				while (this.matchOp(",")) {
+					this.next();
+					args.push(this.parseExpr());
+				}
+			}
+			this.eat("op", ")");
+			return {
+				kind: "Emit",
+				effect,
+				args,
+				pos: start.pos
+			};
+		}
+		const lvalue = this.parseLvalue();
+		this.eat("op", ":=");
+		return {
+			kind: "SlotAssign",
+			lvalue,
+			rhs: this.parseExpr(),
+			pos: lvalue.pos
+		};
+	}
+	/**
+	* Body of a control-flow statement (for / if-stmt / match-stmt arm).
+	* Three accepted forms:
+	*   - `{ stmt (; stmt)* }` explicit brace block
+	*   - `stmt; stmt; ...` semicolon-separated (until next branch keyword)
+	*   - `stmt\n stmt\n ...` newline-separated (until next branch keyword)
+	* Stops at `else`, `}`, `|` (match arm), or EOF — those belong to the enclosing form.
+	*/
+	parseStatementBody() {
+		if (this.matchOp("{")) {
+			this.next();
+			const out = [];
+			if (!this.matchOp("}")) {
+				out.push(this.parseStatement());
+				while (this.matchOp(";") || this.statementLookahead() && !this.matchOp("}")) {
+					if (this.matchOp(";")) this.next();
+					if (this.matchOp("}")) break;
+					out.push(this.parseStatement());
+				}
+			}
+			this.eat("op", "}");
+			return out;
+		}
+		const out = [this.parseStatement()];
+		while (this.matchOp(";") || this.statementLookahead()) {
+			if (this.matchOp(";")) this.next();
+			if (this.matchKw("else") || this.matchOp("}") || this.matchOp("|")) break;
+			out.push(this.parseStatement());
+		}
+		return out;
+	}
+	parseLvalue() {
+		const tok = this.eat("ident");
+		let lv = {
+			kind: "LSlot",
+			name: tok.value,
+			pos: tok.pos
+		};
+		while (true) if (this.matchOp(".")) {
+			this.next();
+			const f = this.eat("ident");
+			lv = {
+				kind: "LField",
+				base: lv,
+				field: f.value,
+				pos: f.pos
+			};
+		} else if (this.matchOp("[")) {
+			const t = this.next();
+			const idx = this.parseExpr();
+			this.eat("op", "]");
+			lv = {
+				kind: "LIndex",
+				base: lv,
+				index: idx,
+				pos: t.pos
+			};
+		} else break;
+		return lv;
+	}
+	parseExpr() {
+		return this.parseLogicOr();
+	}
+	parseLogicOr() {
+		let lhs = this.parseLogicAnd();
+		while (this.matchOp("||") || this.matchOp("|") && !this.looksLikeMatchArm()) {
+			const op = "|";
+			this.next();
+			const rhs = this.parseLogicAnd();
+			lhs = {
+				kind: "BinOp",
+				op,
+				lhs,
+				rhs,
+				pos: lhs.pos
+			};
+		}
+		return lhs;
+	}
+	/** Heuristic: after `|`, does it look like the start of a match arm? */
+	looksLikeMatchArm() {
+		const next = this.peek(1);
+		if (next.kind === "ident" && next.value === "_") return true;
+		if (next.kind === "ident" && next.value[0] && next.value[0] >= "A" && next.value[0] <= "Z") {
+			const after = this.peek(2);
+			if (after.kind === "op" && (after.value === "->" || after.value === "(")) return true;
+		}
+		return false;
+	}
+	parseLogicAnd() {
+		let lhs = this.parseCmp();
+		while (this.matchOp("&&") || this.matchOp("&")) {
+			this.next();
+			const rhs = this.parseCmp();
+			lhs = {
+				kind: "BinOp",
+				op: "&",
+				lhs,
+				rhs,
+				pos: lhs.pos
+			};
+		}
+		return lhs;
+	}
+	parseCmp() {
+		let lhs = this.parseAdd();
+		while (this.matchAnyOp([
+			"==",
+			"!=",
+			"<",
+			">",
+			"<=",
+			">="
+		])) {
+			const op = this.eat("op").value;
+			const rhs = this.parseAdd();
+			lhs = {
+				kind: "BinOp",
+				op,
+				lhs,
+				rhs,
+				pos: lhs.pos
+			};
+		}
+		return lhs;
+	}
+	parseAdd() {
+		let lhs = this.parseMul();
+		while (this.matchAnyOp(["+", "-"])) {
+			const op = this.eat("op").value;
+			const rhs = this.parseMul();
+			lhs = {
+				kind: "BinOp",
+				op,
+				lhs,
+				rhs,
+				pos: lhs.pos
+			};
+		}
+		return lhs;
+	}
+	parseMul() {
+		let lhs = this.parseUnary();
+		while (this.matchAnyOp([
+			"*",
+			"/",
+			"%"
+		])) {
+			const op = this.eat("op").value;
+			const rhs = this.parseUnary();
+			lhs = {
+				kind: "BinOp",
+				op,
+				lhs,
+				rhs,
+				pos: lhs.pos
+			};
+		}
+		return lhs;
+	}
+	parseUnary() {
+		if (this.matchOp("-")) {
+			const tok = this.next();
+			return {
+				kind: "UnaryOp",
+				op: "-",
+				rhs: this.parseUnary(),
+				pos: tok.pos
+			};
+		}
+		if (this.matchOp("!")) {
+			const tok = this.next();
+			return {
+				kind: "UnaryOp",
+				op: "!",
+				rhs: this.parseUnary(),
+				pos: tok.pos
+			};
+		}
+		if (this.matchT("ident", "not")) {
+			const tok = this.next();
+			return {
+				kind: "UnaryOp",
+				op: "!",
+				rhs: this.parseUnary(),
+				pos: tok.pos
+			};
+		}
+		return this.parsePostfix();
+	}
+	parsePostfix() {
+		let e = this.parsePrimary();
+		while (true) if (this.matchOp(".")) {
+			this.next();
+			const fldTok = this.peek();
+			if (fldTok.kind !== "ident" && fldTok.kind !== "kw") throw new ParseError(`Expected field or method name`, fldTok.pos);
+			this.next();
+			const fld = fldTok.value;
+			if (this.matchOp("(")) {
+				this.next();
+				const args = [];
+				if (fld === "copy" && this.matchT("ident") && this.matchTAt(1, "op", "=") && !this.matchTAt(2, "op", "=")) {
+					const fields = [];
+					const firstPos = this.peek().pos;
+					const readKwarg = () => {
+						const nameTok = this.eat("ident");
+						this.eat("op", "=");
+						const value = this.parseExpr();
+						fields.push({
+							kind: "RecordField",
+							name: nameTok.value,
+							value,
+							pos: nameTok.pos
+						});
+					};
+					readKwarg();
+					while (this.matchOp(",")) {
+						this.next();
+						readKwarg();
+					}
+					args.push({
+						kind: "RecordLit",
+						fields,
+						pos: firstPos
+					});
+				} else if (!this.matchOp(")")) {
+					args.push(this.parseExpr());
+					while (this.matchOp(",")) {
+						this.next();
+						args.push(this.parseExpr());
+					}
+				}
+				this.eat("op", ")");
+				e = {
+					kind: "MethodCall",
+					receiver: e,
+					method: fld,
+					args,
+					pos: e.pos
+				};
+			} else e = {
+				kind: "FieldAccess",
+				base: e,
+				field: fld,
+				pos: e.pos
+			};
+		} else if (this.matchOp("[")) {
+			this.next();
+			const idx = this.parseExpr();
+			this.eat("op", "]");
+			e = {
+				kind: "Index",
+				base: e,
+				index: idx,
+				pos: e.pos
+			};
+		} else break;
+		return e;
+	}
+	parsePrimary() {
+		const t = this.peek();
+		if (t.kind === "num") {
+			this.next();
+			return {
+				kind: "Num",
+				value: t.value,
+				pos: t.pos
+			};
+		}
+		if (t.kind === "str") {
+			this.next();
+			return {
+				kind: "Str",
+				value: t.value,
+				pos: t.pos
+			};
+		}
+		if (t.kind === "kw" && (t.value === "true" || t.value === "false")) {
+			this.next();
+			return {
+				kind: "Bool",
+				value: t.value === "true",
+				pos: t.pos
+			};
+		}
+		if (t.kind === "kw" && t.value === "now") {
+			this.next();
+			return {
+				kind: "Call",
+				callee: "now",
+				args: [],
+				pos: t.pos
+			};
+		}
+		if (t.kind === "kw" && t.value === "if") return this.parseIfExpr();
+		if (t.kind === "kw" && t.value === "let") return this.parseLetIn();
+		if (t.kind === "kw" && t.value === "match") return this.parseMatchExpr();
+		if (t.kind === "op" && t.value === "(") {
+			this.next();
+			const inner = this.parseExpr();
+			this.eat("op", ")");
+			return inner;
+		}
+		if (t.kind === "op" && t.value === "{") return this.parseRecordOrMapLit();
+		if (t.kind === "op" && t.value === "[") return this.parseListLit();
+		if (t.kind === "ident") {
+			this.next();
+			const name = t.value;
+			if (!!name[0] && name[0] >= "A" && name[0] <= "Z" && this.matchOp(".") && (this.matchTAt(1, "ident") || this.matchTAt(1, "kw")) && this.matchTAt(2, "op", "(")) {
+				this.next();
+				const subTok = this.next();
+				const sub = "value" in subTok ? String(subTok.value) : "";
+				this.eat("op", "(");
+				const args = [];
+				if (!this.matchOp(")")) {
+					args.push(this.parseExpr());
+					while (this.matchOp(",")) {
+						this.next();
+						args.push(this.parseExpr());
+					}
+				}
+				this.eat("op", ")");
+				return {
+					kind: "Call",
+					callee: `${name}.${sub}`,
+					args,
+					pos: t.pos
+				};
+			}
+			if (this.matchOp("(")) {
+				this.next();
+				const args = [];
+				if (!this.matchOp(")")) {
+					args.push(this.parseExpr());
+					while (this.matchOp(",")) {
+						this.next();
+						args.push(this.parseExpr());
+					}
+				}
+				this.eat("op", ")");
+				if (name[0] && name[0] >= "A" && name[0] <= "Z") return {
+					kind: "Variant",
+					name,
+					payload: args,
+					pos: t.pos
+				};
+				return {
+					kind: "Call",
+					callee: name,
+					args,
+					pos: t.pos
+				};
+			}
+			if (name[0] && name[0] >= "A" && name[0] <= "Z") return {
+				kind: "Variant",
+				name,
+				payload: [],
+				pos: t.pos
+			};
+			return {
+				kind: "Ref",
+				name,
+				pos: t.pos
+			};
+		}
+		if (t.kind === "op" && (t.value === "$1" || t.value === "$2")) {}
+		throw new ParseError(`Unexpected token in expression`, t.pos);
+	}
+	parseIfExpr() {
+		const start = this.eat("kw", "if");
+		const cond = this.parseExpr();
+		this.eat("kw", "then");
+		const thenE = this.parseExpr();
+		this.eat("kw", "else");
+		return {
+			kind: "IfExpr",
+			cond,
+			consequent: thenE,
+			alternate: this.parseExpr(),
+			pos: start.pos
+		};
+	}
+	parseLetIn() {
+		const start = this.eat("kw", "let");
+		const name = this.eat("ident").value;
+		this.eat("op", "=");
+		const value = this.parseExpr();
+		this.eat("kw", "in");
+		return {
+			kind: "LetIn",
+			name,
+			value,
+			body: this.parseExpr(),
+			pos: start.pos
+		};
+	}
+	parseMatchExpr() {
+		const start = this.eat("kw", "match");
+		const scrutinee = this.parseExpr();
+		this.eat("kw", "with");
+		const arms = [];
+		while (this.matchOp("|")) {
+			this.next();
+			const pattern = this.parsePattern();
+			this.eat("op", "->");
+			const body = this.parseExpr();
+			arms.push({
+				pattern,
+				body
+			});
+		}
+		if (arms.length === 0) throw new ParseError("match requires at least one arm", start.pos);
+		return {
+			kind: "MatchExpr",
+			scrutinee,
+			arms,
+			pos: start.pos
+		};
+	}
+	parsePattern() {
+		const t = this.peek();
+		if (t.kind === "ident" && t.value === "_") {
+			this.next();
+			return {
+				kind: "PWildcard",
+				pos: t.pos
+			};
+		}
+		if (t.kind === "ident") {
+			const name = t.value;
+			this.next();
+			if (this.matchOp("(")) {
+				this.next();
+				const binds = [];
+				if (!this.matchOp(")")) {
+					binds.push(this.parsePatternBind());
+					while (this.matchOp(",")) {
+						this.next();
+						binds.push(this.parsePatternBind());
+					}
+				}
+				this.eat("op", ")");
+				return {
+					kind: "PVariant",
+					name,
+					binds,
+					pos: t.pos
+				};
+			}
+			if (name[0] && name[0] >= "A" && name[0] <= "Z") return {
+				kind: "PVariant",
+				name,
+				binds: [],
+				pos: t.pos
+			};
+			return {
+				kind: "PBind",
+				name,
+				pos: t.pos
+			};
+		}
+		if (t.kind === "num") {
+			this.next();
+			return {
+				kind: "PLiteral",
+				value: t.value,
+				pos: t.pos
+			};
+		}
+		if (t.kind === "str") {
+			this.next();
+			return {
+				kind: "PLiteral",
+				value: t.value,
+				pos: t.pos
+			};
+		}
+		throw new ParseError("Expected pattern", t.pos);
+	}
+	parsePatternBind() {
+		const t = this.peek();
+		if (t.kind === "ident") {
+			this.next();
+			return t.value;
+		}
+		throw new ParseError("Expected pattern bind", t.pos);
+	}
+	parseRecordOrMapLit() {
+		const start = this.eat("op", "{");
+		if (this.matchOp("}")) {
+			this.next();
+			return {
+				kind: "MapLit",
+				entries: [],
+				pos: start.pos
+			};
+		}
+		let isRecord = false;
+		if (this.peek().kind === "ident") {
+			const peek1 = this.peek(1);
+			if (peek1.kind === "op" && (peek1.value === "=" || peek1.value === ":" || peek1.value === "," || peek1.value === "}")) isRecord = true;
+		}
+		if (isRecord) {
+			const fields = [];
+			while (true) {
+				const nameTok = this.eat("ident");
+				let value;
+				if (this.matchOp("=") || this.matchOp(":")) {
+					this.next();
+					value = this.parseExpr();
+				} else value = {
+					kind: "Ref",
+					name: nameTok.value,
+					pos: nameTok.pos
+				};
+				fields.push({
+					name: nameTok.value,
+					value
+				});
+				if (!this.matchOp(",")) break;
+				this.next();
+			}
+			this.eat("op", "}");
+			return {
+				kind: "RecordLit",
+				fields,
+				pos: start.pos
+			};
+		}
+		const entries = [];
+		entries.push(this.parseMapEntry());
+		while (this.matchOp(",")) {
+			this.next();
+			entries.push(this.parseMapEntry());
+		}
+		this.eat("op", "}");
+		return {
+			kind: "MapLit",
+			entries,
+			pos: start.pos
+		};
+	}
+	parseMapEntry() {
+		const key = this.parseExpr();
+		this.eat("op", ":");
+		return {
+			key,
+			value: this.parseExpr()
+		};
+	}
+	parseListLit() {
+		const start = this.eat("op", "[");
+		const items = [];
+		if (!this.matchOp("]")) {
+			items.push(this.parseExpr());
+			while (this.matchOp(",")) {
+				this.next();
+				items.push(this.parseExpr());
+			}
+		}
+		this.eat("op", "]");
+		return {
+			kind: "ListLit",
+			items,
+			pos: start.pos
+		};
+	}
+	matchAnyOp(ops) {
+		const t = this.peek();
+		return t.kind === "op" && ops.includes(t.value);
+	}
+	parseTile() {
+		const start = this.eat("kw", "tile");
+		const name = this.eat("ident").value;
+		let inType;
+		let errorBoundary;
+		while (!this.matchOp("=")) {
+			if (this.matchKw("in")) {
+				this.next();
+				this.eat("op", "=");
+				inType = this.parseTypeExpr();
+				continue;
+			}
+			if (this.matchT("ident", "error-boundary")) {
+				this.next();
+				this.eat("op", "=");
+				errorBoundary = this.eat("ident").value;
+				continue;
+			}
+			if (this.matchT("ident", "scroll-restoration")) {
+				this.next();
+				this.eat("op", "=");
+				const t = this.peek();
+				if (t.kind === "kw" && (t.value === "true" || t.value === "false")) this.next();
+				else this.parseExpr();
+				continue;
+			}
+			if (this.matchT("ident", "sub-routes")) {
+				this.next();
+				this.eat("op", "=");
+				this.parseRouteMap();
+				continue;
+			}
+			throw new ParseError(`Unexpected token in tile definition`, this.peek().pos);
+		}
+		this.eat("op", "=");
+		const def = {
+			kind: "TileDef",
+			name,
+			body: this.parseTileExpr(),
+			pos: start.pos
+		};
+		if (inType) def.in = inType;
+		if (errorBoundary) def.errorBoundary = errorBoundary;
+		return def;
+	}
+	parseTileExpr() {
+		if (this.matchKw("for")) {
+			const start = this.next();
+			const bindTok = this.eat("ident");
+			this.eat("kw", "in");
+			const iter = this.parseExpr();
+			const body = this.parseTileExpr();
+			return {
+				kind: "TileFor",
+				bind: bindTok.value,
+				iter,
+				body,
+				pos: start.pos
+			};
+		}
+		if (this.matchKw("when")) {
+			const start = this.next();
+			this.eat("op", "(");
+			const cond = this.parseExpr();
+			this.eat("op", ",");
+			const body = this.parseTileExpr();
+			this.eat("op", ")");
+			return {
+				kind: "TileWhen",
+				cond,
+				body,
+				pos: start.pos
+			};
+		}
+		if (this.matchKw("if")) {
+			const start = this.next();
+			const cond = this.parseExpr();
+			this.eat("kw", "then");
+			const thenT = this.parseTileExpr();
+			this.eat("kw", "else");
+			return {
+				kind: "TileIf",
+				cond,
+				consequent: thenT,
+				alternate: this.parseTileExpr(),
+				pos: start.pos
+			};
+		}
+		if (this.matchKw("match")) {
+			const start = this.next();
+			const scrut = this.parseExpr();
+			this.eat("kw", "with");
+			const arms = [];
+			while (this.matchOp("|")) {
+				this.next();
+				const pattern = this.parsePattern();
+				this.eat("op", "->");
+				const body = this.parseTileExpr();
+				arms.push({
+					pattern,
+					body
+				});
+			}
+			return {
+				kind: "TileMatch",
+				scrutinee: scrut,
+				arms,
+				pos: start.pos
+			};
+		}
+		return this.parseTileCall();
+	}
+	parseTileCall() {
+		const nameTok = this.eat("ident");
+		const name = nameTok.value;
+		const isBuiltin = BUILTIN_TILES$1.has(name);
+		const takesValueArg = VALUE_ARG_BUILTINS.has(name);
+		const args = [];
+		if (this.matchOp("(")) {
+			this.next();
+			if (!this.matchOp(")")) {
+				args.push(this.parseTileArg(isBuiltin, takesValueArg));
+				while (this.matchOp(",")) {
+					this.next();
+					args.push(this.parseTileArg(isBuiltin, takesValueArg));
+				}
+			}
+			this.eat("op", ")");
+		}
+		const props = [];
+		if (this.matchOp("{")) {
+			this.next();
+			if (!this.matchOp("}")) {
+				props.push(this.parseTileProp());
+				while (this.matchOp(",")) {
+					this.next();
+					props.push(this.parseTileProp());
+				}
+			}
+			this.eat("op", "}");
+		}
+		return {
+			kind: "TileCall",
+			name,
+			args,
+			props,
+			pos: nameTok.pos
+		};
+	}
+	parseTileArg(parentIsBuiltin, parentTakesValueArg = false) {
+		const first = this.peek();
+		if ((first.kind === "ident" || first.kind === "kw") && this.matchTAt(1, "op", "=")) {
+			const name = first.value;
+			this.next();
+			this.eat("op", "=");
+			const argTakesValue = parentTakesValueArg || VALUE_NAMED_ARGS.has(name);
+			return {
+				kind: "TileArg",
+				name,
+				value: this.parseArgValue(parentIsBuiltin, argTakesValue)
+			};
+		}
+		return {
+			kind: "TileArg",
+			value: this.parseArgValue(parentIsBuiltin, parentTakesValueArg)
+		};
+	}
+	parseArgValue(parentIsBuiltin = true, parentTakesValueArg = false) {
+		if (this.matchKw("for") || this.matchKw("when")) return this.parseTileExpr();
+		if (this.matchKw("match")) {
+			if (parentTakesValueArg) return this.parseExpr();
+			return this.parseTileExpr();
+		}
+		if (this.matchKw("if")) {
+			if (parentTakesValueArg) return this.parseExpr();
+			return this.parseTileExpr();
+		}
+		const tok0 = this.peek();
+		if (tok0.kind === "ident") {
+			const name = tok0.value;
+			const p1 = this.peek(1);
+			const looksLikeTileCall = p1.kind === "op" && (p1.value === "(" || p1.value === "{");
+			const isBuiltin = BUILTIN_TILES$1.has(name);
+			const isCapital = !!name[0] && name[0] >= "A" && name[0] <= "Z";
+			if (isBuiltin && looksLikeTileCall) return this.parseTileCall();
+			if (!parentIsBuiltin) return this.parseExpr();
+			if (isCapital && looksLikeTileCall) return this.parseTileCall();
+			if (isCapital && !looksLikeTileCall) return this.parseTileCall();
+		}
+		return this.parseExpr();
+	}
+	parseTileProp() {
+		const nameTok = this.peek();
+		if (nameTok.kind !== "ident" && nameTok.kind !== "kw") throw new ParseError("Expected prop name", nameTok.pos);
+		this.next();
+		this.eat("op", ":");
+		const value = this.parseExpr();
+		return {
+			kind: "TileProp",
+			name: nameTok.value,
+			value
+		};
+	}
+	parseFn() {
+		const start = this.eat("kw", "fn");
+		const name = this.eat("ident").value;
+		this.eat("op", "(");
+		const params = [];
+		if (!this.matchOp(")")) {
+			params.push(this.parseFnParam());
+			while (this.matchOp(",")) {
+				this.next();
+				params.push(this.parseFnParam());
+			}
+		}
+		this.eat("op", ")");
+		let ret;
+		if (this.matchOp("->")) {
+			this.next();
+			ret = this.parseTypeExpr();
+		}
+		this.eat("op", "=");
+		const def = {
+			kind: "FnDef",
+			name,
+			params,
+			body: this.parseExpr(),
+			pos: start.pos
+		};
+		if (ret) def.ret = ret;
+		return def;
+	}
+	parseFnParam() {
+		const name = this.eat("ident").value;
+		this.eat("op", ":");
+		return {
+			name,
+			type: this.parseTypeExpr()
+		};
+	}
+	parseEffect() {
+		const start = this.eat("kw", "effect");
+		const name = this.eat("ident").value;
+		let cap;
+		let inType;
+		let outType;
+		let policy;
+		let retry;
+		let mapRequest;
+		while (this.isEffectField()) {
+			const key = this.peek();
+			if (key.kind === "kw" && key.value === "cap") {
+				this.next();
+				this.eat("op", "=");
+				cap = this.readQualifiedName();
+			} else if (key.kind === "kw" && key.value === "in") {
+				this.next();
+				this.eat("op", "=");
+				inType = this.parseTypeExpr();
+			} else if (key.kind === "kw" && key.value === "out") {
+				this.next();
+				this.eat("op", "=");
+				outType = this.parseTypeExpr();
+			} else if (key.kind === "kw" && key.value === "policy") {
+				this.next();
+				this.eat("op", "=");
+				policy = this.parsePolicy();
+			} else if (key.kind === "kw" && key.value === "retry") {
+				this.next();
+				this.eat("op", "=");
+				retry = this.parseRetry();
+			} else if (key.kind === "ident" && key.value === "map-request") {
+				this.next();
+				this.eat("op", "=");
+				mapRequest = this.parseExpr();
+			} else break;
+		}
+		if (!cap || !inType || !outType) throw new ParseError(`effect requires cap, in, out`, start.pos);
+		const def = {
+			kind: "EffectDef",
+			name,
+			cap,
+			inType,
+			outType,
+			pos: start.pos
+		};
+		if (policy) def.policy = policy;
+		if (retry) def.retry = retry;
+		if (mapRequest) def.mapRequest = mapRequest;
+		return def;
+	}
+	isEffectField() {
+		const t = this.peek();
+		if (t.kind === "kw" && [
+			"cap",
+			"in",
+			"out",
+			"policy",
+			"retry"
+		].includes(t.value)) return true;
+		if (t.kind === "ident" && t.value === "map-request") return true;
+		return false;
+	}
+	parsePolicy() {
+		const t = this.eat("ident");
+		if (t.value === "latest") return { kind: "PolLatest" };
+		if (t.value === "queue") return { kind: "PolQueue" };
+		if (t.value === "once") return { kind: "PolOnce" };
+		if (t.value === "latest-per-key") {
+			this.eat("op", "(");
+			const key = this.parseExpr();
+			this.eat("op", ")");
+			return {
+				kind: "PolLatestKey",
+				key
+			};
+		}
+		if (t.value === "debounce") {
+			this.eat("op", "(");
+			const ms = this.parseDuration();
+			this.eat("op", ")");
+			return {
+				kind: "PolDebounce",
+				ms
+			};
+		}
+		if (t.value === "throttle") {
+			this.eat("op", "(");
+			const ms = this.parseDuration();
+			this.eat("op", ")");
+			return {
+				kind: "PolThrottle",
+				ms
+			};
+		}
+		throw new ParseError(`Unknown policy "${t.value}"`, t.pos);
+	}
+	parseRetry() {
+		const t = this.eat("ident");
+		if (t.value === "none") return { kind: "RetryNone" };
+		if (t.value === "linear") {
+			this.eat("op", "(");
+			const n = this.eat("num").value;
+			this.eat("op", ",");
+			const ms = this.parseDuration();
+			this.eat("op", ")");
+			return {
+				kind: "RetryLinear",
+				n,
+				ms
+			};
+		}
+		if (t.value === "exponential") {
+			this.eat("op", "(");
+			const n = this.eat("num").value;
+			this.eat("op", ",");
+			const ms = this.parseDuration();
+			this.eat("op", ",");
+			const factor = this.eat("num").value;
+			this.eat("op", ")");
+			return {
+				kind: "RetryExp",
+				n,
+				ms,
+				factor
+			};
+		}
+		throw new ParseError(`Unknown retry "${t.value}"`, t.pos);
+	}
+	parseDuration() {
+		const n = this.eat("num").value;
+		const unit = this.eat("ident").value;
+		if (unit === "ms") return n;
+		if (unit === "s") return n * 1e3;
+		if (unit === "m") return n * 60 * 1e3;
+		throw new ParseError(`Unknown duration unit "${unit}"`, this.peek().pos);
+	}
+	parseApp() {
+		const start = this.eat("kw", "app");
+		const name = this.eat("ident").value;
+		let caps = [];
+		let routes = [];
+		let init = [];
+		let theme;
+		while (!this.isAppEnd()) {
+			const ident = this.eat("ident");
+			const k = ident.value;
+			this.eat("op", "=");
+			if (k === "caps") caps = this.parseQualifiedList();
+			else if (k === "routes") routes = this.parseRouteMap();
+			else if (k === "init") init = this.parseInitList();
+			else if (k === "theme") theme = this.eat("ident").value;
+			else if (k === "meta" || k === "http" || k === "indexed-db" || k === "analytics") this.parseExpr();
+			else throw new ParseError(`Unknown app field "${k}"`, ident.pos);
+		}
+		const def = {
+			kind: "AppDef",
+			name,
+			caps,
+			routes,
+			init,
+			pos: start.pos
+		};
+		if (theme) def.theme = theme;
+		return def;
+	}
+	isAppEnd() {
+		const t = this.peek();
+		if (t.kind === "eof") return true;
+		if (t.kind === "kw") return true;
+		return false;
+	}
+	parseQualifiedList() {
+		this.eat("op", "[");
+		const out = [];
+		if (!this.matchOp("]")) {
+			out.push(this.readQualifiedName());
+			while (this.matchOp(",")) {
+				this.next();
+				out.push(this.readQualifiedName());
+			}
+		}
+		this.eat("op", "]");
+		return out;
+	}
+	readQualifiedName() {
+		let name = this.eat("ident").value;
+		while (this.matchOp(".")) {
+			this.next();
+			name += `.${this.eat("ident").value}`;
+		}
+		return name;
+	}
+	parseRouteMap() {
+		this.eat("op", "{");
+		const routes = [];
+		if (!this.matchOp("}")) {
+			routes.push(this.parseRouteEntry());
+			while (this.matchOp(",")) {
+				this.next();
+				routes.push(this.parseRouteEntry());
+			}
+		}
+		this.eat("op", "}");
+		return routes;
+	}
+	parseRouteEntry() {
+		const path = this.eat("str").value;
+		if (this.matchOp("->>")) {
+			this.next();
+			return {
+				path,
+				tile: `>>${this.eat("str").value}`
+			};
+		}
+		this.eat("op", "->");
+		return {
+			path,
+			tile: this.eat("ident").value
+		};
+	}
+	parseInitList() {
+		this.eat("op", "[");
+		const out = [];
+		if (!this.matchOp("]")) {
+			out.push(this.parseExpr());
+			while (this.matchOp(",")) {
+				this.next();
+				out.push(this.parseExpr());
+			}
+		}
+		this.eat("op", "]");
+		return out;
+	}
+};
+function parse(tokens) {
+	return new Parser(tokens).parseProgram();
+}
+//#endregion
+//#region src/typecheck.ts
+const BUILTIN_TILES = new Set([
+	"page",
+	"region",
+	"row",
+	"column",
+	"stack",
+	"grid",
+	"box",
+	"card",
+	"panel",
+	"divider",
+	"scroll",
+	"text",
+	"heading",
+	"link",
+	"code",
+	"markdown",
+	"image",
+	"icon",
+	"video",
+	"button",
+	"input",
+	"textarea",
+	"check",
+	"radio",
+	"select",
+	"slider",
+	"switch",
+	"form",
+	"label",
+	"fieldset",
+	"error",
+	"list",
+	"list-item",
+	"table",
+	"table-head",
+	"table-body",
+	"table-row",
+	"table-cell",
+	"modal",
+	"drawer",
+	"tooltip",
+	"popover",
+	"toast",
+	"spinner",
+	"progress",
+	"skeleton",
+	"route-outlet"
+]);
+const A11Y_CODES = new Set([
+	"E0701",
+	"E0702",
+	"E0703"
+]);
+/** Returns errors with a11y warnings filtered out (unless strict). */
+function check(program, opts) {
+	const errors = checkAll(program);
+	if (opts?.strictA11y) return errors;
+	return errors.filter((e) => !A11Y_CODES.has(e.code));
+}
+function checkAll(program) {
+	const errors = [];
+	const sym = {
+		types: /* @__PURE__ */ new Map(),
+		slots: /* @__PURE__ */ new Map(),
+		reducers: /* @__PURE__ */ new Map(),
+		tiles: /* @__PURE__ */ new Map(),
+		fns: /* @__PURE__ */ new Map(),
+		effects: /* @__PURE__ */ new Map()
+	};
+	for (const def of program.defs) switch (def.kind) {
+		case "TypeDef":
+			sym.types.set(def.name, def);
+			break;
+		case "SlotDef":
+			sym.slots.set(def.name, def);
+			break;
+		case "ReducerDef":
+			sym.reducers.set(def.name, def);
+			break;
+		case "TileDef":
+			sym.tiles.set(def.name, def);
+			break;
+		case "FnDef":
+			sym.fns.set(def.name, def);
+			break;
+		case "EffectDef":
+			sym.effects.set(def.name, def);
+			break;
+		case "AppDef":
+			sym.app = def;
+			break;
+	}
+	for (const def of program.defs) {
+		if (def.kind === "SlotDef") checkSlot(def, sym, errors);
+		if (def.kind === "TileDef") checkTile(def, sym, errors);
+		if (def.kind === "ReducerDef") checkReducer(def, sym, errors);
+		if (def.kind === "FnDef") checkFn(def, sym, errors);
+		if (def.kind === "EffectDef") checkEffect(def, sym, errors);
+		if (def.kind === "AppDef") checkApp(def, sym, errors);
+	}
+	return errors;
+}
+function checkSlot(slot, sym, errors) {
+	resolveType(slot.type, sym, errors);
+	checkExpr(slot.init, sym, errors, {
+		kind: "slot-init",
+		localBinds: /* @__PURE__ */ new Set()
+	});
+}
+function checkTile(tile, sym, errors) {
+	const ctx = {
+		kind: "tile",
+		localBinds: /* @__PURE__ */ new Set()
+	};
+	if (tile.in) ctx.localBinds.add("$1");
+	checkTileExpr(tile.body, sym, errors, ctx);
+}
+function checkA11y(t, errors) {
+	if (t.name === "button") {
+		const hasText = t.args.some((a) => a.name === "text");
+		const hasAria = t.props.some((p) => p.name === "aria-label");
+		if (!hasText && !hasAria) errors.push({
+			code: "E0701",
+			kind: "a11y-button",
+			message: `button must have a text= argument or aria-label prop`,
+			pos: t.pos
+		});
+	}
+	if (t.name === "image") {
+		if (!(t.args.some((a) => a.name === "alt") || t.props.some((p) => p.name === "alt"))) errors.push({
+			code: "E0702",
+			kind: "a11y-image",
+			message: `image must have an alt prop`,
+			pos: t.pos
+		});
+	}
+	if (t.name === "link") {
+		const hasText = t.args.some((a) => a.name === "text") || t.props.some((p) => p.name === "text");
+		const hasAria = t.props.some((p) => p.name === "aria-label");
+		if (!hasText && !hasAria) errors.push({
+			code: "E0703",
+			kind: "a11y-link",
+			message: `link must have inner text or aria-label`,
+			pos: t.pos
+		});
+	}
+}
+function checkTileExpr(t, sym, errors, ctx) {
+	switch (t.kind) {
+		case "TileFor": {
+			checkExpr(t.iter, sym, errors, ctx);
+			const inner = {
+				...ctx,
+				localBinds: new Set(ctx.localBinds)
+			};
+			inner.localBinds.add(t.bind);
+			checkTileExpr(t.body, sym, errors, inner);
+			return;
+		}
+		case "TileWhen":
+			checkExpr(t.cond, sym, errors, ctx);
+			checkTileExpr(t.body, sym, errors, ctx);
+			return;
+		case "TileIf":
+			checkExpr(t.cond, sym, errors, ctx);
+			checkTileExpr(t.consequent, sym, errors, ctx);
+			checkTileExpr(t.alternate, sym, errors, ctx);
+			return;
+		case "TileMatch":
+			checkExpr(t.scrutinee, sym, errors, ctx);
+			for (const arm of t.arms) {
+				const inner = {
+					...ctx,
+					localBinds: new Set(ctx.localBinds)
+				};
+				if (arm.pattern.kind === "PVariant") for (const b of arm.pattern.binds) inner.localBinds.add(b);
+				if (arm.pattern.kind === "PBind") inner.localBinds.add(arm.pattern.name);
+				checkTileExpr(arm.body, sym, errors, inner);
+			}
+			return;
+		case "TileCall":
+			checkTileCall(t, sym, errors, ctx);
+			return;
+	}
+}
+function checkTileCall(t, sym, errors, ctx) {
+	if (!BUILTIN_TILES.has(t.name) && !sym.tiles.has(t.name)) errors.push({
+		code: "E0105",
+		kind: "undef-tile",
+		message: `Reference to undefined tile "${t.name}"`,
+		pos: t.pos
+	});
+	checkA11y(t, errors);
+	const HANDLER_NAMES = new Set([
+		"onClick",
+		"onSubmit",
+		"onChange",
+		"onInput",
+		"onFocus",
+		"onBlur"
+	]);
+	for (const arg of t.args) {
+		const v = arg.value;
+		if (v.kind === "TileCall" || v.kind === "TileFor" || v.kind === "TileWhen" || v.kind === "TileIf" || v.kind === "TileMatch") {
+			checkTileExpr(v, sym, errors, ctx);
+			continue;
+		}
+		if (arg.name && HANDLER_NAMES.has(arg.name)) {
+			const expr = v;
+			if (expr.kind !== "Ref") errors.push({
+				code: "E0201",
+				kind: "type-mismatch",
+				message: `Event handler arg "${arg.name}" must be a reducer name`,
+				pos: expr.pos
+			});
+			else if (!sym.reducers.has(expr.name)) errors.push({
+				code: "E0102",
+				kind: "undef-reducer",
+				message: `Reference to undefined reducer "${expr.name}"`,
+				pos: expr.pos
+			});
+			continue;
+		}
+		checkExpr(v, sym, errors, ctx);
+	}
+	for (const prop of t.props) if (HANDLER_NAMES.has(prop.name)) {
+		const ref = prop.value;
+		if (ref.kind !== "Ref") errors.push({
+			code: "E0201",
+			kind: "type-mismatch",
+			message: `Event handler prop "${prop.name}" must be a reducer name`,
+			pos: prop.value.pos
+		});
+		else if (!sym.reducers.has(ref.name)) errors.push({
+			code: "E0102",
+			kind: "undef-reducer",
+			message: `Reference to undefined reducer "${ref.name}"`,
+			pos: ref.pos
+		});
+	} else checkExpr(prop.value, sym, errors, ctx);
+}
+function checkReducer(r, sym, errors) {
+	const ctx = {
+		kind: "reducer",
+		localBinds: /* @__PURE__ */ new Set(),
+		capsAvailable: new Set(sym.app?.caps ?? [])
+	};
+	if (r.on.kind === "EffectEvent") {
+		for (const b of r.on.binds) if (b !== "_") ctx.localBinds.add(b);
+	}
+	if (r.on.kind === "LifecycleEvent") {
+		if (r.on.name.startsWith("route.")) ctx.localBinds.add("$route");
+	}
+	ctx.localBinds.add("$el");
+	ctx.localBinds.add("$event");
+	ctx.localBinds.add("$route");
+	const writtenRoots = /* @__PURE__ */ new Set();
+	for (const stmt of r.do) checkStmt(stmt, sym, errors, ctx, writtenRoots);
+}
+function checkStmt(s, sym, errors, ctx, writtenRoots) {
+	if (s.kind === "ForStmt") {
+		checkExpr(s.iter, sym, errors, ctx);
+		const inner = {
+			...ctx,
+			localBinds: new Set(ctx.localBinds)
+		};
+		inner.localBinds.add(s.bind);
+		const bodyWrites = new Set(writtenRoots);
+		for (const st of s.body) checkStmt(st, sym, errors, inner, bodyWrites);
+		for (const r of bodyWrites) writtenRoots.add(r);
+		return;
+	}
+	if (s.kind === "IfStmt") {
+		checkExpr(s.cond, sym, errors, ctx);
+		const thenWrites = new Set(writtenRoots);
+		for (const st of s.consequent) checkStmt(st, sym, errors, ctx, thenWrites);
+		const elseWrites = new Set(writtenRoots);
+		for (const st of s.alternate) checkStmt(st, sym, errors, ctx, elseWrites);
+		for (const r of thenWrites) writtenRoots.add(r);
+		for (const r of elseWrites) writtenRoots.add(r);
+		return;
+	}
+	if (s.kind === "MatchStmt") {
+		checkExpr(s.scrutinee, sym, errors, ctx);
+		const armSets = [];
+		for (const arm of s.arms) {
+			const inner = {
+				...ctx,
+				localBinds: new Set(ctx.localBinds)
+			};
+			if (arm.pattern.kind === "PVariant") {
+				for (const b of arm.pattern.binds) if (b !== "_") inner.localBinds.add(b);
+			}
+			if (arm.pattern.kind === "PBind") inner.localBinds.add(arm.pattern.name);
+			const armWrites = new Set(writtenRoots);
+			for (const st of arm.body) checkStmt(st, sym, errors, inner, armWrites);
+			armSets.push(armWrites);
+		}
+		for (const set of armSets) for (const r of set) writtenRoots.add(r);
+		return;
+	}
+	if (s.kind === "NoopStmt") return;
+	if (s.kind === "LetStmt") {
+		checkExpr(s.rhs, sym, errors, ctx);
+		ctx.localBinds.add(s.name);
+		return;
+	}
+	if (s.kind === "Emit") {
+		const eff = sym.effects.get(s.effect);
+		const isBuiltinNav = s.effect === "navigate" || s.effect === "navigate-replace" || s.effect === "navigate-back" || s.effect === "toast" || s.effect === "log";
+		if (!eff && !isBuiltinNav) errors.push({
+			code: "E0104",
+			kind: "undef-effect",
+			message: `Reference to undefined effect "${s.effect}"`,
+			pos: s.pos
+		});
+		else if (eff && ctx.capsAvailable && !ctx.capsAvailable.has(eff.cap)) errors.push({
+			code: "E0301",
+			kind: "missing-capability",
+			message: `Effect "${s.effect}" requires capability "${eff.cap}" which is not declared in app.caps`,
+			pos: s.pos
+		});
+		for (const a of s.args) checkExpr(a, sym, errors, ctx);
+		return;
+	}
+	const root = lvalueRoot(s.lvalue);
+	if (!sym.slots.has(root)) errors.push({
+		code: "E0103",
+		kind: "undef-slot",
+		message: `Assignment to undefined slot "${root}"`,
+		pos: s.pos
+	});
+	const shape = lvalueShape(s.lvalue);
+	if (writtenRoots.has(shape)) errors.push({
+		code: "E0601",
+		kind: "duplicate-write",
+		message: `Slot path "${shape}" is written more than once in this reducer`,
+		pos: s.pos
+	});
+	writtenRoots.add(shape);
+	checkLvalue(s.lvalue, sym, errors, ctx);
+	checkExpr(s.rhs, sym, errors, ctx);
+}
+function lvalueShape(lv) {
+	if (lv.kind === "LSlot") return lv.name;
+	const parts = [];
+	let cur = lv;
+	while (cur.kind !== "LSlot") {
+		if (cur.kind === "LField") parts.unshift(`.${cur.field}`);
+		else parts.unshift("[]");
+		cur = cur.base;
+	}
+	return cur.name + parts.join("");
+}
+function lvalueRoot(lv) {
+	while (lv.kind !== "LSlot") lv = lv.base;
+	return lv.name;
+}
+function checkLvalue(lv, sym, errors, ctx) {
+	if (lv.kind === "LSlot") return;
+	if (lv.kind === "LIndex") checkExpr(lv.index, sym, errors, ctx);
+	checkLvalue(lv.base, sym, errors, ctx);
+}
+function checkExpr(e, sym, errors, ctx) {
+	switch (e.kind) {
+		case "Num":
+		case "Str":
+		case "Bool":
+		case "Unit": return;
+		case "Ref":
+			if (ctx.localBinds.has(e.name)) return;
+			if (sym.slots.has(e.name)) {
+				if (ctx.kind === "fn") errors.push({
+					code: "E0305",
+					kind: "fn-impurity",
+					message: `fn "${currentFnName(ctx)}" must not read slot "${e.name}"`,
+					pos: e.pos
+				});
+				return;
+			}
+			if (sym.fns.has(e.name)) return;
+			if (e.name === "route" || e.name === "now" || e.name === "self") return;
+			errors.push({
+				code: "E0103",
+				kind: "undef-ref",
+				message: `Reference to undefined name "${e.name}"`,
+				pos: e.pos
+			});
+			return;
+		case "Variant":
+			for (const p of e.payload) checkExpr(p, sym, errors, ctx);
+			return;
+		case "BinOp":
+			checkExpr(e.lhs, sym, errors, ctx);
+			checkExpr(e.rhs, sym, errors, ctx);
+			return;
+		case "UnaryOp":
+			checkExpr(e.rhs, sym, errors, ctx);
+			return;
+		case "FieldAccess":
+			checkExpr(e.base, sym, errors, ctx);
+			return;
+		case "Index":
+			checkExpr(e.base, sym, errors, ctx);
+			checkExpr(e.index, sym, errors, ctx);
+			return;
+		case "Call":
+			for (const a of e.args) checkExpr(a, sym, errors, ctx);
+			return;
+		case "MethodCall":
+			if (!KNOWN_METHODS.has(e.method)) errors.push({
+				code: "E0801",
+				kind: "unimplemented-method",
+				message: `Method ".${e.method}" is not implemented by the runtime`,
+				pos: e.pos
+			});
+			checkExpr(e.receiver, sym, errors, ctx);
+			for (const a of e.args) {
+				const inner = {
+					...ctx,
+					localBinds: new Set(ctx.localBinds)
+				};
+				inner.localBinds.add("$1");
+				inner.localBinds.add("$2");
+				checkExpr(a, sym, errors, inner);
+			}
+			return;
+		case "RecordLit":
+			for (const f of e.fields) checkExpr(f.value, sym, errors, ctx);
+			return;
+		case "ListLit":
+			for (const it of e.items) checkExpr(it, sym, errors, ctx);
+			return;
+		case "MapLit":
+			for (const ent of e.entries) {
+				checkExpr(ent.key, sym, errors, ctx);
+				checkExpr(ent.value, sym, errors, ctx);
+			}
+			return;
+		case "MatchExpr":
+			checkExpr(e.scrutinee, sym, errors, ctx);
+			for (const arm of e.arms) {
+				const inner = {
+					...ctx,
+					localBinds: new Set(ctx.localBinds)
+				};
+				if (arm.pattern.kind === "PVariant") {
+					for (const b of arm.pattern.binds) if (b !== "_") inner.localBinds.add(b);
+				}
+				if (arm.pattern.kind === "PBind") inner.localBinds.add(arm.pattern.name);
+				checkExpr(arm.body, sym, errors, inner);
+			}
+			return;
+		case "IfExpr":
+			checkExpr(e.cond, sym, errors, ctx);
+			checkExpr(e.consequent, sym, errors, ctx);
+			checkExpr(e.alternate, sym, errors, ctx);
+			return;
+		case "LetIn": {
+			checkExpr(e.value, sym, errors, ctx);
+			const inner = {
+				...ctx,
+				localBinds: new Set(ctx.localBinds)
+			};
+			inner.localBinds.add(e.name);
+			checkExpr(e.body, sym, errors, inner);
+			return;
+		}
+	}
+}
+function currentFnName(ctx) {
+	return ctx.fnName ?? "<fn>";
+}
+function checkFn(fn, sym, errors) {
+	const ctx = {
+		kind: "fn",
+		localBinds: /* @__PURE__ */ new Set()
+	};
+	ctx.fnName = fn.name;
+	for (const p of fn.params) ctx.localBinds.add(p.name);
+	ctx.localBinds.add("$1");
+	ctx.localBinds.add("$2");
+	checkExpr(fn.body, sym, errors, ctx);
+}
+function checkEffect(eff, sym, errors) {
+	resolveType(eff.inType, sym, errors);
+	resolveType(eff.outType, sym, errors);
+	if (eff.mapRequest) checkExpr(eff.mapRequest, sym, errors, {
+		kind: "slot-init",
+		localBinds: new Set(["$1"])
+	});
+}
+function checkApp(app, sym, errors) {
+	let saw404 = false;
+	for (const r of app.routes) {
+		if (r.tile.startsWith(">>")) continue;
+		if (!sym.tiles.has(r.tile)) errors.push({
+			code: "E0105",
+			kind: "undef-tile",
+			message: `Route "${r.path}" targets undefined tile "${r.tile}"`,
+			pos: app.pos
+		});
+		if (r.path === "/404") saw404 = true;
+	}
+	if (!saw404) errors.push({
+		code: "E0001",
+		kind: "missing-404",
+		message: `app.routes must include a "/404" entry`,
+		pos: app.pos
+	});
+	for (const e of app.init) checkExpr(e, sym, errors, {
+		kind: "reducer",
+		localBinds: /* @__PURE__ */ new Set(),
+		capsAvailable: new Set(app.caps)
+	});
+}
+function resolveType(t, sym, errors) {
+	switch (t.kind) {
+		case "TypePrim": return;
+		case "TypeRef":
+			if (!sym.types.has(t.name)) return;
+			return;
+		case "TypeApp":
+			for (const a of t.args) resolveType(a, sym, errors);
+			return;
+		case "TypeRecord":
+			for (const f of t.fields) resolveType(f.type, sym, errors);
+			return;
+		case "TypeUnion":
+			for (const v of t.variants) for (const p of v.payloads) resolveType(p, sym, errors);
+			return;
+		case "TypeNominal":
+			resolveType(t.inner, sym, errors);
+			return;
+		case "TypeRefinement":
+			resolveType(t.inner, sym, errors);
+			return;
+	}
+}
+//#endregion
+//#region src/compile.ts
+/** Inline a runtime bundle into generated module code, stripping the bridging import/export lines. */
+function inlineRuntime(generatedJs, runtimeBundleJs) {
+	return `${runtimeBundleJs.replace(/^export \{[^}]*\};?\s*$/m, "")}\n${generatedJs.replace(/^import \{[^}]*\} from "[^"]*";\s*$/m, "")}`;
+}
+function compile(source, opts) {
+	const program = parse(lex(source));
+	const errors = check(program);
+	if (errors.length > 0) return {
+		kind: "fail",
+		errors
+	};
+	let js = `${RUNTIME_HELPERS}\n${codegen(program, opts)}`;
+	if (opts.bundle) {
+		if (!opts.readRuntimeBundle) throw new Error("compile({ bundle: true }) requires a readRuntimeBundle function (see @kumikijs/compiler/node).");
+		js = inlineRuntime(js, opts.readRuntimeBundle());
+	}
+	return {
+		kind: "ok",
+		js,
+		program
+	};
+}
+//#endregion
+export { ParseError, RUNTIME_HELPERS, check, codegen, compile, inlineRuntime, lex, parse };