wgsl-play 0.1.0 → 0.1.2

package/dist/wgsl-play.js

@@ -630,6 +630,112 @@ function emptyScope(parent, kind = "scope") {
 	};
 }
 //#endregion
+//#region ../wesl/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);
+}
+/**
+* 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)];
+}
+/** 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 ../wesl/src/StandardTypes.ts
 const stdFns = `bitcast all any select arrayLength 
   abs acos acosh asin asinh atan atanh atan2 ceil clamp cos cosh 
@@ -660,17 +766,6 @@ const stdFns = `bitcast all any select arrayLength
   subgroupInclusiveMul subgroupMax subgroupMin subgroupMul subgroupOr 
   subgroupShuffle subgroupShuffleUp subgroupShuffleXor subgroupXor
   quadBroadcast quadSwapDiagonal quadSwapX quadSwapY`.split(/\s+/);
-const sampledTextureTypes = `
-  texture_1d texture_2d texture_2d_array texture_3d 
-  texture_cube texture_cube_array
-`;
-const multisampledTextureTypes = `
-  texture_multisampled_2d texture_depth_multisampled_2d
-`;
-const textureStorageTypes = `
-  texture_storage_1d texture_storage_2d texture_storage_2d_array 
-  texture_storage_3d
-`;
 const stdTypes = `array atomic bool f16 f32 i32 
   mat2x2 mat2x3 mat2x4 mat3x2 mat3x3 mat3x4 mat4x2 mat4x3 mat4x4
   mat2x2f mat2x3f mat2x4f mat3x2f mat3x3f mat3x4f
@@ -680,10 +775,18 @@ const stdTypes = `array atomic bool f16 f32 i32
   u32 vec2 vec3 vec4 ptr
   vec2i vec3i vec4i vec2u vec3u vec4u
   vec2f vec3f vec4f vec2h vec3h vec4h
-  ${sampledTextureTypes}
-  ${multisampledTextureTypes}
+  
+  texture_1d texture_2d texture_2d_array texture_3d 
+  texture_cube texture_cube_array
+
+  
+  texture_multisampled_2d texture_depth_multisampled_2d
+
   texture_external
-  ${textureStorageTypes}
+  
+  texture_storage_1d texture_storage_2d texture_storage_2d_array 
+  texture_storage_3d
+
   texture_depth_2d texture_depth_2d_array texture_depth_cube
   texture_depth_cube_array
   sampler sampler_comparison
@@ -731,6 +834,22 @@ function stdEnumerant(name) {
 }
 //#endregion
 //#region ../wesl/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;
@@ -738,17 +857,30 @@ 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})`;
+}
+/** 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;
@@ -771,24 +903,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":
@@ -800,52 +953,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);
 }
-function emitStatement(e, ctx) {
-	if (!(e.contents.length > 0 && e.contents[0].kind === "attribute")) emitAttributes(e.attributes, ctx);
-	emitContents(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);
+}
+/** 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) {
@@ -853,27 +1085,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) {
@@ -887,125 +1127,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;
@@ -1015,11 +1152,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;
 	}
@@ -1030,24 +1169,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 emitDirective(e, ctx) {
 	const { directive } = e;
 	const { kind } = directive;
@@ -1069,14 +1190,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 ../wesl/src/debug/ScopeToString.ts
@@ -1188,53 +1646,184 @@ var ParseError = class extends Error {
 	}
 };
 //#endregion
-//#region ../wesl/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 ../wesl/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 ../wesl/src/parse/ExpressionUtil.ts
@@ -1248,9 +1837,11 @@ function makeLiteral(token) {
 	};
 }
 function makeUnaryOperator(token) {
+	const [start, end] = token.span;
 	return {
 		value: token.text,
-		span: token.span
+		start,
+		end
 	};
 }
 function makeBinaryOperator(token) {
@@ -1260,12 +1851,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
 	};
 }
@@ -1326,13 +1916,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;
@@ -1388,18 +1981,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;
@@ -1542,10 +2144,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). */
@@ -1567,19 +2166,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");
@@ -1594,8 +2194,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 ../wesl/src/parse/ParseCall.ts
@@ -1606,7 +2206,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) {
@@ -1771,8 +2371,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. */
@@ -1799,7 +2398,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 ../wesl/src/parse/ParseAttribute.ts
@@ -1820,6 +2421,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 ?
@@ -1830,15 +2445,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) {
@@ -1847,13 +2455,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 {
@@ -1870,19 +2480,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) {
@@ -1892,7 +2496,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;
 	}
@@ -1915,22 +2519,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");
@@ -1951,9 +2539,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;
@@ -1975,78 +2560,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 ../wesl/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 ../wesl/src/parse/ParseControlFlow.ts
@@ -2057,37 +2584,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+ '}'
@@ -2097,27 +2637,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
@@ -2125,16 +2681,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 ../wesl/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) {
@@ -2145,20 +2700,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. */
@@ -2168,43 +2719,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 {
@@ -2224,17 +2761,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;
 }
@@ -2244,23 +2783,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;
 }
