wesl-packager 0.6.15 → 0.6.17

package/bin/wesl-packager

@@ -2,19 +2,19 @@
 import { builtinModules } from "node:module";
 import process$1, { exit } from "node:process";
 import { hideBin } from "yargs/helpers";
-import fs, { lstat, mkdir, readdir, readlink, realpath } from "node:fs/promises";
+import * as actualFS from "node:fs";
+import fs, { realpathSync, statSync } from "node:fs";
+import { RecordResolver, WeslParseError, bindIdentsRecursive, filterMap, findValidRootDecls, minimalMangle, noSuffix } from "wesl";
+import fs$1, { lstat, mkdir, readdir, readlink, realpath } from "node:fs/promises";
 import path, { posix, win32 } from "node:path";
 import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
-import { lstatSync, readdir as readdir$1, readdirSync, readlinkSync, realpathSync } from "fs";
-import * as actualFS from "node:fs";
-import fs$1, { realpathSync as realpathSync$1, statSync } from "node:fs";
+import { lstatSync, readdir as readdir$1, readdirSync, readlinkSync, realpathSync as realpathSync$1 } from "fs";
 import { EventEmitter } from "node:events";
 import Stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import assert from "node:assert";
 import v8 from "node:v8";
 import { format, inspect } from "node:util";
-import { WeslParseError, filterMap, findUnboundIdents, noSuffix, parseIntoRegistry, parsedRegistry } from "wesl";
 import yargs from "yargs";
 import { Biome, Distribution } from "@biomejs/js-api";
 
