wesl 0.7.27 → 0.7.28

package/dist/index.js

@@ -499,6 +499,120 @@ function childIdent(child) {
 	return !childScope(child);
 }
 //#endregion
+//#region src/LinkerUtil.ts
+/** A module's top-level declarations of a given kind, narrowed to that elem type. */
+function declsOfKind(moduleElem, kind) {
+	return moduleElem.decls.filter((e) => e.kind === kind);
+}
+/** Visit an elem and all its descendants, parent before children (pre-order). */
+function visitAst(elem, visitor) {
+	visitor(elem);
+	for (const child of childElems(elem)) visitAst(child, visitor);
+}
+/**
+* Child elems of any AST node: the typed structural fields (attributes plus
+* body / condition / decls / ...) in source order. Returns [] for leaf elems.
+*/
+function childElems(elem) {
+	return [...elem.attributes ?? [], ...structuralFields(elem)];
+}
+function identElemLog(identElem, ...messages) {
+	srcLog(identElem.srcModule.src, [identElem.start, identElem.end], ...messages);
+}
+/** The child elems held in a node's typed fields, in source order (attributes
+*  are added separately by {@link childElems}). Empty for leaf kinds. The
+*  switch is exhaustive: a new elem kind without a case fails to compile in the
+*  default, so children can't be silently dropped. */
+function structuralFields(elem) {
+	switch (elem.kind) {
+		case "module": return elem.decls;
+		case "var":
+		case "gvar": return [
+			...elem.template ?? [],
+			elem.name,
+			...elem.init ? [elem.init] : []
+		];
+		case "let":
+		case "const":
+		case "override": return [elem.name, ...elem.init ? [elem.init] : []];
+		case "alias": return [elem.name, elem.typeRef];
+		case "assert": return [elem.expression];
+		case "struct": return [elem.name, ...elem.members];
+		case "member": return [elem.name, elem.typeRef];
+		case "type": return [elem.name.refIdentElem, ...elem.templateParams ?? []];
+		case "expression": return [elem.expression];
+		case "binary-expression": return [elem.left, elem.right];
+		case "unary-expression":
+		case "parenthesized-expression": return [elem.expression];
+		case "component-expression": return [elem.base, elem.access];
+		case "component-member-expression": return [elem.base, elem.access];
+		case "call-expression": return [
+			elem.function,
+			...elem.templateArgs ?? [],
+			...elem.arguments
+		];
+		case "param": return [elem.name];
+		case "typeDecl": return elem.typeRef ? [elem.decl, elem.typeRef] : [elem.decl];
+		case "fn": return [
+			elem.name,
+			...elem.params,
+			...elem.returnType ? [elem.returnType] : [],
+			elem.body
+		];
+		case "block": return elem.body;
+		case "if": return [
+			elem.condition,
+			elem.body,
+			...elem.else ? [elem.else] : []
+		];
+		case "for": return [
+			elem.init,
+			elem.condition,
+			elem.update,
+			elem.body
+		].filter(isDefined);
+		case "while": return [elem.condition, elem.body];
+		case "loop":
+		case "continuing": return [elem.body];
+		case "switch": return [
+			elem.selector,
+			...elem.bodyAttributes ?? [],
+			...elem.clauses
+		];
+		case "switch-clause": return [...exprSelectors(elem.selectors), elem.body];
+		case "return": return elem.value ? [elem.value] : [];
+		case "break": return elem.condition ? [elem.condition] : [];
+		case "assign": return elem.lhs.kind === "phony" ? [elem.rhs] : [elem.lhs, elem.rhs];
+		case "increment":
+		case "decrement": return [elem.target];
+		case "call": return [elem.call];
+		case "continue":
+		case "discard":
+		case "empty": return [];
+		case "do": return [
+			elem.name,
+			...elem.params,
+			elem.body
+		];
+		case "import":
+		case "directive":
+		case "attribute":
+		case "name":
+		case "literal":
+		case "ref":
+		case "decl":
+		case "synthetic": return [];
+		default: return [];
+	}
+}
+function isDefined(value) {
+	return value !== void 0;
+}
+/** Drop the `"default"` sentinel, keeping only real case-selector expressions. */
+function exprSelectors(selectors) {
+	return selectors.filter((s) => s !== "default");
+}
+//#endregion
 //#region src/StandardTypes.ts
 const stdFns = `bitcast all any select arrayLength 
   abs acos acosh asin asinh atan atanh atan2 ceil clamp cos cosh 
@@ -600,6 +714,22 @@ function stdEnumerant(name) {
 }
 //#endregion
 //#region src/LowerAndEmit.ts
+/** Statement kinds that emitStatement must not follow with a ';': compound
+*  statements take none, locals already carry their own, empty needs none. */
+const noSemicolon = new Set([
+	"block",
+	"if",
+	"for",
+	"while",
+	"loop",
+	"continuing",
+	"switch",
+	"empty",
+	"var",
+	"let",
+	"const",
+	"assert"
+]);
 /** Traverse the AST, starting from root elements, emitting WGSL for each. */
 function lowerAndEmit(params) {
 	const { srcBuilder, rootElems, conditions } = params;
@@ -607,17 +737,53 @@ function lowerAndEmit(params) {
 	const emitContext = {
 		conditions,
 		srcBuilder,
-		extracting
+		extracting,
+		indent: 0
 	};
 	const validElements = skipConditionalFiltering ? rootElems : filterValidElements(rootElems, conditions);
 	for (const e of validElements) lowerAndEmitElem(e, emitContext);
 }
+/** Format a diagnostic control as "(severity, rule)" for @diagnostic text. */
+function diagnosticControlToString(severity, rule) {
+	const ruleStr = rule[0].name + (rule[1] !== null ? "." + rule[1].name : "");
+	return `(${severity.name}, ${ruleStr})`;
+}
+/** Render an expression back to WGSL source text (template args elided as <...>). */
+function expressionToString(elem) {
+	const { kind } = elem;
+	switch (kind) {
+		case "binary-expression": {
+			const left = expressionToString(elem.left);
+			const right = expressionToString(elem.right);
+			return `${left} ${elem.operator.value} ${right}`;
+		}
+		case "unary-expression": return `${elem.operator.value}${expressionToString(elem.expression)}`;
+		case "ref": return elem.ident.originalName;
+		case "literal": return elem.value;
+		case "parenthesized-expression": return `(${expressionToString(elem.expression)})`;
+		case "component-expression": return `${expressionToString(elem.base)}[${elem.access}]`;
+		case "component-member-expression": return `${expressionToString(elem.base)}.${elem.access}`;
+		case "call-expression": {
+			const fn = elem.function;
+			return `${fn.kind === "ref" ? fn.ident.originalName : fn.name.originalName}${elem.templateArgs ? `<...>` : ""}(${elem.arguments.map(expressionToString).join(", ")})`;
+		}
+		case "type": return elem.name.originalName;
+		default: assertUnreachable(kind);
+	}
+}
+/** Trace through refersTo links until we find the declaration. */
+function findDecl(ident) {
+	let i = ident;
+	do {
+		if (i.kind === "decl") return i;
+		i = i.refersTo;
+	} while (i);
+	throw new Error(`unresolved identifer: ${ident.originalName}`);
+}
 function lowerAndEmitElem(e, ctx) {
 	switch (e.kind) {
 		case "import": return;
-		case "text":
-			emitText(e, ctx);
-			return;
+		case "do": return;
 		case "name":
 			emitName(e, ctx);
 			return;
@@ -640,24 +806,45 @@ function lowerAndEmitElem(e, ctx) {
 			emitExpression(e, ctx);
 			return;
 		case "param":
+			emitAttributes(e.attributes, ctx);
+			emitTypedDecl(e.name, ctx);
+			return;
 		case "typeDecl":
+			emitTypedDecl(e, ctx);
+			return;
 		case "member":
-		case "memberRef":
+			emitMember(e, ctx);
+			return;
 		case "expression":
-		case "type":
+			emitExpression(e.expression, ctx);
+			return;
 		case "switch-clause":
-			emitContents(e, ctx);
+			emitSwitchClause(e, ctx);
 			return;
-		case "stuff":
-			emitStuff(e, ctx);
+		case "type":
+			emitTypeRef(e, ctx);
 			return;
 		case "module":
 			emitModule(e, ctx);
 			return;
 		case "var":
 		case "let":
-		case "statement":
+		case "block":
+		case "if":
+		case "for":
+		case "while":
+		case "loop":
 		case "continuing":
+		case "switch":
+		case "return":
+		case "break":
+		case "continue":
+		case "discard":
+		case "assign":
+		case "increment":
+		case "decrement":
+		case "call":
+		case "empty":
 			emitStatement(e, ctx);
 			return;
 		case "override":
@@ -669,52 +856,131 @@ function lowerAndEmitElem(e, ctx) {
 			return;
 		case "fn":
 			emitRootElemNl(ctx);
+			emitRootLeading(e, ctx);
 			emitFn(e, ctx);
+			emitTrailingComments(e, ctx);
 			return;
 		case "struct":
 			emitRootElemNl(ctx);
+			emitRootLeading(e, ctx);
 			emitStruct(e, ctx);
+			emitTrailingComments(e, ctx);
 			return;
 		case "attribute":
 			emitAttribute(e, ctx);
 			return;
 		case "directive":
+			ctx.srcBuilder.addNl();
+			emitRootLeading(e, ctx);
 			emitDirective(e, ctx);
+			emitTrailingComments(e, ctx);
 			return;
 		default: assertUnreachable(e);
 	}
 }
-function emitStuff(e, ctx) {
-	emitContentsWithTrimming(e, ctx);
+function emitName(e, ctx) {
+	ctx.srcBuilder.add(e.name, e.start, e.end);
 }
-function emitModule(e, ctx) {
-	const validElements = filterValidElements(e.contents, ctx.conditions);
-	for (const child of validElements) {
-		if (child.kind === "text") {
-			if (child.srcModule.src.slice(child.start, child.end).trim() === "") continue;
+function emitSynthetic(e, ctx) {
+	const { text } = e;
+	ctx.srcBuilder.addSynthetic(text, text, 0, text.length);
+}
+function emitRefIdent(e, ctx) {
+	if (e.ident.std) ctx.srcBuilder.add(e.ident.originalName, e.start, e.end);
+	else ctx.srcBuilder.add(displayName(findDecl(e.ident)), e.start, e.end);
+}
+function emitDeclIdent(e, ctx) {
+	ctx.srcBuilder.add(displayName(e.ident), e.start, e.end);
+}
+/** Emit an expression with any comments attached to it. Comments inside an
+*  expression (e.g. `foo(1, /* x *\/ 2)`) ride on the relevant sub-node and are
+*  emitted inline around it here. */
+function emitExpression(e, ctx) {
+	emitInlineLeading(e, ctx);
+	emitExpressionCore(e, ctx);
+	emitInlineTrailing(e, ctx);
+}
+function emitAttributes(attributes, ctx) {
+	attributes?.forEach((a) => {
+		emitInlineLeading(a, ctx);
+		if (emitAttribute(a, ctx)) {
+			emitInlineTrailing(a, ctx);
+			ctx.srcBuilder.add(" ", a.start, a.end);
 		}
-		lowerAndEmitElem(child, ctx);
+	});
+}
+/** Emit a declared identifier with its optional `: type` annotation. */
+function emitTypedDecl(name, ctx) {
+	emitInlineLeading(name, ctx);
+	emitDeclIdent(name.decl, ctx);
+	if (name.typeRef) {
+		ctx.srcBuilder.appendNext(": ");
+		emitTypeRef(name.typeRef, ctx);
+	}
+	emitInlineTrailing(name, ctx);
+}
+/** Emit a struct member from its typed fields: `[attrs] name: type`. */
+function emitMember(member, ctx) {
+	emitAttributes(member.attributes, ctx);
+	emitName(member.name, ctx);
+	ctx.srcBuilder.appendNext(": ");
+	emitTypeRef(member.typeRef, ctx);
+}
+/** A `case sel, ...:` or `default:` clause with its `{ ... }` body. The selector
+*  colon is optional in WGSL but kept here as the canonical form. */
+function emitSwitchClause(e, ctx) {
+	const builder = ctx.srcBuilder;
+	emitLeadingComments(e, ctx);
+	newLine(ctx);
+	emitAttributes(e.attributes, ctx);
+	if (e.selectors.length === 1 && e.selectors[0] === "default") builder.appendNext("default");
+	else {
+		builder.appendNext("case ");
+		e.selectors.forEach((sel, i) => {
+			if (i > 0) builder.appendNext(", ");
+			if (sel === "default") builder.appendNext("default");
+			else emitExpression(sel, ctx);
+		});
 	}
+	builder.appendNext(": ");
+	emitBlock(e.body, ctx);
+	emitTrailingComments(e, ctx);
+}
+/** Emit a type reference structurally: name plus an optional <...> arg list. */
+function emitTypeRef(e, ctx) {
+	emitRefIdent(e.name.refIdentElem, ctx);
+	if (e.templateParams) emitTemplateArgs(e.templateParams, ctx);
+}
+function emitModule(e, ctx) {
+	const validElements = filterValidElements(e.decls, ctx.conditions);
+	for (const child of validElements) lowerAndEmitElem(child, ctx);
 }
-function emitStatement(e, ctx) {
-	if (!(e.contents.length > 0 && e.contents[0].kind === "attribute")) emitAttributes(e.attributes, ctx);
-	emitContents(e, ctx);
+/** Emit one statement on its own line, with attached leading/trailing comments. */
+function emitStatement(stmt, ctx) {
+	emitLeadingComments(stmt, ctx);
+	newLine(ctx);
+	emitCoreSemi(stmt, ctx);
+	emitTrailingComments(stmt, ctx);
 }
 function emitRootDecl(e, ctx) {
 	emitRootElemNl(ctx);
-	if (!(e.contents.length > 0 && e.contents[0].kind === "attribute")) emitAttributes(e.attributes, ctx);
-	emitContentsWithTrimming(e, ctx);
+	emitRootLeading(e, ctx);
+	emitValueDecl(e, ctx);
+	emitTrailingComments(e, ctx);
 }
 /** Emit newlines between root elements. */
 function emitRootElemNl(ctx) {
 	ctx.srcBuilder.addNl();
 	ctx.srcBuilder.addNl();
 }
-function emitText(e, ctx) {
-	ctx.srcBuilder.addCopy(e.start, e.end);
-}
-function emitName(e, ctx) {
-	ctx.srcBuilder.add(e.name, e.start, e.end);
+/** Leading comments for a root declaration, each on its own line. The inter-decl
+*  spacing already left us at a fresh line, so a newline follows each comment
+*  (rather than preceding it as in emitLeadingComments). */
+function emitRootLeading(e, ctx) {
+	for (const c of e.commentsBefore ?? []) {
+		emitComment(c, ctx);
+		newLine(ctx);
+	}
 }
 /** Emit function explicitly to control commas between conditional parameters. */
 function emitFn(e, ctx) {
@@ -722,27 +988,35 @@ function emitFn(e, ctx) {
 	const { conditions, srcBuilder: builder } = ctx;
 	emitAttributes(attributes, ctx);
 	builder.add("fn ", name.start - 3, name.start);
+	emitInlineLeading(name, ctx);
 	emitDeclIdent(name, ctx);
+	emitInlineTrailing(name, ctx);
 	builder.appendNext("(");
 	const validParams = filterValidElements(params, conditions);
 	validParams.forEach((p, i) => {
-		if (!(p.contents.length > 0 && p.contents[0].kind === "attribute")) emitAttributes(p.attributes, ctx);
-		emitContentsNoWs(p, ctx);
+		emitInlineLeading(p, ctx);
+		emitAttributes(p.attributes, ctx);
+		emitTypedDecl(p.name, ctx);
+		emitInlineTrailing(p, ctx);
 		if (i < validParams.length - 1) builder.appendNext(", ");
 	});
 	builder.appendNext(") ");
 	if (returnType) {
 		builder.appendNext("-> ");
 		emitAttributes(returnAttributes, ctx);
-		emitContentsNoWs(returnType, ctx);
+		emitInlineLeading(returnType, ctx);
+		emitTypeRef(returnType, ctx);
 		builder.appendNext(" ");
 	}
-	emitContents(body, ctx);
+	emitBlock(body, ctx);
 }
-function emitAttributes(attributes, ctx) {
-	attributes?.forEach((a) => {
-		if (emitAttribute(a, ctx)) ctx.srcBuilder.add(" ", a.start, a.end);
-	});
+/** Trailing comments: kept on the element's line, after its text. */
+function emitTrailingComments(e, ctx) {
+	if (!e.commentsAfter) return;
+	for (const c of e.commentsAfter) {
+		ctx.srcBuilder.appendNext(" ");
+		emitComment(c, ctx);
+	}
 }
 /** Emit structs explicitly to control commas between conditional members. */
 function emitStruct(e, ctx) {
@@ -756,125 +1030,22 @@ function emitStruct(e, ctx) {
 	}
 	emitAttributes(attributes, ctx);
 	srcBuilder.add("struct ", start, name.start);
+	emitInlineLeading(name, ctx);
 	emitDeclIdent(name, ctx);
-	if (validLength === 1) {
+	emitInlineTrailing(name, ctx);
+	if (validLength === 1 && !hasComments(validMembers[0])) {
 		srcBuilder.appendNext(" { ");
-		emitContentsWithTrimming(validMembers[0], ctx);
+		emitMember(validMembers[0], ctx);
 		srcBuilder.appendNext(" }");
 		srcBuilder.addNl();
 	} else {
 		srcBuilder.appendNext(" {");
 		srcBuilder.addNl();
-		validMembers.forEach((m) => {
-			srcBuilder.appendNext("  ");
-			emitContentsNoWs(m, ctx);
-			srcBuilder.appendNext(",");
-			srcBuilder.addNl();
-		});
+		for (const m of validMembers) emitMemberLine(m, ctx);
 		srcBuilder.appendNext("}");
 		srcBuilder.addNl();
 	}
 }
-function warnEmptyStruct(e) {
-	const { name, members } = e;
-	const condStr = members.length ? "(with current conditions)" : "";
-	failIdentElem(name, `struct '${name.ident.originalName}' has no members ${condStr}`);
-}
-function emitSynthetic(e, ctx) {
-	const { text } = e;
-	ctx.srcBuilder.addSynthetic(text, text, 0, text.length);
-}
-function emitContents(elem, ctx) {
-	const validElements = filterValidElements(elem.contents, ctx.conditions);
-	for (const e of validElements) lowerAndEmitElem(e, ctx);
-}
-/** Emit contents with leading/trailing whitespace trimming (V2 parser). */
-function emitContentsWithTrimming(elem, ctx) {
-	const validElements = filterValidElements(elem.contents, ctx.conditions);
-	const firstEmit = validElements.findIndex((e) => !isConditionalAttr(e));
-	const lastEmit = validElements.findLastIndex((e) => !isConditionalAttr(e));
-	validElements.forEach((elem, i) => {
-		if (elem.kind === "text") {
-			let text = elem.srcModule.src.slice(elem.start, elem.end);
-			if (i === firstEmit) text = text.trimStart();
-			if (i === lastEmit) text = text.trimEnd();
-			if (text) ctx.srcBuilder.add(text, elem.start, elem.end);
-		} else lowerAndEmitElem(elem, ctx);
-	});
-}
-function isConditionalAttr(e) {
-	if (e.kind !== "attribute") return false;
-	const { kind } = e.attribute;
-	return kind === "@if" || kind === "@elif" || kind === "@else";
-}
-/** Emit contents without whitespace. */
-function emitContentsNoWs(elem, ctx) {
-	filterValidElements(elem.contents, ctx.conditions).forEach((e) => {
-		if (e.kind === "text") {
-			const { srcModule, start, end } = e;
-			if (srcModule.src.slice(start, end).trim() === "") return;
-		}
-		lowerAndEmitElem(e, ctx);
-	});
-}
-function emitRefIdent(e, ctx) {
-	if (e.ident.std) ctx.srcBuilder.add(e.ident.originalName, e.start, e.end);
-	else {
-		const mangledName = displayName(findDecl(e.ident));
-		ctx.srcBuilder.add(mangledName, e.start, e.end);
-	}
-}
-function emitDeclIdent(e, ctx) {
-	const mangledName = displayName(e.ident);
-	ctx.srcBuilder.add(mangledName, e.start, e.end);
-}
-function emitExpression(e, ctx) {
-	const { kind } = e;
-	if (kind === "literal") {
-		ctx.srcBuilder.add(e.value, e.start, e.end);
-		return;
-	}
-	if (kind === "ref") {
-		emitRefIdent(e, ctx);
-		return;
-	}
-	if (kind === "type") {
-		emitContents(e, ctx);
-		return;
-	}
-	if (kind === "binary-expression") {
-		emitExpression(e.left, ctx);
-		ctx.srcBuilder.add(` ${e.operator.value} `, e.operator.span[0], e.operator.span[1]);
-		emitExpression(e.right, ctx);
-		return;
-	}
-	if (kind === "unary-expression") {
-		ctx.srcBuilder.add(e.operator.value, e.operator.span[0], e.operator.span[1]);
-		emitExpression(e.expression, ctx);
-		return;
-	}
-	if (kind === "parenthesized-expression") {
-		emitExpression(e.expression, ctx);
-		return;
-	}
-	if (kind === "call-expression") {
-		emitExpression(e.function, ctx);
-		if (e.templateArgs) for (const targ of e.templateArgs) lowerAndEmitElem(targ, ctx);
-		for (const arg of e.arguments) emitExpression(arg, ctx);
-		return;
-	}
-	if (kind === "component-expression") {
-		emitExpression(e.base, ctx);
-		emitExpression(e.access, ctx);
-		return;
-	}
-	if (kind === "component-member-expression") {
-		emitExpression(e.base, ctx);
-		if (e.access.kind === "name") ctx.srcBuilder.add(e.access.name, e.access.start, e.access.end);
-		return;
-	}
-	assertUnreachable(kind);
-}
 function emitAttribute(e, ctx) {
 	const { kind } = e.attribute;
 	if (kind === "@if" || kind === "@elif" || kind === "@else") return false;
@@ -884,11 +1055,13 @@ function emitAttribute(e, ctx) {
 		return true;
 	}
 	if (kind === "@builtin") {
-		ctx.srcBuilder.add("@builtin(" + e.attribute.param.name + ")", e.start, e.end);
+		const builtinStr = `@builtin(${e.attribute.param.name})`;
+		ctx.srcBuilder.add(builtinStr, e.start, e.end);
 		return true;
 	}
 	if (kind === "@diagnostic") {
-		const diagStr = "@diagnostic" + diagnosticControlToString(e.attribute.severity, e.attribute.rule);
+		const { severity, rule } = e.attribute;
+		const diagStr = `@diagnostic${diagnosticControlToString(severity, rule)}`;
 		ctx.srcBuilder.add(diagStr, e.start, e.end);
 		return true;
 	}
@@ -899,46 +1072,6 @@ function emitAttribute(e, ctx) {
 	}
 	assertUnreachable(kind);
 }
-function emitStandardAttribute(e, ctx) {
-	if (e.attribute.kind !== "@attribute") return;
-	const { params } = e.attribute;
-	if (!params || params.length === 0) {
-		ctx.srcBuilder.add("@" + e.attribute.name, e.start, e.end);
-		return;
-	}
-	ctx.srcBuilder.add("@" + e.attribute.name + "(", e.start, params[0].start);
-	for (let i = 0; i < params.length; i++) {
-		emitContents(params[i], ctx);
-		if (i < params.length - 1) ctx.srcBuilder.add(",", params[i].end, params[i + 1].start);
-	}
-	ctx.srcBuilder.add(")", params[params.length - 1].end, e.end);
-}
-function diagnosticControlToString(severity, rule) {
-	const ruleStr = rule[0].name + (rule[1] !== null ? "." + rule[1].name : "");
-	return `(${severity.name}, ${ruleStr})`;
-}
-function expressionToString(elem) {
-	const { kind } = elem;
-	switch (kind) {
-		case "binary-expression": {
-			const left = expressionToString(elem.left);
-			const right = expressionToString(elem.right);
-			return `${left} ${elem.operator.value} ${right}`;
-		}
-		case "unary-expression": return `${elem.operator.value}${expressionToString(elem.expression)}`;
-		case "ref": return elem.ident.originalName;
-		case "literal": return elem.value;
-		case "parenthesized-expression": return `(${expressionToString(elem.expression)})`;
-		case "component-expression": return `${expressionToString(elem.base)}[${elem.access}]`;
-		case "component-member-expression": return `${expressionToString(elem.base)}.${elem.access}`;
-		case "call-expression": {
-			const fn = elem.function;
-			return `${fn.kind === "ref" ? fn.ident.originalName : fn.name.originalName}${elem.templateArgs ? `<...>` : ""}(${elem.arguments.map(expressionToString).join(", ")})`;
-		}
-		case "type": return elem.name.originalName;
-		default: assertUnreachable(kind);
-	}
-}
 function emitDirective(e, ctx) {
 	const { directive } = e;
 	const { kind } = directive;
@@ -960,14 +1093,351 @@ function displayName(declIdent) {
 	}
 	return declIdent.mangledName || declIdent.originalName;
 }
-/** Trace through refersTo links until we find the declaration. */
-function findDecl(ident) {
-	let i = ident;
-	do {
-		if (i.kind === "decl") return i;
-		i = i.refersTo;
-	} while (i);
-	throw new Error(`unresolved identifer: ${ident.originalName}`);
+/** Leading comments on an inline node: block comments get a trailing space, line
+*  comments force a newline so the following code is not swallowed. */
+function emitInlineLeading(e, ctx) {
+	for (const c of e.commentsBefore ?? []) {
+		emitComment(c, ctx);
+		if (c.style === "line") newLine(ctx);
+		else ctx.srcBuilder.appendNext(" ");
+	}
+}
+function emitExpressionCore(e, ctx) {
+	const builder = ctx.srcBuilder;
+	switch (e.kind) {
+		case "literal":
+			builder.add(e.value, e.start, e.end);
+			return;
+		case "ref":
+			emitRefIdent(e, ctx);
+			return;
+		case "type":
+			emitTypeRef(e, ctx);
+			return;
+		case "binary-expression": {
+			const [start, end] = e.operator.span;
+			emitExpression(e.left, ctx);
+			builder.add(` ${e.operator.value} `, start, end);
+			emitExpression(e.right, ctx);
+			return;
+		}
+		case "unary-expression": {
+			const { value, start, end } = e.operator;
+			builder.add(value, start, end);
+			emitExpression(e.expression, ctx);
+			return;
+		}
+		case "parenthesized-expression":
+			builder.appendNext("(");
+			emitExpression(e.expression, ctx);
+			builder.appendNext(")");
+			return;
+		case "call-expression":
+			emitExpression(e.function, ctx);
+			if (e.templateArgs) emitTemplateArgs(e.templateArgs, ctx);
+			builder.appendNext("(");
+			e.arguments.forEach((arg, i) => {
+				if (i > 0) builder.appendNext(", ");
+				emitExpression(arg, ctx);
+			});
+			builder.appendNext(")");
+			return;
+		case "component-expression":
+			emitExpression(e.base, ctx);
+			builder.appendNext("[");
+			emitExpression(e.access, ctx);
+			builder.appendNext("]");
+			return;
+		case "component-member-expression":
+			emitExpression(e.base, ctx);
+			builder.add("." + e.access.name, e.access.start, e.access.end);
+			return;
+		default: assertUnreachable(e);
+	}
+}
+/** Trailing comments on an inline node: a leading space, plus a newline after a
+*  line comment so following code stays off its line. */
+function emitInlineTrailing(e, ctx) {
+	for (const c of e.commentsAfter ?? []) {
+		ctx.srcBuilder.appendNext(" ");
+		emitComment(c, ctx);
+		if (c.style === "line") newLine(ctx);
+	}
+}
+/** Leading comments: each on its own indented line above the element. */
+function emitLeadingComments(e, ctx) {
+	if (!e.commentsBefore) return;
+	for (const c of e.commentsBefore) {
+		if (c.blankBefore) ctx.srcBuilder.addNl();
+		newLine(ctx);
+		emitComment(c, ctx);
+	}
+}
+/** Start a fresh line at the current indent. */
+function newLine(ctx) {
+	ctx.srcBuilder.addNl();
+	if (ctx.indent > 0) ctx.srcBuilder.appendNext("  ".repeat(ctx.indent));
+}
+/** Emit a `{ ... }` block, one statement per indented line. A block with no
+*  statements collapses to `{ }` unless it holds dangling inner comments. */
+function emitBlock(e, ctx) {
+	emitAttributes(e.attributes, ctx);
+	const stmts = filterValidElements(e.body, ctx.conditions);
+	if (stmts.length === 0 && !e.innerComments?.length) {
+		ctx.srcBuilder.appendNext("{ }");
+		return;
+	}
+	ctx.srcBuilder.appendNext("{");
+	const inner = childIndent(ctx);
+	for (const comment of e.innerComments ?? []) {
+		newLine(inner);
+		emitComment(comment, inner);
+	}
+	for (const stmt of stmts) emitStatement(stmt, inner);
+	newLine(ctx);
+	ctx.srcBuilder.appendNext("}");
+}
+/** Emit a comma-separated template argument list: <a, b, c>. */
+function emitTemplateArgs(args, ctx) {
+	ctx.srcBuilder.appendNext("<");
+	args.forEach((a, i) => {
+		if (i > 0) ctx.srcBuilder.appendNext(", ");
+		emitExpression(a, ctx);
+	});
+	ctx.srcBuilder.appendNext(">");
+}
+/** Emit a statement's syntax followed by ';' unless its kind takes none. */
+function emitCoreSemi(stmt, ctx) {
+	emitStatementCore(stmt, ctx);
+	if (!noSemicolon.has(stmt.kind)) ctx.srcBuilder.appendNext(";");
+}
+/** Emit a declaration from its typed fields, including its trailing ';':
+*  `[attrs] var<...> name: T = init;`, `const name = init;`, `override n;`,
+*  `alias name = T;`, `const_assert expr;`. */
+function emitValueDecl(e, ctx) {
+	emitAttributes(e.attributes, ctx);
+	const builder = ctx.srcBuilder;
+	switch (e.kind) {
+		case "var":
+		case "gvar":
+			builder.appendNext("var");
+			if (e.template) emitVarTemplate(e.template, ctx);
+			builder.appendNext(" ");
+			emitTypedDecl(e.name, ctx);
+			emitInit(e.init, ctx);
+			break;
+		case "let":
+		case "const":
+		case "override":
+			builder.appendNext(`${e.kind} `);
+			emitTypedDecl(e.name, ctx);
+			emitInit(e.init, ctx);
+			break;
+		case "alias":
+			builder.appendNext("alias ");
+			emitInlineLeading(e.name, ctx);
+			emitDeclIdent(e.name, ctx);
+			emitInlineTrailing(e.name, ctx);
+			builder.appendNext(" = ");
+			emitTypeRef(e.typeRef, ctx);
+			break;
+		case "assert":
+			builder.appendNext("const_assert ");
+			emitExpression(e.expression, ctx);
+			break;
+		default: assertUnreachable(e);
+	}
+	builder.appendNext(";");
+}
+function emitComment(c, ctx) {
+	ctx.srcBuilder.add(c.srcModule.src.slice(c.start, c.end), c.start, c.end);
+}
+function warnEmptyStruct(e) {
+	const { name, members } = e;
+	const condStr = members.length ? "(with current conditions)" : "";
+	failIdentElem(name, `struct '${name.ident.originalName}' has no members ${condStr}`);
+}
+/** Whether an element carries any attached comments. */
+function hasComments(e) {
+	return !!(e.commentsBefore?.length || e.commentsAfter?.length);
+}
+/** Emit one struct member on its own line: leading comments above, `name: type,`,
+*  then trailing comments inline. */
+function emitMemberLine(m, ctx) {
+	const builder = ctx.srcBuilder;
+	for (const c of m.commentsBefore ?? []) {
+		builder.appendNext("  ");
+		emitComment(c, ctx);
+		builder.addNl();
+	}
+	builder.appendNext("  ");
+	emitMember(m, ctx);
+	builder.appendNext(",");
+	for (const c of m.commentsAfter ?? []) {
+		builder.appendNext(" ");
+		emitComment(c, ctx);
+	}
+	builder.addNl();
+}
+function emitStandardAttribute(e, ctx) {
+	if (e.attribute.kind !== "@attribute") return;
+	const { params } = e.attribute;
+	if (!params || params.length === 0) {
+		ctx.srcBuilder.add("@" + e.attribute.name, e.start, e.end);
+		return;
+	}
+	ctx.srcBuilder.add("@" + e.attribute.name + "(", e.start, params[0].start);
+	params.forEach((param, i) => {
+		if (i > 0) ctx.srcBuilder.appendNext(", ");
+		emitExpression(param.expression, ctx);
+	});
+	ctx.srcBuilder.add(")", params[params.length - 1].end, e.end);
+}
+/** A child context indented one level deeper. */
+function childIndent(ctx) {
+	return {
+		...ctx,
+		indent: ctx.indent + 1
+	};
+}
+/** Emit a statement's syntax, without surrounding line breaks, ';', or comments. */
+function emitStatementCore(stmt, ctx) {
+	if (stmt.kind === "var" || stmt.kind === "let" || stmt.kind === "const" || stmt.kind === "assert") {
+		emitValueDecl(stmt, ctx);
+		return;
+	}
+	if (stmt.kind !== "block") emitAttributes(stmt.attributes, ctx);
+	const builder = ctx.srcBuilder;
+	switch (stmt.kind) {
+		case "block":
+			emitBlock(stmt, ctx);
+			return;
+		case "if":
+			emitIf(stmt, ctx);
+			return;
+		case "for":
+			emitFor(stmt, ctx);
+			return;
+		case "while":
+			emitWhile(stmt, ctx);
+			return;
+		case "loop":
+			builder.appendNext("loop ");
+			emitBlock(stmt.body, ctx);
+			return;
+		case "continuing":
+			builder.appendNext("continuing ");
+			emitBlock(stmt.body, ctx);
+			return;
+		case "switch":
+			emitSwitch(stmt, ctx);
+			return;
+		case "return":
+			builder.appendNext("return");
+			if (stmt.value) {
+				builder.appendNext(" ");
+				emitExpression(stmt.value, ctx);
+			}
+			return;
+		case "break":
+			builder.appendNext("break");
+			if (stmt.condition) {
+				builder.appendNext(" if ");
+				emitExpression(stmt.condition, ctx);
+			}
+			return;
+		case "continue":
+			builder.appendNext("continue");
+			return;
+		case "discard":
+			builder.appendNext("discard");
+			return;
+		case "assign":
+			emitAssign(stmt, ctx);
+			return;
+		case "increment":
+			emitExpression(stmt.target, ctx);
+			builder.appendNext("++");
+			return;
+		case "decrement":
+			emitExpression(stmt.target, ctx);
+			builder.appendNext("--");
+			return;
+		case "call":
+			emitExpression(stmt.call, ctx);
+			return;
+		case "empty": return;
+		default: assertUnreachable(stmt);
+	}
+}
+/** Emit a var's `<address_space[, access_mode]>` enumerant template. */
+function emitVarTemplate(template, ctx) {
+	const builder = ctx.srcBuilder;
+	builder.appendNext("<");
+	template.forEach((name, i) => {
+		if (i > 0) builder.appendNext(", ");
+		emitName(name, ctx);
+	});
+	builder.appendNext(">");
+}
+/** Emit a ` = init` clause, if present. */
+function emitInit(init, ctx) {
+	if (!init) return;
+	ctx.srcBuilder.appendNext(" = ");
+	emitExpression(init, ctx);
+}
+/** if / else-if / else: a nested IfElem prints as `else if`, a BlockElem as `else`. */
+function emitIf(e, ctx) {
+	const builder = ctx.srcBuilder;
+	builder.appendNext("if ");
+	emitExpression(e.condition, ctx);
+	builder.appendNext(" ");
+	emitBlock(e.body, ctx);
+	if (e.else) {
+		builder.appendNext(" else ");
+		if (e.else.kind === "if") emitIf(e.else, ctx);
+		else emitBlock(e.else, ctx);
+	}
+}
+/** for (init; condition; update) { ... }. The init takes a ';' like any
+*  statement; the update is the last clause before ')', so it gets none. */
+function emitFor(e, ctx) {
+	const builder = ctx.srcBuilder;
+	builder.appendNext("for (");
+	if (e.init) emitCoreSemi(e.init, ctx);
+	else builder.appendNext(";");
+	builder.appendNext(" ");
+	if (e.condition) emitExpression(e.condition, ctx);
+	builder.appendNext("; ");
+	if (e.update) emitStatementCore(e.update, ctx);
+	builder.appendNext(") ");
+	emitBlock(e.body, ctx);
+}
+function emitWhile(e, ctx) {
+	ctx.srcBuilder.appendNext("while ");
+	emitExpression(e.condition, ctx);
+	ctx.srcBuilder.appendNext(" ");
+	emitBlock(e.body, ctx);
+}
+function emitSwitch(e, ctx) {
+	const builder = ctx.srcBuilder;
+	builder.appendNext("switch ");
+	emitExpression(e.selector, ctx);
+	builder.appendNext(" ");
+	emitAttributes(e.bodyAttributes, ctx);
+	builder.appendNext("{");
+	const inner = childIndent(ctx);
+	for (const clause of filterValidElements(e.clauses, ctx.conditions)) emitSwitchClause(clause, inner);
+	newLine(ctx);
+	builder.appendNext("}");
+}
+/** lhs op rhs, with the phony target printed as `_`. */
+function emitAssign(e, ctx) {
+	if (e.lhs.kind === "phony") ctx.srcBuilder.add("_", e.lhs.span[0], e.lhs.span[1]);
+	else emitExpression(e.lhs, ctx);
+	const [start, end] = e.op.span;
+	ctx.srcBuilder.add(` ${e.op.value} `, start, end);
+	emitExpression(e.rhs, ctx);
 }
 //#endregion
 //#region src/debug/ImportToString.ts
@@ -1052,19 +1522,25 @@ function astToString(elem, indent = 0) {
 	const str = new LineWrapper(indent, maxLineLength);
 	str.add(kind);
 	addElemFields(elem, str);
-	let childStrings = [];
-	if ("contents" in elem) childStrings = elem.contents.map((e) => astToString(e, indent + 2));
-	if (childStrings.length) {
+	addCommentFields(elem, str);
+	const children = childElems(elem);
+	if (children.length) {
 		str.nl();
+		const childStrings = children.map((e) => astToString(e, indent + 2));
 		str.addBlock(childStrings.join("\n"), false);
 	}
 	return str.result;
 }
+/** @return string representation of an attribute (for test/debug) */
+function attributeToString(attr) {
+	const str = new LineWrapper(0, maxLineLength);
+	addAttributeFields(attr, str);
+	return str.result;
+}
 function addElemFields(elem, str) {
 	const { kind } = elem;
-	if (kind === "assert" || kind === "module" || kind === "param" || kind === "stuff" || kind === "switch-clause") return;
-	if (kind === "text") str.add(` '${elem.srcModule.src.slice(elem.start, elem.end)}'`);
-	else if (kind === "var" || kind === "let" || kind === "gvar" || kind === "const" || kind === "override") {
+	if (kind === "assert" || kind === "expression" || kind === "module" || kind === "param" || kind === "switch-clause") return;
+	if (kind === "var" || kind === "let" || kind === "gvar" || kind === "const" || kind === "override") {
 		addTypedDeclIdent(elem.name, str);
 		listAttributeElems(elem.attributes, str);
 	} else if (kind === "struct") str.add(" " + elem.name.ident.originalName);
@@ -1072,22 +1548,14 @@ function addElemFields(elem, str) {
 		listAttributeElems(elem.attributes, str);
 		str.add(` ${elem.name.name}: ${typeRefElemToString(elem.typeRef)}`);
 	} else if (kind === "name") str.add(" " + elem.name);
-	else if (kind === "memberRef") {
-		const extra = elem.extraComponents ? debugContentsToString(elem.extraComponents) : "";
-		str.add(` ${elem.name.ident.originalName}.${elem.member.name}${extra}`);
-	} else if (kind === "fn") addFnFields(elem, str);
+	else if (kind === "fn") addFnFields(elem, str);
+	else if (kind === "do") addDoFields(elem, str);
 	else if (kind === "alias") {
 		const prefix = elem.name.ident.kind === "decl" ? "%" : "";
 		str.add(` ${prefix}${elem.name.ident.originalName}=${typeRefElemToString(elem.typeRef)}`);
 	} else if (kind === "attribute") addAttributeFields(elem.attribute, str);
-	else if (kind === "expression") {
-		const contents = elem.contents.map((e) => e.kind === "text" ? `'${e.srcModule.src.slice(e.start, e.end)}'` : astToString(e)).join(" ");
-		str.add(" " + contents);
-	} else if (kind === "type") {
-		const nameStr = typeof elem.name === "string" ? elem.name : elem.name.originalName;
-		const params = elem.templateParams?.map(templateParamToString).join(", ");
-		str.add(params ? ` ${nameStr}<${params}>` : ` ${nameStr}`);
-	} else if (kind === "synthetic") str.add(` '${elem.text}'`);
+	else if (kind === "type") str.add(" " + typeRefElemToString(elem));
+	else if (kind === "synthetic") str.add(` '${elem.text}'`);
 	else if (kind === "import") {
 		str.add(" " + importToString(elem.imports));
 		listAttributeElems(elem.attributes, str);
@@ -1095,7 +1563,7 @@ function addElemFields(elem, str) {
 	else if (kind === "typeDecl") addTypedDeclIdent(elem, str);
 	else if (kind === "decl") str.add(" %" + elem.ident.originalName);
 	else if (kind === "directive") addDirective(elem, str);
-	else if (kind === "statement" || kind === "continuing") listAttributeElems(elem.attributes, str);
+	else if (kind === "block" || kind === "if" || kind === "for" || kind === "while" || kind === "loop" || kind === "continuing" || kind === "switch" || kind === "return" || kind === "break" || kind === "continue" || kind === "discard" || kind === "assign" || kind === "increment" || kind === "decrement" || kind === "call" || kind === "empty") listAttributeElems(elem.attributes, str);
 	else if (kind === "literal") str.add(` literal(${elem.value})`);
 	else if (kind === "binary-expression") str.add(` binop(${elem.operator.value})`);
 	else if (kind === "unary-expression") str.add(` unop(${elem.operator.value})`);
@@ -1105,6 +1573,14 @@ function addElemFields(elem, str) {
 	else if (kind === "component-member-expression") str.add(" .");
 	else assertUnreachable(kind);
 }
+/** Show attached leading/trailing comments to verify comment attachment. */
+function addCommentFields(elem, str) {
+	if (!("start" in elem)) return;
+	const { commentsBefore, commentsAfter } = elem;
+	if (commentsBefore?.length) str.add(commentsToString("before", commentsBefore));
+	if (commentsAfter?.length) str.add(commentsToString("after", commentsAfter));
+	if ("innerComments" in elem && elem.innerComments?.length) str.add(commentsToString("inner", elem.innerComments));
+}
 function addAttributeFields(attr, str) {
 	const { kind } = attr;
 	if (kind === "@attribute") {
@@ -1118,35 +1594,33 @@ function addAttributeFields(attr, str) {
 	else if (kind === "@interpolate") str.add(` @interpolate(${attr.params.map((v) => v.name).join(", ")})`);
 	else assertUnreachable(kind);
 }
-/** @return string representation of an attribute (for test/debug) */
-function attributeToString(attr) {
-	const str = new LineWrapper(0, maxLineLength);
-	addAttributeFields(attr, str);
-	return str.result;
-}
 function addTypedDeclIdent(elem, str) {
 	const { decl, typeRef } = elem;
 	str.add(" %" + decl.ident.originalName);
 	if (typeRef) str.add(" : " + typeRefElemToString(typeRef));
 }
-function addFnFields(elem, str) {
-	const { name, params, returnType, attributes } = elem;
-	const paramStrs = params.map((p) => {
-		const { originalName } = p.name.decl.ident;
-		return `${originalName}: ${typeRefElemToString(p.name.typeRef)}`;
-	});
-	str.add(` ${name.ident.originalName}(${paramStrs.join(", ")})`);
-	listAttributeElems(attributes, str);
-	if (returnType) str.add(" -> " + typeRefElemToString(returnType));
-}
 /** show attribute names in short form to verify collection */
 function listAttributeElems(attrs, str) {
 	attrs?.forEach((a) => {
 		str.add(" " + attributeName(a.attribute));
 	});
 }
-function attributeName(attr) {
-	return attr.kind === "@attribute" ? "@" + attr.name : attr.kind;
+function typeRefElemToString(elem) {
+	if (!elem) return "?type?";
+	const nameStr = typeof elem.name === "string" ? elem.name : elem.name.originalName;
+	const params = elem.templateParams?.map(templateParamToString).join(", ");
+	return params ? `${nameStr}<${params}>` : nameStr;
+}
+function addFnFields(elem, str) {
+	const { name, params, returnType, attributes } = elem;
+	str.add(` ${name.ident.originalName}(${paramListToString(params)})`);
+	listAttributeElems(attributes, str);
+	if (returnType) str.add(" -> " + typeRefElemToString(returnType));
+}
+function addDoFields(elem, str) {
+	const { name, params, attributes } = elem;
+	str.add(` ${name.name}(${paramListToString(params)})`);
+	listAttributeElems(attributes, str);
 }
 function addDirective(elem, str) {
 	const { directive, attributes } = elem;
@@ -1159,30 +1633,29 @@ function addDirective(elem, str) {
 	else assertUnreachable(kind);
 	listAttributeElems(attributes, str);
 }
+function commentsToString(label, comments) {
+	return ` ${label}[${comments.map((c) => {
+		const text = c.srcModule.src.slice(c.start, c.end);
+		return c.blankBefore ? `'${text}'(blank)` : `'${text}'`;
+	}).join(", ")}]`;
+}
 function unknownExpressionToString(elem) {
-	if (!("contents" in elem)) return astToString(elem);
-	return elem.contents.map((e) => {
-		if (e.kind === "text") return `'${e.srcModule.src.slice(e.start, e.end)}'`;
-		return astToString(e);
-	}).join(" ");
+	return astToString(elem.expression);
+}
+function attributeName(attr) {
+	return attr.kind === "@attribute" ? "@" + attr.name : attr.kind;
 }
 function templateParamToString(p) {
 	if (typeof p === "string") return p;
 	if (p.kind === "type") return typeRefElemToString(p);
-	return astToString(p);
+	return expressionToString(p);
 }
-function typeRefElemToString(elem) {
-	if (!elem) return "?type?";
-	const nameStr = typeof elem.name === "string" ? elem.name : elem.name.originalName;
-	const params = elem.templateParams?.map(templateParamToString).join(", ");
-	return params ? `${nameStr}<${params}>` : nameStr;
-}
-function debugContentsToString(elem) {
-	return elem.contents.map((c) => {
-		if (c.kind === "text") return c.srcModule.src.slice(c.start, c.end);
-		if (c.kind === "ref") return c.ident.originalName;
-		return `?${c.kind}?`;
-	}).join(" ");
+/** @return "name: type, ..." for a fn/do parameter list. */
+function paramListToString(params) {
+	return params.map((p) => {
+		const { originalName } = p.name.decl.ident;
+		return `${originalName}: ${typeRefElemToString(p.name.typeRef)}`;
+	}).join(", ");
 }
 //#endregion
 //#region src/debug/ScopeToString.ts
@@ -1365,53 +1838,184 @@ var ParseError = class extends Error {
 	}
 };
 //#endregion
-//#region src/parse/ContentsHelpers.ts
-/** Push partial element onto stack for content collection. */
-function beginElem(ctx, kind, contents = []) {
-	ctx.state.context.openElems.push({
-		kind,
-		contents: [...contents]
-	});
-}
-/** Pop element from stack, fill gaps with TextElems, return contents. */
-function finishContents(ctx, start, end) {
-	const open = ctx.state.context.openElems.pop();
-	if (!open) throw new Error("No open element to close");
-	return coverWithText(ctx, open.contents, start, end);
-}
-/** Finish element: get end position, close contents, return complete element. */
-function finishElem(kind, start, ctx, params) {
-	const end = ctx.stream.checkpoint();
-	return {
-		kind,
-		start,
-		end,
-		contents: finishContents(ctx, start, end),
-		...params
-	};
-}
-/** Create a TextElem */
-function makeText(srcModule, start, end) {
-	return {
-		kind: "text",
+//#region src/parse/AttachComments.ts
+const tab = 9;
+const lineFeed = 10;
+const verticalTab = 11;
+const formFeed = 12;
+const carriageReturn = 13;
+const space = 32;
+const nextLine = 133;
+const leftToRightMark = 8206;
+const rightToLeftMark = 8207;
+const lineSeparator = 8232;
+const paragraphSeparator = 8233;
+/**
+* Attach every recorded comment to a node in the parsed tree.
+*
+* Each comment run (a contiguous group of comments between two real tokens) is
+* anchored to the deepest node that contains it in a gap between children, then
+* distributed to the surrounding children:
+* - a comment that begins its own line leads the next child (`commentsBefore`);
+* - an inline comment trails the previous child (`commentsAfter`), unless it
+*   hugs the next child -- only blank space and comments, no separator token,
+*   between them -- in which case it leads the next child instead;
+* - comments before a closing token with no following child trail the last child,
+*   or land in an empty block's `innerComments`.
+*
+* Descending into expressions (via {@link childElems}) means interior comments
+* like the one in `foo(1, /* x *\/ 2)` are preserved on the `2`, not dropped.
+*/
+function attachComments(ctx, moduleElem) {
+	const { srcModule } = ctx.state.stable;
+	const cache = /* @__PURE__ */ new Map();
+	for (const run of ctx.stream.commentRuns()) distribute(deepestContaining(moduleElem, run[0].start, runEnd(run), cache), run, srcModule, cache);
+}
+/** The deepest node whose span contains the whole [start, end) range, found by
+*  descending into the child that brackets it. Comments live in gaps between
+*  tokens, so the result is the node holding the gap, with the run between two
+*  of its children. */
+function deepestContaining(root, start, end, cache) {
+	let node = root;
+	while (true) {
+		const child = positionedChildren(node, cache).find((c) => c.start <= start && end <= c.end);
+		if (!child) return node;
+		node = child;
+	}
+}
+function runEnd(run) {
+	return run[run.length - 1].end;
+}
+/** Split a comment run between the previous child (trailing) and the next child
+*  (leading) of its anchor, or onto the last child / inner comments when it
+*  dangles before a closing token. */
+function distribute(anchor, run, srcModule, cache) {
+	const children = positionedChildren(anchor, cache);
+	const start = run[0].start;
+	const end = runEnd(run);
+	const prev = children.findLast((c) => c.end <= start);
+	const next = children.find((c) => c.start >= end);
+	if (!next) {
+		if (prev) addComments(prev, "commentsAfter", run, srcModule);
+		else if (anchor.kind === "block") anchor.innerComments = run.map((t) => makeComment(t, srcModule));
+		else addComments(anchor, "commentsBefore", run, srcModule);
+		return;
+	}
+	const split = splitPoint(prev, next, run, srcModule.src);
+	if (prev && split > 0) addComments(prev, "commentsAfter", run.slice(0, split), srcModule);
+	if (split < run.length) addComments(next, "commentsBefore", run.slice(split), srcModule);
+}
+function positionedChildren(node, cache) {
+	let children = cache.get(node);
+	if (children === void 0) {
+		children = positioned(childElems(node));
+		cache.set(node, children);
+	}
+	return children;
+}
+/** Append converted comments to an element's leading or trailing list. */
+function addComments(elem, field, trivia, srcModule) {
+	const comments = trivia.map((t) => makeComment(t, srcModule));
+	const existing = elem[field];
+	elem[field] = existing ? [...existing, ...comments] : comments;
+}
+function makeComment(trivia, srcModule) {
+	const { style, start, end } = trivia;
+	const comment = {
+		kind: "comment",
+		style,
 		start,
 		end,
 		srcModule
 	};
+	if (lineBreaksBefore(srcModule.src, start) >= 2) comment.blankBefore = true;
+	return comment;
 }
-/** Fill gaps between child elements with TextElems. */
-function coverWithText(ctx, contents, start, end) {
-	const { srcModule } = ctx.state.stable;
-	const sorted = contents.slice().sort((a, b) => a.start - b.start);
-	const elems = [];
-	let pos = start;
-	for (const elem of sorted) {
-		if (pos < elem.start) elems.push(makeText(srcModule, pos, elem.start));
-		elems.push(elem);
-		pos = elem.end;
-	}
-	if (pos < end) elems.push(makeText(srcModule, pos, end));
-	return elems;
+/**
+* Index into `run` where it flips from trailing `prev` to leading `next`:
+* caller attaches run[0, split) to `prev` and run[split, end) to `next`.
+*
+* The aim is to keep each comment with the code it describes, so it stays
+* meaningful after the tree is reordered or reformatted. That follows how people
+* write comments: a comment on its own line documents what comes after it, while
+* a comment sharing a line with code documents that code. Hence:
+* - with no previous child the whole run leads (split 0);
+* - otherwise the split is the first comment that begins its own line;
+* - failing that (an all-inline run), it is the start of the suffix that hugs
+*   `next` on the same line, so the comment in `foo(1, /* x *\/ 2)` documents,
+*   and lands on, the `2`.
+*/
+function splitPoint(prev, next, run, src) {
+	if (!prev) return 0;
+	const ownLine = firstOwnLine(run, src);
+	return ownLine >= 0 ? ownLine : hugsNextStart(run, next.start, src);
+}
+/** Source-positioned children, sorted in source order. Synthetic elems (no
+*  source position) cannot anchor comments and are dropped. Children usually
+*  arrive already in source order, so the sort is skipped when possible.
+*  Filtering and order-checking share one pass: this runs per node, so it's
+*  kept deliberately lean. */
+function positioned(elems) {
+	const result = [];
+	let sorted = true;
+	let lastStart = -1;
+	for (const e of elems) {
+		if (e.kind === "synthetic") continue;
+		if (e.start < lastStart) sorted = false;
+		lastStart = e.start;
+		result.push(e);
+	}
+	if (!sorted) result.sort((a, b) => a.start - b.start);
+	return result;
+}
+/** Count line breaks in the whitespace run immediately before `pos`, capped at 2:
+*  callers only need none / one line break / a blank line. Scans backward over
+*  blankspace, stopping at the first non-blankspace char, so cost is the gap
+*  length, not the source length. `\r\n` counts as one break. */
+function lineBreaksBefore(src, pos) {
+	let count = 0;
+	for (let i = pos - 1; i >= 0; i--) {
+		const c = src.charCodeAt(i);
+		if (isLineBreak(c)) {
+			if (c === lineFeed && src.charCodeAt(i - 1) === carriageReturn) i--;
+		} else if (isInlineSpace(c)) continue;
+		else break;
+		if (++count >= 2) return 2;
+	}
+	return count;
+}
+/** Index of the first comment that begins its own line (after a line break),
+*  or -1 if none do. */
+function firstOwnLine(run, src) {
+	return run.findIndex((t) => lineBreaksBefore(src, t.start) >= 1);
+}
+/** Start index of the trailing suffix of `run` that is joined to `next` by
+*  same-line whitespace only (no line break, no separator token between them).
+*  Returns run.length when nothing hugs `next`. */
+function hugsNextStart(run, nextStart, src) {
+	let suffixStart = run.length;
+	let rightStart = nextStart;
+	for (let i = run.length - 1; i >= 0; i--) {
+		const comment = run[i];
+		if (!sameLineGap(src, comment.end, rightStart)) break;
+		suffixStart = i;
+		rightStart = comment.start;
+	}
+	return suffixStart;
+}
+/** A WGSL line break code point. `\r\n` is two of these; callers coalesce it. */
+function isLineBreak(c) {
+	return c === lineFeed || c === carriageReturn || c === verticalTab || c === formFeed || c === nextLine || c === lineSeparator || c === paragraphSeparator;
+}
+/** WGSL blankspace that stays on the same line (not a line break). */
+function isInlineSpace(c) {
+	return c === space || c === tab || c === leftToRightMark || c === rightToLeftMark;
+}
+/** True when [from, to) is inline blankspace only (no line break): the two ends
+*  sit on the same line with nothing but same-line spaces between. */
+function sameLineGap(src, from, to) {
+	for (let i = from; i < to; i++) if (!isInlineSpace(src.charCodeAt(i))) return false;
+	return true;
 }
 //#endregion
 //#region src/parse/ExpressionUtil.ts
@@ -1425,9 +2029,11 @@ function makeLiteral(token) {
 	};
 }
 function makeUnaryOperator(token) {
+	const [start, end] = token.span;
 	return {
 		value: token.text,
-		span: token.span
+		start,
+		end
 	};
 }
 function makeBinaryOperator(token) {
@@ -1437,12 +2043,11 @@ function makeBinaryOperator(token) {
 	};
 }
 function makeUnaryExpression(operator, expr) {
-	const [start] = operator.span;
 	return {
 		kind: "unary-expression",
 		operator,
 		expression: expr,
-		start,
+		start: operator.start,
 		end: expr.end
 	};
 }
@@ -1503,13 +2108,16 @@ function expectWord(stream, errorMsg) {
 	stream.nextToken();
 	return token;
 }
-/** Parse expression and throw ParseError if not found. */
+/** Parse a required expression, throwing if absent. */
 function expectExpression(ctx, errorMsg = "Expected expression") {
 	const expr = parseExpression(ctx);
 	if (!expr) throwParseError(ctx.stream, errorMsg);
-	if (ctx.options.preserveExpressions) ctx.addElem(expr);
 	return expr;
 }
+/** Parse an optional expression. */
+function parseContentExpression(ctx, opts) {
+	return parseExpression(ctx, opts);
+}
 /** Throw a ParseError at the current/next token position. */
 function throwParseError(stream, message) {
 	const weslStream = stream;
@@ -1565,18 +2173,27 @@ function makeRefIdentElem(ctx, refIdent, start, end) {
 	refIdent.refIdentElem = elem;
 	return elem;
 }
-function isConditionalAttribute$1(attr) {
+/** @return true if the attribute is a conditional (@if, @elif, @else) */
+function isConditionalAttribute(attr) {
 	const { kind } = attr;
 	return kind === "@if" || kind === "@elif" || kind === "@else";
 }
 /** @return true if any attribute is a conditional (@if, @elif, @else) */
 function hasConditionalAttribute(attributes) {
-	return attributes.some((attr) => isConditionalAttribute$1(attr.attribute));
+	return attributes.some((attr) => isConditionalAttribute(attr.attribute));
+}
+/** The first conditional (@if, @elif, @else) attribute in the list, if any. */
+function conditionalAttribute(attributes) {
+	return attributes.find((a) => isConditionalAttribute(a.attribute))?.attribute;
 }
 /** Attach non-empty attributes array to element. */
 function attachAttributes(elem, attributes) {
 	if (attributes?.length) elem.attributes = attributes;
 }
+/** Normalize an empty attribute list to undefined (the elem's "no attributes"). */
+function attrsOrUndef(attrs) {
+	return attrs.length ? attrs : void 0;
+}
 /** Link a DeclIdentElem's ident to its parent declaration. */
 function linkDeclIdentElem(declIdentElem, declElem) {
 	declIdentElem.ident.declElem = declElem;
@@ -1719,10 +2336,7 @@ function parseIdent(ctx, conditionRef) {
 	const ident = ctx.createRefIdent(parts.join("::"));
 	if (conditionRef) ident.conditionRef = true;
 	const refIdentElem = makeRefIdentElem(ctx, ident, start, end);
-	if (!conditionRef) {
-		ctx.saveIdent(ident);
-		ctx.addElem(refIdentElem);
-	}
+	if (!conditionRef) ctx.saveIdent(ident);
 	return refIdentElem;
 }
 /** Check if token is valid as a path segment (word or allowed keyword). */
@@ -1744,19 +2358,20 @@ function parseSimpleTypeRef(ctx) {
 	if (!path) return null;
 	const { parts, start, end: nameEnd } = path;
 	const refIdent = ctx.createRefIdent(parts.join("::"));
-	beginElem(ctx, "type");
-	const refIdentElem = makeRefIdentElem(ctx, refIdent, start, nameEnd);
+	makeRefIdentElem(ctx, refIdent, start, nameEnd);
 	ctx.saveIdent(refIdent);
-	ctx.addElem(refIdentElem);
-	return finishElem("type", start, ctx, {
+	return {
+		kind: "type",
 		name: refIdent,
-		templateParams: ctx.stream.nextTemplateStartToken() ? parseTemplateParams(ctx) : void 0
-	});
+		templateParams: ctx.stream.nextTemplateStartToken() ? parseTemplateParams(ctx) : void 0,
+		start,
+		end: ctx.stream.checkpoint()
+	};
 }
 /** Parse comma-separated template parameters until closing '>'. */
 function parseTemplateParams(ctx) {
 	const { stream } = ctx;
-	if (consumeTemplateEnd(stream)) return [];
+	if (consumeTemplateEnd(stream)) throwParseError(stream, "Empty template parameter list '<>'");
 	const params = [parseTemplateParam(ctx)];
 	while (stream.matchText(",")) params.push(parseTemplateParam(ctx));
 	if (!consumeTemplateEnd(stream)) throwParseError(stream, "Expected '>' or ',' after template parameter");
@@ -1771,8 +2386,8 @@ function consumeTemplateEnd(stream) {
 /** Grammar: template_arg_expression : expression */
 function parseTemplateParam(ctx) {
 	const expr = parseExpression(ctx, { inTemplate: true });
-	if (expr) return expr;
-	throwParseError(ctx.stream, "Expected expression in template parameters");
+	if (!expr) throwParseError(ctx.stream, "Expected expression in template parameters");
+	return expr;
 }
 //#endregion
 //#region src/parse/ParseCall.ts
@@ -1783,7 +2398,7 @@ function parseTemplateParam(ctx) {
 function parseCallSuffix(ctx, current, parseExpr) {
 	if (current.kind !== "ref" && current.kind !== "type") return null;
 	const { stream } = ctx;
-	const templateArgs = current.kind === "type" ? current.templateParams ?? null : parseCallTemplateArgs(ctx);
+	const templateArgs = current.kind === "ref" ? parseCallTemplateArgs(ctx) : null;
 	if (!stream.matchText("(")) return null;
 	const args = [];
 	while (true) {
@@ -1948,8 +2563,7 @@ function parseTemplateElaboratedIdent(ctx, conditionRef) {
 		name: refIdent.ident,
 		templateParams,
 		start: refIdent.start,
-		end: ctx.stream.checkpoint(),
-		contents: []
+		end: ctx.stream.checkpoint()
 	};
 }
 /** Parse postfix operators: member access, indexing, function calls. */
@@ -1976,7 +2590,9 @@ function parseMemberAccess(ctx, base) {
 function parseIndexAccess(ctx, base) {
 	const { stream } = ctx;
 	if (!stream.matchText("[")) return null;
-	return makeComponentExpression(base, expectExpression(ctx, "Expected expression in array index"), expect(stream, "]", "array index").span[1]);
+	const indexExpr = parseExpression(ctx);
+	if (!indexExpr) throwParseError(stream, "Expected expression in array index");
+	return makeComponentExpression(base, indexExpr, expect(stream, "]", "array index").span[1]);
 }
 //#endregion
 //#region src/parse/ParseAttribute.ts
@@ -1997,6 +2613,20 @@ function parseElseAttribute(ctx) {
 function parseElifAttribute(ctx) {
 	return parseConditionalAttribute(ctx, "elif", makeElifAttribute);
 }
+/** Parse WESL conditional attributes (@if, @elif, @else) */
+function parseWeslConditional(ctx) {
+	const { stream } = ctx;
+	const peeked = stream.peek();
+	if (peeked?.text !== "@") return null;
+	const startPos = peeked.span[0];
+	const ifAttr = parseIfAttribute(ctx);
+	if (ifAttr) return attributeElem(ifAttr, startPos, stream.checkpoint());
+	const elifAttr = parseElifAttribute(ctx);
+	if (elifAttr) return attributeElem(elifAttr, startPos, stream.checkpoint());
+	const elseAttr = parseElseAttribute(ctx);
+	if (elseAttr) return attributeElem(elseAttr, startPos, stream.checkpoint());
+	return null;
+}
 /**
 * Grammar: attribute :
 *   '@' ident_pattern_token argument_expression_list ?
@@ -2007,15 +2637,8 @@ function parseElifAttribute(ctx) {
 * WESL extensions: @if, @elif, @else
 */
 function parseAttribute(ctx) {
-	const { stream } = ctx;
-	const startPos = stream.checkpoint();
-	if (!stream.matchText("@")) return null;
-	stream.reset(startPos);
-	const weslAttr = parseWeslConditional(ctx);
-	if (weslAttr) return weslAttr;
-	const stdAttr = parseStandardAttribute(ctx);
-	if (stdAttr) return stdAttr;
-	return null;
+	if (ctx.stream.peek()?.text !== "@") return null;
+	return parseWeslConditional(ctx) ?? parseStandardAttribute(ctx);
 }
 /** Parse `@if(expr)` or `@elif(expr)` conditional attributes. */
 function parseConditionalAttribute(ctx, keyword, makeAttr) {
@@ -2024,13 +2647,15 @@ function parseConditionalAttribute(ctx, keyword, makeAttr) {
 	if (!stream.matchSequence("@", keyword)) return null;
 	expect(stream, "(", `@${keyword}`);
 	const expr = parseExpression(ctx, true);
-	if (!expr) return null;
+	if (!expr) throwParseError(stream, `Expected expression after @${keyword}(`);
 	stream.matchText(",");
 	expect(stream, ")", `@${keyword} expression`);
-	return makeAttr(makeTranslateTimeExpressionElem({
-		value: expr,
-		span: [startPos, stream.checkpoint()]
-	}));
+	return makeAttr({
+		kind: "translate-time-expression",
+		expression: expr,
+		start: startPos,
+		end: stream.checkpoint()
+	});
 }
 function makeIfAttribute(param) {
 	return {
@@ -2047,19 +2672,13 @@ function makeElifAttribute(param) {
 		param
 	};
 }
-/** Parse WESL conditional attributes (@if, @elif, @else) */
-function parseWeslConditional(ctx) {
-	const { stream } = ctx;
-	const peeked = stream.peek();
-	if (peeked?.text !== "@") return null;
-	const startPos = peeked.span[0];
-	const ifAttr = parseIfAttribute(ctx);
-	if (ifAttr) return attributeElem(ifAttr, startPos, stream.checkpoint());
-	const elifAttr = parseElifAttribute(ctx);
-	if (elifAttr) return attributeElem(elifAttr, startPos, stream.checkpoint());
-	const elseAttr = parseElseAttribute(ctx);
-	if (elseAttr) return attributeElem(elseAttr, startPos, stream.checkpoint());
-	return null;
+function attributeElem(attribute, start, end) {
+	return {
+		kind: "attribute",
+		attribute,
+		start,
+		end
+	};
 }
 /** Parse a standard attribute (not @if/@elif/@else) */
 function parseStandardAttribute(ctx) {
@@ -2069,7 +2688,7 @@ function parseStandardAttribute(ctx) {
 	if (!atToken) return null;
 	const startPos = atToken.span[0];
 	const nameToken = stream.peek();
-	if (!nameToken || nameToken.kind !== "word" && nameToken.kind !== "keyword") {
+	if (nameToken?.kind !== "word" && nameToken?.kind !== "keyword") {
 		stream.reset(resetPos);
 		return null;
 	}
@@ -2092,22 +2711,6 @@ function parseStandardAttribute(ctx) {
 		params
 	}, startPos, stream.checkpoint());
 }
-function makeTranslateTimeExpressionElem(args) {
-	return {
-		kind: "translate-time-expression",
-		expression: args.value,
-		span: args.span
-	};
-}
-function attributeElem(attribute, start, end) {
-	return {
-		kind: "attribute",
-		attribute,
-		start,
-		end,
-		contents: []
-	};
-}
 function parseBuiltinAttribute(ctx, startPos) {
 	const { stream } = ctx;
 	expect(stream, "(", "@builtin");
@@ -2128,9 +2731,6 @@ function parseInterpolateAttribute(ctx, startPos) {
 		params
 	}, startPos, stream.checkpoint());
 }
-function parseNameElem(ctx) {
-	return makeNameElem(expectWord(ctx.stream, "Expected identifier"));
-}
 /** @diagnostic(severity, rule) or @diagnostic(severity, namespace.rule) */
 function parseDiagnosticAttribute(ctx, startPos) {
 	const { stream } = ctx;
@@ -2152,78 +2752,20 @@ function parseDiagnosticAttribute(ctx, startPos) {
 function parseAttributeParams(ctx) {
 	return parseCommaList(ctx, parseAttrParam);
 }
+function parseNameElem(ctx) {
+	return makeNameElem(expectWord(ctx.stream, "Expected identifier"));
+}
 function parseAttrParam(ctx) {
 	const { stream } = ctx;
 	const start = stream.checkpoint();
-	beginElem(ctx, "expression");
-	parseExpression(ctx);
-	const end = stream.checkpoint();
+	const expression = parseExpression(ctx);
+	if (!expression) throwParseError(stream, "Expected attribute parameter");
 	return {
 		kind: "expression",
+		expression,
 		start,
-		end,
-		contents: finishContents(ctx, start, end)
-	};
-}
-//#endregion
-//#region src/parse/ParseDirective.ts
-/** Grammar: global_directive : diagnostic_directive | enable_directive | requires_directive */
-function parseDirective(ctx) {
-	const { stream } = ctx;
-	const startPos = stream.checkpoint();
-	const attributes = parseAttributeList(ctx);
-	const attrs = attributes.length > 0 ? attributes : void 0;
-	const result = parseExtensionDirective(ctx, "enable", attrs) || parseExtensionDirective(ctx, "requires", attrs) || parseDiagnosticDirective(ctx, attrs);
-	if (!result) stream.reset(startPos);
-	return result;
-}
-/** Grammar: enable_directive | requires_directive : keyword extension_list ';' */
-function parseExtensionDirective(ctx, keyword, attributes) {
-	const { stream } = ctx;
-	const token = stream.matchText(keyword);
-	if (!token) return null;
-	const extensions = parseCommaList(ctx, parseDirectiveName);
-	expect(stream, ";", `${keyword} directive`);
-	return makeDirectiveElem({
-		kind: keyword,
-		extensions
-	}, token, stream, attributes);
-}
-function parseDirectiveName(ctx) {
-	return makeNameElem(expectWord(ctx.stream, "Expected identifier in name list"));
-}
-/**
-* Grammar: diagnostic_directive : 'diagnostic' diagnostic_control ';'
-* Grammar: diagnostic_control : '(' severity_control_name ',' diagnostic_rule_name ',' ? ')'
-*/
-function parseDiagnosticDirective(ctx, attributes) {
-	const { stream } = ctx;
-	const token = stream.matchText("diagnostic");
-	if (!token) return null;
-	expect(stream, "(", "diagnostic");
-	const severity = makeNameElem(expectWord(stream, "Expected severity in diagnostic"));
-	expect(stream, ",", "diagnostic severity");
-	const ruleName = makeNameElem(expectWord(stream, "Expected rule name in diagnostic"));
-	let subrule = null;
-	if (stream.matchText(".")) subrule = makeNameElem(expectWord(stream, "Expected subrule name after '.'"));
-	stream.matchText(",");
-	expect(stream, ")", "diagnostic rule");
-	expect(stream, ";", "diagnostic directive");
-	return makeDirectiveElem({
-		kind: "diagnostic",
-		severity,
-		rule: [ruleName, subrule]
-	}, token, stream, attributes);
-}
-function makeDirectiveElem(directive, token, stream, attributes) {
-	const elem = {
-		kind: "directive",
-		directive,
-		start: attributes?.[0]?.start ?? token.span[0],
 		end: stream.checkpoint()
 	};
-	attachAttributes(elem, attributes);
-	return elem;
 }
 //#endregion
 //#region src/parse/ParseControlFlow.ts
@@ -2234,37 +2776,50 @@ function makeDirectiveElem(directive, token, stream, attributes) {
 function parseIfStatement(ctx, attributes) {
 	const startPos = beginStatement(ctx, "if", attributes);
 	if (startPos === null) return null;
-	expectExpression(ctx, "Expected condition expression after 'if'");
-	const body = expectCompound(ctx, "Expected '{' after if condition");
-	ctx.addElem(body);
-	parseElseChain(ctx);
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("if", startPos, ctx, {
+		condition: expectExpression(ctx, "Expected condition after 'if'"),
+		body: expectCompound(ctx, "Expected '{' after if condition"),
+		else: parseElseChain(ctx)
+	}, attributes);
 }
 /** Grammar: switch_statement : attribute* 'switch' expression switch_body */
 function parseSwitchStatement(ctx, attributes) {
 	const startPos = beginStatement(ctx, "switch", attributes);
 	if (startPos === null) return null;
-	expectExpression(ctx, "Expected expression after 'switch'");
-	expectSwitchClauses(ctx);
-	return finishBlockStatement(startPos, ctx, attributes);
+	const selector = expectExpression(ctx, "Expected expression after 'switch'");
+	const { bodyAttributes, clauses } = expectSwitchClauses(ctx);
+	return finishStatement("switch", startPos, ctx, {
+		selector,
+		clauses,
+		bodyAttributes
+	}, attributes);
 }
 /**
 * Grammar: else_if_clause : 'else' 'if' expression compound_statement
 * Grammar: else_clause : 'else' compound_statement
+*
+* An else-if nests as an IfElem in the outer if's `else` field; a plain else is
+* a BlockElem. Emit and the AST dump read these typed fields.
 */
 function parseElseChain(ctx) {
 	const { stream } = ctx;
-	while (stream.matchText("else")) {
-		if (stream.matchText("if")) {
-			expectExpression(ctx, "Expected expression after 'else if'");
-			const body = expectCompound(ctx, "Expected '{' after else if");
-			ctx.addElem(body);
-			continue;
-		}
-		const body = expectCompound(ctx, "Expected '{' after else");
-		ctx.addElem(body);
-		break;
+	const elseToken = stream.matchText("else");
+	if (!elseToken) return void 0;
+	if (stream.matchText("if")) {
+		const condition = expectExpression(ctx, "Expected expression after 'else if'");
+		const body = expectCompound(ctx, "Expected '{' after else if");
+		const elseBranch = parseElseChain(ctx);
+		const end = stream.checkpoint();
+		return {
+			kind: "if",
+			condition,
+			body,
+			else: elseBranch,
+			start: elseToken.span[0],
+			end
+		};
 	}
+	return expectCompound(ctx, "Expected '{' after else");
 }
 /**
 * Grammar: switch_body : attribute* '{' switch_clause+ '}'
@@ -2274,27 +2829,43 @@ function parseElseChain(ctx) {
 */
 function expectSwitchClauses(ctx) {
 	const { stream } = ctx;
-	parseAttributeList(ctx);
+	const bodyAttrs = parseAttributeList(ctx);
 	expect(stream, "{", "switch expression");
-	while (!stream.matchText("}")) {
-		const clauseStart = stream.checkpoint();
-		const clauseAttrs = parseAttributeList(ctx);
-		beginElem(ctx, "switch-clause", clauseAttrs.length ? clauseAttrs : void 0);
-		if (stream.matchText("case")) {
-			parseCaseSelectors(ctx);
-			parseCaseBody(ctx, "Expected '{' after case value");
-		} else if (stream.matchText("default")) parseCaseBody(ctx, "Expected '{' after 'default'");
-		else throwParseError(stream, "Expected 'case', 'default', or '}' in switch");
-		const clauseElem = finishElem("switch-clause", clauseStart, ctx, {});
-		attachAttributes(clauseElem, clauseAttrs.length ? clauseAttrs : void 0);
-		ctx.addElem(clauseElem);
+	const clauses = [];
+	while (!stream.matchText("}")) clauses.push(parseSwitchClause(ctx));
+	return {
+		bodyAttributes: attrsOrUndef(bodyAttrs),
+		clauses
+	};
+}
+/** Parse one 'case'/'default' clause (the keyword has not yet been consumed). */
+function parseSwitchClause(ctx) {
+	const { stream } = ctx;
+	const attrs = attrsOrUndef(parseAttributeList(ctx));
+	const caseTok = stream.matchText("case");
+	const keyword = caseTok ?? stream.matchText("default");
+	if (!keyword) throwParseError(stream, "Expected 'case', 'default', or '}' in switch");
+	const clauseStart = getStartWithAttributes(attrs, keyword.span[0]);
+	let selectors;
+	let body;
+	if (caseTok) {
+		selectors = parseCaseSelectors(ctx);
+		body = parseCaseBody(ctx, "Expected '{' after case value");
+	} else {
+		selectors = ["default"];
+		body = parseCaseBody(ctx, "Expected '{' after 'default'");
 	}
+	return finishStatement("switch-clause", clauseStart, ctx, {
+		selectors,
+		body
+	}, attrs);
 }
 /** Grammar: case_selectors : case_selector (',' case_selector)* ','? */
 function parseCaseSelectors(ctx) {
 	const { stream } = ctx;
-	expectExpression(ctx, "Expected expression after 'case'");
-	while (stream.matchText(",")) expectExpression(ctx, "Expected expression after ',' in case values");
+	const selectors = [expectExpression(ctx, "Expected expression after 'case'")];
+	while (stream.matchText(",")) selectors.push(expectExpression(ctx, "Expected expression after ',' in case values"));
+	return selectors;
 }
 /**
 * Grammar: case_clause : 'case' case_selectors ':'? compound_statement
@@ -2302,16 +2873,15 @@ function parseCaseSelectors(ctx) {
 */
 function parseCaseBody(ctx, errorMsg) {
 	ctx.stream.matchText(":");
-	const bodyAttrs = parseAttributeList(ctx);
-	const body = parseCompoundStatement(ctx, bodyAttrs.length > 0 ? bodyAttrs : void 0);
+	const body = parseCompoundStatement(ctx, attrsOrUndef(parseAttributeList(ctx)));
 	if (!body) throwParseError(ctx.stream, errorMsg);
-	ctx.addElem(body);
+	return body;
 }
 //#endregion
 //#region src/parse/ParseValueDeclaration.ts
 /** Grammar: 'const' optionally_typed_ident '=' expression (global or local) */
 function parseConstDecl(ctx, attributes) {
-	return parseValueDecl(ctx, "const", true, isModuleScope(ctx), attributes);
+	return parseValueDecl(ctx, "const", true, ctx.isModuleScope(), attributes);
 }
 /** Grammar: 'override' optionally_typed_ident ( '=' expression )? */
 function parseOverrideDecl(ctx, attributes) {
@@ -2322,20 +2892,16 @@ function parseTypedDecl(ctx, isGlobal = true) {
 	const nameToken = ctx.stream.matchKind("word");
 	if (!nameToken) return null;
 	const start = nameToken.span[0];
-	beginElem(ctx, "typeDecl");
 	const decl = createDeclIdentElem(ctx, nameToken, isGlobal);
-	ctx.addElem(decl);
 	ctx.saveIdent(decl.ident);
 	const { typeRef, typeScope } = parseOptionalType(ctx);
-	const end = ctx.stream.checkpoint();
 	return {
 		kind: "typeDecl",
 		decl,
 		typeRef,
 		typeScope,
 		start,
-		end,
-		contents: finishContents(ctx, start, end)
+		end: ctx.stream.checkpoint()
 	};
 }
 /** Shared parser for const/override declarations. */
@@ -2345,43 +2911,29 @@ function parseValueDecl(ctx, keyword, requiresInit, isGlobal, attributes) {
 	if (!token) return null;
 	const startPos = getStartWithAttributes(attributes, token.span[0]);
 	ctx.pushScope("partial");
-	beginElem(ctx, keyword, attributes);
 	const typedDecl = parseTypedDecl(ctx, isGlobal);
 	if (!typedDecl) throwParseError(stream, `Expected identifier after '${keyword}'`);
-	ctx.addElem(typedDecl);
+	let init;
 	if (requiresInit) {
 		expect(stream, "=", `${keyword} identifier`);
-		expectExpression(ctx);
-	} else if (stream.matchText("=")) expectExpression(ctx);
+		init = expectExpression(ctx);
+	} else if (stream.matchText("=")) init = expectExpression(ctx);
 	expect(stream, ";", `${keyword} declaration`);
-	const endPos = stream.checkpoint();
-	const contents = finishContents(ctx, startPos, endPos);
 	typedDecl.decl.ident.dependentScope = ctx.currentScope();
 	ctx.popScope();
-	const elem = {
-		kind: keyword,
+	const elem = finishStatement(keyword, startPos, ctx, {
 		name: typedDecl,
-		start: startPos,
-		end: endPos,
-		contents
-	};
-	attachAttributes(elem, attributes);
+		init
+	}, attributes);
 	linkDeclIdent(typedDecl, elem);
 	return elem;
 }
-/** @return true if ctx is at module level (not inside fn/block) */
-function isModuleScope(ctx) {
-	let scope = ctx.currentScope();
-	while (scope.kind === "partial" && scope.parent) scope = scope.parent;
-	return scope.parent === null;
-}
 /** Parse optional ': type' annotation, managing scope for type references. */
 function parseOptionalType(ctx) {
 	if (!ctx.stream.matchText(":")) return {};
 	ctx.pushScope();
 	const typeRef = parseSimpleTypeRef(ctx);
 	if (!typeRef) throwParseError(ctx.stream, "Expected type after ':'");
-	ctx.addElem(typeRef);
 	const typeScope = ctx.currentScope();
 	ctx.popScope();
 	return {
@@ -2401,17 +2953,19 @@ function parseGlobalVarDecl(ctx, attributes) {
 	if (!varToken) return null;
 	const startPos = getStartWithAttributes(attributes, varToken.span[0]);
 	ctx.pushScope("partial");
-	beginElem(ctx, "gvar", attributes);
-	skipTemplateList(ctx);
+	const template = parseTemplateList(ctx);
 	const typedDecl = parseTypedDecl(ctx);
 	if (!typedDecl) throwParseError(stream, "Expected identifier after 'var'");
-	ctx.addElem(typedDecl);
-	if (stream.matchText("=")) expectExpression(ctx);
+	let init;
+	if (stream.matchText("=")) init = expectExpression(ctx);
 	expect(stream, ";", "var declaration");
 	typedDecl.decl.ident.dependentScope = ctx.currentScope();
 	ctx.popScope();
-	const varElem = finishElem("gvar", startPos, ctx, { name: typedDecl });
-	attachAttributes(varElem, attributes);
+	const varElem = finishStatement("gvar", startPos, ctx, {
+		name: typedDecl,
+		template,
+		init
+	}, attributes);
 	linkDeclIdent(typedDecl, varElem);
 	return varElem;
 }
@@ -2421,23 +2975,19 @@ function parseAliasDecl(ctx, attributes) {
 	const aliasToken = stream.matchText("alias");
 	if (!aliasToken) return null;
 	const startPos = getStartWithAttributes(attributes, aliasToken.span[0]);
-	beginElem(ctx, "alias", attributes);
 	const declIdentElem = createDeclIdentElem(ctx, expectWord(stream, "Expected identifier after 'alias'"), true);
-	ctx.addElem(declIdentElem);
 	ctx.saveIdent(declIdentElem.ident);
 	expect(stream, "=", "alias name");
 	ctx.pushScope();
 	const typeRef = parseSimpleTypeRef(ctx);
 	if (!typeRef) throwParseError(stream, "Expected type after '=' in alias declaration");
-	ctx.addElem(typeRef);
 	declIdentElem.ident.dependentScope = ctx.currentScope();
 	ctx.popScope();
 	expect(stream, ";", "alias declaration");
-	const aliasElem = finishElem("alias", startPos, ctx, {
+	const aliasElem = finishStatement("alias", startPos, ctx, {
 		name: declIdentElem,
 		typeRef
-	});
-	attachAttributes(aliasElem, attributes);
+	}, attributes);
 	linkDeclIdentElem(declIdentElem, aliasElem);
 	return aliasElem;
 }
@@ -2446,25 +2996,29 @@ function parseConstAssert(ctx, attributes) {
 	const assertToken = ctx.stream.matchText("const_assert");
 	if (!assertToken) return null;
 	const startPos = getStartWithAttributes(attributes, assertToken.span[0]);
-	beginElem(ctx, "assert", attributes);
-	expectExpression(ctx);
+	const expression = expectExpression(ctx);
 	expect(ctx.stream, ";", "const_assert expression");
-	const elem = finishElem("assert", startPos, ctx, {});
-	attachAttributes(elem, attributes);
-	return elem;
+	return finishStatement("assert", startPos, ctx, { expression }, attributes);
 }
-/** Skip optional template list (e.g., <storage, read_write>). */
-function skipTemplateList(ctx) {
+/**
+* Parse an optional var template list `<storage, read_write>`. The entries are
+* predeclared enumerants (address space / access mode), not user idents, so they
+* are captured as unbound NameElems.
+*/
+function parseTemplateList(ctx) {
 	const { stream } = ctx;
-	if (!stream.nextTemplateStartToken()) return;
+	if (!stream.nextTemplateStartToken()) return void 0;
+	const names = [];
 	while (true) {
 		const next = stream.peek();
 		if (!next) throwParseError(stream, "Unclosed template in var declaration");
 		if (next.text.startsWith(">")) {
 			stream.nextTemplateEndToken();
-			return;
+			return names;
 		}
-		stream.nextToken();
+		const word = stream.matchKind("word");
+		if (word) names.push(makeNameElem(word));
+		else if (!stream.matchText(",")) throwParseError(stream, "Expected ',' or '>' in var template list");
 	}
 }
 //#endregion
@@ -2486,18 +3040,20 @@ function parseVarOrLet(ctx, keyword, hasTemplate, requiresInit, attributes) {
 	const token = stream.matchText(keyword);
 	if (!token) return null;
 	const startPos = getStartWithAttributes(attributes, token.span[0]);
-	beginElem(ctx, keyword, attributes);
-	if (hasTemplate) skipTemplateList(ctx);
+	const template = hasTemplate ? parseTemplateList(ctx) : void 0;
 	const typedDecl = parseTypedDecl(ctx, false);
 	if (!typedDecl) throwParseError(stream, `Expected identifier after '${keyword}'`);
-	ctx.addElem(typedDecl);
+	let init;
 	if (requiresInit) {
 		expect(stream, "=", `${keyword} identifier (${keyword} requires initialization)`);
-		expectExpression(ctx);
-	} else if (stream.matchText("=")) expectExpression(ctx);
+		init = expectExpression(ctx);
+	} else if (stream.matchText("=")) init = expectExpression(ctx);
 	expect(stream, ";", `${keyword} declaration`);
-	const elem = finishElem(keyword, startPos, ctx, { name: typedDecl });
-	attachAttributes(elem, attributes);
+	const elem = finishStatement(keyword, startPos, ctx, {
+		name: typedDecl,
+		init
+	}, attributes);
+	if (template && elem.kind === "var") elem.template = template;
 	linkDeclIdent(typedDecl, elem);
 	return elem;
 }
@@ -2526,17 +3082,42 @@ const assignmentOps = new Set([
 function parseSimpleStatement(ctx, attributes) {
 	const { stream } = ctx;
 	const startPos = getStartWithAttributes(attributes, stream.checkpoint());
-	return parseReturnStmt(ctx, startPos, attributes) || parseBreakStmt(ctx, startPos, attributes) || parseKeywordStmt(ctx, startPos, attributes, "continue") || parseKeywordStmt(ctx, startPos, attributes, "discard") || parseEmptyStmt(stream, startPos) || parsePhonyAssignment(ctx, startPos, attributes) || parseExpressionStmt(ctx, startPos, attributes);
+	return parseReturnStmt(ctx, startPos, attributes) || parseBreakStmt(ctx, startPos, attributes) || parseContinueStmt(ctx, startPos, attributes) || parseDiscardStmt(ctx, startPos, attributes) || parseEmptyStmt(stream, startPos) || parsePhonyAssignment(ctx, startPos, attributes) || parseExpressionStmt(ctx, startPos, attributes);
+}
+/** Match an assignment operator, capturing its value and span. */
+function parseAssignmentOp(stream) {
+	const token = stream.nextIf(({ text }) => assignmentOps.has(text));
+	if (!token) return null;
+	return {
+		value: token.text,
+		span: token.span
+	};
+}
+/** Match '++' or '--', returning its text and span (or null if absent). */
+function parseIncDecOp(stream) {
+	const token = stream.nextIf(({ text }) => text === "++" || text === "--");
+	if (!token) return null;
+	return {
+		op: token.text,
+		span: token.span
+	};
+}
+/** Grammar: ( '=' | compound_assignment_operator ) expression. Returns op + rhs. */
+function parseAssignmentRhs(ctx) {
+	const op = parseAssignmentOp(ctx.stream);
+	if (!op) return null;
+	return {
+		op,
+		rhs: expectExpression(ctx, "Expected expression after assignment operator")
+	};
 }
 /** Grammar: return_statement : 'return' expression? ';' */
 function parseReturnStmt(ctx, startPos, attributes) {
 	const { stream } = ctx;
 	if (!stream.matchText("return")) return null;
-	beginElem(ctx, "statement", attributes);
-	const expr = parseExpression(ctx);
-	if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
+	const value = parseContentExpression(ctx) ?? void 0;
 	expect(stream, ";", "return statement");
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("return", startPos, ctx, { value }, attributes);
 }
 /**
 * Grammar: break_statement : 'break' ';'
@@ -2545,70 +3126,79 @@ function parseReturnStmt(ctx, startPos, attributes) {
 function parseBreakStmt(ctx, startPos, attributes) {
 	const { stream } = ctx;
 	if (!stream.matchText("break")) return null;
-	beginElem(ctx, "statement", attributes);
-	if (stream.matchText("if")) expectExpression(ctx, "Expected condition after 'break if'");
+	let condition;
+	if (stream.matchText("if")) condition = expectExpression(ctx, "Expected condition after 'break if'");
 	expect(stream, ";", "break statement");
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("break", startPos, ctx, { condition }, attributes);
+}
+/** Grammar: continue_statement : 'continue' ';' */
+function parseContinueStmt(ctx, startPos, attributes) {
+	const { stream } = ctx;
+	if (!stream.matchText("continue")) return null;
+	expect(stream, ";", "continue statement");
+	return finishStatement("continue", startPos, ctx, {}, attributes);
 }
-/** Grammar: continue_statement : 'continue' ';' also handles 'discard' */
-function parseKeywordStmt(ctx, startPos, attributes, keyword) {
+/** Grammar: 'discard' ';' */
+function parseDiscardStmt(ctx, startPos, attributes) {
 	const { stream } = ctx;
-	if (!stream.matchText(keyword)) return null;
-	beginElem(ctx, "statement", attributes);
-	expect(stream, ";", `${keyword} statement`);
-	return finishBlockStatement(startPos, ctx, attributes);
+	if (!stream.matchText("discard")) return null;
+	expect(stream, ";", "discard statement");
+	return finishStatement("discard", startPos, ctx, {}, attributes);
 }
-/** Parse empty statement (just ';'). */
+/** Parse empty statement (just ';'). Spans the ';' so it emits no extra text. */
 function parseEmptyStmt(stream, start) {
 	if (!stream.matchText(";")) return null;
 	return {
-		kind: "statement",
+		kind: "empty",
 		start,
-		end: stream.checkpoint(),
-		contents: []
+		end: stream.checkpoint()
 	};
 }
 /** Grammar: assignment_statement : '_' '=' expression ';' (phony assignment) */
 function parsePhonyAssignment(ctx, startPos, attributes) {
 	const { stream } = ctx;
-	if (!stream.matchText("_")) return null;
-	if (!parseAssignmentOperator(stream)) throwParseError(stream, "Expected assignment operator after '_'");
-	beginElem(ctx, "statement", attributes);
-	expectExpression(ctx, "Expected expression after assignment operator");
+	const underscore = stream.matchText("_");
+	if (!underscore) return null;
+	const lhs = {
+		kind: "phony",
+		span: underscore.span
+	};
+	const eq = stream.matchText("=");
+	if (!eq) throwParseError(stream, "Expected '=' after '_'");
+	const op = {
+		value: "=",
+		span: eq.span
+	};
+	const rhs = expectExpression(ctx, "Expected expression after '_ ='");
 	expect(stream, ";", "assignment");
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("assign", startPos, ctx, {
+		lhs,
+		op,
+		rhs
+	}, attributes);
 }
-/**
-* Parses expression statements: assignments, increments/decrements, or function calls.
-* Grammar: ( assignment_statement | increment_statement | decrement_statement | call_phrase ) ';'
-*/
+/** Grammar: ( assignment_statement | increment_statement | decrement_statement | call_phrase ) ';' */
 function parseExpressionStmt(ctx, startPos, attributes) {
 	const { stream } = ctx;
-	beginElem(ctx, "statement", attributes);
 	const expr = parseExpression(ctx);
 	if (!expr) {
-		finishContents(ctx, startPos, startPos);
 		stream.reset(startPos);
 		return null;
 	}
-	if (ctx.options.preserveExpressions) ctx.addElem(expr);
-	if (!parseIncDecOperator(stream)) parseAssignmentRhs(ctx);
+	const incDec = parseIncDecOp(stream);
+	if (incDec) {
+		expect(stream, ";", "expression");
+		return finishStatement(incDec.op === "++" ? "increment" : "decrement", startPos, ctx, { target: expr }, attributes);
+	}
+	const assign = parseAssignmentRhs(ctx);
 	expect(stream, ";", "expression");
-	return finishBlockStatement(startPos, ctx, attributes);
-}
-/** Grammar: assignment_statement : lhs_expression ( '=' | compound_assignment_operator ) expression */
-function parseAssignmentOperator(stream) {
-	return !!stream.nextIf(({ text }) => assignmentOps.has(text));
-}
-/** Grammar: ( '=' | compound_assignment_operator ) expression (rhs of assignment_statement) */
-function parseAssignmentRhs(ctx) {
-	if (!parseAssignmentOperator(ctx.stream)) return false;
-	expectExpression(ctx, "Expected expression after assignment operator");
-	return true;
-}
-/** Grammar: increment_statement : lhs_expression '++' ; decrement_statement : lhs_expression '--' */
-function parseIncDecOperator(stream) {
-	return !!stream.nextIf(({ text }) => text === "++" || text === "--");
+	if (assign) return finishStatement("assign", startPos, ctx, {
+		lhs: expr,
+		op: assign.op,
+		rhs: assign.rhs
+	}, attributes);
+	if (expr.kind !== "call-expression") throwParseError(stream, "Expected call, assignment, or increment");
+	return finishStatement("call", startPos, ctx, { call: expr }, attributes);
 }
 //#endregion
 //#region src/parse/ParseLoop.ts
@@ -2622,41 +3212,48 @@ function parseForStatement(ctx, attributes) {
 	if (startPos === null) return null;
 	ctx.pushScope();
 	expect(stream, "(", "'for'");
-	parseForInit(ctx);
-	const cond = parseExpression(ctx);
-	if (cond && ctx.options.preserveExpressions) ctx.addElem(cond);
+	const init = parseForInit(ctx);
+	const condition = parseContentExpression(ctx) ?? void 0;
 	expect(stream, ";", "for loop condition");
-	parseForUpdate(ctx);
+	const update = parseForUpdate(ctx);
 	expect(stream, ")", "for loop header");
 	const body = expectCompound(ctx, "Expected '{' after for loop header");
-	ctx.addElem(body);
 	ctx.popScope();
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("for", startPos, ctx, {
+		init,
+		condition,
+		update,
+		body
+	}, attributes);
 }
 /** Grammar: while_statement : attribute* 'while' expression compound_statement */
 function parseWhileStatement(ctx, attributes) {
 	const startPos = beginStatement(ctx, "while", attributes);
 	if (startPos === null) return null;
-	expectExpression(ctx, "Expected condition expression after 'while'");
-	const body = expectCompound(ctx, "Expected '{' after while condition");
-	ctx.addElem(body);
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("while", startPos, ctx, {
+		condition: expectExpression(ctx, "Expected condition after 'while'"),
+		body: expectCompound(ctx, "Expected '{' after while condition")
+	}, attributes);
 }
 /** Grammar: loop_statement : attribute* 'loop' attribute* '{' statement* continuing_statement? '}' */
 function parseLoopStatement(ctx, attributes) {
 	const startPos = beginStatement(ctx, "loop", attributes);
 	if (startPos === null) return null;
 	const body = expectCompound(ctx, "Expected '{' after 'loop'", true);
-	ctx.addElem(body);
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("loop", startPos, ctx, {
+		body,
+		continuing: body.body.find((s) => s.kind === "continuing")
+	}, attributes);
 }
 /** Grammar: continuing_statement : 'continuing' continuing_compound_statement */
 function parseContinuingStatement(ctx, attributes) {
-	const startPos = beginStatement(ctx, "continuing", attributes, "continuing");
+	const startPos = beginStatement(ctx, "continuing", attributes);
 	if (startPos === null) return null;
 	const body = expectCompound(ctx, "Expected '{' after 'continuing'");
-	ctx.addElem(body);
-	return finishBlockStatement(startPos, ctx, attributes, "continuing");
+	return finishStatement("continuing", startPos, ctx, {
+		body,
+		breakIf: body.body.find((s) => s.kind === "break")?.condition
+	}, attributes);
 }
 /** Grammar: for_init? ';'
 *           for_init : variable_or_value_statement | variable_updating_statement | func_call_statement
@@ -2664,19 +3261,60 @@ function parseContinuingStatement(ctx, attributes) {
 function parseForInit(ctx) {
 	const { stream } = ctx;
 	const varDecl = parseLocalVarDecl(ctx);
-	if (varDecl) ctx.addElem(varDecl);
-	else {
-		const expr = parseExpression(ctx);
-		if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
-		expect(stream, ";", "for loop init");
-	}
+	if (varDecl) return varDecl;
+	const expr = parseContentExpression(ctx);
+	const update = expr ? finishForUpdate(ctx, expr) : void 0;
+	expect(stream, ";", "for loop init");
+	return update;
 }
-/** Grammar: for_update : variable_updating_statement | func_call_statement
-*           variable_updating_statement : assignment_statement | increment_statement | decrement_statement */
+/** Grammar: for_update : variable_updating_statement | func_call_statement */
 function parseForUpdate(ctx) {
-	const expr = parseExpression(ctx);
-	if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
-	parseIncDecOperator(ctx.stream) || parseAssignmentRhs(ctx);
+	const expr = parseContentExpression(ctx);
+	if (!expr) return void 0;
+	return finishForUpdate(ctx, expr);
+}
+/**
+* Build a typed for-init/for-update node from an already-parsed lhs expression,
+* consuming its trailing operator (++/-- or an assignment + rhs).
+*/
+function finishForUpdate(ctx, expr) {
+	const { stream } = ctx;
+	const start = expr.start;
+	const incDec = parseIncDecOp(stream);
+	if (incDec) {
+		const end = stream.checkpoint();
+		if (incDec.op === "++") return {
+			kind: "increment",
+			target: expr,
+			start,
+			end
+		};
+		return {
+			kind: "decrement",
+			target: expr,
+			start,
+			end
+		};
+	}
+	const assign = parseAssignmentRhs(ctx);
+	if (assign) {
+		const { op, rhs } = assign;
+		return {
+			kind: "assign",
+			lhs: expr,
+			op,
+			rhs,
+			start,
+			end: stream.checkpoint()
+		};
+	}
+	if (expr.kind === "call-expression") return {
+		kind: "call",
+		call: expr,
+		start,
+		end: stream.checkpoint()
+	};
+	throwParseError(stream, "Expected an assignment, increment, decrement, or call in for-clause");
 }
 //#endregion
 //#region src/parse/ParseStatement.ts
@@ -2692,17 +3330,17 @@ function parseCompoundStatement(ctx, attributes, options) {
 	const brace = ctx.stream.matchText("{");
 	if (!brace) return null;
 	const startPos = getStartWithAttributes(attributes, brace.span[0]);
-	beginElem(ctx, "statement", attributes);
 	const skipScope = options?.noScope || hasConditionalAttr(attributes);
 	if (!skipScope) ctx.pushScope();
-	parseBlockStatements(ctx, options?.loopBody);
+	const body = parseBlockStatements(ctx, options?.loopBody);
 	if (!skipScope) ctx.popScope();
-	return finishBlockStatement(startPos, ctx, attributes);
+	return finishStatement("block", startPos, ctx, { body }, attributes);
 }
 /** Grammar: attribute* compound_statement (for control flow bodies) */
 function expectCompound(ctx, errorMsg, loopBody) {
 	const attrs = parseAttributeList(ctx);
-	const block = parseCompoundStatement(ctx, attrs.length > 0 ? attrs : void 0, loopBody ? { loopBody } : void 0);
+	const options = loopBody ? { loopBody } : void 0;
+	const block = parseCompoundStatement(ctx, attrsOrUndef(attrs), options);
 	if (!block) throwParseError(ctx.stream, errorMsg);
 	return block;
 }
@@ -2710,16 +3348,20 @@ function expectCompound(ctx, errorMsg, loopBody) {
 function getStartWithAttributes(attributes, keywordPos) {
 	return attributes?.[0]?.start ?? keywordPos;
 }
-/** Match keyword and begin statement element. Returns start position or null. */
-function beginStatement(ctx, keyword, attributes, kind = "statement") {
-	const keywordPos = ctx.stream.checkpoint();
-	if (!ctx.stream.matchText(keyword)) return null;
-	const startPos = getStartWithAttributes(attributes, keywordPos);
-	beginElem(ctx, kind, attributes);
-	return startPos;
+/** Match keyword and return the statement's start position (or null if no match). */
+function beginStatement(ctx, keyword, attributes) {
+	const token = ctx.stream.matchText(keyword);
+	if (!token) return null;
+	return getStartWithAttributes(attributes, token.span[0]);
 }
-function finishBlockStatement(start, ctx, attributes, kind = "statement") {
-	const elem = finishElem(kind, start, ctx, {});
+/** Build a statement element from its typed fields and attach its attributes. */
+function finishStatement(kind, start, ctx, params, attributes) {
+	const elem = {
+		kind,
+		start,
+		end: ctx.stream.checkpoint(),
+		...params
+	};
 	attachAttributes(elem, attributes);
 	return elem;
 }
@@ -2729,16 +3371,18 @@ function hasConditionalAttr(attributes) {
 /** Grammar: statement* '}' (after '{' consumed). Loop bodies may end with continuing. */
 function parseBlockStatements(ctx, loopBody) {
 	const { stream } = ctx;
+	const body = [];
 	while (true) {
 		if (stream.matchText("}")) break;
 		const stmt = parseStatement(ctx);
 		if (!stmt) throwParseError(stream, "Expected statement or '}'");
-		ctx.addElem(stmt);
+		body.push(stmt);
 		if (loopBody && stmt.kind === "continuing") {
 			expect(stream, "}", "continuing block");
 			break;
 		}
 	}
+	return body;
 }
 /**
 * Grammar: statement :
@@ -2759,7 +3403,6 @@ function parseStatement(ctx) {
 	}
 	const hasConditional = attributes.length > 0 && hasConditionalAttribute(attributes);
 	if (hasConditional) ctx.pushScope("partial");
-	const attrsOrUndef = attributes.length > 0 ? attributes : void 0;
 	const stmt = findMap([
 		parseLocalVarDecl,
 		parseLetDecl,
@@ -2773,19 +3416,71 @@ function parseStatement(ctx) {
 		parseLoopStatement,
 		parseContinuingStatement,
 		parseSimpleStatement
-	], (p) => p(ctx, attrsOrUndef));
-	if (!stmt) return null;
-	finalizeConditional$1(ctx, hasConditional, attributes);
-	return stmt;
+	], (p) => p(ctx, attrsOrUndef(attributes)));
+	if (hasConditional) {
+		const partialScope = ctx.popScope();
+		if (stmt) partialScope.condAttribute = conditionalAttribute(attributes);
+	}
+	return stmt ? stmt : null;
+}
+//#endregion
+//#region src/parse/ParseDirective.ts
+/** Grammar: global_directive : diagnostic_directive | enable_directive | requires_directive */
+function parseDirective(ctx) {
+	const { stream } = ctx;
+	const startPos = stream.checkpoint();
+	const attrs = attrsOrUndef(parseAttributeList(ctx));
+	const result = parseExtensionDirective(ctx, "enable", attrs) || parseExtensionDirective(ctx, "requires", attrs) || parseDiagnosticDirective(ctx, attrs);
+	if (!result) stream.reset(startPos);
+	return result;
+}
+/** Grammar: enable_directive | requires_directive : keyword extension_list ';' */
+function parseExtensionDirective(ctx, keyword, attributes) {
+	const { stream } = ctx;
+	const token = stream.matchText(keyword);
+	if (!token) return null;
+	const extensions = parseCommaList(ctx, parseDirectiveName);
+	expect(stream, ";", `${keyword} directive`);
+	return makeDirectiveElem({
+		kind: keyword,
+		extensions
+	}, token, stream, attributes);
+}
+/**
+* Grammar: diagnostic_directive : 'diagnostic' diagnostic_control ';'
+* Grammar: diagnostic_control : '(' severity_control_name ',' diagnostic_rule_name ',' ? ')'
+*/
+function parseDiagnosticDirective(ctx, attributes) {
+	const { stream } = ctx;
+	const token = stream.matchText("diagnostic");
+	if (!token) return null;
+	expect(stream, "(", "diagnostic");
+	const severity = makeNameElem(expectWord(stream, "Expected severity in diagnostic"));
+	expect(stream, ",", "diagnostic severity");
+	const ruleName = makeNameElem(expectWord(stream, "Expected rule name in diagnostic"));
+	let subrule = null;
+	if (stream.matchText(".")) subrule = makeNameElem(expectWord(stream, "Expected subrule name after '.'"));
+	stream.matchText(",");
+	expect(stream, ")", "diagnostic rule");
+	expect(stream, ";", "diagnostic directive");
+	return makeDirectiveElem({
+		kind: "diagnostic",
+		severity,
+		rule: [ruleName, subrule]
+	}, token, stream, attributes);
 }
-function finalizeConditional$1(ctx, hasConditional, attributes) {
-	if (hasConditional) {
-		const partialScope = ctx.popScope();
-		partialScope.condAttribute = getConditionalAttribute(attributes);
-	}
+function parseDirectiveName(ctx) {
+	return makeNameElem(expectWord(ctx.stream, "Expected identifier in name list"));
 }
-function getConditionalAttribute(attributes) {
-	return attributes.find((a) => isConditionalAttribute$1(a.attribute))?.attribute;
+function makeDirectiveElem(directive, token, stream, attributes) {
+	const elem = {
+		kind: "directive",
+		directive,
+		start: getStartWithAttributes(attributes, token.span[0]),
+		end: stream.checkpoint()
+	};
+	attachAttributes(elem, attributes);
+	return elem;
 }
 //#endregion
 //#region src/parse/ParseFn.ts
@@ -2822,8 +3517,7 @@ function parseFnDecl(ctx, attributes) {
 		returnType,
 		returnAttributes,
 		start: startPos,
-		end: stream.checkpoint(),
-		contents: buildFnContents(attributes, declIdentElem, params, returnType, body)
+		end: stream.checkpoint()
 	};
 	attachAttributes(fnElem, attributes);
 	linkDeclIdentElem(declIdentElem, fnElem);
@@ -2853,37 +3547,63 @@ function parseFnReturn(ctx) {
 	if (!returnType) throwParseError(stream, "Expected type after '->'");
 	return {
 		returnType,
-		returnAttributes: attrs.length > 0 ? attrs : void 0
+		returnAttributes: attrsOrUndef(attrs)
 	};
 }
-/** Build contents array for function element */
-function buildFnContents(attributes, decl, params, returnType, body) {
-	const base = returnType ? [
-		decl,
-		...params,
-		returnType,
-		body
-	] : [
-		decl,
-		...params,
-		body
-	];
-	return attributes?.length ? [...attributes, ...base] : base;
-}
 /** Grammar: param : attribute* optionally_typed_ident */
 function parseFnParam(ctx) {
-	const attributes = parseAttributeList(ctx);
+	const attrs = parseAttributeList(ctx);
 	if (ctx.stream.peek()?.kind !== "word") return null;
-	beginElem(ctx, "param", attributes.length ? attributes : void 0);
+	const attributes = attrsOrUndef(attrs);
 	const name = parseTypedDecl(ctx, false);
 	if (!name) throw new Error("Unexpected: peek succeeded but parseTypedDecl failed");
-	ctx.addElem(name);
-	const elem = finishElem("param", getStartWithAttributes(attributes, name.start), ctx, { name });
+	const elem = finishStatement("param", getStartWithAttributes(attributes, name.start), ctx, { name }, attributes);
 	linkDeclIdent(name, elem);
-	attachAttributes(elem, attributes.length > 0 ? attributes : void 0);
 	return elem;
 }
 //#endregion
+//#region src/parse/ParseDoBlock.ts
+/**
+* Grammar: do_block_decl : attribute* 'do' ident '(' param_list? ')' compound_statement
+*
+* `do` is a module-level declaration when the `doBlocks` extension is on;
+* otherwise it stays a reserved word. The body is parsed structurally but
+* inside a scope that is detached from the module scope graph, so its idents
+* never reach bindIdents. do blocks are module-local, resolved later by AST
+* name match.
+*/
+function parseDoBlock(ctx, attributes) {
+	if (!ctx.options.weslExtensions?.doBlocks) return null;
+	const { stream } = ctx;
+	const doToken = stream.matchText("do");
+	if (!doToken) return null;
+	const startPos = getStartWithAttributes(attributes, doToken.span[0]);
+	const name = makeNameElem(expectWord(stream, "Expected identifier after 'do'"));
+	const parentScope = ctx.currentScope();
+	ctx.pushScope();
+	const doScope = ctx.currentScope();
+	const params = parseFnParams(ctx);
+	const body = parseFunctionBody(ctx);
+	if (!body) throwParseError(stream, "Expected do block body");
+	ctx.popScope();
+	detachScope(parentScope, doScope);
+	const doBlock = {
+		kind: "do",
+		name,
+		params,
+		body,
+		start: startPos,
+		end: stream.checkpoint()
+	};
+	attachAttributes(doBlock, attributes);
+	return doBlock;
+}
+/** Remove a child scope from its parent so bindIdents never traverses it. */
+function detachScope(parent, child) {
+	const i = parent.contents.indexOf(child);
+	if (i >= 0) parent.contents.splice(i, 1);
+}
+//#endregion
 //#region src/parse/ParseImport.ts
 /** WESL Grammar: translation_unit : import_statement* global_directive* global_decl* */
 function parseWeslImports(ctx) {
@@ -3021,52 +3741,39 @@ function parseStructDecl(ctx, attributes) {
 	const start = getStartWithAttributes(attributes, structToken.span[0]);
 	const identElem = createDeclIdentElem(ctx, expectWord(stream, "Expected identifier after 'struct'"), true);
 	ctx.saveIdent(identElem.ident);
-	beginElem(ctx, "struct", attributes);
-	ctx.addElem(identElem);
 	expect(stream, "{", "struct name");
 	ctx.pushScope();
-	const members = parseStructMembers(ctx);
+	const members = parseCommaList(ctx, parseStructMember);
 	identElem.ident.dependentScope = ctx.currentScope();
 	ctx.popScope();
 	expect(stream, "}", "struct member");
-	const elem = finishElem("struct", start, ctx, {
+	const elem = finishStatement("struct", start, ctx, {
 		name: identElem,
 		members
-	});
-	attachAttributes(elem, attributes);
+	}, attributes);
 	linkDeclIdentElem(identElem, elem);
 	return elem;
 }
-/** Grammar: struct_body_decl : '{' struct_member (',' struct_member)* ','? '}' */
-function parseStructMembers(ctx) {
-	const members = parseCommaList(ctx, parseStructMember);
-	for (const member of members) ctx.addElem(member);
-	return members;
-}
 /** Grammar: struct_member : attribute* member_ident ':' type_specifier */
 function parseStructMember(ctx) {
 	const { stream } = ctx;
 	const checkpoint = stream.checkpoint();
-	const attributes = parseAttributeList(ctx);
+	const attrs = parseAttributeList(ctx);
 	const nameToken = stream.matchKind("word");
 	if (!nameToken) {
 		stream.reset(checkpoint);
 		return null;
 	}
+	const attributes = attrsOrUndef(attrs);
 	const start = getStartWithAttributes(attributes, nameToken.span[0]);
-	beginElem(ctx, "member", attributes.length ? attributes : void 0);
 	const name = makeNameElem(nameToken);
-	ctx.addElem(name);
 	expect(stream, ":", "struct member name");
 	const typeRef = parseSimpleTypeRef(ctx);
 	if (!typeRef) throwParseError(stream, "Expected type after ':'");
-	ctx.addElem(typeRef);
-	const elem = finishElem("member", start, ctx, {
+	return finishStatement("member", start, ctx, {
 		name,
 		typeRef
-	});
-	attachAttributes(elem, attributes.length ? attributes : void 0);
-	return elem;
+	}, attributes);
 }
 //#endregion
 //#region src/parse/ParseModule.ts
@@ -3077,6 +3784,7 @@ const declParsers = [
 	parseAliasDecl,
 	parseStructDecl,
 	parseFnDecl,
+	parseDoBlock,
 	parseConstAssert
 ];
 /** Grammar: translation_unit : global_directive* ( global_decl | global_assert | ';' )* */
@@ -3084,19 +3792,39 @@ function parseModule(ctx) {
 	parseImports(ctx);
 	parseDirectives(ctx);
 	while (parseNextDeclaration(ctx));
+	if (ctx.stream.peek() !== null) throwParseError(ctx.stream, "Expected a declaration or directive");
+}
+/**
+* Reject a module that gives a `do` block a name that clashes with a fn/global
+* or with another `do` block (`do` blocks share the module's declaration
+* namespace, and runners key blocks by name so a duplicate would silently
+* shadow the earlier one). This is a small module-local pass, deliberately not
+* part of bindIdents.
+*/
+function checkDoBlockNames(moduleElem) {
+	const doBlocks = declsOfKind(moduleElem, "do");
+	if (doBlocks.length === 0) return;
+	const declNames = new Set(moduleElem.decls.map(globalDeclName));
+	const seen = /* @__PURE__ */ new Set();
+	for (const block of doBlocks) {
+		const { name, start, end } = block.name;
+		if (declNames.has(name)) throw new ParseError(`'${name}' declared as both fn and do`, [start, end]);
+		if (seen.has(name)) throw new ParseError(`'${name}' declared as do more than once`, [start, end]);
+		seen.add(name);
+	}
 }
 /** Parse WESL import statements at the start of the module. */
 function parseImports(ctx) {
 	const importElems = parseWeslImports(ctx);
 	for (const importElem of importElems) {
-		ctx.addElem(importElem);
+		ctx.addModuleDecl(importElem);
 		ctx.state.stable.imports.push(importElem.imports);
 	}
 }
 /** Grammar: global_directive : diagnostic_directive | enable_directive | requires_directive */
 function parseDirectives(ctx) {
 	const directives = parseMany(ctx, parseDirective);
-	for (const elem of directives) ctx.addElem(elem);
+	for (const elem of directives) ctx.addModuleDecl(elem);
 }
 /** Parse one declaration, return true if more may exist. */
 function parseNextDeclaration(ctx) {
@@ -3111,34 +3839,40 @@ function parseNextDeclaration(ctx) {
 	if (attrs.length) throwParseError(stream, "Expected declaration after attributes");
 	return false;
 }
+/** @return the declared name of a module-level declaration, if it has one. */
+function globalDeclName(elem) {
+	switch (elem.kind) {
+		case "fn":
+		case "struct":
+		case "alias": return elem.name.ident.originalName;
+		case "gvar":
+		case "const":
+		case "override": return elem.name.decl.ident.originalName;
+		default: return;
+	}
+}
 /** Try each declaration parser until one succeeds. */
 function parseDecl(ctx, attrs) {
-	const attrsOrUndef = attrs.length ? attrs : void 0;
-	const elem = findMap(declParsers, (p) => p(ctx, attrsOrUndef));
-	if (elem) {
-		recordDecl(ctx, elem, attrs);
-		return true;
-	}
-	return false;
+	const elem = findMap(declParsers, (p) => p(ctx, attrsOrUndef(attrs)));
+	if (!elem) return false;
+	recordDecl(ctx, elem, attrs);
+	return true;
 }
 /** Pop conditional scope and attach the conditional attribute. */
 function finalizeConditional(ctx, attrs) {
 	const partialScope = ctx.popScope();
-	partialScope.condAttribute = findMap(attrs, ({ attribute }) => isConditionalAttribute(attribute) ? attribute : void 0);
+	partialScope.condAttribute = conditionalAttribute(attrs);
 }
 /** Record a parsed declaration, extending start to include attributes. */
 function recordDecl(ctx, elem, attrs) {
 	if (attrs.length && elem.start > attrs[0].start) elem.start = attrs[0].start;
-	ctx.addElem(elem);
+	ctx.addModuleDecl(elem);
 	if (elem.kind === "assert") {
 		const { stable } = ctx.state;
 		stable.moduleAsserts ??= [];
 		stable.moduleAsserts.push(elem);
 	}
 }
-function isConditionalAttribute(a) {
-	return a.kind === "@if" || a.kind === "@elif" || a.kind === "@else";
-}
 //#endregion
 //#region src/parse/ParsingContext.ts
 /** Context for parsers to build AST and manage scopes. */
@@ -3161,9 +3895,9 @@ var ParsingContext = class {
 	currentScope() {
 		return this.state.context.scope;
 	}
-	addElem(elem) {
-		const { openElems } = this.state.context;
-		if (openElems.length > 0) openElems[openElems.length - 1].contents.push(elem);
+	/** Append a top-level declaration to the module, in source order. */
+	addModuleDecl(elem) {
+		this.state.stable.moduleElem.decls.push(elem);
 	}
 	pushScope(kind = "scope") {
 		const { scope } = this.state.context;
@@ -3231,55 +3965,6 @@ const reservedWords = `NULL Self abstract active alignas alignof as asm asm_frag
   target template this thread_local throw trait try type typedef typeid typename typeof
   union unless unorm unsafe unsized use using varying virtual volatile wgsl where with writeonly yield`.split(/\s+/);
 //#endregion
-//#region src/parse/stream/CachingStream.ts
-var CachingStream = class {
-	cache = new Cache(5);
-	inner;
-	constructor(inner) {
-		this.inner = inner;
-	}
-	checkpoint() {
-		return this.inner.checkpoint();
-	}
-	reset(position) {
-		this.inner.reset(position);
-	}
-	nextToken() {
-		const startPos = this.checkpoint();
-		const cachedValue = this.cache.get(startPos);
-		if (cachedValue !== void 0) {
-			this.reset(cachedValue.checkpoint);
-			return cachedValue.token;
-		} else {
-			const token = this.inner.nextToken();
-			const checkpoint = this.checkpoint();
-			this.cache.set(startPos, {
-				token,
-				checkpoint
-			});
-			return token;
-		}
-	}
-	get src() {
-		return this.inner.src;
-	}
-};
-/** size limited key value cache */
-var Cache = class extends Map {
-	max;
-	constructor(max) {
-		super();
-		this.max = max;
-	}
-	set(k, v) {
-		if (this.size > this.max) {
-			const first = this.keys().next().value;
-			if (first) this.delete(first);
-		}
-		return super.set(k, v);
-	}
-};
-//#endregion
 //#region src/parse/stream/RegexHelpers.ts
 function toRegexSource(nameExp) {
 	const [name, e] = nameExp;
@@ -3309,33 +3994,10 @@ function matchOneOf(syms) {
 	return new RegExp(escaped.join("|"));
 }
 //#endregion
-//#region src/parse/stream/MatchersStream.ts
-/** Runs a `RegexMatchers` on an input string */
-var MatchersStream = class {
-	position = 0;
-	text;
-	matchers;
-	constructor(text, matchers) {
-		this.text = text;
-		this.matchers = matchers;
-	}
-	checkpoint() {
-		return this.position;
-	}
-	reset(position) {
-		this.position = position;
-	}
-	nextToken() {
-		const result = this.matchers.execAt(this.text, this.position);
-		if (result === null) return null;
-		this.position = result.span[1];
-		return result;
-	}
-	get src() {
-		return this.text;
-	}
-};
+//#region src/parse/stream/RegexMatchers.ts
 /**
+* Matches tokens by kind with one combined regex.
+*
 * The matchers passed to this object must follow certain rules:
 * - They must use non-capturing groups: `(?:...)`
 * - They must NOT use `^` or `$`
@@ -3346,55 +4008,230 @@ var RegexMatchers = class {
 	constructor(matchers) {
 		this.groups = Object.keys(matchers);
 		const expParts = Object.entries(matchers).map(toRegexSource).join("|");
-		this.exp = new RegExp(expParts, "dyu");
+		this.exp = new RegExp(expParts, "yu");
 	}
 	execAt(text, position) {
 		this.exp.lastIndex = position;
-		const matchedIndex = findGroupDex(this.exp.exec(text)?.indices);
-		if (matchedIndex) {
-			const { span, groupDex } = matchedIndex;
-			return {
-				kind: this.groups[groupDex],
-				span,
-				text: text.slice(span[0], span[1])
-			};
-		} else return null;
-	}
-};
-function findGroupDex(indices) {
-	if (indices !== void 0) for (let i = 1; i < indices.length; i++) {
-		const span = indices[i];
-		if (span !== void 0) return {
+		const matches = this.exp.exec(text);
+		if (matches === null) return null;
+		const matched = matches[0];
+		const span = [position, position + matched.length];
+		return {
+			kind: this.groups[matchedGroupIndex(matches)],
 			span,
-			groupDex: i - 1
+			text: matched
 		};
 	}
+};
+/** @return index of the alternation group that matched */
+function matchedGroupIndex(matches) {
+	for (let i = 1; i < matches.length; i++) if (matches[i] !== void 0) return i - 1;
+	throw new Error("no matching group");
 }
 //#endregion
-//#region src/parse/WeslStream.ts
+//#region src/parse/stream/WeslLexer.ts
+const ident = /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u;
 /** Whitespaces including new lines */
 const blankspaces = /[ \t\n\v\f\r\u{0085}\u{200E}\u{200F}\u{2028}\u{2029}]+/u;
-const symbolSet = "& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _";
-const ident = /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u;
-const keywordOrReserved = new Set(keywords.concat(reservedWords));
-const weslMatcher = new RegexMatchers({
+const digits = new RegExp(/(?:0[fh])|(?:[1-9][0-9]*[fh])/.source + /|(?:[0-9]*\.[0-9]+(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+\.[0-9]*(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+[eE][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]+[iu]?)/.source + /|(?:0[iu]?)|(?:[1-9][0-9]*[iu]?)/.source);
+/** Unicode-aware fallback for characters the ASCII fast path can't handle.
+*  lastIndex is set on every use, so sharing one instance is safe. */
+const unicodeMatcher = new RegexMatchers({
 	word: ident,
-	number: new RegExp(/(?:0[fh])|(?:[1-9][0-9]*[fh])/.source + /|(?:[0-9]*\.[0-9]+(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+\.[0-9]*(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+[eE][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]+[iu]?)/.source + /|(?:0[iu]?)|(?:[1-9][0-9]*[iu]?)/.source),
+	number: digits,
 	blankspaces,
 	commentStart: /\/\/|\/\*/,
-	symbol: matchOneOf(symbolSet),
+	symbol: matchOneOf("& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _"),
 	invalid: /[^]/
 });
+/**
+* Hand-written scanner for WESL/WGSL raw tokens.
+*
+* The common case is dispatched on ASCII char codes: whitespace is skipped
+* without producing tokens, and idents, numbers, symbols, and comment openers
+* are matched directly. Any character >= 0x80 (unicode idents, unicode
+* blankspace) falls back to the unicode-aware regex, so there is no up-front
+* scan and no unicode restriction.
+*/
+var WeslLexer = class {
+	position = 0;
+	/** sticky number matcher (stateful via lastIndex, so kept per-instance) */
+	numberExp = new RegExp(digits.source, "y");
+	src;
+	constructor(src) {
+		this.src = src;
+	}
+	checkpoint() {
+		return this.position;
+	}
+	reset(position) {
+		this.position = position;
+	}
+	nextToken() {
+		const { src } = this;
+		const len = src.length;
+		let pos = this.position;
+		while (pos < len) {
+			const c = src.charCodeAt(pos);
+			if (c === 32 || c >= 9 && c <= 13) pos++;
+			else break;
+		}
+		if (pos >= len) {
+			this.position = pos;
+			return null;
+		}
+		const c = src.charCodeAt(pos);
+		if (c >= 97 && c <= 122 || c >= 65 && c <= 90) return this.word(pos);
+		if (c >= 48 && c <= 57) return this.number(pos);
+		const n = src.charCodeAt(pos + 1);
+		switch (c) {
+			case 95:
+				if (isWordChar(n)) return this.word(pos);
+				if (n >= 128) return this.regexToken(pos);
+				return this.symbol(pos, "_");
+			case 47:
+				if (n === 47) return this.token("commentStart", pos, "//");
+				if (n === 42) return this.token("commentStart", pos, "/*");
+				if (n === 61) return this.symbol(pos, "/=");
+				return this.symbol(pos, "/");
+			case 46:
+				if (n >= 48 && n <= 57) return this.number(pos);
+				return this.symbol(pos, ".");
+			case 62:
+				if (n === 62) {
+					if (src.charCodeAt(pos + 2) === 61) return this.symbol(pos, ">>=");
+					return this.symbol(pos, ">>");
+				}
+				if (n === 61) return this.symbol(pos, ">=");
+				return this.symbol(pos, ">");
+			case 60:
+				if (n === 60) {
+					if (src.charCodeAt(pos + 2) === 61) return this.symbol(pos, "<<=");
+					return this.symbol(pos, "<<");
+				}
+				if (n === 61) return this.symbol(pos, "<=");
+				return this.symbol(pos, "<");
+			case 38:
+				if (n === 38) return this.symbol(pos, "&&");
+				if (n === 61) return this.symbol(pos, "&=");
+				return this.symbol(pos, "&");
+			case 124:
+				if (n === 124) return this.symbol(pos, "||");
+				if (n === 61) return this.symbol(pos, "|=");
+				return this.symbol(pos, "|");
+			case 45:
+				if (n === 62) return this.symbol(pos, "->");
+				if (n === 45) return this.symbol(pos, "--");
+				if (n === 61) return this.symbol(pos, "-=");
+				return this.symbol(pos, "-");
+			case 43:
+				if (n === 43) return this.symbol(pos, "++");
+				if (n === 61) return this.symbol(pos, "+=");
+				return this.symbol(pos, "+");
+			case 58:
+				if (n === 58) return this.symbol(pos, "::");
+				return this.symbol(pos, ":");
+			case 61:
+				if (n === 61) return this.symbol(pos, "==");
+				return this.symbol(pos, "=");
+			case 33:
+				if (n === 61) return this.symbol(pos, "!=");
+				return this.symbol(pos, "!");
+			case 42:
+				if (n === 47) return this.symbol(pos, "*/");
+				if (n === 61) return this.symbol(pos, "*=");
+				return this.symbol(pos, "*");
+			case 37:
+				if (n === 61) return this.symbol(pos, "%=");
+				return this.symbol(pos, "%");
+			case 94:
+				if (n === 61) return this.symbol(pos, "^=");
+				return this.symbol(pos, "^");
+			case 64: return this.symbol(pos, "@");
+			case 91: return this.symbol(pos, "[");
+			case 93: return this.symbol(pos, "]");
+			case 123: return this.symbol(pos, "{");
+			case 125: return this.symbol(pos, "}");
+			case 40: return this.symbol(pos, "(");
+			case 41: return this.symbol(pos, ")");
+			case 44: return this.symbol(pos, ",");
+			case 59: return this.symbol(pos, ";");
+			case 126: return this.symbol(pos, "~");
+		}
+		if (c >= 128) return this.regexToken(pos);
+		this.position = pos + 1;
+		return {
+			kind: "invalid",
+			span: [pos, pos + 1],
+			text: src[pos]
+		};
+	}
+	token(kind, start, text) {
+		const end = start + text.length;
+		this.position = end;
+		return {
+			kind,
+			span: [start, end],
+			text
+		};
+	}
+	symbol(start, text) {
+		return this.token("symbol", start, text);
+	}
+	word(start) {
+		const { src } = this;
+		const len = src.length;
+		let pos = start + 1;
+		while (pos < len) {
+			const c = src.charCodeAt(pos);
+			if (isWordChar(c)) pos++;
+			else if (c >= 128) return this.regexToken(start);
+			else break;
+		}
+		this.position = pos;
+		return {
+			kind: "word",
+			span: [start, pos],
+			text: src.slice(start, pos)
+		};
+	}
+	number(start) {
+		this.numberExp.lastIndex = start;
+		const text = this.numberExp.exec(this.src)[0];
+		return this.token("number", start, text);
+	}
+	/** match one token (or blankspace run) with the unicode-aware regex */
+	regexToken(start) {
+		const token = unicodeMatcher.execAt(this.src, start);
+		if (token === null) return null;
+		this.position = token.span[1];
+		return token;
+	}
+};
+function isWordChar(c) {
+	return c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 95;
+}
+//#endregion
+//#region src/parse/WeslStream.ts
+/** One line break, treating \r\n as a single break.
+*  Same code points as `isLineBreak` in AttachComments.ts (charCode form). */
+const lineBreak = String.raw`\r\n?|[\n\v\f\u{0085}\u{2028}\u{2029}]`;
+const keywordOrReserved = new Set(keywords.concat(reservedWords));
 /** A stream that produces WESL tokens, skipping over comments and white space */
 var WeslStream = class {
 	stream;
-	/** New line */
-	eolPattern = /[\n\v\f\u{0085}\u{2028}\u{2029}]|\r\n?/gu;
+	/** New line (stateful: scanned via lastIndex, so kept per-instance). */
+	eolPattern = new RegExp(lineBreak, "gu");
 	blockCommentPattern = /\/\*|\*\//g;
+	/** Comments skipped before a real token, keyed by that token's start position. */
+	triviaByPos = /* @__PURE__ */ new Map();
+	/** Last peeked token, so the following nextToken() skips the rescan.
+	*  Never invalidated: tokenization is deterministic per position. */
+	peeked = null;
 	src;
 	constructor(src) {
 		this.src = src;
-		this.stream = new CachingStream(new MatchersStream(src, weslMatcher));
+		this.stream = new WeslLexer(src);
 	}
 	checkpoint() {
 		return this.stream.checkpoint();
@@ -3402,27 +4239,79 @@ var WeslStream = class {
 	reset(position) {
 		this.stream.reset(position);
 	}
+	/** All recorded comment runs (each a contiguous group of comments between two
+	*  real tokens), in source order. Consumed by the post-parse comment pass. */
+	commentRuns() {
+		return [...this.triviaByPos.entries()].sort((a, b) => a[0] - b[0]).map(([, run]) => run);
+	}
+	recordTrivia(pos, pending) {
+		if (pending) this.triviaByPos.set(pos, pending);
+	}
+	/** Next real token (comments/blankspace skipped and recorded as trivia); null at EOF. */
 	nextToken() {
+		const peeked = this.usePeeked();
+		if (peeked !== null) return peeked.token;
+		let pending;
 		while (true) {
 			const token = this.stream.nextToken();
-			if (token === null) return null;
+			if (token === null) {
+				this.recordTrivia(this.src.length, pending);
+				return null;
+			}
 			const kind = token.kind;
 			if (kind === "blankspaces") continue;
-			else if (kind === "commentStart") if (token.text === "//") this.stream.reset(this.skipToEol(token.span[1]));
-			else this.stream.reset(this.skipBlockComment(token.span[1]));
-			else if (kind === "word") {
-				const returnToken = token;
-				if (keywordOrReserved.has(token.text)) returnToken.kind = "keyword";
-				return returnToken;
+			else if (kind === "commentStart") {
+				pending ??= [];
+				pending.push(this.consumeComment(token));
 			} else if (kind === "invalid") throw new ParseError("Invalid token " + token.text, token.span);
-			else return token;
+			else {
+				this.recordTrivia(token.span[0], pending);
+				const result = token;
+				if (kind === "word" && keywordOrReserved.has(token.text)) result.kind = "keyword";
+				return result;
+			}
+		}
+	}
+	/** If the last peek() was at the current position, consume and return it. */
+	usePeeked() {
+		const peeked = this.peeked;
+		if (peeked !== null && peeked.pos === this.checkpoint()) {
+			this.reset(peeked.end);
+			return peeked;
 		}
+		return null;
+	}
+	/** Skip a comment (rejecting embedded \0), advance the stream past it,
+	*  and return it as trivia. */
+	consumeComment(token) {
+		const style = token.text === "//" ? "line" : "block";
+		const start = token.span[0];
+		const end = this.commentEnd(token);
+		const bodyNull = this.src.slice(start, end).indexOf("\0");
+		if (bodyNull >= 0) {
+			const at = start + bodyNull;
+			throw new ParseError("Invalid token \\0", [at, at + 1]);
+		}
+		this.stream.reset(end);
+		return {
+			style,
+			start,
+			end
+		};
 	}
 	/** Peek at the next token without consuming it */
 	peek() {
 		const pos = this.checkpoint();
+		const peeked = this.peeked;
+		if (peeked !== null && peeked.pos === pos) return peeked.token;
 		const token = this.nextToken();
+		const end = this.checkpoint();
 		this.reset(pos);
+		this.peeked = {
+			pos,
+			token,
+			end
+		};
 		return token;
 	}
 	/** Consume token if text matches, otherwise leave position unchanged */
@@ -3466,10 +4355,15 @@ var WeslStream = class {
 		}
 		return tokens;
 	}
-	skipToEol(position) {
+	/** End position of a comment opened by a commentStart token. */
+	commentEnd(token) {
+		return token.text === "//" ? this.lineCommentEnd(token.span[1]) : this.skipBlockComment(token.span[1]);
+	}
+	/** End of a line comment: the start of the next line break (or end of file). */
+	lineCommentEnd(position) {
 		this.eolPattern.lastIndex = position;
-		if (this.eolPattern.exec(this.src) === null) return this.src.length;
-		else return this.eolPattern.lastIndex;
+		const result = this.eolPattern.exec(this.src);
+		return result === null ? this.src.length : result.index;
 	}
 	skipBlockComment(start) {
 		let position = start;
@@ -3491,39 +4385,46 @@ var WeslStream = class {
 		const startPosition = this.stream.checkpoint();
 		const token = this.nextToken();
 		this.stream.reset(startPosition);
-		if (token === null) return null;
-		if (token.kind !== "symbol") return null;
-		if (token.text === "<") if (this.isTemplateStart(token.span[1])) {
-			this.stream.reset(token.span[1]);
-			return token;
-		} else {
+		if (token === null || token.kind !== "symbol" || token.text !== "<") return null;
+		if (!this.isTemplateStart(token.span[1])) {
 			this.stream.reset(startPosition);
 			return null;
 		}
-		else return null;
+		this.stream.reset(token.span[1]);
+		return token;
 	}
+	/** Match a template-closing `>`, splitting it off a `>>`/`>=`/`>>=` token when needed. */
 	nextTemplateEndToken() {
 		const startPosition = this.stream.checkpoint();
 		const token = this.nextToken();
 		this.stream.reset(startPosition);
 		if (token === null) return null;
-		if (token.kind === "symbol" && token.text[0] === ">") {
-			const tokenPosition = token.span[0];
-			this.stream.reset(tokenPosition + 1);
-			return {
-				kind: "symbol",
-				span: [tokenPosition, tokenPosition + 1],
-				text: ">"
-			};
-		} else return null;
+		if (token.kind !== "symbol" || token.text[0] !== ">") return null;
+		const tokenPosition = token.span[0];
+		this.stream.reset(tokenPosition + 1);
+		return {
+			kind: "symbol",
+			span: [tokenPosition, tokenPosition + 1],
+			text: ">"
+		};
+	}
+	/** Next symbol from the raw stream, skipping comment bodies (so symbols
+	*  inside comments don't count) and non-symbol tokens; null at EOF. */
+	nextRawSymbol() {
+		while (true) {
+			const token = this.stream.nextToken();
+			if (token === null) return null;
+			if (token.kind === "commentStart") this.stream.reset(this.commentEnd(token));
+			else if (token.kind === "symbol") return token;
+		}
 	}
+	/** Template-list discovery: scan forward from `<` for a balanced closing `>`. */
 	isTemplateStart(afterToken) {
 		this.stream.reset(afterToken);
 		let pendingCounter = 1;
 		while (true) {
-			const nextToken = this.stream.nextToken();
+			const nextToken = this.nextRawSymbol();
 			if (nextToken === null) return false;
-			if (nextToken.kind !== "symbol") continue;
 			if (nextToken.text === "<") pendingCounter += 1;
 			else if (nextToken.text[0] === ">") {
 				if (nextToken.text === ">" || nextToken.text === ">=") pendingCounter -= 1;
@@ -3541,12 +4442,11 @@ var WeslStream = class {
 	*/
 	skipBracketsTo(closingBracket) {
 		while (true) {
-			const nextToken = this.stream.nextToken();
+			const nextToken = this.nextRawSymbol();
 			if (nextToken === null) {
 				const after = this.stream.checkpoint();
 				throw new ParseError("Unclosed bracket!", [after, after]);
 			}
-			if (nextToken.kind !== "symbol") continue;
 			if (nextToken.text === "(") this.skipBracketsTo(")");
 			else if (nextToken.text === "[") this.skipBracketsTo("]");
 			else if (nextToken.text === closingBracket) return;
@@ -3559,10 +4459,10 @@ var WeslStream = class {
 function parseWesl(srcModule, options) {
 	const { ctx, state } = createParseState(srcModule, options);
 	try {
-		beginElem(ctx, "module");
 		parseModule(ctx);
-		const moduleElem = state.stable.moduleElem;
-		moduleElem.contents = finishContents(ctx, 0, moduleElem.end);
+		const { moduleElem } = state.stable;
+		attachComments(ctx, moduleElem);
+		checkDoBlockNames(moduleElem);
 		return state.stable;
 	} catch (e) {
 		if (e instanceof ParseError) throw new WeslParseError({
@@ -3576,29 +4476,27 @@ function parseWesl(srcModule, options) {
 	}
 }
 /** Initialize parse state: token stream, root scope, and module element. */
-function createParseState(srcModule, options) {
+function createParseState(srcModule, parseOptions) {
 	const stream = new WeslStream(srcModule.src);
 	const rootScope = emptyScope(null);
 	const moduleElem = {
 		kind: "module",
-		contents: [],
+		decls: [],
 		start: 0,
 		end: srcModule.src.length
 	};
 	const state = {
-		context: {
-			scope: rootScope,
-			openElems: []
-		},
+		context: { scope: rootScope },
 		stable: {
 			srcModule,
 			moduleElem,
 			rootScope,
-			imports: []
+			imports: [],
+			parseOptions
 		}
 	};
 	return {
-		ctx: new ParsingContext(stream, state, options),
+		ctx: new ParsingContext(stream, state, parseOptions),
 		state
 	};
 }
@@ -3609,14 +4507,14 @@ var WeslParseError = class extends Error {
 	span;
 	src;
 	constructor(opts) {
-		const source = opts.src.src;
-		const [lineNum, linePos] = offsetToLineNumber(opts.cause.span[0], source);
-		let message = `${opts.src.debugFilePath}:${lineNum}:${linePos}`;
-		message += ` error: ${opts.cause.message}\n`;
-		message += errorHighlight(source, opts.cause.span).join("\n");
-		super(message, { cause: opts.cause });
-		this.span = opts.cause.span;
-		this.src = opts.src;
+		const { cause, src } = opts;
+		const source = src.src;
+		const [lineNum, linePos] = offsetToLineNumber(cause.span[0], source);
+		const highlight = errorHighlight(source, cause.span).join("\n");
+		const message = `${src.debugFilePath}:${lineNum}:${linePos} error: ${cause.message}\n${highlight}`;
+		super(message, { cause });
+		this.span = cause.span;
+		this.src = src;
 	}
 };
 /** Parse a WESL file. */
@@ -3626,8 +4524,8 @@ function parseSrcModule(srcModule, options) {
 /** @return flattened form of import tree for binding idents. */
 function flatImports(ast, conditions) {
 	if (ast._flatImports && !conditions) return ast._flatImports;
-	const importElems = ast.moduleElem.contents.filter((elem) => elem.kind === "import");
-	const flat = (conditions ? filterValidElements(importElems, conditions) : importElems).map((elem) => elem.imports).flatMap(flattenTreeImport);
+	const importElems = declsOfKind(ast.moduleElem, "import");
+	const flat = (conditions ? filterValidElements(importElems, conditions) : importElems).flatMap((elem) => flattenTreeImport(elem.imports));
 	if (!conditions) ast._flatImports = flat;
 	return flat;
 }
@@ -3924,11 +4822,13 @@ var RecordResolver = class {
 	sources;
 	packageName;
 	debugWeslRoot;
+	weslExtensions;
 	constructor(sources, options = {}) {
-		const { packageName = "package", debugWeslRoot } = options;
+		const { packageName = "package", debugWeslRoot, weslExtensions } = options;
 		this.sources = sources;
 		this.packageName = packageName;
 		this.debugWeslRoot = normalizeDebugRoot(debugWeslRoot);
+		this.weslExtensions = weslExtensions;
 	}
 	resolveModule(modulePath) {
 		const cached = this.astCache.get(modulePath);
@@ -3939,7 +4839,7 @@ var RecordResolver = class {
 			modulePath,
 			debugFilePath: this.modulePathToDebugPath(modulePath),
 			src: source
-		});
+		}, { weslExtensions: this.weslExtensions });
 		this.astCache.set(modulePath, ast);
 		return ast;
 	}
@@ -4035,7 +4935,7 @@ function freshResolver(inner) {
 		if (cached) return cached;
 		const ast = inner.resolveModule(modulePath);
 		if (!ast) return void 0;
-		const fresh = parseSrcModule(ast.srcModule);
+		const fresh = parseSrcModule(ast.srcModule, ast.parseOptions);
 		cache.set(modulePath, fresh);
 		return fresh;
 	} };
@@ -4359,12 +5259,13 @@ var SrcMap = class SrcMap {
 			const { src, position: srcStart } = this.destToSrc(e.srcStart);
 			const { src: endSrc, position: srcEnd } = this.destToSrc(e.srcEnd);
 			if (endSrc !== src) throw new Error("NYI, need to split");
+			const { destStart, destEnd } = e;
 			return {
 				src,
 				srcStart,
 				srcEnd,
-				destStart: e.destStart,
-				destEnd: e.destEnd
+				destStart,
+				destEnd
 			};
 		});
 		const otherSources = other.entries.filter((e) => e.src.path !== this.dest.path || e.src.text !== this.dest.text);
@@ -4385,10 +5286,6 @@ var SrcMap = class SrcMap {
 		};
 	}
 };
-/** sort entries in place by src start position */
-function sortSrc(entries) {
-	entries.sort((a, b) => a.srcStart - b.srcStart);
-}
 /** Incrementally append to a string, tracking source references */
 var SrcMapBuilder = class {
 	#fragments = [];
@@ -4442,11 +5339,6 @@ var SrcMapBuilder = class {
 		};
 		this.add("\n", srcStart, srcEnd);
 	}
-	/** copy a string fragment from the src to the destination string */
-	addCopy(srcStart, srcEnd) {
-		const fragment = this.source.text.slice(srcStart, srcEnd);
-		this.add(fragment, srcStart, srcEnd);
-	}
 	/** return a SrcMap */
 	static build(builders) {
 		const map = new SrcMap({ text: builders.map((b) => b.#fragments.join("")).join("") }, builders.flatMap((b) => b.#entries));
@@ -4454,6 +5346,10 @@ var SrcMapBuilder = class {
 		return map;
 	}
 };
+/** sort entries in place by src start position */
+function sortSrc(entries) {
+	entries.sort((a, b) => a.srcStart - b.srcStart);
+}
 //#endregion
 //#region src/Linker.ts
 /**
@@ -4471,10 +5367,12 @@ async function link(params) {
 /** linker api for benchmarking */
 function _linkSync(params) {
 	const { weslSrc, libs = [], packageName, debugWeslRoot, resolver } = params;
+	const { weslExtensions } = params;
 	if (!resolver && !weslSrc) throw new Error("Either resolver or weslSrc must be provided");
 	const allResolvers = [resolver ?? new RecordResolver(weslSrc, {
 		packageName,
-		debugWeslRoot
+		debugWeslRoot,
+		weslExtensions
 	}), ...createLibraryResolvers(libs, debugWeslRoot)];
 	const finalResolver = allResolvers.length === 1 ? allResolvers[0] : new CompositeResolver(allResolvers);
 	return linkRegistry({
@@ -4607,264 +5505,6 @@ function builderFromModule(srcModule) {
 	});
 }
 //#endregion
-//#region src/LinkerUtil.ts
-function visitAst(elem, visitor) {
-	visitor(elem);
-	if (elem.contents) elem.contents.forEach((child) => {
-		visitAst(child, visitor);
-	});
-}
-//#endregion
-//#region src/RawEmit.ts
-function attributeToString$1(e) {
-	const { kind } = e.attribute;
-	if (kind === "@attribute") {
-		const { params } = e.attribute;
-		if (params === void 0 || params.length === 0) return "@" + e.attribute.name;
-		else return `@${e.attribute.name}(${params.map((param) => contentsToString(param)).join(", ")})`;
-	} else if (kind === "@builtin") return "@builtin(" + e.attribute.param.name + ")";
-	else if (kind === "@diagnostic") return "@diagnostic" + diagnosticControlToString(e.attribute.severity, e.attribute.rule);
-	else if (kind === "@if") return `@if(${expressionToString(e.attribute.param.expression)})`;
-	else if (kind === "@elif") return `@elif(${expressionToString(e.attribute.param.expression)})`;
-	else if (kind === "@else") return "@else";
-	else if (kind === "@interpolate") return `@interpolate(${e.attribute.params.map((v) => v.name).join(", ")})`;
-	else assertUnreachable(kind);
-}
-function typeListToString(params) {
-	return `<${params.map(typeParamToString).join(", ")}>`;
-}
-function typeParamToString(param) {
-	if (param === void 0) return "?";
-	if (param.kind === "type") return typeRefToString(param);
-	return expressionToString(param);
-}
-function typeRefToString(t) {
-	if (!t) return "?";
-	const { name, templateParams } = t;
-	const params = templateParams ? typeListToString(templateParams) : "";
-	return `${refToString(name)}${params}`;
-}
-function refToString(ref) {
-	if (typeof ref === "string") return ref;
-	if (ref.std) return ref.originalName;
-	const decl = findDecl(ref);
-	return decl.mangledName || decl.originalName;
-}
-function contentsToString(elem) {
-	if (elem.kind === "translate-time-expression") throw new Error("Not supported");
-	else if (elem.kind === "expression" || elem.kind === "stuff") return elem.contents.map((c) => {
-		const { kind } = c;
-		if (kind === "text") return c.srcModule.src.slice(c.start, c.end);
-		else if (kind === "ref") return refToString(c.ident);
-		else return `?${c.kind}?`;
-	}).join(" ");
-	else if (elem.kind === "name") return elem.name;
-	else assertUnreachable(elem);
-}
-//#endregion
-//#region src/Reflection.ts
-const textureStorage = matchOneOf(textureStorageTypes);
-matchOneOf(sampledTextureTypes);
-matchOneOf(multisampledTextureTypes);
-//#endregion
-//#region src/TransformBindingStructs.ts
-function bindingStructsPlugin() {
-	return { transform: lowerBindingStructs };
-}
-/**
-* Transform binding structures into binding variables by mutating the AST.
-*
-* First we find all the binding structs:
-*   . find all the structs in the module by filtering the moduleElem.contents
-*     . for each struct:
-*       . mark any structs with that contain @group or @binding annotations as 'binding structs' and save them in a list
-*       . (later) create reverse links from structs to struct members
-*       . (later) visit all the binding structs and traverse to referencing structs, marking the referencing structs as binding structs too
-* Generate synethic AST nodes for binding variables
-*
-* Find all references to binding struct members
-*   . find the componound idents by traversing moduleElem.contents
-*   . filter to find the compound idents that refer to 'binding structs'
-*     . go from each ident to its declaration,
-*     . declaration to typeRef reference
-*     . typeRef to type declaration
-*     . check type declaration to see if it's a binding struct
-*     . record the intermediate declaration (e.g. a fn param b:Bindings from 'fn(b:Bindings)' )
-* rewrite references to binding struct members as synthetic elements
-*
-* Remove the binding structs from the AST
-* Remove the intermediate fn param declarations from the AST
-* Add the new binding variables to the AST
-*
-* @return the binding structs and the mutated AST
-*/
-function lowerBindingStructs(ast) {
-	const clonedAst = structuredClone(ast);
-	const { moduleElem, globalNames, notableElems } = clonedAst;
-	const bindingStructs = markBindingStructs(moduleElem);
-	markEntryTypes(moduleElem, bindingStructs);
-	const newVars = bindingStructs.flatMap((s) => transformBindingStruct(s, globalNames));
-	const bindingRefs = findRefsToBindingStructs(moduleElem);
-	bindingRefs.forEach(({ memberRef, struct }) => {
-		transformBindingReference(memberRef, struct);
-	});
-	bindingRefs.forEach(({ intermediates }) => {
-		intermediates.forEach((e) => {
-			e.contents = [];
-		});
-	});
-	const contents = removeBindingStructs(moduleElem);
-	moduleElem.contents = [...newVars, ...contents];
-	notableElems.bindingStructs = bindingStructs;
-	return {
-		...clonedAst,
-		moduleElem
-	};
-}
-function markEntryTypes(moduleElem, bindingStructs) {
-	const fnFound = fnReferencesBindingStruct(moduleElem.contents.filter((e) => e.kind === "fn"), bindingStructs);
-	if (fnFound) {
-		const { fn, struct } = fnFound;
-		struct.entryFn = fn;
-	}
-}
-function fnReferencesBindingStruct(fns, bindingStructs) {
-	for (const fn of fns) {
-		const { params } = fn;
-		for (const p of params) {
-			const referencedElem = ((p.name?.typeRef?.name)?.refersTo)?.declElem;
-			const struct = bindingStructs.find((s) => s === referencedElem);
-			if (struct) return {
-				fn,
-				struct
-			};
-		}
-	}
-}
-function removeBindingStructs(moduleElem) {
-	return moduleElem.contents.filter((elem) => elem.kind !== "struct" || !elem.bindingStruct);
-}
-/** mutate the AST, marking StructElems as bindingStructs
-*  (if they contain ptrs with @group @binding annotations)
-* @return the binding structs
-*/
-function markBindingStructs(moduleElem) {
-	const bindingStructs = moduleElem.contents.filter((elem) => elem.kind === "struct").filter(containsBinding);
-	bindingStructs.forEach((struct) => {
-		struct.bindingStruct = true;
-	});
-	return bindingStructs;
-}
-/** @return true if this struct contains a member with marked with @binding or @group */
-function containsBinding(struct) {
-	return struct.members.some(({ attributes }) => bindingAttribute(attributes));
-}
-function bindingAttribute(attributes) {
-	if (!attributes) return false;
-	return attributes.some(({ attribute }) => attribute.kind === "@attribute" && (attribute.name === "binding" || attribute.name === "group"));
-}
-/** convert each member of the binding struct into a synthetic global variable */
-function transformBindingStruct(s, globalNames) {
-	return s.members.map((member) => {
-		const { typeRef, name: memberName } = member;
-		const { name: typeName } = typeRef;
-		const typeParameters = typeRef?.templateParams;
-		const varName = minimallyMangledName(memberName.name, globalNames);
-		member.mangledVarName = varName;
-		globalNames.add(varName);
-		const attributes = member.attributes?.map(attributeToString$1).join(" ") ?? "";
-		const varTypes = lowerPtrMember(typeName, typeParameters) ?? lowerStdTypeMember(typeName, typeParameters) ?? lowerStorageTextureMember(typeName, typeParameters);
-		if (!varTypes) {
-			console.log("unhandled case transforming member", typeName);
-			return syntheticVar(attributes, varName, "", "??");
-		}
-		const { storage: storageType, varType } = varTypes;
-		return syntheticVar(attributes, varName, storageType, varType);
-	});
-}
-function lowerPtrMember(typeName, typeParameters) {
-	if (typeName.originalName === "ptr") {
-		const origParams = typeParameters ?? [];
-		const newParams = [origParams[0]];
-		if (origParams[2]) newParams.push(origParams[2]);
-		return {
-			storage: typeListToString(newParams),
-			varType: typeParamToString(origParams?.[1])
-		};
-	}
-}
-function lowerStdTypeMember(typeName, typeParameters) {
-	if (typeof typeName !== "string") return {
-		varType: (typeName.std ? typeName.originalName : "??") + (typeParameters ? typeListToString(typeParameters) : ""),
-		storage: ""
-	};
-}
-function lowerStorageTextureMember(typeName, typeParameters) {
-	if (textureStorage.test(typeName.originalName)) return {
-		varType: typeName + (typeParameters ? typeListToString(typeParameters) : ""),
-		storage: ""
-	};
-}
-function syntheticVar(attributes, varName, storageTemplate, varType) {
-	return {
-		kind: "synthetic",
-		text: `${attributes} var${storageTemplate} ${varName} : ${varType};\n`
-	};
-}
-/** find all simple member references in the module that refer to binding structs */
-function findRefsToBindingStructs(moduleElem) {
-	const members = [];
-	visitAst(moduleElem, (elem) => {
-		if (elem.kind === "memberRef") members.push(elem);
-	});
-	return filterMap(members, refersToBindingStruct);
-}
-/** @return true if this memberRef refers to a binding struct */
-function refersToBindingStruct(memberRef) {
-	const found = traceToStruct(memberRef.name.ident);
-	if (found?.struct.bindingStruct) return {
-		memberRef,
-		...found
-	};
-}
-/** If this identifier ultimately refers to a struct type, return the struct declaration */
-function traceToStruct(ident) {
-	const declElem = findDecl(ident).declElem;
-	if (declElem && declElem.kind === "param") {
-		const name = declElem.name.typeRef?.name;
-		if (typeof name !== "string") {
-			if (name?.std) return;
-			const structElem = findDecl(name).declElem;
-			if (structElem?.kind === "struct") return {
-				struct: structElem,
-				intermediates: [declElem]
-			};
-			return;
-		}
-	}
-}
-/** Mutate the member reference elem to instead contain synthetic elem text.
-* The new text is the mangled var name of the struct member that the memberRef refers to. */
-function transformBindingReference(memberRef, struct) {
-	const refName = memberRef.member.name;
-	const structMember = struct.members.find((m) => m.name.name === refName);
-	if (!structMember || !structMember.mangledVarName) {
-		console.log(`missing mangledVarName for ${refName}`);
-		return {
-			kind: "synthetic",
-			text: refName
-		};
-	}
-	const { extraComponents } = memberRef;
-	const extraText = extraComponents ? contentsToString(extraComponents) : "";
-	const synthElem = {
-		kind: "synthetic",
-		text: structMember.mangledVarName + extraText
-	};
-	memberRef.contents = [synthElem];
-	return synthElem;
-}
-//#endregion
 //#region src/WeslDevice.ts
 /**
 * Creates {@link WeslDevice} for usage with WESL.
@@ -4933,4 +5573,4 @@ function makeWeslDevice(device) {
 	return device;
 }
 //#endregion
-export { BundleResolver, CompositeResolver, LinkedWesl, ParseError, RecordResolver, SrcMap, SrcMapBuilder, TrackingResolver, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, discoverModules, emptyScope, errorHighlight, fileToModulePath, filterMap, filterValidElements, findAllRootDecls, findMap, findRefsToBindingStructs, findUnboundIdents, findUnboundRefs, findValidRootDecls, flatImports, freshResolver, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, wgslStandardAttributes, withLoggerAsync };
+export { BundleResolver, CompositeResolver, LinkedWesl, ParseError, RecordResolver, SrcMap, SrcMapBuilder, TrackingResolver, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, childElems, childIdent, childScope, containsScope, debug, declsOfKind, discoverModules, emptyScope, errorHighlight, fileToModulePath, filterMap, filterValidElements, findAllRootDecls, findMap, findUnboundIdents, findUnboundRefs, findValidRootDecls, flatImports, freshResolver, groupBy, grouped, identElemLog, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, makeLiveDecls, makeWeslDevice, mapForward, mapValues, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, underscoreMangle, validation, visitAst, wgslStandardAttributes, withLoggerAsync };