@@ -2269,25 +2804,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
@@ -2309,18 +2848,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;
 }
@@ -2349,17 +2890,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' ';'
@@ -2368,70 +2934,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 ../wesl/src/parse/ParseLoop.ts
@@ -2445,41 +3020,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
@@ -2487,19 +3069,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 ../wesl/src/parse/ParseStatement.ts
@@ -2515,17 +3138,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;
 }
@@ -2533,16 +3156,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;
 }
@@ -2552,16 +3179,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 :
@@ -2582,7 +3211,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,
@@ -2596,19 +3224,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 ../wesl/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;
 }
-function finalizeConditional$1(ctx, hasConditional, attributes) {
-	if (hasConditional) {
-		const partialScope = ctx.popScope();
-		partialScope.condAttribute = getConditionalAttribute(attributes);
-	}
+/** 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 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 ../wesl/src/parse/ParseFn.ts
@@ -2645,8 +3325,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);
@@ -2676,37 +3355,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 ../wesl/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 ../wesl/src/parse/ParseImport.ts
 /** WESL Grammar: translation_unit : import_statement* global_directive* global_decl* */
 function parseWeslImports(ctx) {
@@ -2844,52 +3549,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 ../wesl/src/parse/ParseModule.ts
@@ -2900,6 +3592,7 @@ const declParsers = [
 	parseAliasDecl,
 	parseStructDecl,
 	parseFnDecl,
+	parseDoBlock,
 	parseConstAssert
 ];
 /** Grammar: translation_unit : global_directive* ( global_decl | global_assert | ';' )* */
@@ -2907,19 +3600,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) {
@@ -2934,34 +3647,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 ../wesl/src/parse/ParsingContext.ts
 /** Context for parsers to build AST and manage scopes. */
@@ -2984,9 +3703,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;
@@ -3054,55 +3773,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 ../wesl/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 ../wesl/src/parse/stream/RegexHelpers.ts
 function toRegexSource(nameExp) {
 	const [name, e] = nameExp;
@@ -3132,33 +3802,10 @@ function matchOneOf(syms) {
 	return new RegExp(escaped.join("|"));
 }
 //#endregion
-//#region ../wesl/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 ../wesl/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 `$`
@@ -3169,55 +3816,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 ../wesl/src/parse/WeslStream.ts
+//#region ../wesl/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 ../wesl/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();
@@ -3225,27 +4047,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 */
@@ -3289,10 +4163,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;
@@ -3314,39 +4193,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;
@@ -3364,12 +4250,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;
@@ -3382,10 +4267,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({
@@ -3399,29 +4284,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
 	};
 }
@@ -3432,14 +4315,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. */
@@ -3449,8 +4332,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;
 }
@@ -3747,11 +4630,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);
@@ -3762,7 +4647,7 @@ var RecordResolver = class {
 			modulePath,
 			debugFilePath: this.modulePathToDebugPath(modulePath),
 			src: source
-		});
+		}, { weslExtensions: this.weslExtensions });
 		this.astCache.set(modulePath, ast);
 		return ast;
 	}