@@ -43,6 +43,41 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 
+//#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/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
 const balanced = (a, b, str) => {
@@ -3327,7 +3362,7 @@ while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
 
 //#endregion
 //#region ../../node_modules/.pnpm/path-scurry@2.0.0/node_modules/path-scurry/dist/esm/index.js
-const realpathSync$2 = realpathSync.native;
+const realpathSync$2 = realpathSync$1.native;
 const defaultFS = {
 	lstatSync,
 	readdir: readdir$1,
@@ -9632,16 +9667,17 @@ 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.
 * Provide default values for any required WeslToml fields.
 */
 async function loadWeslToml(tomlFile) {
-	const tomlString = await fs.readFile(tomlFile, "utf-8");
+	const tomlString = await fs$1.readFile(tomlFile, "utf-8");
 	const parsed = import_toml.default.parse(tomlString);
 	return {
 		...defaultWeslToml,
@@ -9658,11 +9694,11 @@ async function loadWeslToml(tomlFile) {
 async function findWeslToml(projectDir, specifiedToml) {
 	let tomlFile;
 	if (specifiedToml) {
-		await fs.access(specifiedToml);
+		await fs$1.access(specifiedToml);
 		tomlFile = specifiedToml;
 	} else {
 		const tomlPath = path.join(projectDir, "wesl.toml");
-		tomlFile = await fs.access(tomlPath).then(() => tomlPath).catch(() => {});
+		tomlFile = await fs$1.access(tomlPath).then(() => tomlPath).catch(() => {});
 	}
 	let parsedToml;
 	let tomlDir;
@@ -9673,13 +9709,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
 	};
 }
@@ -9702,8 +9738,8 @@ async function loadModules(projectDir, baseDir, srcGlob) {
 	let resolvedSrcGlob;
 	if (!baseDir || !srcGlob) {
 		const tomlInfo = await findWeslToml(projectDir);
-		resolvedBaseDir = baseDir ?? tomlInfo.resolvedWeslRoot;
-		resolvedSrcGlob = srcGlob ?? tomlInfo.toml.weslFiles[0];
+		resolvedBaseDir = baseDir ?? tomlInfo.resolvedRoot;
+		resolvedSrcGlob = srcGlob ?? tomlInfo.toml.include[0];
 	} else {
 		resolvedBaseDir = baseDir;
 		resolvedSrcGlob = srcGlob;
@@ -9712,7 +9748,7 @@ async function loadModules(projectDir, baseDir, srcGlob) {
 		cwd: projectDir,
 		ignore: "node_modules/**"
 	})).map((f) => path.resolve(projectDir, f));
-	const promisedSrcs = shaderFiles.map((f) => fs.readFile(f, { encoding: "utf8" }));
+	const promisedSrcs = shaderFiles.map((f) => fs$1.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);
@@ -10064,7 +10100,7 @@ function read(jsonPath, { base, specifier }) {
 	/** @type {string | undefined} */
 	let string;
 	try {
-		string = fs$1.readFileSync(path.toNamespacedPath(jsonPath), "utf8");
+		string = fs.readFileSync(path.toNamespacedPath(jsonPath), "utf8");
 	} catch (error) {
 		const exception = error;
 		if (exception.code !== "ENOENT") throw exception;
@@ -10410,7 +10446,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
 		throw error;
 	}
 	if (!preserveSymlinks) {
-		const real = realpathSync$1(filePath);
+		const real = realpathSync(filePath);
 		const { search, hash } = resolved;
 		resolved = pathToFileURL(real + (filePath.endsWith(path.sep) ? "/" : ""));
 		resolved.search = search;
@@ -10948,48 +10984,48 @@ function resolve(specifier, parent) {
 //#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.
+*
+* Parses sources and partially binds identifiers to reveal unresolved package
+* references. Returns the longest resolvable npm subpath for each dependency.
 *
-* Parse the WESL files and partially bind the identifiers,
-* returning any identifiers that are not succesfully bound.
-* Those identifiers are the package dependencies.
+* For example, 'foo::bar::baz' could resolve to:
+*   - 'foo/bar' (package foo, export './bar' bundle)
+*   - 'foo' (package foo, default export)
 *
-* 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.
+* @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);
@@ -10997,23 +11033,34 @@ 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 ../wesl-tooling/src/Version.ts
+/** Read package.json from a directory.
+* @param projectDir - file:// URL string to directory containing package.json
+* @returns the parsed package.json contents */
+async function readPackageJson(projectDir) {
+	const baseUrl = projectDir.endsWith("/") ? projectDir : `${projectDir}/`;
+	return (await import(new URL("package.json", baseUrl).href, { with: { type: "json" } })).default;
+}
 /**
-* @param projectDir - e.g., file:// URL of the directory containing package.json
+* @param projectDir - file:// URL string to directory containing package.json
 * @returns the 'version' field from the package.json in the `projectDir`
 */
 async function versionFromPackageJson(projectDir) {
-	return (await import(new URL("./package.json", projectDir).href, { with: { type: "json" } })).default.version;
+	return (await readPackageJson(projectDir)).version;
 }
 
 //#endregion
@@ -11044,7 +11091,7 @@ async function packageWgsl(args) {
 /** add an 'exports' entry to package.json for the wesl bundles */
 async function updatePackageJson(projectDir, outDir, multiBundle) {
 	const pkgJsonPath = path.join(projectDir, "package.json");
-	const pkgJsonString = await fs.readFile(pkgJsonPath, { encoding: "utf8" });
+	const pkgJsonString = await fs$1.readFile(pkgJsonPath, { encoding: "utf8" });
 	const pkgJson = JSON.parse(pkgJsonString);
 	const exports = {};
 	const distDir = path.relative(projectDir, outDir);
@@ -11058,7 +11105,7 @@ async function updatePackageJson(projectDir, outDir, multiBundle) {
 	};
 	const newPkgJson = insertExports(pkgJson, exports);
 	const jsonString = JSON.stringify(newPkgJson, null, 2).concat("\n");
-	await fs.writeFile(pkgJsonPath, jsonString);
+	await fs$1.writeFile(pkgJsonPath, jsonString);
 }
 /** insert the exports field into the package.json */
 function insertExports(pkgJson, exports) {
@@ -11109,7 +11156,7 @@ async function writeJsBundle(weslBundle, dependencies, outDir) {
   `;
 	const outPath = path.join(outDir, "weslBundle.js");
 	const formatted = biome.formatContent(biomeKey, outString, { filePath: "b.js" });
-	await fs.writeFile(outPath, formatted.content);
+	await fs$1.writeFile(outPath, formatted.content);
 }
 /** Write weslBundle.d.ts containing the type definitions for a WeslBundle */
 async function writeTypeScriptDts(outDir) {
@@ -11119,7 +11166,7 @@ async function writeTypeScriptDts(outDir) {
   `;
 	const formatted = biome.formatContent(biomeKey, declText, { filePath: "t.d.ts" });
 	const outPath = path.join(outDir, "weslBundle.d.ts");
-	await fs.writeFile(outPath, formatted.content);
+	await fs$1.writeFile(outPath, formatted.content);
 }
 /** @return the bundle plus dependencies as a JavaScript string */
 function bundleToJsString(bundle, dependencies) {
@@ -11139,7 +11186,7 @@ function bundleToJsString(bundle, dependencies) {
 /** parse and extract fields from package.json that we care about
 * (the name of the package) */
 async function loadPackageFields(pkgJsonPath) {
-	const pkgJsonString = await fs.readFile(pkgJsonPath, { encoding: "utf8" });
+	const pkgJsonString = await fs$1.readFile(pkgJsonPath, { encoding: "utf8" });
 	const { name } = JSON.parse(pkgJsonString);
 	verifyField("name", name);
 	function verifyField(field, value) {
@@ -11174,7 +11221,8 @@ async function packagerCli(rawArgs$1) {
 	await packageWgsl(cliArgs);
 }
 async function parseArgs(args) {
-	const appVersion = await versionFromPackageJson(new URL("..", import.meta.url));
+	const projectDir = new URL("..", import.meta.url).href;
+	const appVersion = await versionFromPackageJson(projectDir);
 	return yargs(args).command("$0", "create an npm package from WGSL/WESL files").version(appVersion).option("src", {
 		type: "string",
 		describe: "WGSL/WESL files to bundle in the package (glob syntax, defaults to wesl.toml or shaders/**/*.w[eg]sl)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl-packager",
-  "version": "0.6.15",
+  "version": "0.6.17",
   "type": "module",
   "bin": "bin/wesl-packager",
   "files": [
@@ -10,7 +10,7 @@
     "@biomejs/js-api": "^1.0.0",
     "@biomejs/wasm-nodejs": "^2.0.6",
     "yargs": "^18.0.0",
-    "wesl": "0.6.15"
+    "wesl": "0.6.17"
   },
   "devDependencies": {
     "dependent_package": "x",