wesl 0.7.0 → 0.7.2

package/dist/index.d.ts

@@ -104,6 +104,8 @@ interface RefIdent extends IdentBase {
   std?: true;
   /** True for identifiers in @if/@elif conditions. Binding skips these (for now). */
   conditionRef?: true;
+  /** Attribute name if this ref is inside an attribute param (for skip-binding check). */
+  attrParam?: string;
   ast: WeslAST;
   refIdentElem: RefIdentElem;
 }
@@ -1003,24 +1005,19 @@ declare function srcLog(src: string | SrcMap, pos: number | [number, number], ..
 /** WESL module path utilities for converting between :: and / separators. */
 /**
  * Convert module path segments to relative file path.
- * Handles package/packageName prefixes and super:: resolution.
+ * Resolves package:: and super:: via srcModuleParts context.
  *
- * @param parts - module path as array e.g., ["package", "utils", "helper"]
- * @param packageName - the current package's name (required)
- * @param srcModuleParts - source module path for super:: resolution (optional)
  * @returns relative file path e.g., "utils/helper", or undefined if external
  */
 declare function modulePartsToRelativePath(parts: string[], packageName: string, srcModuleParts?: string[]): string | undefined;
 /** String variant of modulePartsToRelativePath. */
 declare function moduleToRelativePath(modulePath: string, packageName: string, srcModulePath?: string): string | undefined;
 /**
- * Resolve super:: elements to absolute module path.
- *
- * @param parts - module path with potential super:: elements
- * @param srcModuleParts - source module path for context
- * @returns absolute module path parts (no super:: elements)
+ * Resolve package:: and super:: to absolute module path.
+ * - package:: replaced with actual package name from source module
+ * - super:: climbs up the module path hierarchy
  */
-declare function resolveSuper(parts: string[], srcModuleParts: string[]): string[];
+declare function resolveModulePath(parts: string[], srcModuleParts: string[]): string[];
 /** Normalize debug root to end with / or be empty. */
 declare function normalizeDebugRoot(root?: string): string;
 //#endregion
@@ -1200,4 +1197,4 @@ declare function offsetToLineNumber(offset: number, text: string): [lineNum: num
  */
 declare function errorHighlight(source: string, span: Span): [string, string];
 //#endregion
-export { AbstractElem, AbstractElemBase, AliasElem, Attribute, AttributeElem, BatchModuleResolver, BinaryExpression, BinaryOperator, BindIdentsParams, BindResults, BindingAST, BindingStructElem, BlockStatement, BoundAndTransformed, BuiltinAttribute, BundleResolver, ComponentExpression, ComponentMemberExpression, CompositeResolver, ConditionalAttribute, Conditions, ConstAssertElem, ConstElem, ContainerElem, ContinuingElem, DeclIdent, DeclIdentElem, DeclarationElem, DiagnosticAttribute, DiagnosticDirective, DiagnosticRule, DirectiveElem, DirectiveVariant, ElemKindMap, ElemWithAttributes, ElemWithContentsBase, ElifAttribute, ElseAttribute, EmittableElem, EnableDirective, ExpressionElem, ExtendedGPUValidationError, FnElem, FnParamElem, FunctionCallExpression, GlobalDeclarationElem, GlobalVarElem, GrammarElem, HasAttributes, Ident, IfAttribute, ImportCollection, ImportElem, ImportItem, ImportSegment, ImportStatement, InterpolateAttribute, LetElem, LexicalScope, LinkConfig, LinkParams, LinkRegistryParams, LinkedWesl, LinkerTransform, Literal, LiveDecls, ManglerFn, ModuleElem, ModuleResolver, NameElem, OpenElem, OverrideElem, ParenthesizedExpression, ParseError, PartialScope, RecordResolver, RecordResolverOptions, RefIdent, RefIdentElem, RequiresDirective, Scope, SimpleMemberRef, Span, SrcMap, SrcMapBuilder, SrcMapEntry, SrcModule, SrcPosition, SrcWithPath, StableState, StandardAttribute, StatementElem, StructElem, StructMemberElem, StuffElem, SwitchClauseElem, SyntheticElem, TerminalElem, TextElem, TransformedAST, TranslateTimeExpressionElem, TypeRefElem, TypeTemplateParameter, TypedDeclElem, UnaryExpression, UnaryOperator, UnknownExpressionElem, VarElem, VirtualLibrary, VirtualLibraryFn, VirtualLibrarySet, WeslAST, WeslBundle, WeslDevice, WeslGPUCompilationInfo, WeslGPUCompilationMessage, WeslJsPlugin, WeslParseContext, WeslParseError, WeslParseState, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveSuper, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };
+export { AbstractElem, AbstractElemBase, AliasElem, Attribute, AttributeElem, BatchModuleResolver, BinaryExpression, BinaryOperator, BindIdentsParams, BindResults, BindingAST, BindingStructElem, BlockStatement, BoundAndTransformed, BuiltinAttribute, BundleResolver, ComponentExpression, ComponentMemberExpression, CompositeResolver, ConditionalAttribute, Conditions, ConstAssertElem, ConstElem, ContainerElem, ContinuingElem, DeclIdent, DeclIdentElem, DeclarationElem, DiagnosticAttribute, DiagnosticDirective, DiagnosticRule, DirectiveElem, DirectiveVariant, ElemKindMap, ElemWithAttributes, ElemWithContentsBase, ElifAttribute, ElseAttribute, EmittableElem, EnableDirective, ExpressionElem, ExtendedGPUValidationError, FnElem, FnParamElem, FunctionCallExpression, GlobalDeclarationElem, GlobalVarElem, GrammarElem, HasAttributes, Ident, IfAttribute, ImportCollection, ImportElem, ImportItem, ImportSegment, ImportStatement, InterpolateAttribute, LetElem, LexicalScope, LinkConfig, LinkParams, LinkRegistryParams, LinkedWesl, LinkerTransform, Literal, LiveDecls, ManglerFn, ModuleElem, ModuleResolver, NameElem, OpenElem, OverrideElem, ParenthesizedExpression, ParseError, PartialScope, RecordResolver, RecordResolverOptions, RefIdent, RefIdentElem, RequiresDirective, Scope, SimpleMemberRef, Span, SrcMap, SrcMapBuilder, SrcMapEntry, SrcModule, SrcPosition, SrcWithPath, StableState, StandardAttribute, StatementElem, StructElem, StructMemberElem, StuffElem, SwitchClauseElem, SyntheticElem, TerminalElem, TextElem, TransformedAST, TranslateTimeExpressionElem, TypeRefElem, TypeTemplateParameter, TypedDeclElem, UnaryExpression, UnaryOperator, UnknownExpressionElem, VarElem, VirtualLibrary, VirtualLibraryFn, VirtualLibrarySet, WeslAST, WeslBundle, WeslDevice, WeslGPUCompilationInfo, WeslGPUCompilationMessage, WeslJsPlugin, WeslParseContext, WeslParseError, WeslParseState, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };

package/dist/index.js

@@ -283,10 +283,11 @@ function encode_integer(num) {
 
 //#endregion
 //#region src/ClickableError.ts
+const isBrowser = "document" in globalThis;
 /** Throw an error with an embedded source map so that browser users can
 *  click on the error in the browser debug console and see the wesl source code.  */
 function throwClickableError(params) {
-	if (!debug) throw params.error;
+	if (!debug || !isBrowser) throw params.error;
 	const { url, text, lineNumber, lineColumn, length, error } = params;
 	const mappings = encodeVlq([
 		0,
@@ -496,6 +497,25 @@ function childIdent(child) {
 
 //#endregion
 //#region src/LowerAndEmit.ts
+/** Valid WGSL standard attributes (from spec). Non-WGSL attributes are stripped.
+* See: https://www.w3.org/TR/WGSL/#attributes
+* Note: @builtin, @diagnostic, @interpolate are parsed as separate attribute types. */
+const wgslStandardAttributes$1 = new Set([
+	"align",
+	"binding",
+	"blend_src",
+	"compute",
+	"const",
+	"fragment",
+	"group",
+	"id",
+	"invariant",
+	"location",
+	"must_use",
+	"size",
+	"vertex",
+	"workgroup_size"
+]);
 /** Traverse the AST, starting from root elements, emitting WGSL for each. */
 function lowerAndEmit(params) {
 	const { srcBuilder, rootElems, conditions } = params;
@@ -505,9 +525,8 @@ function lowerAndEmit(params) {
 		srcBuilder,
 		extracting
 	};
-	(skipConditionalFiltering ? rootElems : filterValidElements(rootElems, conditions)).forEach((e) => {
-		lowerAndEmitElem(e, emitContext);
-	});
+	const validElements = skipConditionalFiltering ? rootElems : filterValidElements(rootElems, conditions);
+	for (const e of validElements) lowerAndEmitElem(e, emitContext);
 }
 function lowerAndEmitElem(e, ctx) {
 	switch (e.kind) {
@@ -682,9 +701,8 @@ function emitSynthetic(e, ctx) {
 	ctx.srcBuilder.addSynthetic(text, text, 0, text.length);
 }
 function emitContents(elem, ctx) {
-	filterValidElements(elem.contents, ctx.conditions).forEach((e) => {
-		lowerAndEmitElem(e, 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) {
@@ -777,6 +795,7 @@ function emitAttribute(e, ctx) {
 	const { kind } = e.attribute;
 	if (kind === "@if" || kind === "@elif" || kind === "@else") return false;
 	if (kind === "@attribute") {
+		if (!wgslStandardAttributes$1.has(e.attribute.name)) return false;
 		emitStandardAttribute(e, ctx);
 		return true;
 	}
@@ -816,18 +835,25 @@ function diagnosticControlToString(severity, rule) {
 }
 function expressionToString(elem) {
 	const { kind } = elem;
-	if (kind === "binary-expression") return `${expressionToString(elem.left)} ${elem.operator.value} ${expressionToString(elem.right)}`;
-	else if (kind === "unary-expression") return `${elem.operator.value}${expressionToString(elem.expression)}`;
-	else if (kind === "ref") return elem.ident.originalName;
-	else if (kind === "literal") return elem.value;
-	else if (kind === "parenthesized-expression") return `(${expressionToString(elem.expression)})`;
-	else if (kind === "component-expression") return `${expressionToString(elem.base)}[${elem.access}]`;
-	else if (kind === "component-member-expression") return `${expressionToString(elem.base)}.${elem.access}`;
-	else if (kind === "call-expression") {
-		const fn = elem.function;
-		return `${fn.kind === "ref" ? fn.ident.originalName : fn.name.originalName}${elem.templateArgs ? `<...>` : ""}(${elem.arguments.map(expressionToString).join(", ")})`;
-	} else if (kind === "type") return elem.name.originalName;
-	else assertUnreachable(kind);
+	switch (kind) {
+		case "binary-expression": {
+			const left = expressionToString(elem.left);
+			const right = expressionToString(elem.right);
+			return `${left} ${elem.operator.value} ${right}`;
+		}
+		case "unary-expression": return `${elem.operator.value}${expressionToString(elem.expression)}`;
+		case "ref": return elem.ident.originalName;
+		case "literal": return elem.value;
+		case "parenthesized-expression": return `(${expressionToString(elem.expression)})`;
+		case "component-expression": return `${expressionToString(elem.base)}[${elem.access}]`;
+		case "component-member-expression": return `${expressionToString(elem.base)}.${elem.access}`;
+		case "call-expression": {
+			const fn = elem.function;
+			return `${fn.kind === "ref" ? fn.ident.originalName : fn.name.originalName}${elem.templateArgs ? `<...>` : ""}(${elem.arguments.map(expressionToString).join(", ")})`;
+		}
+		case "type": return elem.name.originalName;
+		default: assertUnreachable(kind);
+	}
 }
 function emitDirective(e, ctx) {
 	const { directive } = e;
@@ -1197,15 +1223,12 @@ function minimallyMangledName(proposedName, globalNames) {
 /** WESL module path utilities for converting between :: and / separators. */
 /**
 * Convert module path segments to relative file path.
-* Handles package/packageName prefixes and super:: resolution.
+* Resolves package:: and super:: via srcModuleParts context.
 *
-* @param parts - module path as array e.g., ["package", "utils", "helper"]
-* @param packageName - the current package's name (required)
-* @param srcModuleParts - source module path for super:: resolution (optional)
 * @returns relative file path e.g., "utils/helper", or undefined if external
 */
 function modulePartsToRelativePath(parts, packageName, srcModuleParts) {
-	const resolved = srcModuleParts ? resolveSuper(parts, srcModuleParts) : parts;
+	const resolved = srcModuleParts ? resolveModulePath(parts, srcModuleParts) : parts;
 	const rootSegment = resolved[0];
 	if (rootSegment === "package" || rootSegment === packageName) return resolved.slice(1).join("/");
 }
@@ -1215,16 +1238,15 @@ function moduleToRelativePath(modulePath, packageName, srcModulePath) {
 	return modulePartsToRelativePath(modulePath.split("::"), packageName, srcParts);
 }
 /**
-* Resolve super:: elements to absolute module path.
-*
-* @param parts - module path with potential super:: elements
-* @param srcModuleParts - source module path for context
-* @returns absolute module path parts (no super:: elements)
+* Resolve package:: and super:: to absolute module path.
+* - package:: replaced with actual package name from source module
+* - super:: climbs up the module path hierarchy
 */
-function resolveSuper(parts, srcModuleParts) {
-	const lastSuper = parts.lastIndexOf("super");
-	if (lastSuper === -1) return parts;
-	return [...srcModuleParts.slice(0, -(lastSuper + 1)), ...parts.slice(lastSuper + 1)];
+function resolveModulePath(parts, srcModuleParts) {
+	const resolved = parts[0] === "package" ? [srcModuleParts[0], ...parts.slice(1)] : parts;
+	const lastSuper = resolved.lastIndexOf("super");
+	if (lastSuper === -1) return resolved;
+	return [...srcModuleParts.slice(0, -(lastSuper + 1)), ...resolved.slice(lastSuper + 1)];
 }
 /** Normalize debug root to end with / or be empty. */
 function normalizeDebugRoot(root) {
@@ -1992,7 +2014,9 @@ function parseStandardAttribute(ctx) {
 	if (name === "diagnostic") return parseDiagnosticAttribute(ctx, startPos);
 	let params;
 	if (stream.matchText("(")) {
+		ctx.parsingAttrParam = name;
 		params = parseAttributeParams(ctx);
+		ctx.parsingAttrParam = void 0;
 		expect(stream, ")", "attribute parameters");
 	}
 	if (name === "must_use" && params !== void 0) throw new ParseError("@must_use does not accept parameters", [startPos, stream.checkpoint()]);
@@ -3097,14 +3121,18 @@ var ParsingContext = class {
 		while (scope.kind === "partial" && scope.parent) scope = scope.parent;
 		return scope.parent === null;
 	}
+	/** Attribute name being parsed (for marking refs in attr params). */
+	parsingAttrParam;
 	createRefIdent(name) {
-		return {
+		const ref = {
 			kind: "ref",
 			originalName: name,
 			ast: this.state.stable,
 			id: nextIdentId(),
 			refIdentElem: null
 		};
+		if (this.parsingAttrParam) ref.attrParam = this.parsingAttrParam;
+		return ref;
 	}
 	createDeclIdent(name, isGlobal = false) {
 		return {
@@ -3635,6 +3663,23 @@ function stdEnumerant(name) {
 
 //#endregion
 //#region src/BindIdents.ts
+/** WGSL standard attributes whose params need binding (e.g., @workgroup_size). */
+const wgslStandardAttributes = new Set([
+	"align",
+	"binding",
+	"blend_src",
+	"compute",
+	"const",
+	"fragment",
+	"group",
+	"id",
+	"invariant",
+	"location",
+	"must_use",
+	"size",
+	"vertex",
+	"workgroup_size"
+]);
 /** Bind ref idents to declarations and mangle global declaration names. */
 function bindIdents(params) {
 	const { rootAst, resolver, virtuals, accumulateUnbound } = params;
@@ -3750,6 +3795,7 @@ function processDependentScope(decl, ctx) {
 function handleRef(ident$1, liveDecls, bindContext) {
 	if (ident$1.refersTo || ident$1.std) return;
 	if (ident$1.conditionRef) return;
+	if (ident$1.attrParam && !wgslStandardAttributes.has(ident$1.attrParam)) return;
 	const foundDecl = findDeclInModule(ident$1, liveDecls) ?? findQualifiedImport(ident$1, bindContext);
 	if (foundDecl) {
 		ident$1.refersTo = foundDecl.decl;
@@ -3811,7 +3857,7 @@ function matchingImport(identParts, imports) {
 /** @return an exported root declIdent for the provided path. */
 function findExport(pathParts, srcModule, ctx) {
 	const { resolver, conditions, virtuals } = ctx;
-	const modulePath = resolveSuper(pathParts, srcModule.modulePath.split("::")).slice(0, -1).join("::");
+	const modulePath = resolveModulePath(pathParts, srcModule.modulePath.split("::")).slice(0, -1).join("::");
 	const moduleAst = resolver.resolveModule(modulePath) ?? virtualModule(pathParts[0], conditions, virtuals);
 	if (!moduleAst) return void 0;
 	const decl = publicDecl(moduleAst.rootScope, last(pathParts), conditions);
@@ -4883,4 +4929,4 @@ function makeWeslDevice(device) {
 }
 
 //#endregion
-export { BundleResolver, CompositeResolver, LinkedWesl, ParseError, RecordResolver, SrcMap, SrcMapBuilder, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveSuper, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };
+export { BundleResolver, CompositeResolver, LinkedWesl, ParseError, RecordResolver, SrcMap, SrcMapBuilder, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "type": "module",
   "files": [
     "dist",

package/src/BindIdents.ts

@@ -7,7 +7,7 @@ import type { FlatImport } from "./FlattenTreeImport.ts";
 import type { LinkRegistryParams, VirtualLibraryFn } from "./Linker.ts";
 import { type LiveDecls, makeLiveDecls } from "./LiveDeclarations.ts";
 import { type ManglerFn, minimalMangle } from "./Mangler.ts";
-import { resolveSuper } from "./ModulePathUtil.ts";
+import { resolveModulePath } from "./ModulePathUtil.ts";
 import type { ModuleResolver } from "./ModuleResolver.ts";
 import { flatImports, parseSrcModule, type WeslAST } from "./ParseWESL.ts";
 import type {
@@ -21,6 +21,24 @@ import type {
 import { stdEnumerant, stdFn, stdType } from "./StandardTypes.ts";
 import { last } from "./Util.ts";
 
+/** WGSL standard attributes whose params need binding (e.g., @workgroup_size). */
+const wgslStandardAttributes = new Set([
+  "align",
+  "binding",
+  "blend_src",
+  "compute",
+  "const",
+  "fragment",
+  "group",
+  "id",
+  "invariant",
+  "location",
+  "must_use",
+  "size",
+  "vertex",
+  "workgroup_size",
+]);
+
 /**
  * BindIdents pass: link reference identifiers to declarations.
  *
@@ -281,6 +299,9 @@ function handleRef(
   // Skip binding for condition refs - they resolve via Conditions map (for now)
   if (ident.conditionRef) return;
 
+  // Skip binding for refs in non-WGSL attribute params (e.g., @test(description))
+  if (ident.attrParam && !wgslStandardAttributes.has(ident.attrParam)) return;
+
   const foundDecl =
     findDeclInModule(ident, liveDecls) ??
     findQualifiedImport(ident, bindContext);
@@ -385,7 +406,7 @@ function findExport(
 ): FoundDecl | undefined {
   const { resolver, conditions, virtuals } = ctx;
   const srcParts = srcModule.modulePath.split("::");
-  const fqParts = resolveSuper(pathParts, srcParts);
+  const fqParts = resolveModulePath(pathParts, srcParts);
   const modulePath = fqParts.slice(0, -1).join("::");
 
   const moduleAst =

package/src/ClickableError.ts

@@ -23,10 +23,12 @@ export interface ClickableErrorParams {
   error: Error;
 }
 
+const isBrowser = "document" in globalThis;
+
 /** Throw an error with an embedded source map so that browser users can
  *  click on the error in the browser debug console and see the wesl source code.  */
 export function throwClickableError(params: ClickableErrorParams): void {
-  if (!debug) throw params.error; // skip source map generation in prod
+  if (!debug || !isBrowser) throw params.error;
   const { url, text, lineNumber, lineColumn, length, error } = params;
 
   // Based on https://stackoverflow.com/questions/65274147/sourceurl-for-css

package/src/LowerAndEmit.ts

@@ -36,6 +36,26 @@ interface EmitContext {
   extracting: boolean;
 }
 
+/** Valid WGSL standard attributes (from spec). Non-WGSL attributes are stripped.
+ * See: https://www.w3.org/TR/WGSL/#attributes
+ * Note: @builtin, @diagnostic, @interpolate are parsed as separate attribute types. */
+const wgslStandardAttributes = new Set([
+  "align",
+  "binding",
+  "blend_src",
+  "compute",
+  "const",
+  "fragment",
+  "group",
+  "id",
+  "invariant",
+  "location",
+  "must_use",
+  "size",
+  "vertex",
+  "workgroup_size",
+]);
+
 /** Traverse the AST, starting from root elements, emitting WGSL for each. */
 export function lowerAndEmit(params: EmitParams): void {
   const { srcBuilder, rootElems, conditions } = params;
@@ -45,9 +65,7 @@ export function lowerAndEmit(params: EmitParams): void {
   const validElements = skipConditionalFiltering
     ? rootElems
     : filterValidElements(rootElems, conditions);
-  validElements.forEach(e => {
-    lowerAndEmitElem(e, emitContext);
-  });
+  for (const e of validElements) lowerAndEmitElem(e, emitContext);
 }
 
 function lowerAndEmitElem(e: AbstractElem, ctx: EmitContext): void {
@@ -303,9 +321,7 @@ function emitSynthetic(e: SyntheticElem, ctx: EmitContext): void {
 
 function emitContents(elem: ContainerElem, ctx: EmitContext): void {
   const validElements = filterValidElements(elem.contents, ctx.conditions);
-  validElements.forEach(e => {
-    lowerAndEmitElem(e, ctx);
-  });
+  for (const e of validElements) lowerAndEmitElem(e, ctx);
 }
 
 /** Emit contents with leading/trailing whitespace trimming (V2 parser). */
@@ -444,6 +460,9 @@ function emitAttribute(e: AttributeElem, ctx: EmitContext): boolean {
   }
 
   if (kind === "@attribute") {
+    if (!wgslStandardAttributes.has(e.attribute.name)) {
+      return false; // non-WGSL attribute, dropped from output
+    }
     emitStandardAttribute(e, ctx);
     return true;
   }
@@ -503,30 +522,36 @@ export function diagnosticControlToString(
 
 export function expressionToString(elem: ExpressionElem): string {
   const { kind } = elem;
-  if (kind === "binary-expression") {
-    return `${expressionToString(elem.left)} ${elem.operator.value} ${expressionToString(elem.right)}`;
-  } else if (kind === "unary-expression") {
-    return `${elem.operator.value}${expressionToString(elem.expression)}`;
-  } else if (kind === "ref") {
-    return elem.ident.originalName;
-  } else if (kind === "literal") {
-    return elem.value;
-  } else if (kind === "parenthesized-expression") {
-    return `(${expressionToString(elem.expression)})`;
-  } else if (kind === "component-expression") {
-    return `${expressionToString(elem.base)}[${elem.access}]`;
-  } else if (kind === "component-member-expression") {
-    return `${expressionToString(elem.base)}.${elem.access}`;
-  } else if (kind === "call-expression") {
-    const fn = elem.function;
-    const name =
-      fn.kind === "ref" ? fn.ident.originalName : fn.name.originalName;
-    const targs = elem.templateArgs ? `<...>` : "";
-    return `${name}${targs}(${elem.arguments.map(expressionToString).join(", ")})`;
-  } else if (kind === "type") {
-    return elem.name.originalName;
-  } else {
-    assertUnreachable(kind);
+  switch (kind) {
+    case "binary-expression": {
+      const left = expressionToString(elem.left);
+      const right = expressionToString(elem.right);
+      return `${left} ${elem.operator.value} ${right}`;
+    }
+    case "unary-expression":
+      return `${elem.operator.value}${expressionToString(elem.expression)}`;
+    case "ref":
+      return elem.ident.originalName;
+    case "literal":
+      return elem.value;
+    case "parenthesized-expression":
+      return `(${expressionToString(elem.expression)})`;
+    case "component-expression":
+      return `${expressionToString(elem.base)}[${elem.access}]`;
+    case "component-member-expression":
+      return `${expressionToString(elem.base)}.${elem.access}`;
+    case "call-expression": {
+      const fn = elem.function;
+      const name =
+        fn.kind === "ref" ? fn.ident.originalName : fn.name.originalName;
+      const targs = elem.templateArgs ? `<...>` : "";
+      const args = elem.arguments.map(expressionToString).join(", ");
+      return `${name}${targs}(${args})`;
+    }
+    case "type":
+      return elem.name.originalName;
+    default:
+      assertUnreachable(kind);
   }
 }
 

package/src/ModulePathUtil.ts

@@ -2,11 +2,8 @@
 
 /**
  * Convert module path segments to relative file path.
- * Handles package/packageName prefixes and super:: resolution.
+ * Resolves package:: and super:: via srcModuleParts context.
  *
- * @param parts - module path as array e.g., ["package", "utils", "helper"]
- * @param packageName - the current package's name (required)
- * @param srcModuleParts - source module path for super:: resolution (optional)
  * @returns relative file path e.g., "utils/helper", or undefined if external
  */
 export function modulePartsToRelativePath(
@@ -14,7 +11,9 @@ export function modulePartsToRelativePath(
   packageName: string,
   srcModuleParts?: string[],
 ): string | undefined {
-  const resolved = srcModuleParts ? resolveSuper(parts, srcModuleParts) : parts;
+  const resolved = srcModuleParts
+    ? resolveModulePath(parts, srcModuleParts)
+    : parts;
 
   const rootSegment = resolved[0];
   if (rootSegment === "package" || rootSegment === packageName) {
@@ -35,20 +34,23 @@ export function moduleToRelativePath(
 }
 
 /**
- * Resolve super:: elements to absolute module path.
- *
- * @param parts - module path with potential super:: elements
- * @param srcModuleParts - source module path for context
- * @returns absolute module path parts (no super:: elements)
+ * Resolve package:: and super:: to absolute module path.
+ * - package:: replaced with actual package name from source module
+ * - super:: climbs up the module path hierarchy
  */
-export function resolveSuper(
+export function resolveModulePath(
   parts: string[],
   srcModuleParts: string[],
 ): string[] {
-  const lastSuper = parts.lastIndexOf("super");
-  if (lastSuper === -1) return parts;
+  // Handle package:: - replace with actual package name from source module
+  const resolved =
+    parts[0] === "package" ? [srcModuleParts[0], ...parts.slice(1)] : parts;
+
+  // Handle super:: - climb up the module path
+  const lastSuper = resolved.lastIndexOf("super");
+  if (lastSuper === -1) return resolved;
   const base = srcModuleParts.slice(0, -(lastSuper + 1));
-  return [...base, ...parts.slice(lastSuper + 1)];
+  return [...base, ...resolved.slice(lastSuper + 1)];
 }
 
 /** Normalize debug root to end with / or be empty. */

package/src/Scope.ts

@@ -41,6 +41,9 @@ export interface RefIdent extends IdentBase {
   /** True for identifiers in @if/@elif conditions. Binding skips these (for now). */
   conditionRef?: true;
 
+  /** Attribute name if this ref is inside an attribute param (for skip-binding check). */
+  attrParam?: string;
+
   // LATER consider tracking the current ast in BindIdents so that this field is unnecessary
   ast: WeslAST; // AST from module that contains this ident (to find imports during decl binding)
 

package/src/parse/ParseAttribute.ts

@@ -154,7 +154,9 @@ function parseStandardAttribute(ctx: ParsingContext): AttributeElem | null {
 
   let params: UnknownExpressionElem[] | undefined;
   if (stream.matchText("(")) {
+    ctx.parsingAttrParam = name;
     params = parseAttributeParams(ctx);
+    ctx.parsingAttrParam = undefined;
     expect(stream, ")", "attribute parameters");
   }
 

package/src/parse/ParsingContext.ts

@@ -65,14 +65,19 @@ export class ParsingContext {
     return scope.parent === null;
   }
 
+  /** Attribute name being parsed (for marking refs in attr params). */
+  parsingAttrParam?: string;
+
   createRefIdent(name: string): RefIdent {
-    return {
+    const ref: RefIdent = {
       kind: "ref",
       originalName: name,
       ast: this.state.stable,
       id: nextIdentId(),
       refIdentElem: null as any, // linked by caller
     };
+    if (this.parsingAttrParam) ref.attrParam = this.parsingAttrParam;
+    return ref;
   }
 
   createDeclIdent(name: string, isGlobal = false): DeclIdent {

package/src/test/Linker.test.ts

@@ -20,6 +20,36 @@ test("@diagnostic attribute on statement", async () => {
   expectTokenMatch(result, src);
 });
 
+test("non-WGSL attribute @test stripped from output", async () => {
+  const src = `
+    @test
+    fn myTest() { }
+  `;
+  const expected = `fn myTest() { }`;
+  const result = await linkTest(src);
+  expectTokenMatch(result, expected);
+});
+
+test("non-WGSL attribute @test with params stripped", async () => {
+  const src = `
+    @test(my_test_name)
+    fn myTest() { }
+  `;
+  const expected = `fn myTest() { }`;
+  const result = await linkTest(src);
+  expectTokenMatch(result, expected);
+});
+
+test("non-WGSL attribute @custom stripped from output", async () => {
+  const src = `
+    @custom
+    fn myFn() { }
+  `;
+  const expected = `fn myFn() { }`;
+  const result = await linkTest(src);
+  expectTokenMatch(result, expected);
+});
+
 test("link an alias", async () => {
   const src = /* wgsl */ `
     alias Num = f32;