@@ -4095,12 +4980,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);
@@ -4121,10 +5007,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 = [];
@@ -4178,11 +5060,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));
@@ -4190,6 +5067,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 ../wesl/src/Linker.ts
 /**
@@ -4207,10 +5088,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({
@@ -4342,9 +5225,6 @@ function builderFromModule(srcModule) {
 		path: srcModule.debugFilePath
 	});
 }
-matchOneOf(textureStorageTypes);
-matchOneOf(sampledTextureTypes);
-matchOneOf(multisampledTextureTypes);
 //#endregion
 //#region ../wesl/src/WeslDevice.ts
 /**
@@ -4696,7 +5576,7 @@ async function fetchDependencies(rootModuleSource, options) {
 	const existingSources = options?.existingSources;
 	const fetchLibs = options?.fetchLibs ?? true;
 	const fetchSources = options?.fetchSources ?? true;
-	const rootModuleName = currentPath ? urlToModulePath(currentPath, shaderRoot) : "package::main";
+	const rootModuleName = options?.rootModuleName ?? (currentPath ? urlToModulePath(currentPath, shaderRoot) : "package::main");
 	const resolver = new FetchingResolver({
 		...existingSources,
 		[rootModuleName]: rootModuleSource
@@ -4850,24 +5730,33 @@ function findAnnotation(elem, name) {
 		if (attr.kind === "@attribute" && attr.name === name) return attr;
 	}
 }
-/** Extract string params from an annotation's UnknownExpressionElem params. */
+/** The string value of each of an annotation's params. */
 function annotationParams(attr) {
-	if (!attr.params) return [];
-	return attr.params.map((expr) => exprToString(expr.contents));
+	return attr.params?.map((param) => exprToString(param.expression)) ?? [];
 }
