wesl 0.6.15 → 0.6.17

package/dist/index.js

@@ -976,6 +976,11 @@ function makeLiveDecls(parent = null) {
 		parent
 	};
 }
+/** debug routine for logging LiveDecls */
+function liveDeclsToString(liveDecls) {
+	const { decls, parent } = liveDecls;
+	return `decls: { ${Array.from(decls.entries()).map(([name$1, decl]) => `${name$1}:${identToString(decl)}`).join(", ")} }, parent: ${parent ? liveDeclsToString(parent) : "null"}`;
+}
 
 //#endregion
 //#region src/Mangler.ts
@@ -2306,63 +2311,46 @@ function stdEnumerant(name$1) {
 * @return any new declaration elements found (they will need to be emitted)
 */
 function bindIdents(params) {
-	const { rootAst, registry, virtuals, accumulateUnbound } = params;
+	const { rootAst, resolver, virtuals, accumulateUnbound } = params;
 	const { conditions = {}, mangler = minimalMangle } = params;
-	const { rootScope } = rootAst;
-	const globalNames = /* @__PURE__ */ new Set();
-	const knownDecls = /* @__PURE__ */ new Set();
-	const validRootDecls = findValidRootDecls(rootScope, conditions);
-	validRootDecls.forEach((decl) => {
-		decl.mangledName = decl.originalName;
-		globalNames.add(decl.originalName);
-		knownDecls.add(decl);
-	});
-	const unbound = accumulateUnbound ? [] : void 0;
-	const globalStatements = /* @__PURE__ */ new Map();
+	const validRootDecls = findValidRootDecls(rootAst.rootScope, conditions);
+	const { globalNames, knownDecls } = initializeRootDecls(validRootDecls);
 	const bindContext = {
-		registry,
+		resolver,
 		conditions,
 		knownDecls,
-		foundScopes: /* @__PURE__ */ new Set(),
-		globalNames,
-		globalStatements,
 		virtuals,
 		mangler,
-		unbound
+		foundScopes: /* @__PURE__ */ new Set(),
+		globalNames,
+		globalStatements: /* @__PURE__ */ new Map(),
+		unbound: accumulateUnbound ? [] : void 0
 	};
 	const declEntries = validRootDecls.map((d) => [d.originalName, d]);
+	const liveDecls = {
+		decls: new Map(declEntries),
+		parent: null
+	};
 	return {
-		decls: bindIdentsRecursive(rootScope, bindContext, {
-			decls: new Map(declEntries),
-			parent: null
-		}, true),
+		decls: bindIdentsRecursive(rootAst.rootScope, bindContext, liveDecls, true),
 		globalNames,
-		newStatements: [...globalStatements.values()],
-		unbound
+		newStatements: [...bindContext.globalStatements.values()],
+		unbound: bindContext.unbound
 	};
 }
-/** bind local references in library sources to reveal references to external packages */
-function findUnboundIdents(registry) {
-	const bindContext = {
-		registry,
-		conditions: {},
-		knownDecls: /* @__PURE__ */ new Set(),
-		foundScopes: /* @__PURE__ */ new Set(),
-		globalNames: /* @__PURE__ */ new Set(),
-		globalStatements: /* @__PURE__ */ new Map(),
-		mangler: minimalMangle,
-		unbound: [],
-		dontFollowDecls: true
-	};
-	Object.entries(registry.modules).forEach(([_module, ast]) => {
-		const declEntries = findValidRootDecls(ast.rootScope, {}).map((d) => [d.originalName, d]);
-		const liveDecls = {
-			decls: new Map(declEntries),
-			parent: null
-		};
-		bindIdentsRecursive(ast.rootScope, bindContext, liveDecls, true);
+/** Initialize root declarations with mangled names and add to tracking sets */
+function initializeRootDecls(validRootDecls) {
+	const globalNames = /* @__PURE__ */ new Set();
+	const knownDecls = /* @__PURE__ */ new Set();
+	validRootDecls.forEach((decl) => {
+		decl.mangledName = decl.originalName;
+		globalNames.add(decl.originalName);
+		knownDecls.add(decl);
 	});
-	return bindContext.unbound;
+	return {
+		globalNames,
+		knownDecls
+	};
 }
 /**
 * Find all conditionally valid declarations at the root level.
@@ -2384,13 +2372,13 @@ function findValidRootDecls(rootScope, conditions) {
 	let elseValid = false;
 	for (const item of rootScope.contents) if (item.kind === "decl") {
 		assertThatDebug(item.declElem);
-		const { valid, nextElseState } = validateConditional(findConditional(item.declElem.attributes), elseValid, conditions);
-		elseValid = nextElseState;
-		if (valid) found.push(item);
+		const validation = validateConditional(findConditional(item.declElem.attributes), elseValid, conditions);
+		elseValid = validation.nextElseState;
+		if (validation.valid) found.push(item);
 	} else if (item.kind === "partial") {
-		const { valid, nextElseState } = validateConditional(item.condAttribute, elseValid, conditions);
-		elseValid = nextElseState;
-		if (valid) collectDecls(item, found);
+		const validation = validateConditional(item.condAttribute, elseValid, conditions);
+		elseValid = validation.nextElseState;
+		if (validation.valid) collectDecls(item, found);
 	}
 	return found;
 }
@@ -2431,14 +2419,22 @@ function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
 	const { dontFollowDecls, foundScopes } = bindContext;
 	if (foundScopes.has(scope)) return [];
 	foundScopes.add(scope);
+	const { newGlobals, newFromChildren } = processScope(scope, bindContext, liveDecls, isRoot);
+	return [
+		newGlobals,
+		newFromChildren,
+		dontFollowDecls ? [] : handleDecls(newGlobals, bindContext)
+	].flat();
+}
+/** Process all identifiers and subscopes in this scope */
+function processScope(scope, bindContext, liveDecls, isRoot) {
 	const newGlobals = [];
 	const newFromChildren = [];
 	let elseValid = false;
 	scope.contents.forEach((child) => {
-		const { kind: kind$1 } = child;
-		if (kind$1 === "decl") {
+		if (child.kind === "decl") {
 			if (!isRoot) liveDecls.decls.set(child.originalName, child);
-		} else if (kind$1 === "ref") {
+		} else if (child.kind === "ref") {
 			const newDecl = handleRef(child, liveDecls, bindContext);
 			if (newDecl) newGlobals.push(newDecl);
 		} else {
@@ -2449,24 +2445,21 @@ function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
 			}
 		}
 	});
-	return [
+	return {
 		newGlobals,
-		newFromChildren,
-		dontFollowDecls ? [] : handleDecls(newGlobals, bindContext)
-	].flat();
+		newFromChildren
+	};
 }
 /**
-* Trace references to their declarations
-* mutates to:
-*  mangle declarations
-*  mark references as 'std' if they match a wgsl std function or type
+* Trace references to their declarations.
+* Mutates to mangle declarations and mark std references.
 *
 * @return the found declaration, or undefined if this ref has already been processed
 */
 function handleRef(ident$1, liveDecls, bindContext) {
-	const { registry, conditions, unbound, virtuals } = bindContext;
+	const { resolver, conditions, unbound, virtuals } = bindContext;
 	if (ident$1.refersTo || ident$1.std) return;
-	const foundDecl = findDeclInModule(ident$1, liveDecls) ?? findQualifiedImport(ident$1, registry, conditions, virtuals, unbound);
+	const foundDecl = findDeclInModule(ident$1, liveDecls) ?? findQualifiedImport(ident$1, resolver, conditions, virtuals, unbound);
 	if (foundDecl) {
 		ident$1.refersTo = foundDecl.decl;
 		return handleNewDecl(ident$1, foundDecl, bindContext);
@@ -2519,7 +2512,7 @@ function handleNewDecl(refIdent$1, foundDecl, bindContext) {
 		return decl;
 	}
 }
-/** Using the LiveDecls, search earlier in the scope and in parent scopes to find a matching decl ident */
+/** Search earlier in the scope and parent scopes for a matching declaration */
 function findDeclInModule(ident$1, liveDecls) {
 	const found = liveDecls.decls.get(ident$1.originalName);
 	if (found) return {
@@ -2532,25 +2525,27 @@ function findDeclInModule(ident$1, liveDecls) {
 * Match a reference identifier to a declaration in another module via an import statement
 * or via an inline qualified ident e.g. foo::bar().
 */
-function findQualifiedImport(refIdent$1, parsed, conditions, virtuals, unbound) {
+function findQualifiedImport(refIdent$1, resolver, conditions, virtuals, unbound) {
 	const flatImps = flatImports(refIdent$1.ast, conditions);
 	const identParts = refIdent$1.originalName.split("::");
 	const modulePathParts = matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);
-	if (modulePathParts) {
-		const result = findExport(modulePathParts, refIdent$1.ast.srcModule, parsed, conditions, virtuals);
-		if (!result) if (unbound) unbound.push(modulePathParts);
-		else failIdent(refIdent$1, `module not found for '${modulePathParts.join("::")}'`);
-		return result;
-	} else if (unbound) unbound.push(identParts);
-}
-/** Combine an import using the flattened import array, find an import that matches a provided ident */
+	if (!modulePathParts) {
+		if (unbound) unbound.push(identParts);
+		return;
+	}
+	const result = findExport(modulePathParts, refIdent$1.ast.srcModule, resolver, conditions, virtuals);
+	if (!result) if (unbound) unbound.push(modulePathParts);
+	else failIdent(refIdent$1, `module not found for '${modulePathParts.join("::")}'`);
+	return result;
+}
+/** Find an import statement that matches a provided identifier */
 function matchingImport(identParts, flatImports$1) {
 	for (const flat of flatImports$1) if (flat.importPath.at(-1) === identParts.at(0)) return [...flat.modulePath, ...identParts.slice(1)];
 }
 /** @return an exported root declIdent for the provided path */
-function findExport(modulePathParts, srcModule, parsed, conditions = {}, virtuals) {
+function findExport(modulePathParts, srcModule, resolver, conditions = {}, virtuals) {
 	const modulePath = absoluteModulePath(modulePathParts, srcModule).slice(0, -1).join("::");
-	const moduleAst = parsed.modules[modulePath] ?? virtualModule(modulePathParts[0], conditions, virtuals);
+	const moduleAst = resolver.resolveModule(modulePath) ?? virtualModule(modulePathParts[0], conditions, virtuals);
 	if (!moduleAst) return void 0;
 	const name$1 = last(modulePathParts);
 	const decl = publicDecl(moduleAst.rootScope, name$1, conditions);
@@ -2594,9 +2589,8 @@ function rootLiveDecls(decl, conditions) {
 	return liveDecls;
 }
 /**
-* Mutate a DeclIdent to set a unique name for global linking
-* using a mangling function to choose a unique name.
-* Also update the set of globally unique names.
+* Set a globally unique mangled name for this declaration.
+* Uses the mangler function to avoid name collisions.
 */
 function setMangledName(proposedName, decl, globalNames, srcModule, mangler) {
 	if (decl.mangledName) return;
@@ -2758,68 +2752,136 @@ function noSuffix(path) {
 }
 
 //#endregion
-//#region src/ParsedRegistry.ts
-function parsedRegistry() {
-	resetScopeIds();
-	return { modules: {} };
-}
-/** for debug */
-function registryToString(registry) {
-	return `modules: ${[...Object.keys(registry.modules)]}`;
-}
-/** Look up a module with a flexible selector.
-*    :: separated module path,   package::util
-*    / separated file path       ./util.wesl (or ./util)
-*          - note: a file path should not include a weslRoot prefix, e.g. not ./shaders/util.wesl
-*    simpleName                  util
-*/
-function selectModule(parsed, selectPath, packageName = "package") {
-	let modulePath;
-	if (selectPath.includes("::")) modulePath = selectPath;
-	else if (selectPath.includes("/") || selectPath.endsWith(".wesl") || selectPath.endsWith(".wgsl")) modulePath = fileToModulePath(selectPath, packageName);
-	else modulePath = packageName + "::" + selectPath;
-	return parsed.modules[modulePath];
-}
-/**
-* @param srcFiles    map of source strings by file path
-*                    key is '/' separated relative path (relative to srcRoot, not absolute file path )
-*                    value is wesl source string
-* @param registry    add parsed modules to this registry
-* @param packageName name of package
-*/
-function parseIntoRegistry(srcFiles, registry, packageName = "package", debugWeslRoot) {
-	let weslRoot$1 = debugWeslRoot;
-	if (weslRoot$1 === void 0) weslRoot$1 = "";
-	else if (!weslRoot$1.endsWith("/")) weslRoot$1 += "/";
-	Object.entries(srcFiles).map(([filePath, src]) => {
-		return {
-			modulePath: fileToModulePath(filePath, packageName),
-			debugFilePath: weslRoot$1 + filePath,
-			src
-		};
-	}).forEach((mod) => {
-		const parsed = parseSrcModule(mod);
-		if (registry.modules[mod.modulePath]) return;
-		registry.modules[mod.modulePath] = parsed;
-	});
-}
-function parseLibsIntoRegistry(libs, registry) {
-	libs.forEach(({ modules, name: name$1 }) => {
-		parseIntoRegistry(modules, registry, name$1);
-	});
-	libs.forEach(({ dependencies }) => {
-		parseLibsIntoRegistry(dependencies || [], registry);
-	});
-}
+//#region src/ModuleResolver.ts
 const libRegex = /^lib\.w[eg]sl$/i;
-/** convert a file path (./foo/bar.wesl)
-*  to a module path (package::foo::bar) */
-function fileToModulePath(filePath, packageName) {
+/** Module resolver for in-memory source records. Lazy by default. */
+var RecordResolver = class {
+	astCache = /* @__PURE__ */ new Map();
+	sources;
+	packageName;
+	debugWeslRoot;
+	constructor(sources, options = {}) {
+		const { packageName = "package", debugWeslRoot } = options;
+		this.sources = sources;
+		this.packageName = packageName;
+		this.debugWeslRoot = normalizeDebugRoot(debugWeslRoot);
+	}
+	resolveModule(modulePath) {
+		const cached = this.astCache.get(modulePath);
+		if (cached) return cached;
+		const source = this.findSource(modulePath);
+		if (!source) return void 0;
+		const ast = parseSrcModule({
+			modulePath,
+			debugFilePath: this.modulePathToDebugPath(modulePath),
+			src: source
+		});
+		this.astCache.set(modulePath, ast);
+		return ast;
+	}
+	findSource(modulePath) {
+		if (this.sources[modulePath]) return this.sources[modulePath];
+		const filePath = this.moduleToFilePath(modulePath);
+		return findInVariants(this.sources, filePath);
+	}
+	moduleToFilePath(modulePath) {
+		const parts = modulePath.split("::");
+		if (parts[0] !== this.packageName && parts[0] !== "package") return modulePath;
+		return parts.slice(1).join("/");
+	}
+	modulePathToDebugPath(modulePath) {
+		const filePath = this.moduleToFilePath(modulePath);
+		return this.debugWeslRoot + filePath + ".wesl";
+	}
+	/** Return all modules, parsing them on-demand if needed. */
+	allModules() {
+		for (const filePath of Object.keys(this.sources)) {
+			const modulePath = fileToModulePath(filePath, this.packageName, this.packageName !== "package");
+			this.resolveModule(modulePath);
+		}
+		return this.astCache.entries();
+	}
+};
+/** Composite resolver that tries each resolver in order until one succeeds. */
+var CompositeResolver = class {
+	resolvers;
+	constructor(resolvers) {
+		this.resolvers = resolvers;
+	}
+	resolveModule(modulePath) {
+		for (const resolver of this.resolvers) {
+			const ast = resolver.resolveModule(modulePath);
+			if (ast) return ast;
+		}
+	}
+};
+/** Lazy resolver for WeslBundle library modules. */
+var BundleResolver = class {
+	astCache = /* @__PURE__ */ new Map();
+	sources;
+	packageName;
+	debugWeslRoot;
+	constructor(bundle, debugWeslRoot) {
+		this.sources = bundle.modules;
+		this.packageName = bundle.name;
+		this.debugWeslRoot = normalizeDebugRoot(debugWeslRoot);
+	}
+	resolveModule(modulePath) {
+		if (modulePath !== this.packageName && !modulePath.startsWith(this.packageName + "::")) return;
+		const cached = this.astCache.get(modulePath);
+		if (cached) return cached;
+		const source = this.findSource(modulePath);
+		if (!source) return void 0;
+		const ast = parseSrcModule({
+			modulePath,
+			debugFilePath: this.modulePathToDebugPath(modulePath),
+			src: source
+		});
+		this.astCache.set(modulePath, ast);
+		return ast;
+	}
+	findSource(modulePath) {
+		const filePath = this.moduleToFilePath(modulePath);
+		if (modulePath === this.packageName) {
+			const libSrc = findInVariants(this.sources, "lib", ["wesl", "wgsl"]);
+			if (libSrc) return libSrc;
+		}
+		return findInVariants(this.sources, filePath);
+	}
+	moduleToFilePath(modulePath) {
+		const parts = modulePath.split("::");
+		if (parts[0] !== this.packageName) return modulePath;
+		return parts.slice(1).join("/");
+	}
+	modulePathToDebugPath(modulePath) {
+		const filePath = this.moduleToFilePath(modulePath);
+		return this.debugWeslRoot + this.packageName + "/" + filePath + ".wesl";
+	}
+};
+/** Convert file path to module path (e.g., "foo/bar.wesl" -> "package::foo::bar"). */
+function fileToModulePath(filePath, packageName, treatLibAsRoot) {
 	if (filePath.includes("::")) return filePath;
-	if (packageName !== "package" && libRegex.test(filePath)) return packageName;
+	if (treatLibAsRoot && libRegex.test(filePath)) return packageName;
 	const moduleSuffix = noSuffix(normalize(filePath)).replaceAll("/", "::");
 	return packageName + "::" + moduleSuffix;
 }
+/** Normalize debug root to end with / or be empty. */
+function normalizeDebugRoot(debugWeslRoot) {
+	if (debugWeslRoot === void 0) return "./";
+	if (debugWeslRoot === "") return "";
+	return debugWeslRoot.endsWith("/") ? debugWeslRoot : debugWeslRoot + "/";
+}
+/** Try path variants with and without ./ prefix and extension suffixes. */
+function findInVariants(sources, basePath, extensions = ["wesl", "wgsl"]) {
+	for (const prefix of ["", "./"]) {
+		const path = prefix + basePath;
+		if (sources[path]) return sources[path];
+		for (const ext of extensions) {
+			const withExt = `${path}.${ext}`;
+			if (sources[withExt]) return sources[withExt];
+		}
+	}
+}
 
 //#endregion
 //#region src/Linker.ts
@@ -2833,25 +2895,47 @@ function fileToModulePath(filePath, packageName) {
 * Only code that is valid with the current conditions is included in the output.
 */
 async function link(params) {
-	const { weslSrc, debugWeslRoot, libs = [] } = params;
-	const registry = parsedRegistry();
-	parseIntoRegistry(weslSrc, registry, "package", debugWeslRoot);
-	parseLibsIntoRegistry(libs, registry);
-	return new LinkedWesl(linkRegistry({
-		registry,
-		...params
-	}));
+	return new LinkedWesl(_linkSync(params));
 }
 /** linker api for benchmarking */
 function _linkSync(params) {
-	const { weslSrc, debugWeslRoot, libs = [] } = params;
-	const registry = parsedRegistry();
-	parseIntoRegistry(weslSrc, registry, "package", debugWeslRoot);
-	parseLibsIntoRegistry(libs, registry);
-	return new LinkedWesl(linkRegistry({
-		registry,
-		...params
+	const { weslSrc, libs = [], packageName, debugWeslRoot } = params;
+	const { resolver } = params;
+	const resolvers = [];
+	if (resolver) resolvers.push(resolver);
+	else if (weslSrc) resolvers.push(new RecordResolver(weslSrc, {
+		packageName,
+		debugWeslRoot
 	}));
+	else throw new Error("Either resolver or weslSrc must be provided");
+	if (libs.length > 0) {
+		const libResolvers = createLibraryResolvers(libs, debugWeslRoot);
+		resolvers.push(...libResolvers);
+	}
+	return linkRegistry({
+		resolver: resolvers.length === 1 ? resolvers[0] : new CompositeResolver(resolvers),
+		...params
+	});
+}
+function createLibraryResolvers(libs, debugWeslRoot) {
+	return flattenLibraryTree(libs).map((lib) => new BundleResolver(lib, debugWeslRoot));
+}
+/** Flatten library dependency tree, deduplicating by object identity rather than package name.
+*
+* Some packages (like Lygia) provide multiple bundles in the same npm package
+* to enable tree shaking. All bundles share the same package name, so we deduplicate
+* by object identity to keep them distinct. Also handles circular dependencies correctly. */
+function flattenLibraryTree(libs) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	function visit(bundle) {
+		if (seen.has(bundle)) return;
+		seen.add(bundle);
+		result.push(bundle);
+		bundle.dependencies?.forEach(visit);
+	}
+	libs.forEach(visit);
+	return result;
 }
 /** Link wesl from a registry of already parsed modules.
 *
@@ -2864,22 +2948,16 @@ function linkRegistry(params) {
 	const { transformedAst, newDecls, newStatements } = bindAndTransform(params);
 	return SrcMapBuilder.build(emitWgsl(transformedAst.moduleElem, transformedAst.srcModule, newDecls, newStatements, params.conditions));
 }
-/** bind identifers and apply any transform plugins */
+/** Bind identifiers and apply transform plugins */
 function bindAndTransform(params) {
-	const { registry, mangler } = params;
+	const { resolver, mangler, constants, config } = params;
 	const { rootModuleName = "main", conditions = {} } = params;
-	const rootAst = getRootModule(registry, rootModuleName);
-	const { constants, config } = params;
-	let { virtualLibs } = params;
-	if (constants) virtualLibs = {
-		...virtualLibs,
-		constants: constantsGenerator(constants)
-	};
+	const rootAst = getRootModule(resolver, normalizeModuleName(rootModuleName), rootModuleName);
 	const { globalNames, decls: newDecls, newStatements } = bindIdents({
 		rootAst,
-		registry,
+		resolver,
 		conditions,
-		virtuals: virtualLibs && mapValues(virtualLibs, (fn$1) => ({ fn: fn$1 })),
+		virtuals: setupVirtualLibs(params.virtualLibs, constants),
 		mangler
 	});
 	return {
@@ -2888,22 +2966,34 @@ function bindAndTransform(params) {
 		newStatements
 	};
 }
-function constantsGenerator(constants) {
-	return () => Object.entries(constants).map(([name$1, value]) => `const ${name$1} = ${value};`).join("\n");
+/** Convert root module name to module path format.
+* Accepts: module path (package::foo), file path (./foo.wesl), or name (foo) */
+function normalizeModuleName(name$1) {
+	if (name$1.includes("::")) return name$1;
+	if (name$1.includes("/") || name$1.endsWith(".wesl") || name$1.endsWith(".wgsl")) return "package::" + name$1.replace(/\.(wesl|wgsl)$/, "").replace(/^\.\//, "").replaceAll("/", "::");
+	return "package::" + name$1;
 }
-/** get a reference to the root module, selecting by module name */
-function getRootModule(parsed, rootModuleName) {
-	const rootModule = selectModule(parsed, rootModuleName);
-	if (!rootModule) {
-		if (tracing) {
-			console.log(`parsed modules: ${Object.keys(parsed.modules)}`);
-			console.log(`root module not found: ${rootModuleName}`);
-		}
+/** Resolve root module AST or throw if not found. */
+function getRootModule(resolver, modulePath, rootModuleName) {
+	const rootAst = resolver.resolveModule(modulePath);
+	if (!rootAst) {
+		if (tracing) console.log(`root module not found: ${modulePath} (from ${rootModuleName})`);
 		throw new Error(`Root module not found: ${rootModuleName}`);
 	}
-	return rootModule;
+	return rootAst;
+}
+/** Create virtual library set from code generators and host constants. */
+function setupVirtualLibs(virtualLibs, constants) {
+	let libs = virtualLibs;
+	if (constants) {
+		const constantsGen = () => Object.entries(constants).map(([name$1, value]) => `const ${name$1} = ${value};`).join("\n");
+		libs = {
+			...libs,
+			constants: constantsGen
+		};
+	}
+	return libs && mapValues(libs, (fn$1) => ({ fn: fn$1 }));
 }
-/** run any plugins that transform the AST */
 function applyTransformPlugins(rootModule, globalNames, config) {
 	const { moduleElem, srcModule } = rootModule;
 	const startAst = {
@@ -2914,23 +3004,8 @@ function applyTransformPlugins(rootModule, globalNames, config) {
 	};
 	return filterMap(config?.plugins ?? [], (plugin) => plugin.transform).reduce((ast, transform) => transform(ast), startAst);
 }
-/** traverse the AST and emit WGSL */
 function emitWgsl(rootModuleElem, srcModule, newDecls, newStatements, conditions = {}) {
-	const prologueBuilders = newStatements.map((s) => {
-		const { elem, srcModule: srcModule$1 } = s;
-		const { src: text$1, debugFilePath: path } = srcModule$1;
-		const builder = new SrcMapBuilder({
-			text: text$1,
-			path
-		});
-		lowerAndEmit({
-			srcBuilder: builder,
-			rootElems: [elem],
-			conditions
-		});
-		builder.addNl();
-		return builder;
-	});
+	const prologueBuilders = newStatements.map((s) => emitStatement(s, conditions));
 	const rootBuilder = new SrcMapBuilder({
 		text: srcModule.src,
 		path: srcModule.debugFilePath
@@ -2941,25 +3016,43 @@ function emitWgsl(rootModuleElem, srcModule, newDecls, newStatements, conditions
 		conditions,
 		extracting: false
 	});
-	const declBuilders = newDecls.map((decl) => {
-		const builder = new SrcMapBuilder({
-			text: decl.srcModule.src,
-			path: decl.srcModule.debugFilePath
-		});
-		lowerAndEmit({
-			srcBuilder: builder,
-			rootElems: [decl.declElem],
-			conditions,
-			skipConditionalFiltering: true
-		});
-		return builder;
-	});
+	const declBuilders = newDecls.map((decl) => emitDecl(decl, conditions));
 	return [
 		...prologueBuilders,
 		rootBuilder,
 		...declBuilders
 	];
 }
+function emitStatement(s, conditions) {
+	const { elem, srcModule } = s;
+	const { src: text$1, debugFilePath: path } = srcModule;
+	const builder = new SrcMapBuilder({
+		text: text$1,
+		path
+	});
+	lowerAndEmit({
+		srcBuilder: builder,
+		rootElems: [elem],
+		conditions
+	});
+	builder.addNl();
+	return builder;
+}
+/** Skip conditional filtering because findValidRootDecls already validated these declarations */
+function emitDecl(decl, conditions) {
+	const { src: text$1, debugFilePath: path } = decl.srcModule;
+	const builder = new SrcMapBuilder({
+		text: text$1,
+		path
+	});
+	lowerAndEmit({
+		srcBuilder: builder,
+		rootElems: [decl.declElem],
+		conditions,
+		skipConditionalFiltering: true
+	});
+	return builder;
+}
 
 //#endregion
 //#region src/LinkerUtil.ts
@@ -3294,4 +3387,4 @@ function makeWeslDevice(device) {
 }
 
 //#endregion
-export { LinkedWesl, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindingStructsPlugin, blankWeslParseState, childIdent, childScope, containsScope, debugContentsToString, emptyScope, errorHighlight, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, isGlobal, last, lengthPrefixMangle, link, linkRegistry, lowerBindingStructs, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, multiKeySet, nextIdentId, noSuffix, normalize, offsetToLineNumber, overlapTail, parseIntoRegistry, parseLibsIntoRegistry, parseSrcModule, parsedRegistry, partition, publicDecl, registryToString, replaceWords, requestWeslDevice, resetScopeIds, scan, scopeToString, scopeToStringLong, selectModule, syntheticWeslParseState, transformBindingReference, transformBindingStruct, underscoreMangle };
+export { BundleResolver, CompositeResolver, LinkedWesl, RecordResolver, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, blankWeslParseState, childIdent, childScope, containsScope, debugContentsToString, emptyScope, errorHighlight, filterMap, findMap, findRefsToBindingStructs, findValidRootDecls, flatImports, groupBy, grouped, identToString, isGlobal, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, multiKeySet, nextIdentId, noSuffix, normalize, normalizeModuleName, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, scan, scopeToString, scopeToStringLong, syntheticWeslParseState, transformBindingReference, transformBindingStruct, underscoreMangle };