wesl-plugin 0.6.70 → 0.6.72

package/dist/plugins/farm.mjs

@@ -1,9 +1,7 @@
-import { n as weslPlugin } from "../WeslPlugin-BKQJvQve.mjs";
-import "../StaticExtension-Chl5KPpw.mjs";
+import { n as weslPlugin } from "../WeslPlugin-B91dE_tA.mjs";
+import "../StaticExtension-CDqA2teq.mjs";
 import { createFarmPlugin } from "unplugin";
-
 //#region src/plugins/farm.ts
 var farm_default = createFarmPlugin(weslPlugin);
-
 //#endregion
-export { farm_default as default };
+export { farm_default as default };

package/dist/plugins/nuxt.d.mts

@@ -1,4 +1,4 @@
-import { t as WeslPluginOptions } from "../WeslPluginOptions-DWIrd183.mjs";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-D81oyynl.mjs";
 import * as _nuxt_schema0 from "@nuxt/schema";
 
 //#region src/plugins/nuxt.d.ts

package/dist/plugins/nuxt.mjs

@@ -1,10 +1,9 @@
-import "../WeslPlugin-BKQJvQve.mjs";
-import "../StaticExtension-Chl5KPpw.mjs";
+import "../WeslPlugin-B91dE_tA.mjs";
+import "../StaticExtension-CDqA2teq.mjs";
 import vite_default from "./vite.mjs";
 import webpack_default from "./webpack.mjs";
 import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
 import "@nuxt/schema";