-/** Extract the string value from an expression's contents. */
-function exprToString(contents) {
-	for (const child of contents) {
-		if (child.kind === "literal") return child.value;
-		if (child.kind === "name") return child.name;
-		if (child.kind === "ref") return child.ident.originalName;
-		if (child.kind === "text") return child.srcModule.src.slice(child.start, child.end);
-	}
+/** Extract numeric params from an annotation, parsing WGSL numeric literals
+*  (suffixes like `256u`/`1.5f`, digit separators, and hex). */
+function numericParams(attr) {
+	return annotationParams(attr).map(wgslNumber);
+}
+/** The originalName of an attribute parameter that is a bare identifier ref. */
+function firstRefName(param) {
+	const expr = param?.expression;
+	return expr?.kind === "ref" ? expr.ident.originalName : void 0;
+}
+/** Extract the string value of an attribute-parameter expression. */
+function exprToString(expr) {
+	if (expr.kind === "literal") return expr.value;
+	if (expr.kind === "ref") return expr.ident.originalName;
 	return "";
 }
-/** Extract numeric params from an annotation. */
-function numericParams(attr) {
-	return annotationParams(attr).map(Number);
+/** Convert a WGSL numeric literal's text to a number. Strips the `u`/`i`/`f`/`h`
+*  suffix (only `u`/`i` for hex, where `f`/`h` are digits) and `_` separators.
+*  Non-numeric text (e.g. an unresolved ref name) yields NaN. */
+function wgslNumber(text) {
+	const t = text.replace(/_/g, "");
+	if (/^[+-]?0[xX]/.test(t)) return Number(t.replace(/[uiUI]$/, ""));
+	return Number(t.replace(/[uifhUIFH]$/, ""));
 }
 //#endregion
 //#region ../wesl-reflect/src/WeslStructs.ts
@@ -4923,7 +5812,7 @@ function structLayout(struct, conditions, structs) {
 /** Build a StructRegistry from all top-level struct declarations in `ast`. */
 function buildStructRegistry(ast) {
 	const reg = /* @__PURE__ */ new Map();
-	for (const e of ast.moduleElem.contents) if (e.kind === "struct") reg.set(e.name.ident.originalName, e);
+	for (const e of declsOfKind(ast.moduleElem, "struct")) reg.set(e.name.ident.originalName, e);
 	return reg;
 }
 /** Resolve alignment and size for any host-shareable typeRef (primitive, array, or nested struct). */
@@ -5341,7 +6230,7 @@ function scalarSize(s) {
 	return s === "f16" ? 2 : 4;
 }
 function findGlobalVar(ast, varName) {
-	return ast.moduleElem.contents.find((e) => e.kind === "gvar" && e.name.decl.ident.originalName === varName);
+	return declsOfKind(ast.moduleElem, "gvar").find((g) => g.name.decl.ident.originalName === varName);
 }
 function parseAddressSpace(declText) {
 	const m = declText.match(/var\s*<\s*([a-z_]+)/);
@@ -5497,7 +6386,7 @@ function namedTypeShape(name, structs, varName) {
 function findAnnotatedResources(ast) {
 	const src = ast.srcModule.src;
 	const structs = buildStructRegistry(ast);
-	return ast.moduleElem.contents.filter((e) => e.kind === "gvar").flatMap((gvar) => discoverResource(gvar, src, structs));
+	return declsOfKind(ast.moduleElem, "gvar").flatMap((gvar) => discoverResource(gvar, src, structs));
 }
 /** Linker plugin that decorates @buffer/@test_texture/@sampler globals with
 *  @group(0) @binding(N) so they emit as bindable WGSL vars.
@@ -5506,8 +6395,7 @@ function findAnnotatedResources(ast) {
 function annotatedResourcesPlugin(resources, startBinding = 1) {
 	const bindingByName = new Map(resources.map((r, i) => [r.varName, startBinding + i]));
 	return { transform: (ast) => {
-		for (const elem of ast.moduleElem.contents) {
-			if (elem.kind !== "gvar") continue;
+		for (const elem of declsOfKind(ast.moduleElem, "gvar")) {
 			const varName = elem.name.decl.ident.originalName;
 			const binding = bindingByName.get(varName);
 			if (binding === void 0) continue;
@@ -5520,11 +6408,6 @@ function annotatedResourcesPlugin(resources, startBinding = 1) {
 				groupAttr,
 				bindingAttr
 			];
-			elem.contents = [
-				groupAttr,
-				bindingAttr,
-				...elem.contents
-			];
 		}
 		return ast;
 	} };
@@ -5533,7 +6416,7 @@ function annotatedResourcesPlugin(resources, startBinding = 1) {
 function discoverResource(gvar, src, structs) {
 	if (findAnnotation(gvar, "buffer")) return [discoverBuffer(gvar, src, structs)];
 	const textureAttr = findAnnotation(gvar, "test_texture");
-	if (textureAttr) return [discoverTexture(gvar, textureAttr, src)];
+	if (textureAttr) return [discoverTexture(gvar, textureAttr)];
 	const userTextureAttr = findAnnotation(gvar, "texture");
 	if (userTextureAttr) return [discoverUserTexture(gvar, userTextureAttr)];
 	const samplerAttr = findAnnotation(gvar, "sampler");
@@ -5571,7 +6454,6 @@ function makeStandardAttr(name, value, anchor) {
 		kind: "attribute",
 		start,
 		end,
-		contents: [],
 		attribute: {
 			kind: "@attribute",
 			name,
@@ -5579,12 +6461,12 @@ function makeStandardAttr(name, value, anchor) {
 				kind: "expression",
 				start,
 				end,
-				contents: [{
+				expression: {
 					kind: "literal",
 					value: String(value),
 					start,
 					end
-				}]
+				}
 			}]
 		}
 	};
@@ -5600,14 +6482,12 @@ function discoverBuffer(gvar, src, structs) {
 		byteSize: typeRef ? typeShape(typeRef, structs, varName).size : 0
 	};
 }
-function discoverTexture(gvar, attr, src) {
-	const varName = gvar.name.decl.ident.originalName;
-	const params = attr.params ?? [];
+function discoverTexture(gvar, attr) {
 	return {
 		kind: "test_texture",
-		varName,
-		source: firstRefName(params[0]) ?? "",
-		params: params.slice(1).map((p) => Number.parseInt(src.slice(p.start, p.end).trim(), 10) || 0),
+		varName: gvar.name.decl.ident.originalName,
+		source: firstRefName(attr.params?.[0]) ?? "",
+		params: numericParams(attr).slice(1).map((n) => n || 0),
 		typeName: gvar.name.typeRef ? originalTypeName(gvar.name.typeRef) : ""
 	};
 }
@@ -5626,11 +6506,6 @@ function discoverSampler(gvar, attr) {
 		filter: (firstRefName(attr.params?.[0]) ?? "linear") === "nearest" ? "nearest" : "linear"
 	};
 }
-/** Extract the originalName of the first `ref` expression in an attribute parameter. */
-function firstRefName(param) {
-	const ref = param?.contents.find((c) => c.kind === "ref");
-	return ref?.kind === "ref" ? ref.ident.originalName : void 0;
-}
 //#endregion
 //#region ../wesl-reflect/src/EntryPoints.ts
 const stageNames = [
@@ -5640,7 +6515,7 @@ const stageNames = [
 ];
 /** Classify all functions in a parsed WESL module by entry-point stage. */
 function classifyEntryPoints(ast) {
-	return ast.moduleElem.contents.filter((e) => e.kind === "fn").flatMap((fn) => entryPointFor(fn));
+	return declsOfKind(ast.moduleElem, "fn").flatMap((fn) => entryPointFor(fn));
 }
 function entryPointFor(fn) {
 	const stage = stageNames.find((s) => findAnnotation(fn, s));
@@ -5704,11 +6579,11 @@ function scanUniforms(entrySource, rootModulePath = "package::main") {
 }
 /** Parse source and find a struct annotated with @uniforms. */
 function findUniformsStruct(src, modulePath) {
-	return parseSrcModule({
+	return declsOfKind(parseSrcModule({
 		modulePath,
 		debugFilePath: "entry",
 		src
-	}).moduleElem.contents.filter((e) => e.kind === "struct").find(isUniformsStruct);
+	}).moduleElem, "struct").find(isUniformsStruct);
 }
 //#endregion
 //#region ../wesl-gpu/src/LinkWeslModule.ts
@@ -5717,8 +6592,11 @@ function findUniformsStruct(src, modulePath) {
 async function linkWeslModule(params) {
 	const { rootSource, scanSource, conditions, constants } = params;
 	const { device, resolver, libs = [], rootModuleName = "main" } = params;
-	const { packageName, config, weslSrc, virtualLibs } = params;
-	const resolvers = [new RecordResolver({ [rootModuleName]: rootSource }, { packageName })];
+	const { packageName, config, weslSrc, virtualLibs, weslExtensions } = params;
+	const resolvers = [new RecordResolver({ [rootModuleName]: rootSource }, {
+		packageName,
+		weslExtensions
+	})];
 	if (weslSrc) resolvers.push(new RecordResolver(weslSrc, { packageName }));
 	let finalResolver = resolvers.length === 1 ? resolvers[0] : new CompositeResolver(resolvers);
 	if (resolver) finalResolver = new CompositeResolver([finalResolver, resolver]);
@@ -5758,6 +6636,17 @@ async function linkComputeShader(params) {
 async function runCompute(p) {
 	return withErrorScopes(p.device, () => dispatchAndReadback(p));
 }
+/** Record one compute pass into the caller's encoder; the caller submits.
+*  Used by interpreters that need many passes in a single command buffer. */
+function recordComputePass(p) {
+	const dispatch = p.dispatchWorkgroups ?? 1;
+	const pass = p.encoder.beginComputePass();
+	pass.setPipeline(p.pipeline);
+	pass.setBindGroup(0, p.bindGroup);
+	if (typeof dispatch === "number") pass.dispatchWorkgroups(dispatch);
+	else pass.dispatchWorkgroups(...dispatch);
+	pass.end();
+}
 /** Clear each buffer to zeros so re-runs / re-tests see deterministic initial state. */
 function clearBuffers(device, buffers) {
 	const list = [...buffers];
@@ -5770,7 +6659,6 @@ function clearBuffers(device, buffers) {
 *  buffer, and return the mapped contents. */
 async function dispatchAndReadback(p) {
 	const { device, module, entryPoint, bindGroup, pipelineLayout } = p;
-	const dispatch = p.dispatchWorkgroups ?? 1;
 	const pipeline = device.createComputePipeline({
 		layout: pipelineLayout,
 		compute: {
@@ -5781,12 +6669,12 @@ async function dispatchAndReadback(p) {
 	const stagingBuffers = /* @__PURE__ */ new Map();
 	for (const [name, src] of p.readBuffers) stagingBuffers.set(name, createStagingBuffer(device, src.size, name));
 	const encoder = device.createCommandEncoder();
-	const pass = encoder.beginComputePass();
-	pass.setPipeline(pipeline);
-	pass.setBindGroup(0, bindGroup);
-	if (typeof dispatch === "number") pass.dispatchWorkgroups(dispatch);
-	else pass.dispatchWorkgroups(...dispatch);
-	pass.end();
+	recordComputePass({
+		encoder,
+		pipeline,
+		bindGroup,
+		dispatchWorkgroups: p.dispatchWorkgroups
+	});
 	for (const [name, src] of p.readBuffers) {
 		const dst = stagingBuffers.get(name);
 		encoder.copyBufferToBuffer(src, 0, dst, 0, src.size);
@@ -6744,7 +7632,7 @@ async function createPipeline(state, shaderSource, resolveTexture, options) {
 		modulePath: `${pkg}::${root}`,
 		debugFilePath: `./${root}.wesl`,
 		src: shaderSource
-	});
+	}, { weslExtensions: options?.weslExtensions });
 	const resources = findAnnotatedResources(ast);
 	const entryPoints = classifyEntryPoints(ast);
 	const mode = detectMode(entryPoints);
@@ -7115,7 +8003,7 @@ var WgslPlay = class extends HTMLElement {
 	_weslSrc = {};
 	_rootModuleName = "package::main";
 	_libs;
-	_linkOptions = {};
+	_linkOptions = { weslExtensions: { doBlocks: true } };
 	_fetchSources = true;
 	_initPromise;
 	_sourceEl = null;
@@ -7261,10 +8149,11 @@ var WgslPlay = class extends HTMLElement {
 	/** Set project configuration (mirrors wesl link() API). */
 	set project(value) {
 		const { weslSrc, rootModuleName, libs } = value;
-		const { packageName, conditions, constants } = value;
+		const { packageName, conditions, constants, weslExtensions } = value;
 		if (packageName !== void 0) this._linkOptions.packageName = packageName;
 		if (conditions !== void 0) this._linkOptions.conditions = conditions;
 		if (constants !== void 0) this._linkOptions.constants = constants;
+		if (weslExtensions !== void 0) this._linkOptions.weslExtensions = weslExtensions;
 		if (libs) this._libs = libs;
 		if (weslSrc) {
 			const pkg = this._linkOptions.packageName || "package";
@@ -7612,6 +8501,7 @@ var WgslPlay = class extends HTMLElement {
 		if (this._fetchSources || this._fetchLibs) {
 			const { weslSrc, libs } = await fetchDependencies(mainSource, {
 				shaderRoot: this.getConfigOverrides()?.shaderRoot,
+				rootModuleName: this._rootModuleName,
 				existingSources: this._weslSrc,
 				fetchLibs: this._fetchLibs,
 				fetchSources: this._fetchSources