@swiftuijs/twill 0.1.2 → 0.3.0

package/dist/typescript-plugin.cjs

@@ -38,6 +38,7 @@ let node_fs = require("node:fs");
 let node_path = require("node:path");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
+let node_crypto = require("node:crypto");
 //#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
@@ -15049,7 +15050,8 @@ function exits(node) {
 		case "BreakStatement":
 		case "ContinueStatement": return true;
 		case "BlockStatement": return node.body.some(exits);
-		case "IfStatement": return !!node.alternate && exits(node.consequent) && exits(node.alternate);
+		case "IfStatement":
+		case "TwillIfBinding": return !!node.alternate && exits(node.consequent) && exits(node.alternate);
 		default: return false;
 	}
 }
@@ -15143,17 +15145,83 @@ function moveNodes(node, delta, locate) {
 	}
 }
 var parsers = /* @__PURE__ */ new Map();
+function associatedEnumAt(input, offset) {
+	try {
+		const tokens = Parser.tokenizer(input.slice(offset), { ecmaVersion: "latest" });
+		tokens.getToken();
+		const next = tokens.getToken();
+		return next.value === "<" || next.type === types$1.braceL && tokens.getToken().type === types$1._case && tokens.getToken().type === types$1.name;
+	} catch {
+		return false;
+	}
+}
 function parserFor(language) {
 	if (parsers.has(language)) return parsers.get(language);
 	const Base = bases[language];
 	class TwillParser extends Base {
+		declareName(name, bindingType, position) {
+			if (bindingType === 6 || bindingType === 7) {
+				const scope = this.currentScope();
+				(scope.types ??= []).push(name);
+				if (this.inModule && scope.flags & 1) delete this.undefinedExports[name];
+				return;
+			}
+			super.declareName(name, bindingType, position);
+		}
 		skipHeader = null;
 		closures = [];
 		lineStarts = null;
 		classSuperDepth = null;
 		subscriptDepth = 0;
+		conditionDepth = null;
 		derivedClassElement = false;
 		implicitClosure = null;
+		tsParseEnumDeclaration(node, modifiers = {}) {
+			if (!associatedEnumAt(this.input, this.end)) return super.tsParseEnumDeclaration(node, modifiers);
+			if (modifiers.const || modifiers.declare || this.isAmbientContext) this.raise(node.start, "Associated-value enums cannot be const or ambient declarations.");
+			this.expectContextual("enum");
+			node.id = this.parseIdent();
+			this.checkLValSimple(node.id, 2);
+			node.typeParameters = this.tsTryParseTypeParameters(() => {
+				if (this.type === types$1._in || this.isContextual("out") && this.lookahead().type === types$1.name) this.raise(this.start, "Associated-value enum type parameters cannot have const/in/out modifiers.");
+			});
+			const constant = node.typeParameters?.params.find((parameter) => parameter.const);
+			if (constant) this.raise(constant.start, "Associated-value enum type parameters cannot have const/in/out modifiers.");
+			node.braceStart = this.start;
+			this.expect(types$1.braceL);
+			node.cases = [];
+			const names = /* @__PURE__ */ new Set();
+			while (this.type !== types$1.braceR) {
+				const branch = this.startNode();
+				this.expect(types$1._case);
+				branch.id = this.parseIdent();
+				if (names.has(branch.id.name)) this.raise(branch.id.start, "Duplicate enum case.");
+				names.add(branch.id.name);
+				branch.params = [];
+				branch.hasParens = this.eat(types$1.parenL);
+				if (branch.hasParens) {
+					const fields = /* @__PURE__ */ new Set();
+					while (this.type !== types$1.parenR) {
+						const field = this.parseIdent();
+						this.checkLValSimple(field);
+						if (field.name === "kind") this.raise(field.start, "Enum payload fields cannot use the discriminator name kind.");
+						if (fields.has(field.name)) this.raise(field.start, "Duplicate enum payload field.");
+						fields.add(field.name);
+						if (this.type !== types$1.colon) this.raise(this.start, "Enum payload fields require a name and type; optional/default/rest fields are unsupported.");
+						field.typeAnnotation = this.tsParseTypeAnnotation();
+						branch.params.push(field);
+						if (!this.eat(types$1.comma)) break;
+					}
+					this.expect(types$1.parenR);
+				}
+				branch.valueEnd = this.lastTokEnd;
+				this.semicolon();
+				node.cases.push(this.finishNode(branch, "TwillEnumCase"));
+			}
+			if (!node.cases.length) this.raise(node.start, "An associated-value enum needs at least one case.");
+			this.next();
+			return this.finishNode(node, "TwillEnumDeclaration");
+		}
 		locate(offset) {
 			if (!this.lineStarts) {
 				this.lineStarts = [0];
@@ -15192,7 +15260,11 @@ function parserFor(language) {
 				node.cleanup = cleanup;
 				return this.finishNode(node, "DeferStatement");
 			}
-			if (!this.isContextual("guard") || !guardAt(this.input, this.end, !!this.implicitClosure)) return super.parseStatement(context, ...args);
+			if (!this.isContextual("guard") || !guardAt(this.input, this.end, !!this.implicitClosure)) {
+				const statement = super.parseStatement(context, ...args);
+				if (context && statement.type === "TwillEnumDeclaration") this.raise(statement.start, "An associated-value enum requires a block; add braces around this body.");
+				return statement;
+			}
 			const node = this.startNode();
 			node.singleStatement = !!context;
 			this.next();
@@ -15212,6 +15284,36 @@ function parserFor(language) {
 			if (!exits(node.failure)) this.raise(node.failure.start, "Every guard else path must exit with return, throw, break or continue.");
 			return this.finishNode(node, "GuardStatement");
 		}
+		parseIfStatement(node) {
+			if (/^\s*\(/.test(this.input.slice(this.end))) return super.parseIfStatement(node);
+			let binding;
+			try {
+				binding = Parser.tokenizer(this.input.slice(this.end), options).getToken().type;
+			} catch {}
+			if (binding !== types$1._const) return super.parseIfStatement(node);
+			this.next();
+			const declaration = this.startNode();
+			this.next();
+			this.enterScope(0);
+			const previous = this.conditionDepth;
+			this.conditionDepth = this.subscriptDepth;
+			try {
+				this.parseVar(declaration, false, "const");
+			} finally {
+				this.conditionDepth = previous;
+			}
+			node.binding = this.finishNode(declaration, "VariableDeclaration");
+			if (node.binding.declarations.length !== 1) this.raise(node.start, "if const requires one binding declaration.");
+			if (this.type !== types$1.braceL) this.raise(this.start, "if const requires a braced success branch.");
+			node.consequent = this.parseBlock(false);
+			this.exitScope();
+			node.alternate = null;
+			if (this.eat(types$1._else)) {
+				if (this.type !== types$1.braceL && this.type !== types$1._if) this.raise(this.start, "if const else requires a block or another if.");
+				node.alternate = this.parseStatement("if");
+			}
+			return this.finishNode(node, "TwillIfBinding");
+		}
 		tsParseTypeParameter(...args) {
 			const start = this.start;
 			const loc = this.startLoc;
@@ -15283,12 +15385,21 @@ function parserFor(language) {
 			}
 			return super.parseExprAtom(...args);
 		}
-		parseSwitchExpression() {
-			const node = this.startNode();
-			this.next();
-			node.parenStart = this.start;
-			node.discriminant = this.parseParenExpression();
-			node.parenEnd = this.lastTokStart;
+		parseSwitchExpression(call) {
+			const node = call ? this.startNodeAt(call.start, call.loc.start) : this.startNode();
+			node.keyword = call ? "match" : "switch";
+			if (call) {
+				if (call.arguments.length !== 1 || call.arguments[0].type === "SpreadElement") this.raise(call.start, "A match expression requires one subject; parenthesize comma expressions.");
+				const opening = Parser.tokenizer(this.input.slice(call.callee.end), options).getToken();
+				node.parenStart = call.callee.end + opening.start;
+				node.discriminant = call.arguments[0];
+				node.parenEnd = call.end - 1;
+			} else {
+				this.next();
+				node.parenStart = this.start;
+				node.discriminant = this.parseParenExpression();
+				node.parenEnd = this.lastTokStart;
+			}
 			this.expect(types$1.braceL);
 			node.cases = [];
 			let mode, discriminator, sawDefault = false;
@@ -15302,6 +15413,34 @@ function parserFor(language) {
 					if (sawDefault) this.raise(branch.start, "Multiple default clauses.");
 					sawDefault = true;
 					branch.test = null;
+				} else if (call && this.type !== types$1.braceL || !call && this.type.label === "name" && this.value === "enum" && !this.containsEsc) {
+					if (mode === "value") this.raise(branch.start, "Cannot mix enum patterns and value cases.");
+					if (discriminator !== void 0 && discriminator !== "kind") this.raise(branch.start, "Enum patterns require the kind discriminator.");
+					mode = "pattern";
+					discriminator = "kind";
+					const pattern = this.startNode();
+					pattern.explicitKeyword = !call;
+					if (!call) this.next();
+					let reference = this.parseIdent();
+					while (this.eat(types$1.dot)) {
+						const member = this.startNodeAt(reference.start, reference.loc.start);
+						member.object = reference;
+						member.property = this.parseIdent(true);
+						member.computed = false;
+						member.optional = false;
+						reference = this.finishNode(member, "MemberExpression");
+					}
+					if (reference.type !== "MemberExpression") this.raise(reference.start, "An enum pattern requires a qualified case reference.");
+					pattern.reference = reference;
+					pattern.parenStart = this.start;
+					this.expect(types$1.parenL);
+					if (this.type === types$1.braceL) {
+						pattern.binding = this.parseObj(true);
+						this.checkLValPattern(pattern.binding, 2, false);
+					}
+					pattern.parenEnd = this.start;
+					this.expect(types$1.parenR);
+					branch.enumPattern = this.finishNode(pattern, "TwillEnumPattern");
 				} else if (this.type === types$1.braceL) {
 					if (mode === "value") this.raise(branch.start, "Cannot mix object patterns and value cases.");
 					mode = "pattern";
@@ -15347,7 +15486,7 @@ function parserFor(language) {
 				node.cases.push(this.finishNode(branch, "TwillSwitchCase"));
 			}
 			this.next();
-			if (!node.cases.length) this.raise(node.start, "A switch expression requires at least one arm.");
+			if (!node.cases.length) this.raise(node.start, `A ${node.keyword} expression requires at least one arm.`);
 			node.discriminator = discriminator;
 			return this.finishNode(node, "TwillSwitchExpression");
 		}
@@ -15410,6 +15549,13 @@ function parserFor(language) {
 		}
 		parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
 			const classBody = this.classSuperDepth !== null && this.subscriptDepth === this.classSuperDepth + 1;
+			if (!noCalls && !classBody && this.type === types$1.braceL && base.type === "CallExpression" && !base.optional && !base.typeParameters && base.callee.type === "Identifier" && base.callee.name === "match" && base.callee.start === base.start && this.input.slice(base.callee.start, base.callee.end) === "match") {
+				let first;
+				try {
+					first = Parser.tokenizer(this.input.slice(this.end), options).getToken().type;
+				} catch {}
+				if (first === types$1._case || first === types$1._default) return this.parseSwitchExpression(base);
+			}
 			if (!noCalls && !classBody && this.tsMatchLeftRelational?.() && this.start === base.end) {
 				const parameters = this.tsTryParseAndCatch(() => {
 					const parsed = this.tsParseTypeArgumentsInExpression();
@@ -15428,6 +15574,7 @@ function parserFor(language) {
 				"MemberExpression",
 				"TSInstantiationExpression"
 			].includes(base.type);
+			if (this.conditionDepth !== null && this.subscriptDepth === this.conditionDepth + 1 && this.type === types$1.braceL) return base;
 			if (!noCalls && supported && this.type === types$1.braceL && !classBody) {
 				if (base.trailing) this.raise(this.start, "Additional trailing closures require labels (for example completion: { ... }).");
 				if (base.type !== "CallExpression" && /[\r\n]/.test(this.input.slice(base.end, this.start))) return base;
@@ -15481,18 +15628,23 @@ function parse$1(source, language = "ts", sourceType = "module") {
 	const live = /* @__PURE__ */ new Set();
 	const calls = [];
 	const guards = [];
+	const ifBindings = [];
 	const defers = [];
 	const switches = [];
+	const enums = [];
 	const visit = (node) => {
 		if (!node || typeof node !== "object") return;
 		if (node.type === "ArrowFunctionExpression" || node.type === "Identifier" && node.start === node.end && node.name === "__twillImplicit") live.add(node);
 		if (node.trailing) calls.push(node);
 		if (node.type === "GuardStatement") guards.push(node);
+		if (node.type === "TwillIfBinding") ifBindings.push(node);
 		if (node.type === "DeferStatement") defers.push(node);
 		if (node.type === "TwillSwitchExpression") switches.push(node);
-		for (const [key, value] of Object.entries(node)) {
+		if (node.type === "TwillEnumDeclaration") enums.push(node);
+		for (const key of Object.keys(node)) {
 			if (key === "trailing" || key === "loc") continue;
-			if (Array.isArray(value)) value.forEach(visit);
+			const value = node[key];
+			if (Array.isArray(value)) for (const child of value) visit(child);
 			else if (value?.type) visit(value);
 		}
 	};
@@ -15501,8 +15653,10 @@ function parse$1(source, language = "ts", sourceType = "module") {
 		ast,
 		calls,
 		guards,
+		ifBindings,
 		defers,
 		switches,
+		enums,
 		comments,
 		closures: parser.closures.filter((closure) => live.has(closure.node)).map((closure) => ({
 			...closure,
@@ -15511,6 +15665,11 @@ function parse$1(source, language = "ts", sourceType = "module") {
 	};
 }
 //#endregion
+//#region src/defer-helper.ts
+function syncDeferBody(names) {
+	return "\n  let " + names.failed + " = false,\n    " + names.failure + ";\n  while (" + names.stack + "?.length) {\n    const " + names.cleanup + " = " + names.stack + ".pop();\n    if (" + names.cleanup + ") {\n      try {\n        " + names.cleanup + "();\n      } catch (" + names.error + ") {\n        " + names.failed + " = true;\n        " + names.failure + " = " + names.error + ";\n      }\n    }\n  }\n  if (" + names.failed + ") throw " + names.failure + ";\n";
+}
+//#endregion
 //#region src/defer.ts
 var functions = /* @__PURE__ */ new Set([
 	"FunctionDeclaration",
@@ -15518,16 +15677,16 @@ var functions = /* @__PURE__ */ new Set([
 	"ArrowFunctionExpression"
 ]);
 function children(node, visit) {
-	for (const [key, value] of Object.entries(node)) {
+	for (const key of Object.keys(node)) {
 		if (key === "loc" || key === "trailing") continue;
-		if (Array.isArray(value)) value.forEach((child) => {
-			if (child?.type) visit(child);
-		});
-		else if (value?.type) visit(value);
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (child?.type) visit(child);
+		} else if (value?.type) visit(value);
 	}
 }
-/** Scope-local cleanup callbacks; dynamic registrations use lazy stacks. */
-function lowerDefers(source, ast, code, language, usedNames, contentStarts, comments, fail) {
+/** Native finally where scope permits; callbacks retain dynamic registration semantics. */
+function lowerDefers(source, ast, code, language, usedNames, contentStarts, comments, runtime, sourceType, fail) {
 	const scopes = [];
 	const visit = (node, scope, parent) => {
 		if (functions.has(node.type) || [
@@ -15576,10 +15735,40 @@ function lowerDefers(source, ast, code, language, usedNames, contentStarts, comm
 		}
 		return start;
 	};
+	let sharedHelper;
 	for (const scope of scopes) {
 		if (!scope.defers.length) continue;
 		const { block } = scope;
 		const statements = block.body;
+		const first = statements.indexOf(scope.defers[0]);
+		let native = first >= 0 && scope.defers.every((node) => !node.awaited && statements.includes(node));
+		if (native) {
+			native = !statements.some((node, index) => node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction" || node.type === "VariableDeclaration" && node.kind.endsWith("using") || index > first && (node.type === "VariableDeclaration" && node.kind !== "var" || node.type.endsWith("Declaration") && node.type !== "VariableDeclaration" || node.type === "GuardStatement" && node.binding));
+			const check = (node) => {
+				if (node.type === "WithStatement" || node.type === "ThisExpression" || node.type === "VariableDeclarator" && !node.init || node.type === "VariableDeclaration" && node.kind === "var" && (!statements.includes(node) || node.start > scope.defers[0].start) || node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "eval") native = false;
+				children(node, check);
+			};
+			if (native) check(block);
+			const cleanupScope = (node) => {
+				if (node.type === "FunctionDeclaration" || node.directive || node.type === "VariableDeclaration" && node.kind === "var") native = false;
+				if (!functions.has(node.type)) children(node, cleanupScope);
+			};
+			if (native) for (const node of scope.defers) cleanupScope(node.cleanup.body);
+		}
+		if (native) {
+			for (const node of [...scope.defers].reverse()) {
+				code.overwrite(node.start, node.cleanup.body.start, ";try {");
+				if (!node.cleanup.body.body.length) {
+					code.remove(node.cleanup.body.start, node.cleanup.body.end);
+					code.appendLeft(block.end - 1, "\n} finally " + source.slice(node.cleanup.body.start, node.cleanup.body.end) + "\n");
+					continue;
+				}
+				code.prependRight(node.cleanup.body.start, "\n} finally ");
+				code.appendLeft(node.cleanup.body.end, "\n");
+				if (node.cleanup.body.end !== block.end - 1) code.move(node.cleanup.body.start, node.cleanup.body.end, block.end - 1);
+			}
+			continue;
+		}
 		const single = scope.defers.length === 1 && statements.includes(scope.defers[0]);
 		const stack = fresh(single ? "Cleanup" : "Defers");
 		const failure = single ? "" : fresh("Failure");
@@ -15600,7 +15789,7 @@ function lowerDefers(source, ast, code, language, usedNames, contentStarts, comm
 		const declarations = scope.functionBody ? ordinary.filter((node) => node.type === "FunctionDeclaration") : [];
 		if (scope.functionBody && ordinary.some((node) => node.type === "TSDeclareFunction")) fail(ordinary.find((node) => node.type === "TSDeclareFunction"), "Function overloads/ambient function declarations in a defer scope are not supported; move them to a separate scope.");
 		const names = [...new Set(declarations.map((node) => node.id.name))];
-		code.appendLeft(start, `;${jsdoc}let ${stack}${annotation};${names.length ? `var ${names.join(",")};` : ""}try {\n`);
+		code.prependLeft(start, `;${jsdoc}let ${stack}${annotation};${names.length ? `var ${names.join(",")};` : ""}try {\n`);
 		let anchor = start;
 		const initial = /* @__PURE__ */ new Set();
 		for (const statement of ordinary) {
@@ -15624,11 +15813,37 @@ function lowerDefers(source, ast, code, language, usedNames, contentStarts, comm
 		}
 		if (single) {
 			const call = allAsync ? `if (${stack}) await ${stack}();` : `${stack}?.();`;
-			code.prependLeft(block.end - 1, `\n} finally { ${call} }\n`);
+			code.appendLeft(block.end - 1, `\n} finally { ${call} }\n`);
+			continue;
+		}
+		if (!anyAsync) {
+			let body;
+			if (runtime === "external") {
+				if (sourceType !== "module") fail(scope.defers[0], "External runtime helpers require module sourceType; use runtime: inline for scripts.");
+				sharedHelper ??= fresh("RunDefers");
+				body = `${sharedHelper}(${stack});`;
+			} else body = syncDeferBody({
+				stack,
+				failed,
+				failure,
+				cleanup: callback,
+				error
+			});
+			code.appendLeft(block.end - 1, `} finally { ${body} }`);
 			continue;
 		}
 		const call = mixed ? `if (${callback}.async) await ${callback}.run(); else ${callback}.run();` : `${allAsync ? "await " : ""}${callback}();`;
-		code.prependLeft(block.end - 1, `} finally { let ${failed} = false, ${failure}; while (${stack}?.length) { const ${callback} = ${stack}.pop(); if (${callback}) { try { ${call} } catch (${error}) { ${failed} = true; ${failure} = ${error}; } } } if (${failed}) throw ${failure}; }`);
+		code.appendLeft(block.end - 1, `} finally { let ${failed} = false, ${failure}; while (${stack}?.length) { const ${callback} = ${stack}.pop(); if (${callback}) { try { ${call} } catch (${error}) { ${failed} = true; ${failure} = ${error}; } } } if (${failed}) throw ${failure}; }`);
+	}
+	if (sharedHelper) {
+		let start = ast.body.find((node) => !node.directive).start;
+		for (const comment of sortedComments) {
+			if (comment.end > start) continue;
+			if (/\S/.test(source.slice(comment.end, start))) break;
+			if ((source.startsWith("/**", comment.start) || /@ts-(?:ignore|expect-error)\b/.test(comment.value)) && !/@(?:ts-(?:check|nocheck)|jsxImportSource|jsxRuntime)\b/.test(comment.value)) start = comment.start;
+			else break;
+		}
+		code.prependLeft(start, `\nimport { runDefers as ${sharedHelper} } from '@swiftuijs/twill-runtime/helpers/v1';\n`);
 	}
 }
 //#endregion
@@ -15652,22 +15867,68 @@ function suspension(node) {
 		}
 	}
 }
-/** Native switches with per-arm scopes; expression contexts use a synchronous
-* lexical IIFE. Direct returns need no extra function or scheduling. */
-function lowerSwitchExpressions(source, ast, switches, code, language, usedNames, fail) {
+/** Native switches with per-arm scopes. Direct returns and standalone variable
+* initializers need no extra function; other expressions keep a lexical IIFE. */
+function lowerSwitchExpressions(source, ast, switches, code, language, usedNames, comments, fail) {
 	const returns = /* @__PURE__ */ new Set();
-	const visit = (node) => {
+	const initializers = /* @__PURE__ */ new Map();
+	const leadingDoc = (start) => {
+		let low = 0, high = comments.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			if (comments[middle].end <= start) low = middle + 1;
+			else high = middle;
+		}
+		const comment = comments[low - 1];
+		return comment && /^\s*$/.test(source.slice(comment.end, start)) ? comment : void 0;
+	};
+	const directEval = (node) => {
+		if ([
+			"FunctionDeclaration",
+			"FunctionExpression",
+			"ArrowFunctionExpression"
+		].includes(node.type)) return false;
+		if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "eval" && !node.optional) return true;
+		return Object.entries(node).some(([key, value]) => ![
+			"loc",
+			"trailing",
+			"tag"
+		].includes(key) && (Array.isArray(value) ? value : [value]).some((child) => child?.type && directEval(child)));
+	};
+	const grouping = (start, end, initializer = false) => {
+		const parentheses = [];
+		const tokens = Parser.tokenizer(source.slice(start, end), { ecmaVersion: "latest" });
+		for (;;) {
+			const token = tokens.getToken();
+			if (token.type === types$1.eof) break;
+			if (initializer && token.type === types$1.eq) parentheses.length = 0;
+			if (token.type === types$1.parenL || token.type === types$1.parenR) parentheses.push(token);
+		}
+		for (const token of parentheses) code.remove(start + token.start, start + token.end);
+	};
+	const visit = (node, parent) => {
+		if (node.type === "VariableDeclaration" && node.declarations.length === 1) {
+			const declaration = node.declarations[0];
+			if (declaration.id.type === "Identifier" && declaration.init?.type === "TwillSwitchExpression" && [
+				"Program",
+				"BlockStatement",
+				"SwitchCase",
+				"ExportNamedDeclaration"
+			].includes(parent?.type ?? "")) {
+				const statement = parent?.type === "ExportNamedDeclaration" ? parent : node;
+				const comment = leadingDoc(statement.start);
+				const prefixStart = comment && source.startsWith("/**", comment.start) ? comment.start : statement.start;
+				if (!(comment && /@ts-(?:ignore|expect-error|nocheck|check)\b/.test(source.slice(comment.start, comment.end))) && !directEval(declaration.init) && (language.startsWith("ts") || prefixStart === statement.start)) initializers.set(declaration.init, {
+					declaration,
+					statement,
+					prefixStart
+				});
+			}
+		}
 		if (node.type === "ReturnStatement" && node.argument?.type === "TwillSwitchExpression") {
 			returns.add(node.argument);
 			code.remove(node.start, node.start + 6);
-			for (const [start, end] of [[node.start + 6, node.argument.start], [node.argument.end, node.end]]) {
-				const tokens = Parser.tokenizer(source.slice(start, end), { ecmaVersion: "latest" });
-				for (;;) {
-					const token = tokens.getToken();
-					if (token.type === types$1.eof) break;
-					if (token.type === types$1.parenL || token.type === types$1.parenR) code.remove(start + token.start, start + token.end);
-				}
-			}
+			for (const [start, end] of [[node.start + 6, node.argument.start], [node.argument.end, node.end]]) grouping(start, end);
 		}
 		for (const [key, value] of Object.entries(node)) {
 			if ([
@@ -15675,7 +15936,7 @@ function lowerSwitchExpressions(source, ast, switches, code, language, usedNames
 				"trailing",
 				"tag"
 			].includes(key)) continue;
-			for (const child of Array.isArray(value) ? value : [value]) if (child?.type) visit(child);
+			for (const child of Array.isArray(value) ? value : [value]) if (child?.type) visit(child, node);
 		}
 	};
 	visit(ast);
@@ -15691,26 +15952,84 @@ function lowerSwitchExpressions(source, ast, switches, code, language, usedNames
 	for (const node of switches) {
 		const direct = returns.has(node);
 		const suspended = !direct && suspension(node);
-		if (suspended) fail(suspended, "await/yield inside a switch expression requires a direct return. Bind the subject first, or await the whole result explicitly.");
+		if (suspended) fail(suspended, `await/yield inside a ${node.keyword} expression requires a direct return. Bind the subject first, or await the whole result explicitly.`);
+		const initializer = initializers.get(node);
+		const result = initializer ? fresh("Result") : void 0;
+		const exit = initializer ? fresh("Exit") : void 0;
 		const subject = fresh("Subject");
-		code.appendLeft(node.start, `${direct ? "{" : "(() => {"}const ${subject} = `);
+		if (initializer) {
+			const { declaration, statement, prefixStart } = initializer;
+			const annotation = language.startsWith("ts") && declaration.id.typeAnnotation ? `: typeof ${declaration.id.name}` : "";
+			grouping(declaration.id.end, node.start, true);
+			grouping(node.end, statement.end);
+			code.appendLeft(prefixStart, `let ${result}${annotation}; ${exit}: {const ${subject} = `);
+			if (prefixStart < statement.start) code.prependRight(prefixStart, "\n");
+			code.move(prefixStart, node.start, node.end);
+			code.appendRight(node.end, ` ${result}`);
+		}
+		const valuePrefix = result ? `${result} = (` : "return ";
+		const valueSuffix = result ? `); break ${exit};` : ";";
+		const kind = node.cases.some((branch) => branch.enumPattern) ? fresh("Kind") : void 0;
+		if (!initializer) code.appendLeft(node.start, `${direct ? "{" : "(() => {"}const ${subject} = `);
 		code.remove(node.parenStart, node.parenStart + 1);
-		code.move(node.start, node.start + 6, node.parenEnd);
-		code.appendLeft(node.parenEnd, "; ");
-		code.overwrite(node.parenEnd, node.parenEnd + 1, ` (${subject}${node.discriminator === void 0 ? "" : `[${JSON.stringify(node.discriminator)}]`})`);
-		for (const branch of node.cases) if (branch.pattern) {
+		if (node.keyword === "match") {
+			const tokens = Parser.tokenizer(source.slice(node.discriminant.end, node.parenEnd), { ecmaVersion: "latest" });
+			for (;;) {
+				const token = tokens.getToken();
+				if (token.type === types$1.eof) break;
+				if (token.type === types$1.comma) code.remove(node.discriminant.end + token.start, node.discriminant.end + token.end);
+			}
+		}
+		const keywordEnd = node.start + (node.keyword === "match" ? 5 : 6);
+		if (node.keyword === "match") code.overwrite(node.start, keywordEnd, "switch");
+		code.move(node.start, keywordEnd, node.parenEnd);
+		code.appendLeft(node.parenEnd, `; ${kind ? `const ${kind} = ${subject}["kind"]; ` : ""}`);
+		code.overwrite(node.parenEnd, node.parenEnd + 1, ` (${kind ?? subject}${kind || node.discriminator === void 0 ? "" : `[${JSON.stringify(node.discriminator)}]`})`);
+		for (const branch of node.cases) if (branch.enumPattern) {
+			const { reference, binding, start, parenStart, parenEnd, explicitKeyword } = branch.enumPattern;
+			const tag = JSON.stringify(reference.property.name);
+			if (language.startsWith("ts")) {
+				const witness = `(${tag} satisfies (typeof `;
+				if (explicitKeyword) code.overwrite(start, start + 4, witness);
+				else code.appendLeft(start, witness);
+				code.appendLeft(reference.end, ` extends (...args: never[]) => { readonly kind: ${tag} } ? ${tag} : never))`);
+			} else if (explicitKeyword) {
+				code.overwrite(start, start + 4, tag);
+				code.remove(reference.start, reference.end);
+			} else code.overwrite(reference.start, reference.end, tag);
+			code.remove(parenStart, parenStart + 1);
+			code.remove(parenEnd, parenEnd + 1);
+			if (binding) {
+				code.appendLeft(binding.start, ": { const ");
+				code.overwrite(branch.colonStart, branch.colonStart + 1, ` = ${subject}; ${branch.throw ? "" : valuePrefix}`);
+				code.appendLeft(branch.valueEnd, `${branch.throw ? ";" : valueSuffix} }`);
+				if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+			} else if (!branch.throw) {
+				code.appendLeft(branch.colonStart + 1, ` ${valuePrefix}`);
+				if (result) {
+					code.appendLeft(branch.valueEnd, valueSuffix);
+					if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+				}
+			}
+		} else if (branch.pattern) {
 			const { pattern, tag } = branch;
 			code.appendLeft(tag.value.start, fresh("Tag"));
 			code.move(tag.value.start, tag.value.end, pattern.start);
 			code.appendLeft(tag.value.end, ": { const ");
-			code.overwrite(branch.colonStart, branch.colonStart + 1, ` = ${subject}; ${branch.throw ? "" : "return "}`);
-			code.appendLeft(branch.valueEnd, "; }");
+			code.overwrite(branch.colonStart, branch.colonStart + 1, ` = ${subject}; ${branch.throw ? "" : valuePrefix}`);
+			code.appendLeft(branch.valueEnd, `${branch.throw ? ";" : valueSuffix} }`);
 			if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
-		} else if (!branch.throw) code.appendLeft(branch.colonStart + 1, " return ");
-		const hasDefault = node.cases.some((branch) => !branch.pattern && branch.test === null);
-		const check = !hasDefault && language.startsWith("ts") ? ` ${subject} satisfies never;` : "";
+		} else if (!branch.throw) {
+			code.appendLeft(branch.colonStart + 1, ` ${valuePrefix}`);
+			if (result) {
+				code.appendLeft(branch.valueEnd, valueSuffix);
+				if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+			}
+		}
+		const hasDefault = node.cases.some((branch) => !branch.pattern && !branch.enumPattern && branch.test === null);
+		const check = !hasDefault && language.startsWith("ts") ? ` ${kind ? `(0 as unknown as typeof ${kind})` : subject} satisfies never;` : "";
 		const failure = hasDefault ? "" : `${check} throw new TypeError('Non-exhaustive switch expression');`;
-		code.overwrite(node.end - 1, node.end, `}${failure}${direct ? "}" : "})()"}`);
+		code.overwrite(node.end - 1, node.end, `}${failure}${direct || initializer ? "}" : "})()"}`, { contentOnly: true });
 	}
 }
 //#endregion
@@ -15842,7 +16161,7 @@ function normalizePath(url, type) {
 /**
 * Attempts to resolve `input` URL/path relative to `base`.
 */
-function resolve$3(input, base) {
+function resolve$4(input, base) {
 	if (!input && !base) return "";
 	const url = parseUrl(input);
 	let inputType = url.type;
@@ -15887,7 +16206,7 @@ function stripFilename(path) {
 function resolver(mapUrl, sourceRoot) {
 	const from = stripFilename(mapUrl);
 	const prefix = sourceRoot ? sourceRoot + "/" : "";
-	return (source) => resolve$3(prefix + (source || ""), from);
+	return (source) => resolve$4(prefix + (source || ""), from);
 }
 var COLUMN$1 = 0;
 var SOURCES_INDEX$1 = 1;
@@ -16028,6 +16347,10 @@ var TraceMap = class {
 function cast$1(map) {
 	return map;
 }
+function encodedMappings(map) {
+	var _a, _b;
+	return (_b = (_a = cast$1(map))._encoded) != null ? _b : _a._encoded = encode(cast$1(map)._decoded);
+}
 function decodedMappings(map) {
 	var _a;
 	return (_a = cast$1(map))._decoded || (_a._decoded = decode(cast$1(map)._encoded));
@@ -16113,11 +16436,193 @@ function generatedPosition$1(map, source, line, column, bias, all) {
 	return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
 }
 //#endregion
-//#region src/compiler.ts
+//#region src/enums.ts
+/** Find free type references, respecting generic function/mapped/infer binders. */
+function references(node, names, found = /* @__PURE__ */ new Set(), bound = /* @__PURE__ */ new Set()) {
+	const local = new Set(bound);
+	for (const parameter of node.typeParameters?.params ?? []) local.add(parameter.name);
+	if (node.type === "TSMappedType") local.add(node.typeParameter.name);
+	if (node.type === "TSInferType") local.add(node.typeParameter.name);
+	if (node.type === "TSTypeReference" && node.typeName.type === "Identifier") {
+		const name = node.typeName.name;
+		if (names.has(name) && !local.has(name)) found.add(name);
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (["loc", "typeName"].includes(key)) continue;
+		for (const child of Array.isArray(value) ? value : [value]) {
+			if (!child?.type) continue;
+			const childBound = new Set(local);
+			if (node.type === "TSConditionalType" && key === "trueType") {
+				const bind = (part) => {
+					if (part.type === "TSInferType") childBound.add(part.typeParameter.name);
+					for (const [property, nested] of Object.entries(part)) {
+						if (property === "loc") continue;
+						if (part.type === "TSConditionalType" && property === "extendsType") continue;
+						for (const item of Array.isArray(nested) ? nested : [nested]) if (item?.type) bind(item);
+					}
+				};
+				bind(node.extendsType);
+			}
+			references(child, names, found, childBound);
+		}
+	}
+	return found;
+}
+function enumTypeParameters(node, branch) {
+	const parameters = node.typeParameters?.params ?? [];
+	const names = new Set(parameters.map((parameter) => parameter.name));
+	const used = /* @__PURE__ */ new Set();
+	for (const field of branch.params) references(field.typeAnnotation, names, used);
+	for (let size = -1; size !== used.size;) {
+		size = used.size;
+		for (const parameter of parameters) {
+			if (!used.has(parameter.name)) continue;
+			if (parameter.constraint) references(parameter.constraint, names, used);
+			if (parameter.default) references(parameter.default, names, used);
+		}
+	}
+	return parameters.filter((parameter) => used.has(parameter.name));
+}
+/** Tagged records and precise factories; no application runtime is introduced. */
+function lowerEnums(source, ast, enums, code) {
+	const insertions = [];
+	const exported = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (node.type === "ExportNamedDeclaration") exported.add(node.declaration);
+		for (const [key, value] of Object.entries(node)) {
+			if (["loc", "trailing"].includes(key)) continue;
+			for (const child of Array.isArray(value) ? value : [value]) if (child?.type) visit(child);
+		}
+	};
+	visit(ast);
+	for (const node of enums) {
+		const replacement = {
+			anchor: node.braceStart,
+			before: false,
+			text: "= ",
+			copies: []
+		};
+		for (const [index, branch] of node.cases.entries()) {
+			if (index) replacement.text += " | ";
+			replacement.text += `{ readonly kind: ${JSON.stringify(branch.id.name)}; `;
+			for (const field of branch.params) {
+				replacement.text += "readonly ";
+				const text = source.slice(field.start, field.typeAnnotation.end);
+				replacement.copies.push({
+					start: replacement.text.length,
+					sourceStart: field.start,
+					length: text.length
+				});
+				replacement.text += text + "; ";
+			}
+			replacement.text += "}";
+		}
+		replacement.text += `; ${exported.has(node) ? "export " : ""}const `;
+		replacement.copies.push({
+			start: replacement.text.length,
+			sourceStart: node.id.start,
+			length: node.id.end - node.id.start
+		});
+		replacement.text += source.slice(node.id.start, node.id.end) + " = {";
+		insertions.push(replacement);
+		code.overwrite(node.start, node.start + 4, "type");
+		code.overwrite(node.braceStart, node.braceStart + 1, replacement.text);
+		for (const branch of node.cases) {
+			code.remove(branch.start, branch.start + 4);
+			const parameters = enumTypeParameters(node, branch);
+			const copied = {
+				anchor: branch.id.end,
+				before: true,
+				text: parameters.length ? "<" : "",
+				copies: []
+			};
+			for (const [index, parameter] of parameters.entries()) {
+				if (index) copied.text += ", ";
+				const text = source.slice(parameter.start, parameter.end);
+				copied.copies.push({
+					start: copied.text.length,
+					sourceStart: parameter.start,
+					length: text.length
+				});
+				copied.text += text;
+			}
+			if (parameters.length) copied.text += ">";
+			const generic = copied.text;
+			if (generic) insertions.push(copied);
+			code.appendLeft(branch.id.end, generic + (branch.hasParens ? "" : "()"));
+			const fields = branch.params.map((field) => field.name);
+			code.appendLeft(branch.valueEnd, `{ return { kind: ${JSON.stringify(branch.id.name)}${fields.length ? ", " + fields.join(", ") : ""} } as const; },`);
+			if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+		}
+		code.appendLeft(node.end, ";");
+	}
+	return insertions;
+}
+/** Generated type copies map to their actual source tokens, including .d.ts maps. */
+function mapEnumCopies(source, generated, map, insertions) {
+	const starts = (text) => {
+		const result = [0];
+		for (let index = 0; index < text.length; index++) if (text[index] === "\n") result.push(index + 1);
+		return result;
+	};
+	const originalLines = starts(source), generatedLines = starts(generated);
+	const position = (lines, offset) => {
+		let line = 0;
+		while (line + 1 < lines.length && lines[line + 1] <= offset) line++;
+		return {
+			line,
+			column: offset - lines[line]
+		};
+	};
+	const trace = new TraceMap(map);
+	const decoded = decodedMappings(trace);
+	const copies = [];
+	for (const insertion of insertions) {
+		const anchor = position(originalLines, insertion.anchor);
+		const location = generatedPositionFor(trace, {
+			source: map.sources[0],
+			line: anchor.line + 1,
+			column: anchor.column
+		});
+		const offset = generatedLines[location.line - 1] + location.column - (insertion.before ? insertion.text.length : 0);
+		if (generated.slice(offset, offset + insertion.text.length) !== insertion.text) throw new Error("Enum mapping anchor does not match generated text.");
+		for (const copy of insertion.copies) {
+			copies.push({
+				generatedStart: offset + copy.start,
+				sourceStart: copy.sourceStart,
+				length: copy.length
+			});
+			for (let index = 0; index < copy.length; index++) {
+				const target = position(generatedLines, offset + copy.start + index);
+				const original = position(originalLines, copy.sourceStart + index);
+				const line = decoded[target.line];
+				const entry = [
+					target.column,
+					0,
+					original.line,
+					original.column
+				];
+				const existing = line.findIndex((segment) => segment[0] === target.column);
+				if (existing >= 0) line[existing] = entry;
+				else line.push(entry);
+			}
+		}
+	}
+	for (const line of decoded) line.sort((left, right) => left[0] - right[0]);
+	map.mappings = encodedMappings(new TraceMap({
+		...JSON.parse(map.toString()),
+		mappings: decoded
+	}));
+	return copies;
+}
+//#endregion
+//#region src/extensions.ts
 var extensions = [".twill", ".twillx"];
 function isTwillFile(id) {
 	return extensions.some((extension) => id.split(/[?#]/, 1)[0].endsWith(extension));
 }
+//#endregion
+//#region src/compiler.ts
 function inferLanguage(filename) {
 	if (/\.(?:twillx|tsx)$/.test(filename)) return "tsx";
 	if (/\.jsx$/.test(filename)) return "jsx";
@@ -16144,12 +16649,12 @@ var TwillSyntaxError = class extends SyntaxError {
 };
 function walk(node, visit) {
 	visit(node);
-	for (const [key, value] of Object.entries(node)) {
-		if (["loc", "trailing"].includes(key)) continue;
-		if (Array.isArray(value)) value.forEach((child) => {
-			if (child?.type) walk(child, visit);
-		});
-		else if (value?.type) walk(value, visit);
+	for (const key of Object.keys(node)) {
+		if (key === "loc" || key === "trailing") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (child?.type) walk(child, visit);
+		} else if (value?.type) walk(value, visit);
 	}
 }
 function calleeName(node) {
@@ -16160,6 +16665,7 @@ function calleeName(node) {
 	}
 }
 function transform(source, options = {}) {
+	if (options.runtime !== void 0 && !["inline", "external"].includes(options.runtime)) throw new TypeError("runtime must be inline or external");
 	const filename = options.filename ?? "input.twill";
 	let parsed;
 	try {
@@ -16168,11 +16674,28 @@ function transform(source, options = {}) {
 		throw new TwillSyntaxError(source, filename, error);
 	}
 	const code = new MagicString(source);
+	const enumInsertions = parsed.enums.length ? lowerEnums(source, parsed.ast, parsed.enums, code) : [];
 	const usedNames = /* @__PURE__ */ new Set();
-	if (parsed.guards.filter((guard) => guard.binding && guard.binding.declarations[0].id.type !== "Identifier").length || parsed.switches.length || parsed.defers.length || parsed.closures.some((closure) => closure.implicitMembers.length) || /\.twillx$/.test(filename.split(/[?#]/, 1)[0])) walk(parsed.ast, (node) => {
-		if (node.type === "Identifier") usedNames.add(node.name);
+	if (parsed.guards.filter((guard) => guard.binding && guard.binding.declarations[0].id.type !== "Identifier").length || parsed.ifBindings.length || parsed.switches.length || parsed.defers.length || parsed.closures.some((closure) => closure.implicitMembers.length) || /\.twillx$/.test(filename.split(/[?#]/, 1)[0])) walk(parsed.ast, (node) => {
+		if (node.type === "Identifier" || node.type === "JSXIdentifier") usedNames.add(node.name);
 	});
 	let guardCounter = 0;
+	const ifBindingStarts = new Set(parsed.ifBindings.map((node) => node.consequent.start + 1));
+	for (const statement of parsed.ifBindings) {
+		const binding = statement.binding.declarations[0].id;
+		let temporary;
+		do
+			temporary = `__twillIf${guardCounter++}`;
+		while (usedNames.has(temporary));
+		usedNames.add(temporary);
+		const patternEnd = binding.typeAnnotation?.start ?? binding.end;
+		code.overwrite(statement.start, binding.start, `{const ${temporary}`);
+		code.move(binding.start, patternEnd, statement.consequent.start + 1);
+		code.prependRight(binding.start, "const ");
+		code.appendLeft(patternEnd, ` = ${temporary};`);
+		code.prependLeft(statement.consequent.start, `; if (${temporary} !== null && ${temporary} !== void 0) `);
+		code.appendLeft(statement.end, "}");
+	}
 	for (const guard of parsed.guards) {
 		if (guard.singleStatement) {
 			code.prependLeft(guard.start, "{");
@@ -16379,13 +16902,15 @@ function transform(source, options = {}) {
 				const collect = (statement) => {
 					switch (statement.type) {
 						case "ExpressionStatement":
-							code.prependLeft(statement.start, `${collector}.push(`);
+							if (ifBindingStarts.has(statement.start)) code.appendRight(statement.start, `${collector}.push(`);
+							else code.prependLeft(statement.start, `${collector}.push(`);
 							code.appendLeft(source[statement.end - 1] === ";" ? statement.end - 1 : statement.end, ")");
 							break;
 						case "BlockStatement":
 							statement.body.forEach(collect);
 							break;
 						case "IfStatement":
+						case "TwillIfBinding":
 							collect(statement.consequent);
 							if (statement.alternate) collect(statement.alternate);
 							break;
@@ -16429,7 +16954,7 @@ function transform(source, options = {}) {
 		if (component) code.prependLeft(closures.at(-1).end, (vue ? "})}" : directChild || metadataByNode.get(closures[0]).header ? ")}" : ")()}") + `</${calleeName(node.callee)}>)`);
 		else code.appendLeft(closures.at(-1).end, ")");
 	}
-	if (parsed.switches.length) lowerSwitchExpressions(source, parsed.ast, parsed.switches, code, options.language ?? inferLanguage(filename), usedNames, (node, message) => {
+	if (parsed.switches.length) lowerSwitchExpressions(source, parsed.ast, parsed.switches, code, options.language ?? inferLanguage(filename), usedNames, parsed.comments, (node, message) => {
 		throw new TwillSyntaxError(source, filename, {
 			message,
 			pos: node.start,
@@ -16440,7 +16965,7 @@ function transform(source, options = {}) {
 	if (parsed.defers.length) {
 		const starts = /* @__PURE__ */ new Map();
 		for (const metadata of parsed.closures) if (metadata.header) starts.set(metadata.node.body, metadata.header.end);
-		lowerDefers(source, parsed.ast, code, options.language ?? inferLanguage(filename), usedNames, starts, parsed.comments, (node, message) => {
+		lowerDefers(source, parsed.ast, code, options.language ?? inferLanguage(filename), usedNames, starts, parsed.comments, options.runtime ?? "inline", options.sourceType ?? "module", (node, message) => {
 			throw new TwillSyntaxError(source, filename, {
 				message,
 				pos: node.start,
@@ -16454,14 +16979,19 @@ function transform(source, options = {}) {
 		includeContent: true,
 		hires: true
 	});
+	const enumCopies = enumInsertions.length ? mapEnumCopies(source, code.toString(), map, enumInsertions) : [];
 	return {
 		code: code.toString(),
 		map,
 		changed: code.hasChanged(),
 		closures: parsed.closures.length,
 		guards: parsed.guards.length,
+		ifBindings: parsed.ifBindings.length,
 		defers: parsed.defers.length,
 		switches: parsed.switches.length,
+		associatedEnums: parsed.enums,
+		enumPatterns: parsed.switches.flatMap((node) => node.cases.flatMap((branch) => branch.enumPattern ? [branch.enumPattern] : [])),
+		enumCopies,
 		componentProps
 	};
 }
@@ -16490,21 +17020,78 @@ function generatedPosition(result, line, column) {
 	});
 }
 //#endregion
-//#region src/config.ts
+//#region src/compilation-cache.ts
+var digest = (source) => (0, node_crypto.createHash)("sha256").update(source).digest("hex");
+function observe(path, kind) {
+	try {
+		if (kind === "directory") return (0, node_fs.statSync)(path).isDirectory() ? "directory" : "absent";
+		return digest((0, node_fs.readFileSync)(path));
+	} catch (error) {
+		return ["ENOENT", "ENOTDIR"].includes(error.code ?? "") ? "absent" : "unavailable";
+	}
+}
+//#endregion
+//#region src/configuration.ts
 var jsxConfigs = /* @__PURE__ */ new Map();
+function record(observations, path, kind) {
+	path = (0, node_path.resolve)(path);
+	observations.set(kind + path, {
+		path,
+		kind,
+		value: observe(path, kind)
+	});
+}
 /** Use the project's standard JSX setting, including extended tsconfigs. */
-function jsxSource(root, configFile) {
-	const filename = configFile ?? typescript.default.findConfigFile(root, typescript.default.sys.fileExists);
+function jsxSource(root, configFile, observations) {
+	const system = observations ? {
+		...typescript.default.sys,
+		fileExists(path) {
+			record(observations, path, "file");
+			return typescript.default.sys.fileExists(path);
+		},
+		directoryExists(path) {
+			record(observations, path, "directory");
+			return typescript.default.sys.directoryExists(path);
+		}
+	} : typescript.default.sys;
+	const filename = configFile ?? typescript.default.findConfigFile(root, system.fileExists);
 	if (!filename) return void 0;
 	const cached = jsxConfigs.get(filename);
-	if (cached && [...cached.files].every(([file, time]) => ((0, node_fs.existsSync)(file) ? (0, node_fs.statSync)(file).mtimeMs : -1) === time)) return cached.source;
+	if (!observations && cached && [...cached.files].every(([file, time]) => ((0, node_fs.existsSync)(file) ? (0, node_fs.statSync)(file).mtimeMs : -1) === time)) return cached.source;
 	const files = /* @__PURE__ */ new Map();
 	const source = typescript.default.getParsedCommandLineOfConfigFile(filename, {}, {
-		...typescript.default.sys,
+		...system,
 		readDirectory: () => [],
 		readFile(file) {
 			files.set(file, (0, node_fs.existsSync)(file) ? (0, node_fs.statSync)(file).mtimeMs : -1);
-			return typescript.default.sys.readFile(file);
+			if (!observations) return typescript.default.sys.readFile(file);
+			const path = (0, node_path.resolve)(file);
+			let bytes;
+			try {
+				bytes = (0, node_fs.readFileSync)(file);
+			} catch {
+				observations.set("file" + path, {
+					path,
+					kind: "file",
+					value: "unavailable"
+				});
+				return;
+			}
+			observations.set("file" + path, {
+				path,
+				kind: "file",
+				value: digest(bytes)
+			});
+			if (bytes[0] === 254 && bytes[1] === 255) {
+				for (let i = 0; i < (bytes.length & -2); i += 2) {
+					const byte = bytes[i];
+					bytes[i] = bytes[i + 1];
+					bytes[i + 1] = byte;
+				}
+				return bytes.toString("utf16le", 2);
+			}
+			if (bytes[0] === 255 && bytes[1] === 254) return bytes.toString("utf16le", 2);
+			return bytes.toString("utf8", bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191 ? 3 : 0);
 		},
 		getCurrentDirectory: () => root,
 		onUnRecoverableConfigFileDiagnostic() {}
@@ -16515,19 +17102,35 @@ function jsxSource(root, configFile) {
 	});
 	return source;
 }
-function loadConfig(root = process.cwd(), configFile) {
+function readConfig(root, configFile, observations) {
 	const filename = (0, node_path.resolve)(root, "twill.config.json");
-	const jsxImportSource = jsxSource(root, configFile);
+	const jsxImportSource = jsxSource(root, configFile, observations);
+	if (observations) record(observations, filename, "file");
 	if (!(0, node_fs.existsSync)(filename)) return { jsxImportSource };
-	const value = JSON.parse((0, node_fs.readFileSync)(filename, "utf8"));
+	const text = (0, node_fs.readFileSync)(filename, "utf8");
+	if (observations) observations.set("file" + filename, {
+		path: filename,
+		kind: "file",
+		value: digest(text)
+	});
+	const value = JSON.parse(text);
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${filename}: expected an object`);
 	if (value.implicitReturn !== void 0 && typeof value.implicitReturn !== "boolean") throw new Error(`${filename}: implicitReturn must be a boolean`);
-	for (const key of Object.keys(value)) if (!["implicitReturn", "$schema"].includes(key)) throw new Error(`${filename}: unknown option ${key}`);
+	if (value.runtime !== void 0 && !["inline", "external"].includes(value.runtime)) throw new Error(`${filename}: runtime must be inline or external`);
+	for (const key of Object.keys(value)) if (![
+		"implicitReturn",
+		"runtime",
+		"$schema"
+	].includes(key)) throw new Error(`${filename}: unknown option ${key}`);
 	return {
 		implicitReturn: value.implicitReturn,
-		jsxImportSource
+		jsxImportSource,
+		...value.runtime === void 0 ? {} : { runtime: value.runtime }
 	};
 }
+function loadConfig(root = process.cwd(), configFile) {
+	return readConfig(root, configFile);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
 var SetArray = class {
@@ -16828,7 +17431,7 @@ function remapping(input, loader, options) {
 //#endregion
 //#region src/recovery.ts
 /** Editor-only recovery; build and CLI compilation always use strict parsing. */
-function recoverTransform(source, options) {
+function recoverTransform(source, options, onSyntaxError) {
 	const repaired = new MagicString(source);
 	let text = source;
 	for (let attempt = 0; attempt < 8; attempt++) try {
@@ -16839,13 +17442,37 @@ function recoverTransform(source, options) {
 			includeContent: true,
 			hires: true
 		});
+		const repairedResult = {
+			...result,
+			map: repairMap
+		};
+		const starts = [0];
+		for (const match of source.matchAll(/\n/g)) starts.push(match.index + 1);
+		const sourceOffset = (offset) => {
+			const prefix = text.slice(0, offset).split("\n");
+			const point = originalPosition(repairedResult, prefix.length, prefix.at(-1).length);
+			return starts[point.line - 1] + point.column;
+		};
+		const enumPatterns = result.enumPatterns.map((pattern) => ({
+			...pattern,
+			reference: {
+				...pattern.reference,
+				property: {
+					...pattern.reference.property,
+					start: sourceOffset(pattern.reference.property.start),
+					end: sourceOffset(pattern.reference.property.end)
+				}
+			}
+		}));
 		const map = remapping([JSON.parse(result.map.toString()), JSON.parse(repairMap.toString())], () => null);
 		return {
 			...result,
+			enumPatterns,
 			map
 		};
 	} catch (error) {
 		if (!(error instanceof TwillSyntaxError)) throw error;
+		if (attempt === 0) onSyntaxError?.(error);
 		const before = text.slice(0, error.offset);
 		let insertion;
 		let offset = error.offset;
@@ -17110,13 +17737,18 @@ var TwillProject = class {
 	result(filename, source) {
 		const cached = this.results.get(filename);
 		if (cached?.source === source) return cached.result;
-		const result = (this.recover ? recoverTransform : transform)(source, {
+		const options = {
 			...this.options,
 			filename
-		});
+		};
+		let syntaxError;
+		const result = this.recover ? recoverTransform(source, options, (error) => {
+			syntaxError = error;
+		}) : transform(source, options);
 		this.results.set(filename, {
 			source,
-			result
+			result,
+			syntaxError
 		});
 		return result;
 	}
@@ -17210,11 +17842,9 @@ var TwillProject = class {
 		for (const file of files) {
 			if (/\.d\.[cm]?ts$/.test(file)) continue;
 			try {
-				if (this.recover && isTwillFile(sourceFilename(file))) transform(this.text(file) ?? "", {
-					...this.options,
-					filename: sourceFilename(file)
-				});
 				this.transformed(file);
+				const syntaxError = this.results.get(sourceFilename(file))?.syntaxError;
+				if (syntaxError) throw syntaxError;
 				result.push(...[...this.service.getSyntacticDiagnostics(file), ...this.service.getSemanticDiagnostics(file)].map((error) => this.diagnostic(error)));
 			} catch (error) {
 				const syntax = error;
@@ -17241,6 +17871,7 @@ var TwillProject = class {
 var TwillEditor = class {
 	project;
 	attributeCache = /* @__PURE__ */ new WeakMap();
+	descriptorCache = /* @__PURE__ */ new WeakMap();
 	constructor(project) {
 		this.project = project;
 	}
@@ -17309,10 +17940,11 @@ var TwillEditor = class {
 		const source = this.project.text(filename);
 		if (source === void 0) return void 0;
 		if (!isTwillFile(filename)) return span.start >= 0 && span.start + span.length <= source.length ? span : void 0;
-		const generated = this.project.transformed(filename)?.code;
+		const transformed = this.project.transformed(filename);
+		const generated = transformed?.code;
 		if (generated === void 0) return void 0;
 		const start = this.project.toOriginalOffset(filename, span.start);
-		if (start < 0 || start + span.length > source.length || this.project.toGeneratedOffset(filename, start) !== span.start || source.slice(start, start + span.length) !== generated.slice(span.start, span.start + span.length)) return void 0;
+		if (start < 0 || start + span.length > source.length || this.project.toGeneratedOffset(filename, start) !== span.start && !transformed.enumCopies.some((copy) => span.start >= copy.generatedStart && span.start + span.length <= copy.generatedStart + copy.length && start === copy.sourceStart + span.start - copy.generatedStart || start >= copy.sourceStart && start + span.length <= copy.sourceStart + copy.length && this.project.toOriginalOffset(filename, span.start + span.length - 1) === start + span.length - 1) || source.slice(start, start + span.length) !== generated.slice(span.start, span.start + span.length)) return void 0;
 		return {
 			start,
 			length: span.length
@@ -17400,8 +18032,77 @@ var TwillEditor = class {
 	references(filename, position) {
 		return this.referenceGroups(filename, position)?.flatMap((group) => group.references);
 	}
+	descriptorSymbols(program) {
+		const cached = this.descriptorCache.get(program);
+		if (cached) return cached;
+		const symbols = /* @__PURE__ */ new Set();
+		const checker = program.getTypeChecker();
+		for (const file of program.getSourceFiles()) {
+			const original = sourceFilename(file.fileName);
+			if (!isTwillFile(original)) continue;
+			let patterns;
+			try {
+				patterns = this.project.transformed(original)?.enumPatterns;
+			} catch {
+				continue;
+			}
+			if (!patterns?.length) continue;
+			const offsets = new Set(patterns.map((pattern) => this.project.toGeneratedOffset(original, pattern.reference.property.start)));
+			const visit = (node) => {
+				if (typescript.default.isIdentifier(node) && offsets.has(node.getStart())) {
+					const symbol = checker.getSymbolAtLocation(node);
+					if (symbol) for (const root of checker.getRootSymbols(symbol)) symbols.add(root);
+				}
+				typescript.default.forEachChild(node, visit);
+			};
+			visit(file);
+		}
+		this.descriptorCache.set(program, symbols);
+		return symbols;
+	}
 	renameInfo(filename, position) {
-		const info = this.project.service.getRenameInfo(virtualFilename(filename), this.project.toGeneratedOffset(filename, position), { allowRenameOfImportPath: false });
+		const offset = this.project.toGeneratedOffset(filename, position);
+		const definitions = this.project.service.getDefinitionAtPosition(virtualFilename(filename), offset);
+		const program = this.project.service.getProgram();
+		const descriptors = this.descriptorSymbols(program);
+		for (const definition of definitions ?? []) {
+			const file = sourceFilename(definition.fileName);
+			const definitionFile = this.sourceFile(file);
+			let descriptor = false;
+			const visitDefinition = (node) => {
+				if (definition.textSpan.start < node.getStart() || definition.textSpan.start >= node.end) return;
+				if (typescript.default.isIdentifier(node) || typescript.default.isStringLiteral(node)) {
+					const symbol = program.getTypeChecker().getSymbolAtLocation(node);
+					descriptor = !!symbol && program.getTypeChecker().getRootSymbols(symbol).some((root) => descriptors.has(root));
+				} else typescript.default.forEachChild(node, visitDefinition);
+			};
+			if (descriptors.size && definitionFile) visitDefinition(definitionFile);
+			if (descriptor) return {
+				canRename: false,
+				localizedErrorMessage: "Renaming an enum-pattern case descriptor requires linked discriminator edits and is not supported yet."
+			};
+			const declarations = this.project.transformed(file)?.associatedEnums;
+			if (!declarations?.length) continue;
+			const sourceFile = this.sourceFile(file);
+			let generatedEnum = false;
+			const visit = (node) => {
+				if (definition.textSpan.start < node.getStart() || definition.textSpan.start >= node.end) return;
+				if ((typescript.default.isTypeAliasDeclaration(node) || typescript.default.isVariableDeclaration(node)) && typescript.default.isIdentifier(node.name)) {
+					const start = this.project.toOriginalOffset(file, node.name.getStart());
+					if (declarations.some((declaration) => declaration.id.start === start)) {
+						generatedEnum = true;
+						return;
+					}
+				}
+				typescript.default.forEachChild(node, visit);
+			};
+			if (sourceFile) visit(sourceFile);
+			if (generatedEnum) return {
+				canRename: false,
+				localizedErrorMessage: "Renaming associated-value enum declarations, cases, payload fields and type parameters is not supported yet."
+			};
+		}
+		const info = this.project.service.getRenameInfo(virtualFilename(filename), offset, { allowRenameOfImportPath: false });
 		if (!info.canRename) return info;
 		const span = this.mapSpan(filename, info.triggerSpan);
 		return span ? {