-
 //#region src/plugins/nuxt.ts
 var nuxt_default = defineNuxtModule({
 	meta: {
@@ -17,6 +16,5 @@ var nuxt_default = defineNuxtModule({
 		addWebpackPlugin(() => webpack_default(options));
 	}
 });
-
 //#endregion
-export { nuxt_default as default };
+export { nuxt_default as default };

package/dist/plugins/rollup.d.mts

@@ -1,4 +1,4 @@
-import { t as WeslPluginOptions } from "../WeslPluginOptions-DWIrd183.mjs";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-D81oyynl.mjs";
 import * as rollup from "rollup";
 
 //#region src/plugins/rollup.d.ts

package/dist/plugins/rollup.mjs

@@ -1,9 +1,7 @@
-import { n as weslPlugin } from "../WeslPlugin-BKQJvQve.mjs";
-import "../StaticExtension-Chl5KPpw.mjs";
+import { n as weslPlugin } from "../WeslPlugin-B91dE_tA.mjs";
+import "../StaticExtension-CDqA2teq.mjs";
 import { createRollupPlugin } from "unplugin";
-
 //#region src/plugins/rollup.ts
 var rollup_default = createRollupPlugin(weslPlugin);
-
 //#endregion
-export { rollup_default as default };
+export { rollup_default as default };

package/dist/plugins/rspack.d.mts

@@ -1,4 +1,4 @@
-import { t as WeslPluginOptions } from "../WeslPluginOptions-DWIrd183.mjs";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-D81oyynl.mjs";
 
 //#region src/plugins/rspack.d.ts
 declare const _default: (options?: WeslPluginOptions | undefined) => RspackPluginInstance;

package/dist/plugins/rspack.mjs

@@ -1,9 +1,7 @@
-import { n as weslPlugin } from "../WeslPlugin-BKQJvQve.mjs";
-import "../StaticExtension-Chl5KPpw.mjs";
+import { n as weslPlugin } from "../WeslPlugin-B91dE_tA.mjs";
+import "../StaticExtension-CDqA2teq.mjs";
 import { createRspackPlugin } from "unplugin";
-
 //#region src/plugins/rspack.ts
 var rspack_default = createRspackPlugin(weslPlugin);
-
 //#endregion
-export { rspack_default as default };
+export { rspack_default as default };

package/dist/plugins/vite.d.mts

@@ -1,4 +1,4 @@
-import { t as WeslPluginOptions } from "../WeslPluginOptions-DWIrd183.mjs";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-D81oyynl.mjs";
 import * as vite from "vite";
 
 //#region src/plugins/vite.d.ts

package/dist/plugins/vite.mjs

@@ -1,9 +1,7 @@
-import { n as weslPlugin } from "../WeslPlugin-BKQJvQve.mjs";
-import "../StaticExtension-Chl5KPpw.mjs";
+import { n as weslPlugin } from "../WeslPlugin-B91dE_tA.mjs";
+import "../StaticExtension-CDqA2teq.mjs";
 import { createVitePlugin } from "unplugin";
-
 //#region src/plugins/vite.ts
 var vite_default = createVitePlugin(weslPlugin);
-
 //#endregion
-export { vite_default as default };
+export { vite_default as default };

package/dist/plugins/webpack.d.mts

@@ -1,4 +1,4 @@
-import { t as WeslPluginOptions } from "../WeslPluginOptions-DWIrd183.mjs";
+import { t as WeslPluginOptions } from "../WeslPluginOptions-D81oyynl.mjs";
 import * as webpack from "webpack";
 
 //#region src/plugins/webpack.d.ts

package/dist/plugins/webpack.mjs

@@ -1,9 +1,7 @@
-import { n as weslPlugin } from "../WeslPlugin-BKQJvQve.mjs";
-import "../StaticExtension-Chl5KPpw.mjs";
+import { n as weslPlugin } from "../WeslPlugin-B91dE_tA.mjs";
+import "../StaticExtension-CDqA2teq.mjs";
 import { createWebpackPlugin } from "unplugin";
-
 //#region src/plugins/webpack.ts
 var webpack_default = createWebpackPlugin(weslPlugin);
-
 //#endregion
-export { webpack_default as default };
+export { webpack_default as default };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wesl-plugin",
   "description": "",
-  "version": "0.6.70",
+  "version": "0.6.72",
   "type": "module",
   "files": [
     "src",
@@ -25,7 +25,8 @@
   },
   "dependencies": {
     "unplugin": "^2.3.5",
-    "wesl": "0.7.22"
+    "wesl": "0.7.24",
+    "wesl-reflect": "0.0.3"
   },
   "devDependencies": {
     "@nuxt/kit": "^3.17.6",
@@ -34,6 +35,7 @@
     "chalk": "^5.4.1",
     "import-meta-resolve": "^4.1.0",
     "nodemon": "^3.1.10",
+    "random_wgsl": "x",
     "rollup": "^4.44.1",
     "toml": "^3.0.0",
     "webpack": "^5.99.9",

package/src/PluginApi.ts

@@ -2,29 +2,79 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { glob } from "glob";
 import type { UnpluginBuildContext, UnpluginContext } from "unplugin";
-import { RecordResolver } from "wesl";
+import {
+  discoverModules,
+  fileToModulePath,
+  freshResolver,
+  RecordResolver,
+} from "wesl";
 import {
   findWeslToml,
   parseDependencies,
+  resolvePkgDeps,
   type WeslTomlInfo,
 } from "wesl-tooling";
-import type { PluginExtensionApi } from "./PluginExtension.ts";
+import type { PluginExtensionApi, ProjectSources } from "./PluginExtension.ts";
 import type { PluginContext } from "./WeslPlugin.ts";
 
+/** Construct the API surface available to plugin extensions. */
 export function buildApi(
   context: PluginContext,
   unpluginCtx: UnpluginBuildContext & UnpluginContext,
 ): PluginExtensionApi {
-  return {
+  const api: PluginExtensionApi = {
     weslToml: async () => getWeslToml(context, unpluginCtx),
     weslSrc: async () => loadWesl(context, unpluginCtx),
     weslRegistry: async () => getRegistry(context, unpluginCtx),
     weslMain: makeGetWeslMain(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: string,
+  context: PluginContext,
+  unpluginCtx: UnpluginBuildContext & UnpluginContext,
+): Promise<ProjectSources> {
+  const fullSrc = await loadWesl(context, unpluginCtx);
+  const { toml, tomlDir: projectDir } = await getWeslToml(context, unpluginCtx);
+
+  const registry = await getRegistry(context, unpluginCtx);
+  const resolver = freshResolver(registry);
+  const modulePath = fileToModulePath(rootModuleName, "package", false);
+  const { weslSrc, unbound } = discoverModules(fullSrc, resolver, modulePath);
+  const dependencies = resolveDepsFromUnbound(
+    toml.dependencies,
+    unbound,
+    projectDir,
+  );
+  return { weslSrc, dependencies };
+}
+
+/** Resolve dependencies using pre-computed unbound refs (avoids re-parsing). */
+function resolveDepsFromUnbound(
+  dependencies: string | string[] | undefined,
+  unbound: string[][],
+  projectDir: string,
+): string[] {
+  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 the wesl.toml  */
+/** Load and cache the wesl.toml configuration. */
 export async function getWeslToml(
   context: PluginContext,
   unpluginCtx: UnpluginBuildContext & UnpluginContext,
@@ -32,8 +82,7 @@ export async function getWeslToml(
   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); // The cache gets cleared by the watchChange hook
@@ -41,10 +90,10 @@ export async function getWeslToml(
   }
 
   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: PluginContext,
   unpluginCtx: UnpluginBuildContext & UnpluginContext,
@@ -53,7 +102,6 @@ async function getRegistry(
   let { registry } = cache;
   if (registry) return registry;
 
-  // load wesl files into registry
   const loaded = await loadWesl(context, unpluginCtx);
   const { resolvedRoot } = await getWeslToml(context, unpluginCtx);
 
@@ -62,35 +110,64 @@ async function getRegistry(
   // The paths are relative to the weslRoot, but vite needs actual filesystem paths
   const fullPaths = Object.keys(loaded).map(p => path.resolve(resolvedRoot, p));
 
-  // trigger clearing cache on shader file change
-  fullPaths.forEach(f => {
-    unpluginCtx.addWatchFile(f);
-  });
+  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: PluginContext,
+  unpluginCtx: UnpluginBuildContext & UnpluginContext,
+): Promise<string> {
+  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: PluginExtensionApi,
+  rootModuleName: string,
+  options?: Record<string, string>,
+): Promise<ProjectSources> {
+  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: PluginContext,
   unpluginCtx: UnpluginBuildContext & UnpluginContext,
 ): Promise<string[]> {
   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: string | string[] | undefined,
+  weslSrc: Record<string, string>,
+  projectDir: string,
+): string[] {
+  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);
-  const combined = new Set([...base, ...deps]);
-  return [...combined];
+  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: PluginContext,
   unpluginContext: UnpluginBuildContext & UnpluginContext,
@@ -111,55 +188,40 @@ function makeGetWeslMain(
   }
 }
 
-/**
- * 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: PluginContext,
   unpluginCtx: UnpluginBuildContext & UnpluginContext,
 ): Promise<Record<string, string>> {
-  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 =>
     glob(g, { cwd: tomlDir, absolute: true }),
   );
   const files = (await Promise.all(futureFiles)).flat();
 
-  // trigger rebuild on shader file change
-  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: string[],
   weslRoot: string,
 ): Promise<Record<string, string>> {
-  const loaded: [string, string][] = [];
-
-  for (const fullPath of files) {
-    const data = await fs.readFile(fullPath, "utf-8");
-    const normalized = data.replace(/\r\n/g, "\n"); // normalize line endings to LF
-    const relativePath = path.relative(weslRoot, fullPath);
-    loaded.push([toUnixPath(relativePath), normalized]);
-  }
-  return Object.fromEntries(loaded);
+  const entries = await Promise.all(
+    files.map(async (fullPath): Promise<[string, string]> => {
+      const data = await fs.readFile(fullPath, "utf-8");
+      const normalized = data.replace(/\r\n/g, "\n"); // normalize line endings to LF
+      const key = toUnixPath(path.relative(weslRoot, fullPath));
+      return [key, normalized];
+    }),
+  );
+  return Object.fromEntries(entries);
 }
 
 function toUnixPath(p: string): string {
-  if (path.sep !== "/") {
-    return p.replaceAll(path.sep, "/");
-  } else {
-    return p;
-  }
+  return path.sep !== "/" ? p.replaceAll(path.sep, "/") : p;
 }

package/src/PluginExtension.ts

@@ -1,7 +1,7 @@
 import type { BatchModuleResolver, WeslJsPlugin } from "wesl";
 import type { WeslTomlInfo } from "wesl-tooling";
 
-/** function type required for for emit extensions */
+/** function type required for emit extensions */
 export type ExtensionEmitFn = (
   /** absolute path to the shader to which the extension is attached */
   shaderPath: string,
@@ -9,8 +9,11 @@ export type ExtensionEmitFn = (
   /** support functions available to plugin extensions */
   pluginApi: PluginExtensionApi,
 
-  /** static conditions specified on the js import */ // (currently used for ?static)
+  /** static conditions specified on the js import */
   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 */
@@ -23,6 +26,11 @@ export interface PluginExtension extends WeslJsPlugin {
   emitFn: ExtensionEmitFn;
 }
 
+export interface ProjectSources {
+  weslSrc: Record<string, string>;
+  dependencies: string[];
+}
+
 /** api supplied to plugin extensions */
 export interface PluginExtensionApi {
   weslToml: () => Promise<WeslTomlInfo>;
@@ -30,4 +38,15 @@ export 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>;
 }