wesl 0.7.20 → 0.7.22

package/dist/index.d.ts

@@ -725,9 +725,13 @@ declare class LinkedWesl {
  * . lengthPrefixMangle constructs long but predictable names for every declaration
  */
 type ManglerFn = (/** global declaration that needs a name */
+
 decl: DeclIdent, /** module that contains the declaration */
+
 srcModule: SrcModule, /** name at use site (possibly import as renamed from declaration) */
+
 proposedName: string, /** current set of mangled root level names for the linked result (read only) */
+
 globalNames: Set<string>) => string;
 /**
  * Construct a globally unique name based on the declaration
@@ -977,6 +981,8 @@ interface BindIdentsParams extends Pick<LinkRegistryParams, "resolver" | "condit
 declare function bindIdents(params: BindIdentsParams): BindResults;
 /** Find all conditionally valid declarations at the root level. */
 declare function findValidRootDecls(rootScope: Scope, conditions: Conditions): DeclIdent[];
+/** Find all declarations at the root level, ignoring conditions. */
+declare function findAllRootDecls(rootScope: Scope): DeclIdent[];
 /** Find a public declaration with the given original name. */
 declare function publicDecl(scope: Scope, name: string, conditions: Conditions): DeclIdent | undefined;
 /** State used during the recursive scope tree walk to bind references to declarations. */
@@ -1000,6 +1006,8 @@ interface BindContext {
   unbound?: UnboundRef[];
   /** Don't follow references from declarations (for library dependency detection). */
   dontFollowDecls?: boolean;
+  /** Visit all conditional branches (for dependency discovery). */
+  discoveryMode?: boolean;
 }
 /**
  * Recursively bind references to declarations in this scope and child scopes.
@@ -1233,4 +1241,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, type ParseOptions, 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, UnboundRef, 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, findUnboundRefs, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, 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, type ParseOptions, 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, UnboundRef, 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, findAllRootDecls, findMap, findRefsToBindingStructs, findUnboundIdents, findUnboundRefs, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };

package/dist/index.js

@@ -334,8 +334,8 @@ function throwClickableError(params) {
 	}
 }
 /** Warn the user about an identifier and throw a clickable exception */
-function failIdent(ident$1, msg) {
-	const { refIdentElem, originalName } = ident$1;
+function failIdent(ident, msg) {
+	const { refIdentElem, originalName } = ident;
 	const baseMessage = msg ?? `'${originalName}'`;
 	if (refIdentElem) failIdentElem(refIdentElem, baseMessage);
 	else throw new Error(baseMessage);
@@ -717,13 +717,13 @@ 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$1, i) => {
-		if (elem$1.kind === "text") {
-			let text = elem$1.srcModule.src.slice(elem$1.start, elem$1.end);
+	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$1.start, elem$1.end);
-		} else lowerAndEmitElem(elem$1, ctx);
+			if (text) ctx.srcBuilder.add(text, elem.start, elem.end);
+		} else lowerAndEmitElem(elem, ctx);
 	});
 }
 function isConditionalAttr(e) {
@@ -885,13 +885,13 @@ function displayName(declIdent) {
 	return declIdent.mangledName || declIdent.originalName;
 }
 /** Trace through refersTo links until we find the declaration. */
-function findDecl(ident$1) {
-	let i = ident$1;
+function findDecl(ident) {
+	let i = ident;
 	do {
 		if (i.kind === "decl") return i;
 		i = i.refersTo;
 	} while (i);
-	throw new Error(`unresolved identifer: ${ident$1.originalName}`);
+	throw new Error(`unresolved identifer: ${ident.originalName}`);
 }
 
 //#endregion
@@ -1122,7 +1122,7 @@ function scopeToString(scope, indent = 0, shortIdents = true) {
 	if (attrStrings) str.add(attrStrings + " ");
 	if (kind === "partial") str.add("-");
 	str.add("{ ");
-	const last$1 = contents.length - 1;
+	const last = contents.length - 1;
 	let lastWasScope = false;
 	let hasBlock = false;
 	contents.forEach((elem, i) => {
@@ -1135,10 +1135,10 @@ function scopeToString(scope, indent = 0, shortIdents = true) {
 		} else {
 			if (lastWasScope) str.add("  ");
 			lastWasScope = false;
-			const ident$1 = elem;
-			if (shortIdents) str.add(identShortString(ident$1));
-			else str.add(identToString(ident$1));
-			if (i < last$1) str.add(" ");
+			const ident = elem;
+			if (shortIdents) str.add(identShortString(ident));
+			else str.add(identToString(ident));
+			if (i < last) str.add(" ");
 		}
 	});
 	if (!hasBlock && str.oneLine) str.add(" }");
@@ -1154,17 +1154,17 @@ function scopeToStringLong(scope) {
 	return scopeToString(scope, 0, false);
 }
 /** name of an identifier, with decls prefixed with '%' */
-function identShortString(ident$1) {
-	const { kind, originalName } = ident$1;
+function identShortString(ident) {
+	const { kind, originalName } = ident;
 	return `${kind === "decl" ? "%" : ""}${originalName}`;
 }
-function identToString(ident$1) {
-	if (!ident$1) return JSON.stringify(ident$1);
-	const { kind, originalName } = ident$1;
-	const idStr = ident$1.id ? `#${ident$1.id}` : "";
-	if (kind === "ref") return `${originalName} ${idStr} -> ${identToString(ident$1.refersTo)}`;
+function identToString(ident) {
+	if (!ident) return JSON.stringify(ident);
+	const { kind, originalName } = ident;
+	const idStr = ident.id ? `#${ident.id}` : "";
+	if (kind === "ref") return `${originalName} ${idStr} -> ${identToString(ident.refersTo)}`;
 	else {
-		const { mangledName } = ident$1;
+		const { mangledName } = ident;
 		return `%${originalName}${mangledName ? `(${mangledName})` : ""} ${idStr} `;
 	}
 }
@@ -1655,11 +1655,11 @@ function parseIdent(ctx, conditionRef) {
 	const path = parseModulePath(ctx.stream);
 	if (!path) return null;
 	const { parts, start, end } = path;
-	const ident$1 = ctx.createRefIdent(parts.join("::"));
-	if (conditionRef) ident$1.conditionRef = true;
-	const refIdentElem = makeRefIdentElem(ctx, ident$1, start, end);
+	const ident = ctx.createRefIdent(parts.join("::"));
+	if (conditionRef) ident.conditionRef = true;
+	const refIdentElem = makeRefIdentElem(ctx, ident, start, end);
 	if (!conditionRef) {
-		ctx.saveIdent(ident$1);
+		ctx.saveIdent(ident);
 		ctx.addElem(refIdentElem);
 	}
 	return refIdentElem;
@@ -2202,8 +2202,8 @@ function parseElseChain(ctx) {
 	while (stream.matchText("else")) {
 		if (stream.matchText("if")) {
 			expectExpression(ctx, "Expected expression after 'else if'");
-			const body$1 = expectCompound(ctx, "Expected '{' after else if");
-			ctx.addElem(body$1);
+			const body = expectCompound(ctx, "Expected '{' after else if");
+			ctx.addElem(body);
 			continue;
 		}
 		const body = expectCompound(ctx, "Expected '{' after else");
@@ -3162,8 +3162,8 @@ var ParsingContext = class {
 			declElem: null
 		};
 	}
-	saveIdent(ident$1) {
-		this.state.context.scope.contents.push(ident$1);
+	saveIdent(ident) {
+		this.state.context.scope.contents.push(ident);
 	}
 };
 
@@ -3252,7 +3252,7 @@ function toRegexSource(nameExp) {
 	}
 }
 function verifyNonCapturing(name, exp) {
-	if ((/* @__PURE__ */ new RegExp("|" + exp.source)).exec("").length > 1) throw new Error(`match expression groups must be non-capturing: ${name}: /${exp.source}/. Use (?:...) instead.`);
+	if (new RegExp("|" + exp.source).exec("").length > 1) throw new Error(`match expression groups must be non-capturing: ${name}: /${exp.source}/. Use (?:...) instead.`);
 }
 const regexSpecials = /[$+*.?|(){}[\]\\/^]/g;
 function escapeRegex(s) {
@@ -3761,6 +3761,13 @@ function findValidRootDecls(rootScope, conditions) {
 	else if (item.kind === "partial") collectDecls(item, found);
 	return found;
 }
+/** Find all declarations at the root level, ignoring conditions. */
+function findAllRootDecls(rootScope) {
+	const found = [];
+	for (const item of rootScope.contents) if (item.kind === "decl") found.push(item);
+	else if (item.kind === "partial") collectDecls(item, found);
+	return found;
+}
 /** Find a public declaration with the given original name. */
 function publicDecl(scope, name, conditions) {
 	return getValidRootDecls(scope, conditions).find((d) => d.originalName === name);
@@ -3785,7 +3792,8 @@ function bindIdentsRecursive(scope, bindContext, liveDecls) {
 function processScope(scope, bindContext, liveDecls) {
 	const newGlobals = [];
 	const newFromChildren = [];
-	for (const child of validItems(scope, bindContext.conditions)) if (child.kind === "decl") liveDecls.decls.set(child.originalName, child);
+	const items = bindContext.discoveryMode ? scope.contents : validItems(scope, bindContext.conditions);
+	for (const child of items) if (child.kind === "decl") liveDecls.decls.set(child.originalName, child);
 	else if (child.kind === "ref") {
 		const newDecl = handleRef(child, liveDecls, bindContext);
 		if (newDecl) newGlobals.push(newDecl);
@@ -3811,20 +3819,20 @@ function processDependentScope(decl, ctx) {
 * Mutates to mangle declarations and mark std references.
 * @return found declaration, or undefined if already processed
 */
-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);
+function handleRef(ident, liveDecls, bindContext) {
+	if (ident.refersTo || ident.std) return;
+	if (ident.conditionRef) return;
+	if (ident.attrParam && !wgslStandardAttributes.has(ident.attrParam)) return;
+	const foundDecl = findDeclInModule(ident, liveDecls) ?? findQualifiedImport(ident, bindContext);
 	if (foundDecl) {
-		ident$1.refersTo = foundDecl.decl;
-		return handleNewDecl(ident$1, foundDecl, bindContext);
+		ident.refersTo = foundDecl.decl;
+		return handleNewDecl(ident, foundDecl, bindContext);
 	}
-	if (stdWgsl(ident$1.originalName)) {
-		ident$1.std = true;
+	if (stdWgsl(ident.originalName)) {
+		ident.std = true;
 		return;
 	}
-	if (!bindContext.unbound) failIdent(ident$1, `unresolved identifier '${ident$1.originalName}'`);
+	if (!bindContext.unbound) failIdent(ident, `unresolved identifier '${ident.originalName}'`);
 }
 function handleDecls(newGlobals, bindContext) {
 	return newGlobals.flatMap((decl) => processDependentScope(decl, bindContext));
@@ -3845,18 +3853,18 @@ function handleNewDecl(refIdent, foundDecl, ctx) {
 	return decl;
 }
 /** Search current scope and parent scopes for a matching declaration. */
-function findDeclInModule(ident$1, liveDecls) {
-	const found = liveDecls.decls.get(ident$1.originalName);
+function findDeclInModule(ident, liveDecls) {
+	const found = liveDecls.decls.get(ident.originalName);
 	if (found) return {
 		decl: found,
-		moduleAst: ident$1.ast
+		moduleAst: ident.ast
 	};
-	if (liveDecls.parent) return findDeclInModule(ident$1, liveDecls.parent);
+	if (liveDecls.parent) return findDeclInModule(ident, liveDecls.parent);
 }
 /** Match a ref ident to a declaration in another module via import or qualified ident. */
 function findQualifiedImport(refIdent, ctx) {
-	const { conditions, unbound } = ctx;
-	const flatImps = flatImports(refIdent.ast, conditions);
+	const { conditions, unbound, discoveryMode } = ctx;
+	const flatImps = flatImports(refIdent.ast, discoveryMode ? void 0 : conditions);
 	const identParts = refIdent.originalName.split("::");
 	const pathParts = matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);
 	if (!pathParts) {
@@ -3975,10 +3983,11 @@ function findUnboundRefs(resolver) {
 		mangler: minimalMangle,
 		packageName: "package",
 		unbound: [],
-		dontFollowDecls: true
+		dontFollowDecls: true,
+		discoveryMode: true
 	};
 	for (const [, ast] of resolver.allModules()) {
-		const rootDecls = findValidRootDecls(ast.rootScope, {});
+		const rootDecls = findAllRootDecls(ast.rootScope);
 		const liveDecls = {
 			decls: new Map(rootDecls.map((d) => [d.originalName, d])),
 			parent: null
@@ -4857,8 +4866,8 @@ function refersToBindingStruct(memberRef) {
 	};
 }
 /** If this identifier ultimately refers to a struct type, return the struct declaration */
-function traceToStruct(ident$1) {
-	const declElem = findDecl(ident$1).declElem;
+function traceToStruct(ident) {
+	const declElem = findDecl(ident).declElem;
 	if (declElem && declElem.kind === "param") {
 		const name = declElem.name.typeRef?.name;
 		if (typeof name !== "string") {
@@ -4963,4 +4972,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, findUnboundRefs, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, 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, findAllRootDecls, findMap, findRefsToBindingStructs, findUnboundIdents, findUnboundRefs, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl",
-  "version": "0.7.20",
+  "version": "0.7.22",
   "type": "module",
   "files": [
     "dist",
@@ -26,14 +26,6 @@
     "typedoc-theme-hierarchy": "^6.0.0",
     "wrangler": "^4.22.0"
   },
-  "peerDependencies": {
-    "random_wgsl": "^0.6.68"
-  },
-  "peerDependenciesMeta": {
-    "random_wgsl": {
-      "optional": true
-    }
-  },
   "license": "MIT",
   "keywords": [
     "webgpu",

package/src/BindIdents.ts

@@ -203,6 +203,16 @@ export function findValidRootDecls(
   return found;
 }
 
+/** Find all declarations at the root level, ignoring conditions. */
+export function findAllRootDecls(rootScope: Scope): DeclIdent[] {
+  const found: DeclIdent[] = [];
+  for (const item of rootScope.contents) {
+    if (item.kind === "decl") found.push(item);
+    else if (item.kind === "partial") collectDecls(item, found);
+  }
+  return found;
+}
+
 /** Find a public declaration with the given original name. */
 export function publicDecl(
   scope: Scope,
@@ -244,6 +254,9 @@ interface BindContext {
 
   /** Don't follow references from declarations (for library dependency detection). */
   dontFollowDecls?: boolean;
+
+  /** Visit all conditional branches (for dependency discovery). */
+  discoveryMode?: boolean;
 }
 
 /**
@@ -277,7 +290,10 @@ function processScope(
   const newGlobals: DeclIdent[] = [];
   const newFromChildren: DeclIdent[] = [];
 
-  for (const child of validItems(scope, bindContext.conditions)) {
+  const items = bindContext.discoveryMode
+    ? scope.contents
+    : validItems(scope, bindContext.conditions);
+  for (const child of items) {
     if (child.kind === "decl") {
       liveDecls.decls.set(child.originalName, child);
     } else if (child.kind === "ref") {
@@ -380,8 +396,11 @@ function findQualifiedImport(
   refIdent: RefIdent,
   ctx: BindContext,
 ): FoundDecl | undefined {
-  const { conditions, unbound } = ctx;
-  const flatImps = flatImports(refIdent.ast, conditions);
+  const { conditions, unbound, discoveryMode } = ctx;
+  const flatImps = flatImports(
+    refIdent.ast,
+    discoveryMode ? undefined : conditions,
+  );
   const identParts = refIdent.originalName.split("::");
   const pathParts =
     matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);

package/src/discovery/FindUnboundIdents.ts

@@ -2,7 +2,7 @@ import type { AbstractElem } from "../AbstractElems.ts";
 import {
   bindIdentsRecursive,
   type EmittableElem,
-  findValidRootDecls,
+  findAllRootDecls,
   type UnboundRef,
 } from "../BindIdents.ts";
 import { type LiveDecls, makeLiveDecls } from "../LiveDeclarations.ts";
@@ -38,10 +38,11 @@ export function findUnboundRefs(resolver: BatchModuleResolver): UnboundRef[] {
     packageName: "package",
     unbound: [] as UnboundRef[],
     dontFollowDecls: true,
+    discoveryMode: true,
   };
 
   for (const [, ast] of resolver.allModules()) {
-    const rootDecls = findValidRootDecls(ast.rootScope, {});
+    const rootDecls = findAllRootDecls(ast.rootScope);
     const liveDecls: LiveDecls = {
       decls: new Map(rootDecls.map(d => [d.originalName, d] as const)),
       parent: null,

package/src/test/FindUnboundIdents.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "vitest";
+import { findUnboundIdents } from "../discovery/FindUnboundIdents.ts";
+import { RecordResolver } from "../ModuleResolver.ts";
+
+test("ref inside @if block is discovered", () => {
+  const srcs = {
+    "./test.wesl": `
+      import package::util::helper;
+      fn main() {
+        @if(feature) helper();
+      }
+    `,
+    "./util.wesl": `
+      import ext_pkg::dep;
+      fn helper() { dep(); }
+    `,
+  };
+  const resolver = new RecordResolver(srcs);
+  const unbound = findUnboundIdents(resolver);
+  expect(unbound).toContainEqual(["ext_pkg", "dep"]);
+});
+
+test("ref inside @else block is discovered", () => {
+  const srcs = {
+    "./test.wesl": `
+      import package::util::a;
+      import package::util::b;
+      fn main() {
+        @if(feature) a();
+        @else b();
+      }
+    `,
+    "./util.wesl": `
+      import ext_pkg::dep;
+      fn a() { }
+      fn b() { dep(); }
+    `,
+  };
+  const resolver = new RecordResolver(srcs);
+  const unbound = findUnboundIdents(resolver);
+  expect(unbound).toContainEqual(["ext_pkg", "dep"]);
+});
+
+test("import declaration inside @if block is discovered", () => {
+  const srcs = {
+    "./test.wesl": `
+      @if(feature)
+      import ext_pkg::mod::helper;
+
+      fn main() {
+        @if(feature) helper();
+      }
+    `,
+  };
+  const resolver = new RecordResolver(srcs);
+  const unbound = findUnboundIdents(resolver);
+  expect(unbound).toContainEqual(["ext_pkg", "mod", "helper"]);
+});
+
+test("inline qualified ref inside @if is discovered", () => {
+  const srcs = {
+    "./test.wesl": `
+      fn main() {
+        @if(feature) ext_pkg::mod::helper();
+      }
+    `,
+  };
+  const resolver = new RecordResolver(srcs);
+  const unbound = findUnboundIdents(resolver);
+  expect(unbound).toContainEqual(["ext_pkg", "mod", "helper"]);
+});

package/src/test/LinkPackage.test.ts

@@ -1,30 +1,36 @@
 import second from "multi_pkg/second";
 import trans from "multi_pkg/transitive";
-import rand from "random_wgsl";
 import { expect, test } from "vitest";
 import { link } from "../Linker.ts";
+import type { WeslBundle } from "../WeslBundle.ts";
 import { expectNoLogAsync } from "./LogCatcher.ts";
 
-test("import rand() from a package", async () => {
-  const src = `
-    import random_wgsl::pcg_2u_3f; 
+// Static fixture bundle - no external package dependency needed
+const hashPkg: WeslBundle = {
+  name: "hash_pkg",
+  edition: "unstable_2025_1",
+  modules: {
+    "hash.wesl":
+      "fn hashFn(v: u32) -> u32 { return v ^ (v >> 16u); }\nfn unusedFn() { }",
+  },
+};
 
-    struct Uniforms { frame: u32 }
-    @binding(0) @group(0) var<uniform> u: Uniforms;
+test("import fn from a package bundle", async () => {
+  const src = `
+    import hash_pkg::hash::hashFn;
 
-    @fragment
-    fn fragmentMain(@builtin(position) pos: vec4f) -> @location(0) vec4f {
-        let rand = pcg_2u_3f(vec2u(pos.xy) + u.frame);
-        return vec4(rand, 1f);
-    }
+    @compute @workgroup_size(1)
+    fn main() { let x = hashFn(1u); }
   `;
-
-  const weslSrc = { "./main.wesl": src };
-  const result = await expectNoLogAsync(async () =>
-    link({ weslSrc, rootModuleName: "./main.wesl", libs: [rand] }),
+  const result = await expectNoLogAsync(() =>
+    link({
+      weslSrc: { "./main.wesl": src },
+      rootModuleName: "./main.wesl",
+      libs: [hashPkg],
+    }),
   );
-  expect(result.dest).toContain("fn pcg_2u_3f");
-  expect(result.dest).not.toContain("sinRand");
+  expect(result.dest).toContain("fn hashFn");
+  expect(result.dest).not.toContain("unusedFn");
 });
 
 test("import from multi_pkg/second", async () => {