wesl-plugin 0.6.15 → 0.6.16

package/dist/{PluginExtension-CRGiifnw.d.ts → PluginExtension-DlhUTOLC.d.ts}

@@ -1,14 +1,20 @@
-import { ParsedRegistry, WeslJsPlugin } from "wesl";
+import { BatchModuleResolver, WeslJsPlugin } from "wesl";
 
 //#region ../wesl-tooling/src/LoadWeslToml.d.ts
 /** Configuration from wesl.toml */
 interface WeslToml {
-  /** glob search strings to find .wesl/.wgsl files. Relative to the toml directory. */
-  weslFiles: string[];
+  /** WESL edition (e.g. "unstable_2025") */
+  edition: string;
+  /** glob patterns to find .wesl/.wgsl files. Relative to the toml directory. */
+  include: string[];
   /** base directory for wesl files. Relative to the toml directory. */
-  weslRoot: string;
-  /** names of directly referenced wesl shader packages (e.g. npm package names) */
-  dependencies?: string[];
+  root: string;
+  /** glob patterns to exclude directories. */
+  exclude?: string[];
+  /** package manager ("npm" or "cargo") */
+  "package-manager"?: string;
+  /** names of directly referenced wesl shader packages (e.g. npm package names), or "auto" for auto-detection */
+  dependencies?: string[] | string;
 }
 /** Information about the loaded wesl.toml file and its location */
 interface WeslTomlInfo {
@@ -18,8 +24,8 @@ interface WeslTomlInfo {
    * Paths inside the toml are relative to this. */
   tomlDir: string;
   /** The wesl root, relative to the projectDir.
-   * This lets loadModules do `path.resolve(projectDir, resolvedWeslRoot)` */
-  resolvedWeslRoot: string;
+   * This lets loadModules do `path.resolve(projectDir, resolvedRoot)` */
+  resolvedRoot: string;
   /** The underlying toml file */
   toml: WeslToml;
 }
@@ -41,7 +47,7 @@ interface PluginExtension extends WeslJsPlugin {
 interface PluginExtensionApi {
   weslToml: () => Promise<WeslTomlInfo>;
   weslSrc: () => Promise<Record<string, string>>;
-  weslRegistry: () => Promise<ParsedRegistry>;
+  weslRegistry: () => Promise<BatchModuleResolver>;
   weslMain: (baseId: string) => Promise<string>;
   weslDependencies: () => Promise<string[]>;
 }

package/dist/{WeslPlugin-CqSrnjCh.js → WeslPlugin-C5v2QWgI.js}

@@ -1,6 +1,6 @@
 import { t as resolve } from "./import-meta-resolve-CUFqnZwT.js";
 import path, { posix, win32 } from "node:path";
-import { WeslParseError, filterMap, findUnboundIdents, parseIntoRegistry, parsedRegistry } from "wesl";
+import { RecordResolver, WeslParseError, bindIdentsRecursive, filterMap, findValidRootDecls, minimalMangle } from "wesl";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import * as actualFS from "node:fs";
 import { createUnplugin } from "unplugin";
@@ -5841,6 +5841,41 @@ const glob = Object.assign(glob_, {
 });
 glob.glob = glob;
 
+//#endregion
+//#region ../wesl-tooling/src/FindUnboundIdents.ts
+/**
+* Find unbound package references in library sources.
+*
+* Binds local references without following cross-package imports, revealing
+* which external packages are referenced but not resolved.
+*
+* @param resolver - Module resolver that supports batch operations
+* @returns Array of unbound module paths, each as an array of path segments
+*   (e.g., [['foo', 'bar', 'baz'], ['other', 'pkg']])
+*/
+function findUnboundIdents(resolver) {
+	const bindContext = {
+		resolver,
+		conditions: {},
+		knownDecls: /* @__PURE__ */ new Set(),
+		foundScopes: /* @__PURE__ */ new Set(),
+		globalNames: /* @__PURE__ */ new Set(),
+		globalStatements: /* @__PURE__ */ new Map(),
+		mangler: minimalMangle,
+		unbound: [],
+		dontFollowDecls: true
+	};
+	for (const [_modulePath, ast] of resolver.allModules()) {
+		const declEntries = findValidRootDecls(ast.rootScope, {}).map((d) => [d.originalName, d]);
+		const liveDecls = {
+			decls: new Map(declEntries),
+			parent: null
+		};
+		bindIdentsRecursive(ast.rootScope, bindContext, liveDecls, true);
+	}
+	return bindContext.unbound;
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/toml@3.0.0/node_modules/toml/lib/parser.js
 var require_parser = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/toml@3.0.0/node_modules/toml/lib/parser.js": ((exports, module) => {
@@ -9624,9 +9659,10 @@ var require_toml = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/toml@3
 var import_toml = /* @__PURE__ */ __toESM(require_toml(), 1);
 /** Default configuration when no wesl.toml is found */
 const defaultWeslToml = {
-	weslFiles: ["shaders/**/*.w[eg]sl"],
-	weslRoot: "shaders",
-	dependencies: ["auto"]
+	edition: "unstable_2025",
+	include: ["shaders/**/*.w[eg]sl"],
+	root: "shaders",
+	dependencies: "auto"
 };
 /**
 * Load and parse a wesl.toml file from the fs.
@@ -9665,13 +9701,13 @@ async function findWeslToml(projectDir, specifiedToml) {
 		parsedToml = defaultWeslToml;
 		tomlDir = projectDir;
 	}
-	const tomlToWeslRoot = path.resolve(tomlDir, parsedToml.weslRoot);
+	const tomlToWeslRoot = path.resolve(tomlDir, parsedToml.root);
 	const projectDirAbs = path.resolve(projectDir);
-	const resolvedWeslRoot = path.relative(projectDirAbs, tomlToWeslRoot);
+	const resolvedRoot = path.relative(projectDirAbs, tomlToWeslRoot);
 	return {
 		tomlFile,
 		tomlDir,
-		resolvedWeslRoot,
+		resolvedRoot,
 		toml: parsedToml
 	};
 }
@@ -9679,48 +9715,48 @@ async function findWeslToml(projectDir, specifiedToml) {
 //#endregion
 //#region ../wesl-tooling/src/ParseDependencies.ts
 /**
-* Find the wesl package dependencies in a set of WESL files
-* (for packaging WESL files into a library)
+* Find package dependencies in WESL source files.
 *
-* Parse the WESL files and partially bind the identifiers,
-* returning any identifiers that are not succesfully bound.
-* Those identifiers are the package dependencies.
+* Parses sources and partially binds identifiers to reveal unresolved package
+* references. Returns the longest resolvable npm subpath for each dependency.
 *
-* The dependency might be a default export bundle or
-* a named export bundle. e.g. for 'foo::bar::baz', it could be
-*    . package foo, export '.' bundle, module bar
-*    . package foo, export './bar' bundle, element baz
-*    . package foo, export './bar/baz' bundle, module lib.wesl, element baz
-* To distinguish these, we node resolve the longest path we can.
+* For example, 'foo::bar::baz' could resolve to:
+*   - 'foo/bar' (package foo, export './bar' bundle)
+*   - 'foo' (package foo, default export)
+*
+* @param weslSrc - Record of WESL source files by path
+* @param projectDir - Project directory for resolving package imports
+* @returns Dependency paths in npm format (e.g., 'foo/bar', 'foo')
 */
 function parseDependencies(weslSrc, projectDir) {
-	const registry = parsedRegistry();
+	let resolver;
 	try {
-		parseIntoRegistry(weslSrc, registry);
+		resolver = new RecordResolver(weslSrc);
 	} catch (e) {
-		if (e.cause instanceof WeslParseError) console.error(e.message, "\n");
-		else throw e;
+		if (e.cause instanceof WeslParseError) {
+			console.error(e.message, "\n");
+			return [];
+		}
+		throw e;
 	}
-	const unbound = findUnboundIdents(registry);
+	const unbound = findUnboundIdents(resolver);
 	if (!unbound) return [];
 	const pkgRefs = unbound.filter((modulePath) => modulePath.length > 1 && modulePath[0] !== "constants");
 	if (pkgRefs.length === 0) return [];
-	const projectURL = pathToFileURL(path.resolve(path.join(projectDir, "foo"))).href;
+	const projectURL = projectDirURL(projectDir);
 	const deps = filterMap(pkgRefs, (mPath) => unboundToDependency(mPath, projectURL));
 	return [...new Set(deps)];
 }
-/**
-* Find the longest resolvable npm subpath from a module path.
+/** Find longest resolvable npm subpath from module path segments.
 *
-* @param mPath module path, e.g. ['foo', 'bar', 'baz', 'elem']
-* @param importerURL URL of the importer, e.g. 'file:///path/to/project/foo/bar/baz.wesl' (doesn't need to be a real file)
-* @returns longest resolvable subpath of mPath, e.g. 'foo/bar/baz' or 'foo/bar'
+* @param mPath - Module path segments (e.g., ['foo', 'bar', 'baz', 'elem'])
+* @param importerURL - Base URL for resolution (e.g., 'file:///path/to/project/')
+* @returns Longest resolvable subpath (e.g., 'foo/bar/baz' or 'foo')
 */
 function unboundToDependency(mPath, importerURL) {
 	return [...exportSubpaths(mPath)].find((subPath) => tryResolve(subPath, importerURL));
 }
-/** Try to resolve a path using node's resolve algorithm.
-* @return the resolved path */
+/** Try Node.js module resolution; returns undefined if unresolvable. */
 function tryResolve(path$2, importerURL) {
 	try {
 		return resolve(path$2, importerURL);
@@ -9728,14 +9764,18 @@ function tryResolve(path$2, importerURL) {
 		return;
 	}
 }
-/**
-* Yield possible export entry subpaths from module path
-* longest subpath first.
-*/
+/** Yield possible export subpaths from module path, longest first.
+* Drops the last segment (element name) and iterates down. */
 function* exportSubpaths(mPath) {
 	const longest = mPath.length - 1;
 	for (let i = longest; i >= 0; i--) yield mPath.slice(0, i).join("/");
 }
+/** Normalize project directory to file:// URL with trailing slash. */
+function projectDirURL(projectDir) {
+	if (projectDir.startsWith("file://")) return projectDir.endsWith("/") ? projectDir : `${projectDir}/`;
+	const fileUrl = pathToFileURL(projectDir).href;
+	return fileUrl.endsWith("/") ? fileUrl : `${fileUrl}/`;
+}
 
 //#endregion
 //#region src/PluginApi.ts
@@ -9767,10 +9807,9 @@ async function getRegistry(context, unpluginCtx) {
 	let { registry } = cache;
 	if (registry) return registry;
 	const loaded = await loadWesl(context, unpluginCtx);
-	const { resolvedWeslRoot } = await getWeslToml(context, unpluginCtx);
-	registry = parsedRegistry();
-	parseIntoRegistry(loaded, registry);
-	Object.keys(loaded).map((p) => path.resolve(resolvedWeslRoot, p)).forEach((f) => {
+	const { resolvedRoot } = await getWeslToml(context, unpluginCtx);
+	registry = new RecordResolver(loaded);
+	Object.keys(loaded).map((p) => path.resolve(resolvedRoot, p)).forEach((f) => {
 		unpluginCtx.addWatchFile(f);
 	});
 	cache.registry = registry;
@@ -9784,8 +9823,9 @@ async function findDependencies(context, unpluginCtx) {
 	const { toml: toml$1, tomlDir: projectDir } = await getWeslToml(context, unpluginCtx);
 	const weslSrc = await loadWesl(context, unpluginCtx);
 	const { dependencies = [] } = toml$1;
-	if (!dependencies.includes("auto")) return dependencies;
-	const base = dependencies.filter((dep) => dep !== "auto");
+	const depsArray = Array.isArray(dependencies) ? dependencies : [dependencies];
+	if (!depsArray.includes("auto")) return depsArray;
+	const base = depsArray.filter((dep) => dep !== "auto");
 	const deps = parseDependencies(weslSrc, projectDir);
 	return [...new Set([...base, ...deps])];
 }
@@ -9796,9 +9836,9 @@ function makeGetWeslMain(context, unpluginContext) {
 	* @return the / separated path to the shader file, relative to the weslRoot
 	*/
 	async function getWeslMain(shaderPath) {
-		const { resolvedWeslRoot } = await getWeslToml(context, unpluginContext);
+		const { resolvedRoot } = await getWeslToml(context, unpluginContext);
 		await fs$1.access(shaderPath);
-		const absRoot = path.join(process.cwd(), resolvedWeslRoot);
+		const absRoot = path.join(process.cwd(), resolvedRoot);
 		return toUnixPath(path.relative(absRoot, shaderPath));
 	}
 }
@@ -9810,8 +9850,8 @@ function makeGetWeslMain(context, unpluginContext) {
 *    values as wesl file contents.
 */
 async function loadWesl(context, unpluginCtx) {
-	const { toml: { weslFiles }, resolvedWeslRoot, tomlDir } = await getWeslToml(context, unpluginCtx);
-	const futureFiles = weslFiles.map((g) => glob(g, {
+	const { toml: { include }, resolvedRoot, tomlDir } = await getWeslToml(context, unpluginCtx);
+	const futureFiles = include.map((g) => glob(g, {
 		cwd: tomlDir,
 		absolute: true
 	}));
@@ -9819,7 +9859,7 @@ async function loadWesl(context, unpluginCtx) {
 	files.forEach((f) => {
 		unpluginCtx.addWatchFile(f);
 	});
-	return await loadFiles(files, resolvedWeslRoot);
+	return await loadFiles(files, resolvedRoot);
 }
 /** load a set of shader files, converting to paths relative to the weslRoot directory */
 async function loadFiles(files, weslRoot) {

package/dist/{WeslPluginOptions-BhpzoXUz.d.ts → WeslPluginOptions-BXvD7dWh.d.ts}

@@ -1,4 +1,4 @@
-import { n as PluginExtension } from "./PluginExtension-CRGiifnw.js";
+import { n as PluginExtension } from "./PluginExtension-DlhUTOLC.js";
 
 //#region src/WeslPluginOptions.d.ts
 interface WeslPluginOptions {

package/dist/pluginIndex.d.ts

@@ -1,4 +1,4 @@
-import { n as PluginExtension, r as PluginExtensionApi, t as ExtensionEmitFn } from "./PluginExtension-CRGiifnw.js";
+import { n as PluginExtension, r as PluginExtensionApi, t as ExtensionEmitFn } from "./PluginExtension-DlhUTOLC.js";
 
 //#region src/extensions/LinkExtension.d.ts
 declare const linkBuildExtension: PluginExtension;

package/dist/pluginIndex.js

@@ -10,10 +10,10 @@ const linkBuildExtension = {
 };
 /** Emit a JavaScript LinkParams structure, ready for linking at runtime. */
 async function emitLinkJs(baseId, api) {
-	const { resolvedWeslRoot, tomlDir } = await api.weslToml();
+	const { resolvedRoot, tomlDir } = await api.weslToml();
 	const weslSrc = await api.weslSrc();
 	const rootModuleName = noSuffix(await api.weslMain(baseId));
-	const debugWeslRoot = path.relative(tomlDir, resolvedWeslRoot).replaceAll(path.sep, "/");
+	const debugWeslRoot = path.relative(tomlDir, resolvedRoot).replaceAll(path.sep, "/");
 	const autoDeps = await api.weslDependencies();
 	const sanitizedDeps = autoDeps.map((dep) => dep.replaceAll("/", "_"));
 	const bundleImports = autoDeps.map((p, i) => `import ${sanitizedDeps[i]} from "${p}";`).join("\n");
@@ -55,7 +55,7 @@ const staticBuildExtension = {
 };
 /** Emit a JavaScript file containing the wgsl string */
 async function emitStaticJs(baseId, api, conditions) {
-	const { resolvedWeslRoot, tomlDir } = await api.weslToml();
+	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);
@@ -63,7 +63,7 @@ async function emitStaticJs(baseId, api, conditions) {
     export const wgsl = \`${(await link({
 		weslSrc: await api.weslSrc(),
 		rootModuleName: noSuffix(await api.weslMain(baseId)),
-		debugWeslRoot: path.relative(tomlDir, resolvedWeslRoot).replaceAll(path.sep, "/"),
+		debugWeslRoot: path.relative(tomlDir, resolvedRoot).replaceAll(path.sep, "/"),
 		libs,
 		conditions
 	})).dest}\`;

package/dist/plugins/astro.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 
 //#region src/plugins/astro.d.ts
 declare const _default: (options: WeslPluginOptions) => any;

package/dist/plugins/astro.js

@@ -1,4 +1,4 @@
-import { t as WeslPlugin_default } from "../WeslPlugin-CqSrnjCh.js";
+import { t as WeslPlugin_default } from "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
 
 //#region src/plugins/astro.ts

package/dist/plugins/esbuild.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 import * as esbuild0 from "esbuild";
 
 //#region src/plugins/esbuild.d.ts

package/dist/plugins/esbuild.js

@@ -1,4 +1,4 @@
-import { n as weslPlugin } from "../WeslPlugin-CqSrnjCh.js";
+import { n as weslPlugin } from "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
 import { createEsbuildPlugin } from "unplugin";
 

package/dist/plugins/farm.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 import * as _farmfe_core0 from "@farmfe/core";
 
 //#region src/plugins/farm.d.ts

package/dist/plugins/farm.js

@@ -1,4 +1,4 @@
-import { n as weslPlugin } from "../WeslPlugin-CqSrnjCh.js";
+import { n as weslPlugin } from "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
 import { createFarmPlugin } from "unplugin";
 

package/dist/plugins/nuxt.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 import * as _nuxt_schema0 from "@nuxt/schema";
 
 //#region src/plugins/nuxt.d.ts

package/dist/plugins/nuxt.js

@@ -1,7 +1,7 @@
-import "../WeslPlugin-CqSrnjCh.js";
+import "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
-import { t as vite_default } from "../vite-Dc5eE4Lm.js";
-import { t as webpack_default } from "../webpack-lAPeYZlg.js";
+import { t as vite_default } from "../vite-DIETRAJZ.js";
+import { t as webpack_default } from "../webpack-CKpSvDUR.js";
 import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
 import "@nuxt/schema";
 

package/dist/plugins/rollup.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 import * as rollup0 from "rollup";
 
 //#region src/plugins/rollup.d.ts

package/dist/plugins/rollup.js

@@ -1,4 +1,4 @@
-import { n as weslPlugin } from "../WeslPlugin-CqSrnjCh.js";
+import { n as weslPlugin } from "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
 import { createRollupPlugin } from "unplugin";
 

package/dist/plugins/rspack.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 
 //#region src/plugins/rspack.d.ts
 declare const _default: (options: WeslPluginOptions) => RspackPluginInstance;

package/dist/plugins/rspack.js

@@ -1,4 +1,4 @@
-import { n as weslPlugin } from "../WeslPlugin-CqSrnjCh.js";
+import { n as weslPlugin } from "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
 import { createRspackPlugin } from "unplugin";
 

package/dist/plugins/vite.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 import * as vite0 from "vite";
 
 //#region src/plugins/vite.d.ts

package/dist/plugins/vite.js

@@ -1,5 +1,5 @@
-import "../WeslPlugin-CqSrnjCh.js";
+import "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
-import { t as vite_default } from "../vite-Dc5eE4Lm.js";
+import { t as vite_default } from "../vite-DIETRAJZ.js";
 
 export { vite_default as default };

package/dist/plugins/webpack.d.ts

@@ -1,5 +1,5 @@
-import "../PluginExtension-CRGiifnw.js";
-import { t as WeslPluginOptions } from "../WeslPluginOptions-BhpzoXUz.js";
+import "../PluginExtension-DlhUTOLC.js";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-BXvD7dWh.js";
 import * as webpack0 from "webpack";
 
 //#region src/plugins/webpack.d.ts

package/dist/plugins/webpack.js

@@ -1,5 +1,5 @@
-import "../WeslPlugin-CqSrnjCh.js";
+import "../WeslPlugin-C5v2QWgI.js";
 import "../import-meta-resolve-CUFqnZwT.js";
-import { t as webpack_default } from "../webpack-lAPeYZlg.js";
+import { t as webpack_default } from "../webpack-CKpSvDUR.js";
 
 export { webpack_default as default };

package/dist/{vite-Dc5eE4Lm.js → vite-DIETRAJZ.js}

@@ -1,4 +1,4 @@
-import { n as weslPlugin } from "./WeslPlugin-CqSrnjCh.js";
+import { n as weslPlugin } from "./WeslPlugin-C5v2QWgI.js";
 import { createVitePlugin } from "unplugin";
 
 //#region src/plugins/vite.ts

package/dist/{webpack-lAPeYZlg.js → webpack-CKpSvDUR.js}

@@ -1,4 +1,4 @@
-import { n as weslPlugin } from "./WeslPlugin-CqSrnjCh.js";
+import { n as weslPlugin } from "./WeslPlugin-C5v2QWgI.js";
 import { createWebpackPlugin } from "unplugin";
 
 //#region src/plugins/webpack.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wesl-plugin",
   "description": "",
-  "version": "0.6.15",
+  "version": "0.6.16",
   "type": "module",
   "files": [
     "src",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "unplugin": "^2.3.5",
-    "wesl": "0.6.15"
+    "wesl": "0.6.16"
   },
   "devDependencies": {
     "@nuxt/kit": "^3.17.6",

package/src/BindingLayoutExtension.ts

@@ -29,7 +29,8 @@ async function bindingLayoutJs(
       }),
     ],
   };
-  bindAndTransform({ registry, rootModuleName: main, config });
+
+  bindAndTransform({ resolver: registry, rootModuleName: main, config });
 
   return structsJs;
 }

package/src/PluginApi.ts

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { glob } from "glob";
 import type { UnpluginBuildContext, UnpluginContext } from "unplugin";
-import { type ParsedRegistry, parsedRegistry, parseIntoRegistry } from "wesl";
+import { RecordResolver } from "wesl";
 import {
   findWeslToml,
   parseDependencies,
@@ -48,22 +48,19 @@ export async function getWeslToml(
 async function getRegistry(
   context: PluginContext,
   unpluginCtx: UnpluginBuildContext & UnpluginContext,
-): Promise<ParsedRegistry> {
+): Promise<RecordResolver> {
   const { cache } = context;
   let { registry } = cache;
   if (registry) return registry;
 
   // load wesl files into registry
   const loaded = await loadWesl(context, unpluginCtx);
-  const { resolvedWeslRoot } = await getWeslToml(context, unpluginCtx);
+  const { resolvedRoot } = await getWeslToml(context, unpluginCtx);
 
-  registry = parsedRegistry();
-  parseIntoRegistry(loaded, registry);
+  registry = new RecordResolver(loaded);
 
   // The paths are relative to the weslRoot, but vite needs actual filesystem paths
-  const fullPaths = Object.keys(loaded).map(p =>
-    path.resolve(resolvedWeslRoot, p),
-  );
+  const fullPaths = Object.keys(loaded).map(p => path.resolve(resolvedRoot, p));
 
   // trigger clearing cache on shader file change
   fullPaths.forEach(f => {
@@ -85,10 +82,10 @@ async function findDependencies(
   const { toml, tomlDir: projectDir } = await getWeslToml(context, unpluginCtx);
   const weslSrc = await loadWesl(context, unpluginCtx);
   const { dependencies = [] } = toml;
-  const hasAuto = dependencies.includes("auto");
-  if (!hasAuto) return dependencies;
+  const depsArray = Array.isArray(dependencies) ? dependencies : [dependencies];
+  if (!depsArray.includes("auto")) return depsArray;
 
-  const base = dependencies.filter(dep => dep !== "auto");
+  const base = depsArray.filter(dep => dep !== "auto");
   const deps = parseDependencies(weslSrc, projectDir);
   const combined = new Set([...base, ...deps]);
   return [...combined];
@@ -105,10 +102,10 @@ function makeGetWeslMain(
    * @return the / separated path to the shader file, relative to the weslRoot
    */
   async function getWeslMain(shaderPath: string): Promise<string> {
-    const { resolvedWeslRoot } = await getWeslToml(context, unpluginContext);
+    const { resolvedRoot } = await getWeslToml(context, unpluginContext);
     await fs.access(shaderPath); // if file doesn't exist, report now when the user problem is clear.
 
-    const absRoot = path.join(process.cwd(), resolvedWeslRoot);
+    const absRoot = path.join(process.cwd(), resolvedRoot);
     const weslRootToMain = path.relative(absRoot, shaderPath);
     return toUnixPath(weslRootToMain);
   }
@@ -126,11 +123,11 @@ async function loadWesl(
   unpluginCtx: UnpluginBuildContext & UnpluginContext,
 ): Promise<Record<string, string>> {
   const {
-    toml: { weslFiles },
-    resolvedWeslRoot,
+    toml: { include },
+    resolvedRoot,
     tomlDir,
   } = await getWeslToml(context, unpluginCtx);
-  const futureFiles = weslFiles.map(g =>
+  const futureFiles = include.map(g =>
     glob(g, { cwd: tomlDir, absolute: true }),
   );
   const files = (await Promise.all(futureFiles)).flat();
@@ -140,7 +137,7 @@ async function loadWesl(
     unpluginCtx.addWatchFile(f);
   });
 
-  return await loadFiles(files, resolvedWeslRoot);
+  return await loadFiles(files, resolvedRoot);
 }
 
 /** load a set of shader files, converting to paths relative to the weslRoot directory */

package/src/PluginExtension.ts

@@ -1,4 +1,4 @@
-import type { ParsedRegistry, WeslJsPlugin } from "wesl";
+import type { BatchModuleResolver, WeslJsPlugin } from "wesl";
 import type { WeslTomlInfo } from "wesl-tooling";
 
 /** function type required for for emit extensions */
@@ -27,7 +27,7 @@ export interface PluginExtension extends WeslJsPlugin {
 export interface PluginExtensionApi {
   weslToml: () => Promise<WeslTomlInfo>;
   weslSrc: () => Promise<Record<string, string>>;
-  weslRegistry: () => Promise<ParsedRegistry>;
+  weslRegistry: () => Promise<BatchModuleResolver>;
   weslMain: (baseId: string) => Promise<string>;
   weslDependencies: () => Promise<string[]>;
 }

package/src/WeslPlugin.ts

@@ -9,7 +9,7 @@ import {
   type UnpluginContextMeta,
   type UnpluginOptions,
 } from "unplugin";
-import type { Conditions, ParsedRegistry } from "wesl";
+import type { Conditions, RecordResolver } from "wesl";
 import type { WeslToml, WeslTomlInfo } from "wesl-tooling";
 import { buildApi } from "./PluginApi.ts";
 import type { PluginExtension } from "./PluginExtension.ts";
@@ -22,7 +22,7 @@ export type { WeslToml, WeslTomlInfo };
  * (a plugin instance supports only one shader project)
  */
 interface PluginCache {
-  registry?: ParsedRegistry;
+  registry?: RecordResolver;
   weslToml?: WeslTomlInfo;
 }
 

package/src/extensions/LinkExtension.ts

@@ -15,14 +15,14 @@ async function emitLinkJs(
   baseId: string,
   api: PluginExtensionApi,
 ): Promise<string> {
-  const { resolvedWeslRoot, tomlDir } = await api.weslToml();
+  const { resolvedRoot, tomlDir } = await api.weslToml();
 
   const weslSrc = await api.weslSrc();
 
   const rootModule = await api.weslMain(baseId);
   const rootModuleName = noSuffix(rootModule);
 
-  const tomlRelative = path.relative(tomlDir, resolvedWeslRoot);
+  const tomlRelative = path.relative(tomlDir, resolvedRoot);
   const debugWeslRoot = tomlRelative.replaceAll(path.sep, "/");
 
   const autoDeps = await api.weslDependencies();

package/src/extensions/StaticExtension.ts

@@ -28,7 +28,7 @@ async function emitStaticJs(
   api: PluginExtensionApi,
   conditions?: Conditions,
 ): Promise<string> {
-  const { resolvedWeslRoot, tomlDir } = await api.weslToml();
+  const { resolvedRoot, tomlDir } = await api.weslToml();
 
   // resolve import module relative to the root of the shader project
   const parentModule = url
@@ -49,7 +49,7 @@ async function emitStaticJs(
   const rootModuleName = noSuffix(rootModule);
 
   // find weslRoot
-  const tomlRelative = path.relative(tomlDir, resolvedWeslRoot);
+  const tomlRelative = path.relative(tomlDir, resolvedRoot);
   const debugWeslRoot = tomlRelative.replaceAll(path.sep, "/");
 
   const result = await link({