wesl-plugin 0.6.70 → 0.6.71

package/README.md

@@ -96,10 +96,10 @@ export default {
 
 ### Conditions in Import Path
 
-For `?static`, you can specify conditions directly in the import:
+For `?static`, you can specify conditions as query parameters:
 
 ```ts
-import wgsl from "./app.wesl MOBILE=true DEBUG=false ?static";
+import wgsl from "./app.wesl?MOBILE=true&DEBUG=false&static";
 ```
 
 ## Configuration (wesl.toml)
@@ -124,7 +124,7 @@ import type { PluginExtension } from "wesl-plugin";
 
 const myExtension: PluginExtension = {
   extensionName: "myfeature",  // enables ?myfeature imports
-  emitFn: async (shaderPath, api, conditions) => {
+  emitFn: async (shaderPath, api, conditions, options) => {
     const sources = await api.weslSrc();
     // Return JavaScript code as a string
     return `export default ${JSON.stringify(sources)};`;

package/dist/{PluginExtension-nH8vi0nm.d.mts → PluginExtension-CHxUB0-8.d.mts}

@@ -31,14 +31,16 @@ interface WeslTomlInfo {
 }
 //#endregion
 //#region src/PluginExtension.d.ts
-/** function type required for for emit extensions */
+/** function type required for emit extensions */
 type ExtensionEmitFn = (/** absolute path to the shader to which the extension is attached */
 
 shaderPath: string, /** support functions available to plugin extensions */
 
 pluginApi: PluginExtensionApi, /** static conditions specified on the js import */
 
-conditions?: Record<string, boolean>) => Promise<string>;
+conditions?: Record<string, boolean>, /** plugin-level options from query params (e.g., { include: "all" }) */
+
+options?: Record<string, string>) => Promise<string>;
 /** an extension that runs inside the wesl-js build plugin */
 interface PluginExtension extends WeslJsPlugin {
   /** javascript imports with this suffix will trigger the plugin */
@@ -47,6 +49,10 @@ interface PluginExtension extends WeslJsPlugin {
    *   e.g. import myPluginJs from "./foo.wesl?myPlugin"; */
   emitFn: ExtensionEmitFn;
 }
+interface ProjectSources {
+  weslSrc: Record<string, string>;
+  dependencies: string[];
+}
 /** api supplied to plugin extensions */
 interface PluginExtensionApi {
   weslToml: () => Promise<WeslTomlInfo>;
@@ -54,6 +60,12 @@ interface PluginExtensionApi {
   weslRegistry: () => Promise<BatchModuleResolver>;
   weslMain: (baseId: string) => Promise<string>;
   weslDependencies: () => Promise<string[]>;
+  /** weslRoot relative to tomlDir, with forward slashes. */
+  debugWeslRoot: () => Promise<string>;
+  /** Get weslSrc scoped to modules reachable from a root, plus their deps. */
+  scopedProject: (rootModuleName: string) => Promise<ProjectSources>;
+  /** Fetch project sources, either all or scoped to reachable modules. */
+  fetchProject: (rootModuleName: string, options?: Record<string, string>) => Promise<ProjectSources>;
 }
 //#endregion
-export { PluginExtension as n, PluginExtensionApi as r, ExtensionEmitFn as t };
+export { ProjectSources as i, PluginExtension as n, PluginExtensionApi as r, ExtensionEmitFn as t };

package/dist/{StaticExtension-Chl5KPpw.mjs → StaticExtension-Q8HMuFJa.mjs}

@@ -14,12 +14,9 @@ const linkBuildExtension = {
 	emitFn: emitLinkJs
 };
 /** Emit a JavaScript LinkParams structure, ready for linking at runtime. */
-async function emitLinkJs(baseId, api) {
-	const { resolvedRoot, tomlDir } = await api.weslToml();
-	const weslSrc = await api.weslSrc();
+async function emitLinkJs(baseId, api, _conditions, options) {
 	const rootModuleName = noSuffix(await api.weslMain(baseId));
-	const debugWeslRoot = path.relative(tomlDir, resolvedRoot).replaceAll(path.sep, "/");
-	const autoDeps = await api.weslDependencies();
+	const [{ weslSrc, dependencies: autoDeps }, debugWeslRoot] = await Promise.all([api.fetchProject(rootModuleName, options), api.debugWeslRoot()]);
 	const sanitizedDeps = autoDeps.map((dep) => dep.replaceAll("/", "_"));
 	const bundleImports = autoDeps.map((p, i) => `import ${sanitizedDeps[i]} from "${p}";`).join("\n");
 	const paramsName = `link${path.basename(rootModuleName).replace(/\W/g, "_")}Config`;
@@ -1301,34 +1298,28 @@ function resolve(specifier, parent) {
 
 //#endregion
 //#region src/extensions/StaticExtension.ts
-/**
-* a wesl-js ?static build extension that statically links from the root file
-* and emits a JavaScript file containing the linked wgsl string.
-*
-* use it like this:
-*   import wgsl from "./shaders/app.wesl?static";
-*
-* or with conditions, like this:
-*   import wgsl from "../shaders/foo/app.wesl MOBILE=true FUN SAFE=false ?static";
-*/
+/** Build extension for ?static imports: links WESL at build time, emits WGSL string. */
 const staticBuildExtension = {
 	extensionName: "static",
 	emitFn: emitStaticJs
 };
-/** Emit a JavaScript file containing the wgsl string */
-async function emitStaticJs(baseId, api, conditions) {
+/** Emit a JS module exporting the statically linked WGSL string. */
+async function emitStaticJs(baseId, api, conditions, _options) {
 	const { resolvedRoot, tomlDir } = await api.weslToml();
 	const parentModule = url.pathToFileURL(path.join(tomlDir, "wesl.toml")).toString();
-	const futureLibs = (await api.weslDependencies()).map((d) => resolve(d, parentModule)).map((f) => import(f));
-	const libs = (await Promise.all(futureLibs)).map((m) => m.default);
-	return `
-    export const wgsl = \`${(await link({
-		weslSrc: await api.weslSrc(),
-		rootModuleName: noSuffix(await api.weslMain(baseId)),
+	const rootModuleName = noSuffix(await api.weslMain(baseId));
+	const [weslSrc, dependencies] = await Promise.all([api.weslSrc(), api.weslDependencies()]);
+	const libFileUrls = dependencies.map((d) => resolve(d, parentModule));
+	const libs = (await Promise.all(libFileUrls.map((f) => import(f)))).map((m) => m.default);
+	const { dest: wgsl } = await link({
+		weslSrc,
+		rootModuleName,
 		debugWeslRoot: path.relative(tomlDir, resolvedRoot).replaceAll(path.sep, "/"),
 		libs,
 		conditions
-	})).dest}\`;
+	});
+	return `
+    export const wgsl = \`${wgsl}\`;
     export default wgsl;
   `;
 }

package/dist/{WeslPlugin-BKQJvQve.mjs → WeslPlugin-CajtfXHH.mjs}

@@ -1,10 +1,10 @@
-import { n as resolve, r as linkBuildExtension, t as staticBuildExtension } from "./StaticExtension-Chl5KPpw.mjs";
+import { n as resolve, r as linkBuildExtension, t as staticBuildExtension } from "./StaticExtension-Q8HMuFJa.mjs";
 import path, { posix, win32 } from "node:path";
-import { RecordResolver, WeslParseError, filterMap, findUnboundIdents, npmNameVariations } from "wesl";
+import { RecordResolver, WeslParseError, discoverModules, fileToModulePath, filterMap, findUnboundIdents, npmNameVariations } from "wesl";
+import fs, { lstat, readdir, readlink, realpath } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import * as xi from "node:fs";
 import { createUnplugin } from "unplugin";
-import fs$1, { lstat, readdir, readlink, realpath } from "node:fs/promises";
 import { lstatSync, readdir as readdir$1, readdirSync, readlinkSync, realpathSync as realpathSync$1 } from "fs";
 import { EventEmitter } from "node:events";
 import Pe from "node:stream";
@@ -6947,7 +6947,7 @@ const defaultWeslToml = {
 * Provide default values for any required WeslToml fields.
 */
 async function loadWeslToml(tomlFile) {
-	const tomlString = await fs$1.readFile(tomlFile, "utf-8");
+	const tomlString = await fs.readFile(tomlFile, "utf-8");
 	const parsed = import_toml.default.parse(tomlString);
 	return {
 		...defaultWeslToml,
@@ -6964,11 +6964,11 @@ async function loadWeslToml(tomlFile) {
 async function findWeslToml(projectDir, specifiedToml) {
 	let tomlFile;
 	if (specifiedToml) {
-		await fs$1.access(specifiedToml);
+		await fs.access(specifiedToml);
 		tomlFile = specifiedToml;
 	} else {
 		const tomlPath = path.join(projectDir, "wesl.toml");
-		tomlFile = await fs$1.access(tomlPath).then(() => tomlPath).catch(() => {});
+		tomlFile = await fs.access(tomlPath).then(() => tomlPath).catch(() => {});
 	}
 	let parsedToml;
 	let tomlDir;
@@ -7047,7 +7047,7 @@ function* exportSubpaths(mPath) {
 *
 * @param weslSrc - Record of WESL source files by path
 * @param projectDir - Project directory for resolving package imports
-* @param virtualLibNames - Virtual lib names to exclude (e.g., ['test', 'constants'])
+* @param virtualLibNames - Virtual lib names to exclude (e.g., ['env', 'constants'])
 * @returns Dependency paths in npm format (e.g., 'foo/bar', 'foo')
 */
 function parseDependencies(weslSrc, projectDir, virtualLibNames = []) {
@@ -7063,6 +7063,10 @@ function parseDependencies(weslSrc, projectDir, virtualLibNames = []) {
 	}
 	const unbound = findUnboundIdents(resolver);
 	if (!unbound) return [];
+	return resolvePkgDeps(unbound, projectDir, virtualLibNames);
+}
+/** Resolve pre-computed unbound refs to npm dependency paths. */
+function resolvePkgDeps(unbound, projectDir, virtualLibNames = []) {
 	const excludeRoots = new Set(["constants", ...virtualLibNames]);
 	const pkgRefs = unbound.filter((modulePath) => modulePath.length > 1 && !excludeRoots.has(modulePath[0]));
 	if (pkgRefs.length === 0) return [];
@@ -7079,29 +7083,51 @@ function projectDirURL(projectDir) {
 
 //#endregion
 //#region src/PluginApi.ts
+/** Construct the API surface available to plugin extensions. */
 function buildApi(context, unpluginCtx) {
-	return {
+	const api = {
 		weslToml: async () => getWeslToml(context, unpluginCtx),
 		weslSrc: async () => loadWesl(context, unpluginCtx),
 		weslRegistry: async () => getRegistry(context, unpluginCtx),
 		weslMain: makeGetWeslMain(context, unpluginCtx),
-		weslDependencies: async () => findDependencies(context, unpluginCtx)
+		weslDependencies: async () => findDependencies(context, unpluginCtx),
+		debugWeslRoot: async () => getDebugWeslRoot(context, unpluginCtx),
+		scopedProject: (rootModuleName) => getScopedProject(rootModuleName, context, unpluginCtx),
+		fetchProject: (rootModuleName, options) => fetchProject(api, rootModuleName, options)
+	};
+	return api;
+}
+/** Get weslSrc scoped to modules reachable from root, plus their deps. */
+async function getScopedProject(rootModuleName, context, unpluginCtx) {
+	const fullSrc = await loadWesl(context, unpluginCtx);
+	const { toml, tomlDir: projectDir } = await getWeslToml(context, unpluginCtx);
+	const { weslSrc, unbound } = discoverModules(fullSrc, new RecordResolver(fullSrc), fileToModulePath(rootModuleName, "package", false));
+	return {
+		weslSrc,
+		dependencies: resolveDepsFromUnbound(toml.dependencies, unbound, projectDir)
 	};
 }
-/** load the wesl.toml  */
+/** Resolve dependencies using pre-computed unbound refs (avoids re-parsing). */
+function resolveDepsFromUnbound(dependencies, unbound, projectDir) {
+	const depsArray = Array.isArray(dependencies) ? dependencies : [dependencies ?? "auto"];
+	if (!depsArray.includes("auto")) return depsArray;
+	const base = depsArray.filter((dep) => dep !== "auto");
+	const discovered = resolvePkgDeps(unbound, projectDir);
+	return [...new Set([...base, ...discovered])];
+}
+/** Load and cache the wesl.toml configuration. */
 async function getWeslToml(context, unpluginCtx) {
 	const { cache } = context;
 	if (cache.weslToml) return cache.weslToml;
-	const specifiedToml = context.options.weslToml;
-	const tomlInfo = await findWeslToml(process.cwd(), specifiedToml);
+	const tomlInfo = await findWeslToml(process.cwd(), context.options.weslToml);
 	if (tomlInfo.tomlFile) {
 		unpluginCtx.addWatchFile(tomlInfo.tomlFile);
 		context.weslToml = tomlInfo.tomlFile;
 	}
 	cache.weslToml = tomlInfo;
-	return cache.weslToml;
+	return tomlInfo;
 }
-/** load and parse all the wesl files into a ParsedRegistry */
+/** Load all wesl files and return a cached RecordResolver. */
 async function getRegistry(context, unpluginCtx) {
 	const { cache } = context;
 	let { registry } = cache;
@@ -7109,26 +7135,42 @@ async function getRegistry(context, unpluginCtx) {
 	const loaded = await loadWesl(context, unpluginCtx);
 	const { resolvedRoot } = await getWeslToml(context, unpluginCtx);
 	registry = new RecordResolver(loaded);
-	Object.keys(loaded).map((p) => path.resolve(resolvedRoot, p)).forEach((f) => {
-		unpluginCtx.addWatchFile(f);
-	});
+	const fullPaths = Object.keys(loaded).map((p) => path.resolve(resolvedRoot, p));
+	for (const f of fullPaths) unpluginCtx.addWatchFile(f);
 	cache.registry = registry;
 	return registry;
 }
-/** if the dependency list includes "auto", fill in the missing dependencies
-* by parsing the source files to find references to packages
-* @return the list of dependencies with "auto" replaced by the found dependencies
-*/
+/** Compute weslRoot relative to tomlDir, with forward slashes. */
+async function getDebugWeslRoot(context, unpluginCtx) {
+	const { resolvedRoot, tomlDir } = await getWeslToml(context, unpluginCtx);
+	return toUnixPath(path.relative(tomlDir, resolvedRoot));
+}
+/** Fetch project sources, either all or scoped to reachable modules. */
+async function fetchProject(api, rootModuleName, options) {
+	if (options?.include === "all") {
+		const [weslSrc, dependencies] = await Promise.all([api.weslSrc(), api.weslDependencies()]);
+		return {
+			weslSrc,
+			dependencies
+		};
+	}
+	return api.scopedProject(rootModuleName);
+}
+/** Find dependencies, resolving "auto" entries by parsing source files. */
 async function findDependencies(context, unpluginCtx) {
 	const { toml, tomlDir: projectDir } = await getWeslToml(context, unpluginCtx);
 	const weslSrc = await loadWesl(context, unpluginCtx);
-	const { dependencies = "auto" } = toml;
-	const depsArray = Array.isArray(dependencies) ? dependencies : [dependencies];
+	return resolveDeps(toml.dependencies, weslSrc, projectDir);
+}
+/** Resolve the dependency list, replacing "auto" entries with discovered deps. */
+function resolveDeps(dependencies, weslSrc, projectDir) {
+	const depsArray = Array.isArray(dependencies) ? dependencies : [dependencies ?? "auto"];
 	if (!depsArray.includes("auto")) return depsArray;
 	const base = depsArray.filter((dep) => dep !== "auto");
-	const deps = parseDependencies(weslSrc, projectDir);
-	return [...new Set([...base, ...deps])];
+	const discovered = parseDependencies(weslSrc, projectDir);
+	return [...new Set([...base, ...discovered])];
 }
+/** @return a function that resolves a shader path to a weslRoot-relative module path. */
 function makeGetWeslMain(context, unpluginContext) {
 	return getWeslMain;
 	/**
@@ -7137,58 +7179,40 @@ function makeGetWeslMain(context, unpluginContext) {
 	*/
 	async function getWeslMain(shaderPath) {
 		const { resolvedRoot } = await getWeslToml(context, unpluginContext);
-		await fs$1.access(shaderPath);
+		await fs.access(shaderPath);
 		const absRoot = path.join(process.cwd(), resolvedRoot);
 		return toUnixPath(path.relative(absRoot, shaderPath));
 	}
 }
-/**
-* Load the wesl files referenced in the wesl.toml file
-*
-* @return a record of wesl files with
-*    keys as wesl file paths, and
-*    values as wesl file contents.
-*/
+/** Load wesl files referenced in wesl.toml as a path-to-contents record. */
 async function loadWesl(context, unpluginCtx) {
-	const { toml: { include }, resolvedRoot, tomlDir } = await getWeslToml(context, unpluginCtx);
+	const tomlInfo = await getWeslToml(context, unpluginCtx);
+	const { resolvedRoot, tomlDir } = tomlInfo;
+	const { include } = tomlInfo.toml;
 	const futureFiles = include.map((g) => Ze(g, {
 		cwd: tomlDir,
 		absolute: true
 	}));
 	const files = (await Promise.all(futureFiles)).flat();
-	files.forEach((f) => {
-		unpluginCtx.addWatchFile(f);
-	});
+	for (const f of files) unpluginCtx.addWatchFile(f);
 	return await loadFiles(files, resolvedRoot);
 }
-/** load a set of shader files, converting to paths relative to the weslRoot directory */
+/** Load shader files, returning paths relative to weslRoot. */
 async function loadFiles(files, weslRoot) {
-	const loaded = [];
-	for (const fullPath of files) {
-		const normalized = (await fs$1.readFile(fullPath, "utf-8")).replace(/\r\n/g, "\n");
-		const relativePath = path.relative(weslRoot, fullPath);
-		loaded.push([toUnixPath(relativePath), normalized]);
-	}
-	return Object.fromEntries(loaded);
+	const entries = await Promise.all(files.map(async (fullPath) => {
+		const normalized = (await fs.readFile(fullPath, "utf-8")).replace(/\r\n/g, "\n");
+		return [toUnixPath(path.relative(weslRoot, fullPath)), normalized];
+	}));
+	return Object.fromEntries(entries);
 }
 function toUnixPath(p) {
-	if (path.sep !== "/") return p.replaceAll(path.sep, "/");
-	else return p;
+	return path.sep !== "/" ? p.replaceAll(path.sep, "/") : p;
 }
 
 //#endregion
 //#region src/WeslPlugin.ts
-/**
-* A bundler plugin for processing WESL files.
-*
-* The plugin works by reading the wesl.toml file and possibly package.json
-*
-* The plugin is triggered by imports to special virtual module urls
-* two urls suffixes are supported:
-*  1. `import "./shaders/bar.wesl?reflect"` - produces a javascript file for binding struct reflection
-*  2. `import "./shaders/bar.wesl?link"` - produces a javascript file for preconstructed link functions
-*/
 const builtinExtensions = [staticBuildExtension, linkBuildExtension];
+/** Bundler plugin for WESL files, triggered by ?link or ?static import suffixes. */
 function weslPlugin(options, meta) {
 	const o = options ?? {};
 	const extensions = [...builtinExtensions, ...o.extensions ?? []];
@@ -7210,10 +7234,8 @@ function weslPlugin(options, meta) {
 		load: buildLoader(context, log),
 		watchChange(id, _change) {
 			log("watchChange", { id });
-			if (id.endsWith("wesl.toml")) {
-				cache.weslToml = void 0;
-				cache.registry = void 0;
-			} else cache.registry = void 0;
+			if (id.endsWith("wesl.toml")) cache.weslToml = void 0;
+			cache.registry = void 0;
 		}
 	};
 }
@@ -7224,110 +7246,91 @@ function pluginsByName(options) {
 	const entries = options.extensions?.map((p) => [p.extensionName, p]) ?? [];
 	return Object.fromEntries(entries);
 }
-/** wesl plugins match import statements of the form:
-*
-*   foo/bar.wesl?link
-* or
-*   foo/bar.wesl COND=false ?static
-*
-* Bundlers may add extra query params (e.g. Vite adds ?import for dynamic imports,
-* ?t=123 for cache busting), so we capture the full query and search within it.
-*
-* someday it'd be nice to support import attributes like:
-*    import "foo.bar.wesl?static" with { COND: false};
-* (but that doesn't seem supported to be supported in the the bundler plugins yet)
-*/
-const pluginMatch = /(^^)?(?<baseId>.*\.w[eg]sl)(?<cond>(\s*\w+(=\w+)?\s*)*)\?(?<query>.+)$/;
+/** Match .wesl/.wgsl imports with query params. Bundlers may append extra params. */
+const pluginMatch = /(^^)?(?<baseId>.*\.w[eg]sl)\?(?<query>.+)$/;
 const resolvedPrefix = "^^";
-/** build plugin entry for 'resolverId'
-* to validate our javascript virtual module imports (with e.g. ?static or ?link suffixes) */
+/** Reserved query param names (not treated as conditions). */
+const reservedParams = new Set(["include"]);
+/** Parse query string into plugin name, conditions, and options. */
+function parsePluginQuery(query, suffixes) {
+	const segments = query.split("&");
+	const pluginName = suffixes.find((s) => segments.includes(s));
+	if (!pluginName) return null;
+	const isBundlerParam = (s) => s === "import" || /^t=\d+/.test(s);
+	const userSegments = segments.filter((s) => s !== pluginName && !isBundlerParam(s));
+	const conditions = {};
+	const options = {};
+	for (const seg of userSegments) {
+		const eqIdx = seg.indexOf("=");
+		if (eqIdx === -1) conditions[seg] = true;
+		else {
+			const key = seg.slice(0, eqIdx);
+			const val = seg.slice(eqIdx + 1);
+			if (reservedParams.has(key)) options[key] = val;
+			else conditions[key] = val !== "false";
+		}
+	}
+	const hasConds = Object.keys(conditions).length > 0;
+	const hasOpts = Object.keys(options).length > 0;
+	return {
+		pluginName,
+		conditions: hasConds ? conditions : void 0,
+		options: hasOpts ? options : void 0
+	};
+}
+/** Build the resolveId hook for virtual module imports (?static, ?link, etc). */
 function buildResolver(options, context, log) {
 	const suffixes = pluginNames(options);
 	return resolver;
-	/**
-	* For imports with conditions, vite won't resolve the module-path part of the js import
-	* so we do it here.
-	*
-	* To avoid recirculating on resolve(), we rewrite the resolution id to start with ^^
-	* The loader will drop the prefix.
-	*/
 	function resolver(id, importer) {
 		if (id.startsWith(resolvedPrefix)) return id;
 		if (id === context.weslToml) return id;
-		const matched = pluginSuffixMatch(id, suffixes);
+		const match = id.match(pluginMatch);
+		const query = match?.groups?.query;
+		if (!query) return null;
+		const parsed = parsePluginQuery(query, suffixes);
 		log("resolveId", {
 			id,
-			matched: !!matched,
+			matched: !!parsed,
 			suffixes
 		});
-		if (matched) {
-			const { importParams, baseId, pluginName } = matched;
-			const importerDir = path.dirname(importer);
-			const result = resolvedPrefix + path.join(importerDir, baseId) + importParams + "?" + pluginName;
-			log("resolveId resolved", { result });
-			return result;
-		}
-		return matched ? id : null;
+		if (!parsed) return null;
+		const baseId = match.groups.baseId;
+		const importerDir = path.dirname(importer);
+		const result = resolvedPrefix + path.join(importerDir, baseId) + "?" + query;
+		log("resolveId resolved", { result });
+		return result;
 	}
 }
-/** Find matching plugin suffix in query string (handles ?import&static, ?t=123&static, etc.) */
-function pluginSuffixMatch(id, suffixes) {
-	const match = id.match(pluginMatch);
-	const query = match?.groups?.query;
-	if (!query) return null;
-	const segments = query.split("&");
-	const pluginName = suffixes.find((s) => segments.includes(s));
-	if (!pluginName) return null;
-	return {
-		pluginName,
-		baseId: match.groups.baseId,
-		importParams: match.groups?.cond
-	};
-}
-/** build plugin function for serving a javascript module in response to
-* an import of of our virtual import modules. */
+/** Build the load hook that emits JS for virtual module imports. */
 function buildLoader(context, log) {
 	const { options } = context;
 	const suffixes = pluginNames(options);
 	const pluginsMap = pluginsByName(options);
 	return loader;
 	async function loader(id) {
-		const matched = pluginSuffixMatch(id, suffixes);
+		const match = id.match(pluginMatch);
+		const query = match?.groups?.query;
+		if (!query) return null;
+		const parsed = parsePluginQuery(query, suffixes);
 		log("load", {
 			id,
-			matched: matched?.pluginName ?? null
+			matched: parsed?.pluginName ?? null
 		});
-		if (matched) {
-			const buildPluginApi = buildApi(context, this);
-			const plugin = pluginsMap[matched.pluginName];
-			const { baseId, importParams } = matched;
-			const conditions = importParamsToConditions(importParams);
-			const shaderPath = baseId.startsWith(resolvedPrefix) ? baseId.slice(2) : baseId;
-			log("load emitting", {
-				shaderPath,
-				conditions
-			});
-			return await plugin.emitFn(shaderPath, buildPluginApi, conditions);
-		}
-		return null;
+		if (!parsed) return null;
+		const buildPluginApi = buildApi(context, this);
+		const plugin = pluginsMap[parsed.pluginName];
+		const rawPath = match.groups.baseId;
+		const shaderPath = rawPath.startsWith(resolvedPrefix) ? rawPath.slice(2) : rawPath;
+		const { conditions, options: opts } = parsed;
+		log("load emitting", {
+			shaderPath,
+			conditions,
+			options: opts
+		});
+		return await plugin.emitFn(shaderPath, buildPluginApi, conditions, opts);
 	}
 }
-/**
-* Convert an import parameters string to a Conditions record.
-*
-* Import parameters are key=value pairs separated by spaces.
-* Values may be "true" or "false" or missing (default to true)
-* e.g. ' MOBILE=true FUN SAFE=false '
-*/
-function importParamsToConditions(importParams) {
-	if (!importParams) return void 0;
-	const condEntries = importParams.trim().split(/\s+/).map((p) => {
-		const [cond, value] = p.trim().split("=");
-		if (value === void 0 || value === "true") return [cond, true];
-		else return [cond, false];
-	});
-	return Object.fromEntries(condEntries);
-}
 function fmtDebugData(data) {
 	return data ? " " + JSON.stringify(data) : "";
 }
@@ -7335,9 +7338,7 @@ function debugLog(msg, data) {
 	console.error(`[wesl-plugin] ${msg}${fmtDebugData(data)}`);
 }
 function noopLog() {}
-const unplugin = createUnplugin((options, meta) => {
-	return weslPlugin(options, meta);
-});
+const unplugin = createUnplugin(weslPlugin);
 
 //#endregion
 export { weslPlugin as n, unplugin as t };

package/dist/{WeslPluginOptions-DWIrd183.d.mts → WeslPluginOptions-kd-CXSl9.d.mts}

@@ -1,4 +1,4 @@
-import { n as PluginExtension } from "./PluginExtension-nH8vi0nm.mjs";
+import { n as PluginExtension } from "./PluginExtension-CHxUB0-8.mjs";
 
 //#region src/WeslPluginOptions.d.ts
 interface WeslPluginOptions {

package/dist/pluginIndex.d.mts

@@ -1,19 +1,18 @@
-import { n as PluginExtension, r as PluginExtensionApi, t as ExtensionEmitFn } from "./PluginExtension-nH8vi0nm.mjs";
+import { i as ProjectSources, n as PluginExtension, r as PluginExtensionApi, t as ExtensionEmitFn } from "./PluginExtension-CHxUB0-8.mjs";
 
 //#region src/extensions/LinkExtension.d.ts
 declare const linkBuildExtension: PluginExtension;
 //#endregion
+//#region src/extensions/ReflectExtension.d.ts
+interface SimpleReflectOptions {
+  /** directory to contain the .d.ts files or undefined to not write .d.ts files */
+  typesDir?: string;
+}
+/** wesl-js build extension to reflect wgsl structs into js and .d.ts files. */
+declare function simpleReflect(options?: SimpleReflectOptions): PluginExtension;
+//#endregion
 //#region src/extensions/StaticExtension.d.ts
-/**
- * a wesl-js ?static build extension that statically links from the root file
- * and emits a JavaScript file containing the linked wgsl string.
- *
- * use it like this:
- *   import wgsl from "./shaders/app.wesl?static";
- *
- * or with conditions, like this:
- *   import wgsl from "../shaders/foo/app.wesl MOBILE=true FUN SAFE=false ?static";
- */
+/** Build extension for ?static imports: links WESL at build time, emits WGSL string. */
 declare const staticBuildExtension: PluginExtension;
 //#endregion
-export { ExtensionEmitFn, PluginExtension, PluginExtensionApi, linkBuildExtension, staticBuildExtension };
+export { ExtensionEmitFn, PluginExtension, PluginExtensionApi, ProjectSources, SimpleReflectOptions, linkBuildExtension, simpleReflect, staticBuildExtension };

package/dist/pluginIndex.mjs

@@ -1,3 +1,32 @@
-import { r as linkBuildExtension, t as staticBuildExtension } from "./StaticExtension-Chl5KPpw.mjs";
+import { r as linkBuildExtension, t as staticBuildExtension } from "./StaticExtension-Q8HMuFJa.mjs";
+import fs from "node:fs/promises";
+import { originalTypeName, weslStructs, wgslTypeToTs } from "wesl-reflect";
 
-export { linkBuildExtension, staticBuildExtension };
+//#region src/extensions/ReflectExtension.ts
+/** wesl-js build extension to reflect wgsl structs into js and .d.ts files. */
+function simpleReflect(options = {}) {
+	const { typesDir = "./src/types" } = options;
+	return {
+		extensionName: "simple_reflect",
+		emitFn: async (_baseId, api) => {
+			const astStructs = [...(await api.weslRegistry()).allModules()].flatMap(([, module]) => module.moduleElem.contents.filter((e) => e.kind === "struct"));
+			const jsStructs = weslStructs(astStructs);
+			if (typesDir) await writeTypes(astStructs, typesDir);
+			return `export const structs = ${JSON.stringify(jsStructs, null, 2)};`;
+		}
+	};
+}
+/** Write .d.ts file with TypeScript interfaces for reflected structs. */
+async function writeTypes(structs, typesDir) {
+	const tsdInterfaces = structs.map((s) => {
+		return `interface ${s.name.ident.originalName} {\n${s.members.map((m) => {
+			const tsType = wgslTypeToTs(originalTypeName(m.typeRef));
+			return `  ${m.name.name}: ${tsType};`;
+		}).join("\n")}\n}`;
+	});
+	await fs.mkdir(typesDir, { recursive: true });
+	await fs.writeFile(`${typesDir}/reflectTypes.d.ts`, tsdInterfaces.join("\n"));
+}
+
+//#endregion
+export { linkBuildExtension, simpleReflect, staticBuildExtension };

package/dist/plugins/astro.d.mts

@@ -1,4 +1,4 @@
-import { t as WeslPluginOptions } from "../WeslPluginOptions-DWIrd183.mjs";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-kd-CXSl9.mjs";
 
 //#region src/plugins/astro.d.ts
 declare const _default: (options: WeslPluginOptions) => any;

package/dist/plugins/astro.mjs

@@ -1,5 +1,5 @@
-import { t as unplugin } from "../WeslPlugin-BKQJvQve.mjs";
-import "../StaticExtension-Chl5KPpw.mjs";
+import { t as unplugin } from "../WeslPlugin-CajtfXHH.mjs";
+import "../StaticExtension-Q8HMuFJa.mjs";
 
 //#region src/plugins/astro.ts
 var astro_default = (options) => ({