wesl-tooling 0.6.9 → 0.6.12

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "wesl-tooling",
-  "version": "0.6.9",
+  "version": "0.6.12",
   "type": "module",
   "files": [
-    "dist"
+    "src"
   ],
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "repository": "github:wgsl-tooling-wg/wesl-js",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts"
+    }
+  },
   "dependencies": {
-    "glob": "^11.0.2",
+    "glob": "^11.0.3",
     "import-meta-resolve": "^4.1.0",
-    "thimbleberry": "^0.2.10"
+    "toml": "^3.0.0"
   },
   "devDependencies": {
-    "dependent_package": "x",
-    "tsdown": "^0.11.12"
+    "dependent_package": "x"
   },
   "peerDependencies": {
-    "wesl": "^0.6.9"
+    "wesl": "^0.6.49"
   },
   "scripts": {
-    "build": "tsdown",
-    "dev": "tsdown --watch",
-    "typecheck": "tsgo",
-    "test": "FORCE_COLOR=1 vitest",
-    "test:once": "vitest run"
+    "test": "cross-env FORCE_COLOR=1 vitest",
+    "test:once": "vitest run",
+    "typecheck": "tsgo"
   }
 }

package/src/FileModuleResolver.ts

@@ -0,0 +1,110 @@
+import * as fs from "node:fs";
+import type { ModuleResolver, WeslAST } from "wesl";
+import { moduleToRelativePath, normalizeDebugRoot, parseSrcModule } from "wesl";
+
+/**
+ * Loads WESL modules from the filesystem on demand with caching.
+ *
+ * Resolves module paths like `package::foo::bar` to filesystem paths
+ * like `baseDir/foo/bar.wesl` or `baseDir/foo/bar.wgsl`.
+ *
+ * @example
+ * ```ts
+ * const resolver = new FileModuleResolver("./shaders", "my-package");
+ * const ast = resolver.resolveModule("package::utils::helper");
+ * ```
+ */
+export class FileModuleResolver implements ModuleResolver {
+  /** Cached parsed ASTs to avoid re-parsing the same module */
+  readonly astCache = new Map<string, WeslAST>();
+
+  /** Root directory containing shader source files */
+  readonly baseDir: string;
+
+  /** Package name that this resolver handles (in addition to generic "package") */
+  readonly packageName: string;
+
+  /** Optional root path for debug file paths (for browser-clickable errors) */
+  readonly debugWeslRoot?: string;
+
+  /**
+   * @param baseDir - Root directory containing shader source files
+   * @param packageName - Package name to resolve (defaults to "package")
+   * @param debugWeslRoot - Optional root path for debug file paths. If provided, error messages
+   *   will show paths relative to this root (e.g., "shaders/foo.wesl") instead of absolute
+   *   filesystem paths. This is needed for clickable errors in browser dev tools.
+   */
+  constructor(
+    baseDir: string,
+    packageName = "package",
+    debugWeslRoot?: string,
+  ) {
+    this.baseDir = baseDir;
+    this.packageName = packageName;
+    this.debugWeslRoot = debugWeslRoot;
+  }
+
+  /**
+   * Resolves and parses a module by its import path.
+   *
+   * Returns cached AST if available, otherwise loads from filesystem,
+   * parses, caches, and returns the AST. Returns undefined if module
+   * cannot be found.
+   *
+   * @param modulePath - Module path like "package::foo::bar"
+   * @returns Parsed AST or undefined if module not found
+   */
+  resolveModule(modulePath: string): WeslAST | undefined {
+    const cached = this.astCache.get(modulePath);
+    if (cached) return cached;
+
+    const sourceFile = this.tryExtensions(modulePath);
+    if (!sourceFile) return undefined;
+
+    const debugFilePath = this.debugWeslRoot
+      ? this.modulePathToDebugPath(modulePath)
+      : sourceFile.filePath;
+    const ast = parseSrcModule({
+      modulePath,
+      debugFilePath,
+      src: sourceFile.source,
+    });
+    this.astCache.set(modulePath, ast);
+    return ast;
+  }
+
+  /** Try .wesl first, then .wgsl */
+  private tryExtensions(modulePath: string) {
+    const basePath = this.moduleToFilePath(modulePath);
+    if (!basePath) return undefined;
+
+    for (const ext of [".wesl", ".wgsl"]) {
+      const filePath = basePath + ext;
+      const source = this.loadSource(filePath);
+      if (source) return { filePath, source };
+    }
+    return undefined;
+  }
+
+  private loadSource(filePath: string): string | undefined {
+    try {
+      return fs.readFileSync(filePath, "utf8");
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Convert module path (package::foo::bar) to filesystem path (baseDir/foo/bar) */
+  private moduleToFilePath(modulePath: string): string | undefined {
+    const relativePath = moduleToRelativePath(modulePath, this.packageName);
+    if (!relativePath) return undefined;
+    return `${this.baseDir}/${relativePath}`;
+  }
+
+  /** Convert module path to debug path for error messages */
+  private modulePathToDebugPath(modulePath: string): string {
+    const relative = moduleToRelativePath(modulePath, this.packageName) ?? "";
+    const root = normalizeDebugRoot(this.debugWeslRoot);
+    return root + relative + ".wesl";
+  }
+}

package/src/LoadModules.ts

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { glob } from "glob";
+import { findWeslToml } from "./LoadWeslToml.ts";
+
+/**
+ * Load the wesl/wgsl shader sources.
+ *
+ * If baseDir or srcGlob are not provided, this function will attempt to read
+ * configuration from wesl.toml in the projectDir. If no wesl.toml exists,
+ * default values will be used.
+ *
+ * @param projectDir The project directory (typically cwd or directory containing package.json)
+ * @param baseDir Optional base directory for shaders (overrides wesl.toml if provided)
+ * @param srcGlob Optional glob pattern for shader files (overrides wesl.toml if provided)
+ */
+export async function loadModules(
+  projectDir: string,
+  baseDir?: string,
+  srcGlob?: string,
+): Promise<Record<string, string>> {
+  // If baseDir or srcGlob not provided, load from wesl.toml
+  let resolvedBaseDir: string;
+  let resolvedSrcGlob: string;
+
+  if (!baseDir || !srcGlob) {
+    const tomlInfo = await findWeslToml(projectDir);
+    resolvedBaseDir = baseDir ?? tomlInfo.resolvedRoot;
+    resolvedSrcGlob = srcGlob ?? tomlInfo.toml.include[0]; // Use first glob pattern
+  } else {
+    resolvedBaseDir = baseDir;
+    resolvedSrcGlob = srcGlob;
+  }
+
+  const foundFiles = await glob(`${resolvedSrcGlob}`, {
+    cwd: projectDir,
+    ignore: "node_modules/**",
+  });
+  const shaderFiles = foundFiles.map(f => path.resolve(projectDir, f));
+  const promisedSrcs = shaderFiles.map(f =>
+    fs.readFile(f, { encoding: "utf8" }),
+  );
+  const src = await Promise.all(promisedSrcs);
+  if (src.length === 0) {
+    throw new Error(`no WGSL/WESL files found in ${resolvedSrcGlob}`);
+  }
+  const baseDirAbs = path.resolve(projectDir, resolvedBaseDir);
+  const relativePaths = shaderFiles.map(p =>
+    path.relative(baseDirAbs, path.resolve(p)),
+  );
+
+  // Normalize Windows paths and line endings
+  const normalPaths = relativePaths.map(p => p.replace(/\\/g, "/"));
+  const normalSrc = src.map(s => s.replace(/\r\n/g, "\n"));
+
+  const moduleEntries = zip(normalPaths, normalSrc);
+  return Object.fromEntries(moduleEntries);
+}
+
+export function zip<A, B>(as: A[], bs: B[]): [A, B][] {
+  return as.map((a, i) => [a, bs[i]]);
+}

package/src/LoadWeslToml.ts

@@ -0,0 +1,104 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import toml from "toml";
+
+/** Configuration from wesl.toml */
+export interface WeslToml {
+  /** 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. */
+  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 */
+export interface WeslTomlInfo {
+  /** The path to the toml file, relative to the cwd, undefined if no toml file */
+  tomlFile: string | undefined;
+
+  /** The absolute path to the directory that contains the toml.
+   * Paths inside the toml are relative to this. */
+  tomlDir: string;
+
+  /** The wesl root, relative to the projectDir.
+   * This lets loadModules do `path.resolve(projectDir, resolvedRoot)` */
+  resolvedRoot: string;
+
+  /** The underlying toml file */
+  toml: WeslToml;
+}
+
+/** Default configuration when no wesl.toml is found */
+export const defaultWeslToml: WeslToml = {
+  edition: "unstable_2025",
+  include: ["shaders/**/*.w[eg]sl"],
+  root: "shaders",
+  dependencies: "auto",
+};
+
+/**
+ * Load and parse a wesl.toml file from the fs.
+ * Provide default values for any required WeslToml fields.
+ */
+export async function loadWeslToml(tomlFile: string): Promise<WeslToml> {
+  const tomlString = await fs.readFile(tomlFile, "utf-8");
+  const parsed = toml.parse(tomlString) as WeslToml;
+  const weslToml = { ...defaultWeslToml, ...parsed };
+  return weslToml;
+}
+
+/**
+ * Find and load the wesl.toml file, or use defaults if not found
+ *
+ * @param projectDir The directory to search for wesl.toml (typically cwd or project root)
+ * @param specifiedToml Optional explicit path to a toml file
+ * @returns Information about the loaded TOML configuration
+ */
+export async function findWeslToml(
+  projectDir: string,
+  specifiedToml?: string,
+): Promise<WeslTomlInfo> {
+  // find the wesl.toml file if it exists
+  let tomlFile: string | undefined;
+  if (specifiedToml) {
+    await fs.access(specifiedToml);
+    tomlFile = specifiedToml;
+  } else {
+    const tomlPath = path.join(projectDir, "wesl.toml");
+    tomlFile = await fs
+      .access(tomlPath)
+      .then(() => tomlPath)
+      .catch(() => {
+        return undefined;
+      });
+  }
+
+  // load the toml contents
+  let parsedToml: WeslToml;
+  let tomlDir: string;
+  if (tomlFile) {
+    parsedToml = await loadWeslToml(tomlFile);
+    tomlDir = path.dirname(tomlFile);
+  } else {
+    parsedToml = defaultWeslToml;
+    tomlDir = projectDir;
+  }
+
+  const tomlToWeslRoot = path.resolve(tomlDir, parsedToml.root);
+  const projectDirAbs = path.resolve(projectDir);
+  const resolvedRoot = path.relative(projectDirAbs, tomlToWeslRoot);
+
+  return { tomlFile, tomlDir, resolvedRoot, toml: parsedToml };
+}

package/src/NpmResolver.ts

@@ -0,0 +1,59 @@
+import { resolve } from "import-meta-resolve";
+import { npmNameVariations } from "wesl";
+
+/** Find longest resolvable npm subpath from WESL module path segments.
+ *
+ * A WESL statement containing a WESL module path like 'import foo__bar::baz::elem;' references
+ * an npm package, an export within that package, a module within the WeslBundle,
+ * and an element within the WESL module.
+ * This function returns the npm package and export portion from the module path.
+ * The return value is usable to dynamically import the corresponding weslBundle.js file.
+ *
+ * Translation from a WESL module path to an npm package path involves:
+ * - Mapping WESL package names to their npm counterparts (e.g., 'foo__bar' -> '@foo/bar')
+ * - Probing to find the longest valid export subpath within the package
+ *   - package.json allows export subpaths, so 'mypkg::gpu' could be 'mypkg/gpu' or just 'mypkg' in npm
+ * - Probing to handle variations in package naming
+ *   - foo_bar could be foo-bar in npm
+ *
+ * Note that the resolution is based on package.json.
+ * The resolved file itself may not exist yet. (e.g. dist/weslBundle.js may not have been built yet)
+ *
+ * @param mPath - Module path segments
+ * @param importerURL - Base URL for resolution (e.g., 'file:///path/to/project/')
+ * @returns Longest resolvable subpath (e.g., 'foo/bar/baz' or 'foo')
+ */
+export function npmResolveWESL(
+  mPath: string[],
+  importerURL: string,
+): string | undefined {
+  // Try longest subpaths first
+  for (const subPath of exportSubpaths(mPath)) {
+    // Try npm name variations to handle sanitized package names
+    for (const npmPath of npmNameVariations(subPath)) {
+      if (tryResolve(npmPath, importerURL)) {
+        return npmPath;
+      }
+    }
+  }
+  return undefined;
+}
+
+/** Try Node.js module resolution.
+ * @return undefined if unresolvable. */
+function tryResolve(path: string, importerURL: string): string | undefined {
+  try {
+    return resolve(path, importerURL);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Yield possible export subpaths from module path, longest first.
+ * Drops the last segment (element name) and iterates down. */
+function* exportSubpaths(mPath: string[]): Generator<string> {
+  const longest = mPath.length - 1;
+  for (let i = longest; i >= 0; i--) {
+    yield mPath.slice(0, i).join("/");
+  }
+}

package/src/ParseDependencies.ts

@@ -0,0 +1,104 @@
+import { pathToFileURL } from "node:url";
+import { resolve } from "import-meta-resolve";
+import type { WeslBundle } from "wesl";
+import {
+  filterMap,
+  findUnboundIdents,
+  RecordResolver,
+  WeslParseError,
+} from "wesl";
+import { npmResolveWESL } from "./NpmResolver.ts";
+
+/**
+ * Find package dependencies in WESL source files.
+ *
+ * Parses sources and partially binds identifiers to reveal unresolved package
+ * references. Returns the longest resolvable npm subpath for each dependency.
+ *
+ * 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')
+ */
+export function parseDependencies(
+  weslSrc: Record<string, string>,
+  projectDir: string,
+): string[] {
+  let resolver: RecordResolver;
+  try {
+    resolver = new RecordResolver(weslSrc);
+  } catch (e: any) {
+    if (e.cause instanceof WeslParseError) {
+      console.error(e.message, "\n");
+      return [];
+    }
+    throw e;
+  }
+
+  const unbound = findUnboundIdents(resolver);
+  if (!unbound) return [];
+
+  // Filter: skip builtins (1 segment) and linker virtuals ('constants')
+  const pkgRefs = unbound.filter(
+    modulePath => modulePath.length > 1 && modulePath[0] !== "constants",
+  );
+  if (pkgRefs.length === 0) return [];
+
+  const projectURL = projectDirURL(projectDir);
+  const deps = filterMap(pkgRefs, mPath => npmResolveWESL(mPath, projectURL));
+  const uniqueDeps = [...new Set(deps)];
+
+  return uniqueDeps;
+}
+
+/**
+ * Load WeslBundle instances referenced by WESL sources.
+ *
+ * Parses sources to find external module references, then dynamically imports
+ * the corresponding weslBundle.js files.
+ *
+ * @param weslSrc - Record of WESL source files by path
+ * @param projectDir - Project directory for resolving imports
+ * @param packageName - Optional current package name
+ * @param includeCurrentPackage - Include current package in results (default: false)
+ * @returns Loaded WeslBundle instances
+ */
+export async function dependencyBundles(
+  weslSrc: Record<string, string>,
+  projectDir: string,
+  packageName?: string,
+  includeCurrentPackage = false,
+): Promise<WeslBundle[]> {
+  const deps = parseDependencies(weslSrc, projectDir);
+  const filteredDeps = includeCurrentPackage
+    ? deps
+    : otherPackages(deps, packageName);
+  const projectURL = projectDirURL(projectDir);
+  const bundles = filteredDeps.map(async dep => {
+    const url = resolve(dep, projectURL);
+    const module = await import(url);
+    return module.default;
+  });
+
+  return await Promise.all(bundles);
+}
+
+/** Exclude current package from dependency list. */
+function otherPackages(deps: string[], packageName?: string): string[] {
+  if (!packageName) return deps;
+  return deps.filter(
+    dep => dep !== packageName && !dep.startsWith(`${packageName}/`),
+  );
+}
+
+/** Normalize project directory to file:// URL with trailing slash. */
+function projectDirURL(projectDir: string): string {
+  if (projectDir.startsWith("file://")) {
+    return projectDir.endsWith("/") ? projectDir : `${projectDir}/`;
+  }
+  const fileUrl = pathToFileURL(projectDir).href;
+  return fileUrl.endsWith("/") ? fileUrl : `${fileUrl}/`;
+}

package/src/ResolveProjectDir.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/**
+ * Resolves a project directory by searching upward for package.json or wesl.toml.
+ *
+ * @param startPath - Optional starting path (file:// URL or filesystem path).
+ *   If a file URL is provided, uses its directory.
+ *   If omitted or falsy, defaults to process.cwd().
+ * @returns file:// URL string pointing to the project directory
+ *   (the first ancestor containing package.json or wesl.toml, or the start directory)
+ */
+export async function resolveProjectDir(startPath?: string): Promise<string> {
+  let dir: string;
+
+  if (!startPath) {
+    dir = process.cwd();
+  } else if (startPath.startsWith("file://")) {
+    // Convert file:// URL to path, then get its directory
+    const fsPath = fileURLToPath(startPath);
+    dir = (await isFile(fsPath)) ? path.dirname(fsPath) : fsPath;
+  } else {
+    // Treat as filesystem path
+    dir = (await isFile(startPath)) ? path.dirname(startPath) : startPath;
+  }
+
+  // Search upward for package.json or wesl.toml
+  let current = path.resolve(dir);
+  while (true) {
+    const hasPkgJson = await fileExists(path.join(current, "package.json"));
+    const hasWeslToml = await fileExists(path.join(current, "wesl.toml"));
+
+    if (hasPkgJson || hasWeslToml) {
+      return pathToFileURL(current).href;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      // Reached filesystem root without finding package.json or wesl.toml
+      // Return the original dir as file:// URL
+      return pathToFileURL(dir).href;
+    }
+    current = parent;
+  }
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function isFile(fsPath: string): Promise<boolean> {
+  try {
+    const stat = await fs.stat(fsPath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}

package/src/Version.ts

@@ -0,0 +1,22 @@
+/** Read package.json from a directory.
+ * @param projectDir - file:// URL string to directory containing package.json
+ * @returns the parsed package.json contents */
+export async function readPackageJson(
+  projectDir: string,
+): Promise<Record<string, any>> {
+  const baseUrl = projectDir.endsWith("/") ? projectDir : `${projectDir}/`;
+  const pkgJsonPath = new URL("package.json", baseUrl);
+  const pkgModule = await import(pkgJsonPath.href, { with: { type: "json" } });
+  return pkgModule.default;
+}
+
+/**
+ * @param projectDir - file:// URL string to directory containing package.json
+ * @returns the 'version' field from the package.json in the `projectDir`
+ */
+export async function versionFromPackageJson(
+  projectDir: string,
+): Promise<string> {
+  const pkg = await readPackageJson(projectDir);
+  return pkg.version;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from "./FileModuleResolver.ts";
+export * from "./LoadModules.ts";
+export * from "./LoadWeslToml.ts";
+export * from "./ParseDependencies.ts";
+export * from "./ResolveProjectDir.ts";
+export * from "./Version.ts";

package/dist/index.d.ts

@@ -1,118 +0,0 @@
-import { VirtualLibraryFn, WeslBundle } from "wesl";
-import { WgslElementType, WgslElementType as WgslElementType$1 } from "thimbleberry";
-
-//#region src/ParseDependencies.d.ts
-/**
-* Find the wesl package dependencies in a set of WESL files
-* (for packaging WESL files into a library)
-*
-* Parse the WESL files and partially bind the identifiers,
-* returning any identifiers that are not succesfully bound.
-* Those identifiers are the package dependencies.
-*
-* 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.
-*/
-/**
- * Find the wesl package dependencies in a set of WESL files
- * (for packaging WESL files into a library)
- *
- * Parse the WESL files and partially bind the identifiers,
- * returning any identifiers that are not succesfully bound.
- * Those identifiers are the package dependencies.
- *
- * 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.
- */
-declare function parseDependencies(weslSrc: Record<string, string>, projectDir: string): string[];
-/** @return WeslBundle instances referenced by wesl sources
- *
- * Parse the WESL files to find references to external WESL modules,
- * and then load those modules (weslBundle.js files) using node dynamic imports.
- */
-declare function dependencyBundles(weslSrc: Record<string, string>, projectDir: string): Promise<WeslBundle[]>;
-
-//#endregion
-//#region src/SimpleComputeShader.d.ts
-interface CompileShaderParams {
-  /** The project directory, used for resolving dependencies.  */
-  projectDir: string;
-  /** The GPUDevice to use for shader compilation. */
-  device: GPUDevice;
-  /** The WGSL/WESL shader source code. */
-  src: string;
-  /** Optional conditions for shader compilation. */
-  conditions?: Record<string, boolean>;
-  /** Optional virtual libraries to include in the shader. */
-  virtualLibs?: Record<string, VirtualLibraryFn>;
-}
-/**
- * Compiles a single WESL shader source string into a GPUShaderModule for testing
- * with automatic package detection.
- *
- * Parses the shader source to find references to wesl packages, and
- * then searches installed npm packages to find the appropriate npm package
- * bundle to include in the link.
- *
- * @param projectDir - The project directory, used for resolving dependencies.
- * @param device - The GPUDevice to use for shader compilation.
- * @param src - The WESL shader source code.
- * @returns A Promise that resolves to the compiled GPUShaderModule.
- */
-declare function compileShader(params: CompileShaderParams): Promise<GPUShaderModule>;
-/**
- * Transpiles and runs a simple compute shader on the GPU for testing.
- *
- * A storage buffer is available for the shader to write test results.
- * `test::results[0]` is the first element of the buffer in wesl.
- * After execution the storage buffer is copied back to the CPU and returned
- * for test validation.
- *
- * Shader libraries mentioned in the shader source are attached automatically
- * if they are in node_modules.
- *
- * @param module - The compiled GPUShaderModule containing the compute shader.
- * The shader is invoked once.
- * @param resultFormat - format for interpreting the result buffer data. (default u32)
- * @returns storage result array (typically four numbers if the buffer format is u32 or f32)
- */
-declare function testComputeShader(projectDir: string, gpu: GPU, src: string, resultFormat: WgslElementType$1, conditions?: Record<string, boolean>): Promise<number[]>;
-/**
- * Transpiles and runs a simple compute shader on the GPU for testing.
- *
- * a 16 byte storage buffer is available for the shader at `@group(0) @binding(0)`.
- * Compute shaders can write test results into the buffer.
- * After execution the storage buffer is copied back to the CPU and returned
- * for test validation.
- *
- * Shader libraries mentioned in the shader source are attached automatically
- * if they are in node_modules.
- *
- * @param module - The compiled GPUShaderModule containing the compute shader.
- * The shader is invoked once.
- * @param resultFormat - format for interpreting the result buffer data. (default u32)
- * @returns storage result array
- */
-declare function runSimpleComputePipeline(device: GPUDevice, module: GPUShaderModule, resultFormat?: WgslElementType$1): Promise<number[]>;
-
-//#endregion
-//#region src/Version.d.ts
-/** @returns the version from the package.json in the provided directory */
-declare function versionFromPackageJson(projectDir: string): Promise<string>;
-
-//#endregion
-//#region src/LoadModules.d.ts
-/** load the wesl/wgsl shader sources */
-declare function loadModules(projectDir: string, baseDir: string, srcGlob: string): Promise<Record<string, string>>;
-declare function zip<A, B>(as: A[], bs: B[]): [A, B][];
-
-//#endregion
-export { CompileShaderParams, WgslElementType, compileShader, dependencyBundles, loadModules, parseDependencies, runSimpleComputePipeline, testComputeShader, versionFromPackageJson, zip };

package/dist/index.js

@@ -1,235 +0,0 @@
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { resolve } from "import-meta-resolve";
-import { WeslParseError, filterMap, findUnboundIdents, link, parseIntoRegistry, parsedRegistry, requestWeslDevice } from "wesl";
-import { copyBuffer, elementStride } from "thimbleberry";
-import fs from "node:fs/promises";
-import { glob } from "glob";
-
-//#region src/ParseDependencies.ts
-/**
-* Find the wesl package dependencies in a set of WESL files
-* (for packaging WESL files into a library)
-*
-* Parse the WESL files and partially bind the identifiers,
-* returning any identifiers that are not succesfully bound.
-* Those identifiers are the package dependencies.
-*
-* 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.
-*/
-function parseDependencies(weslSrc, projectDir) {
-	const registry = parsedRegistry();
-	try {
-		parseIntoRegistry(weslSrc, registry);
-	} catch (e) {
-		if (e.cause instanceof WeslParseError) console.error(e.message, "\n");
-		else throw e;
-	}
-	const unbound = findUnboundIdents(registry);
-	if (!unbound) return [];
-	const pkgRefs = unbound.filter((modulePath) => modulePath.length > 1);
-	if (pkgRefs.length === 0) return [];
-	const fullProjectDir = path.resolve(path.join(projectDir, "foo"));
-	const projectURL = pathToFileURL(fullProjectDir).href;
-	const deps = filterMap(pkgRefs, (mPath) => unboundToDependency(mPath, projectURL));
-	const uniqueDeps = [...new Set(deps)];
-	return uniqueDeps;
-}
-/**
-* Find the longest resolvable npm subpath from a module path.
-*
-* @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'
-*/
-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 */
-function tryResolve(path$1, importerURL) {
-	try {
-		return resolve(path$1, importerURL);
-	} catch {
-		return void 0;
-	}
-}
-/**
-* Yield possible export entry subpaths from module path
-* longest subpath first.
-*/
-function* exportSubpaths(mPath) {
-	const longest = mPath.length - 1;
-	for (let i = longest; i >= 0; i--) {
-		const subPath = mPath.slice(0, i).join("/");
-		yield subPath;
-	}
-}
-/** @return WeslBundle instances referenced by wesl sources
-*
-* Parse the WESL files to find references to external WESL modules,
-* and then load those modules (weslBundle.js files) using node dynamic imports.
-*/
-async function dependencyBundles(weslSrc, projectDir) {
-	const deps = parseDependencies(weslSrc, projectDir);
-	const bundles = deps.map(async (dep) => {
-		const url = resolve(dep, projectDir);
-		const module = await import(url);
-		return module.default;
-	});
-	return await Promise.all(bundles);
-}
-
-//#endregion
-//#region src/SimpleComputeShader.ts
-const resultBufferSize = 16;
-/**
-* Compiles a single WESL shader source string into a GPUShaderModule for testing
-* with automatic package detection.
-*
-* Parses the shader source to find references to wesl packages, and
-* then searches installed npm packages to find the appropriate npm package
-* bundle to include in the link.
-*
-* @param projectDir - The project directory, used for resolving dependencies.
-* @param device - The GPUDevice to use for shader compilation.
-* @param src - The WESL shader source code.
-* @returns A Promise that resolves to the compiled GPUShaderModule.
-*/
-async function compileShader(params) {
-	const { projectDir, device, src, conditions, virtualLibs } = params;
-	const weslSrc = { main: src };
-	const libs = await dependencyBundles(weslSrc, projectDir);
-	const linked = await link({
-		weslSrc,
-		libs,
-		virtualLibs,
-		conditions
-	});
-	return device.createShaderModule({ code: linked.dest });
-}
-/**
-* Transpiles and runs a simple compute shader on the GPU for testing.
-*
-* A storage buffer is available for the shader to write test results.
-* `test::results[0]` is the first element of the buffer in wesl.
-* After execution the storage buffer is copied back to the CPU and returned
-* for test validation.
-*
-* Shader libraries mentioned in the shader source are attached automatically
-* if they are in node_modules.
-*
-* @param module - The compiled GPUShaderModule containing the compute shader.
-* The shader is invoked once.
-* @param resultFormat - format for interpreting the result buffer data. (default u32)
-* @returns storage result array (typically four numbers if the buffer format is u32 or f32)
-*/
-async function testComputeShader(projectDir, gpu, src, resultFormat, conditions = {}) {
-	const adapter = await gpu.requestAdapter();
-	const device = await requestWeslDevice(adapter);
-	try {
-		const arraySize = resultBufferSize / elementStride(resultFormat);
-		const arrayType = `array<${resultFormat}, ${arraySize}>`;
-		const virtualLibs = { test: () => `@group(0) @binding(0) var <storage, read_write> results: ${arrayType};` };
-		const params = {
-			projectDir,
-			device,
-			src,
-			conditions,
-			virtualLibs
-		};
-		const module = await compileShader(params);
-		const result = await runSimpleComputePipeline(device, module, resultFormat);
-		return result;
-	} finally {
-		device.destroy();
-	}
-}
-/**
-* Transpiles and runs a simple compute shader on the GPU for testing.
-*
-* a 16 byte storage buffer is available for the shader at `@group(0) @binding(0)`.
-* Compute shaders can write test results into the buffer.
-* After execution the storage buffer is copied back to the CPU and returned
-* for test validation.
-*
-* Shader libraries mentioned in the shader source are attached automatically
-* if they are in node_modules.
-*
-* @param module - The compiled GPUShaderModule containing the compute shader.
-* The shader is invoked once.
-* @param resultFormat - format for interpreting the result buffer data. (default u32)
-* @returns storage result array
-*/
-async function runSimpleComputePipeline(device, module, resultFormat) {
-	const bgLayout = device.createBindGroupLayout({ entries: [{
-		binding: 0,
-		visibility: GPUShaderStage.COMPUTE,
-		buffer: { type: "storage" }
-	}] });
-	const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bgLayout] });
-	const pipeline = device.createComputePipeline({
-		layout: pipelineLayout,
-		compute: { module }
-	});
-	const storageBuffer = device.createBuffer({
-		label: "storage",
-		size: resultBufferSize,
-		usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-	});
-	const bindGroup = device.createBindGroup({
-		layout: bgLayout,
-		entries: [{
-			binding: 0,
-			resource: { buffer: storageBuffer }
-		}]
-	});
-	const commands = device.createCommandEncoder();
-	const pass = commands.beginComputePass();
-	pass.setPipeline(pipeline);
-	pass.setBindGroup(0, bindGroup);
-	pass.dispatchWorkgroups(1);
-	pass.end();
-	device.queue.submit([commands.finish()]);
-	const data = await copyBuffer(device, storageBuffer, resultFormat);
-	return data;
-}
-
-//#endregion
-//#region src/Version.ts
-/** @returns the version from the package.json in the provided directory */
-async function versionFromPackageJson(projectDir) {
-	const pkgJsonPath = new URL("./package.json", projectDir);
-	const pkgModule = await import(pkgJsonPath.href, { with: { type: "json" } });
-	const version = pkgModule.default.version;
-	return version;
-}
-
-//#endregion
-//#region src/LoadModules.ts
-/** load the wesl/wgsl shader sources */
-async function loadModules(projectDir, baseDir, srcGlob) {
-	const foundFiles = await glob(`${srcGlob}`, {
-		cwd: projectDir,
-		ignore: "node_modules/**"
-	});
-	const shaderFiles = foundFiles.map((f) => path.resolve(projectDir, f));
-	const promisedSrcs = shaderFiles.map((f) => fs.readFile(f, { encoding: "utf8" }));
-	const src = await Promise.all(promisedSrcs);
-	if (src.length === 0) throw new Error(`no WGSL/WESL files found in ${srcGlob}`);
-	const baseDirAbs = path.resolve(projectDir, baseDir);
-	const relativePaths = shaderFiles.map((p) => path.relative(baseDirAbs, path.resolve(p)));
-	const moduleEntries = zip(relativePaths, src);
-	return Object.fromEntries(moduleEntries);
-}
-function zip(as, bs) {
-	return as.map((a, i) => [a, bs[i]]);
-}
-
-//#endregion
-export { compileShader, dependencyBundles, loadModules, parseDependencies, runSimpleComputePipeline, testComputeShader, versionFromPackageJson, zip };