wesl-link 0.6.15 → 0.6.16

package/bin/wesl-link

@@ -3,11 +3,11 @@ import { hideBin } from "yargs/helpers";
 import path, { posix, win32 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { resolve } from "import-meta-resolve";
-import { CachingStream, MatchersStream, ParseError, RegexMatchers, collectArray, delimited, enableTracing, eof, fn, kind, log, matchOneOf, not, opt, or, preceded, repeat, repeatPlus, req, separated_pair, seq, seqObj, span, tagScope, terminated, text, token, tokenKind, tokenOf, tracing, withSep, withSepPlus, withStreamAction, yes } from "mini-parse";
-import { WeslParseError, astToString, filterMap, findUnboundIdents, link, parseIntoRegistry, parsedRegistry, scopeToString } from "wesl";
+import { enableTracing, log } from "mini-parse";
+import { RecordResolver, WeslParseError, astToString, bindIdentsRecursive, filterMap, findValidRootDecls, link, minimalMangle, scopeToString } from "wesl";
+import * as actualFS from "node:fs";
 import fs, { lstat, readdir, readlink, realpath } from "node:fs/promises";
 import { lstatSync, readdir as readdir$1, readdirSync, readlinkSync, realpathSync } from "fs";
-import * as actualFS from "node:fs";
 import { EventEmitter } from "node:events";
 import Stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
@@ -38,6 +38,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) => {
@@ -373,7 +408,7 @@ const parseClass = (glob$1, position) => {
 * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
 * or unescaped.
 */
-const unescape$1 = (s, { windowsPathsNoEscape = false } = {}) => {
+const unescape = (s, { windowsPathsNoEscape = false } = {}) => {
 	return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
 };
 
@@ -504,7 +539,7 @@ var AST = class AST {
 		for (const p of this.#parts) c.copyIn(p);
 		return c;
 	}
-	static #parseAST(str, ast, pos, opt$1) {
+	static #parseAST(str, ast, pos, opt) {
 		let escaping = false;
 		let inBrace = false;
 		let braceStart = -1;
@@ -532,11 +567,11 @@ var AST = class AST {
 					acc$1 += c;
 					continue;
 				}
-				if (!opt$1.noext && isExtglobType(c) && str.charAt(i$1) === "(") {
+				if (!opt.noext && isExtglobType(c) && str.charAt(i$1) === "(") {
 					ast.push(acc$1);
 					acc$1 = "";
 					const ext$1 = new AST(c, ast);
-					i$1 = AST.#parseAST(str, ext$1, i$1, opt$1);
+					i$1 = AST.#parseAST(str, ext$1, i$1, opt);
 					ast.push(ext$1);
 					continue;
 				}
@@ -574,7 +609,7 @@ var AST = class AST {
 				acc = "";
 				const ext$1 = new AST(c, part);
 				part.push(ext$1);
-				i = AST.#parseAST(str, ext$1, i, opt$1);
+				i = AST.#parseAST(str, ext$1, i, opt);
 				continue;
 			}
 			if (c === "|") {
@@ -645,7 +680,7 @@ var AST = class AST {
 			if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") end = "(?:$|\\/)";
 			return [
 				start$1 + src + end,
-				unescape$1(src),
+				unescape(src),
 				this.#hasMagic = !!this.#hasMagic,
 				this.#uflag
 			];
@@ -660,7 +695,7 @@ var AST = class AST {
 			this.#hasMagic = void 0;
 			return [
 				s,
-				unescape$1(this.toString()),
+				unescape(this.toString()),
 				false,
 				false
 			];
@@ -676,7 +711,7 @@ var AST = class AST {
 		}
 		return [
 			final,
-			unescape$1(body),
+			unescape(body),
 			this.#hasMagic = !!this.#hasMagic,
 			this.#uflag
 		];
@@ -732,7 +767,7 @@ var AST = class AST {
 		}
 		return [
 			re,
-			unescape$1(glob$1),
+			unescape(glob$1),
 			!!hasMagic$1,
 			uflag
 		];
@@ -1319,7 +1354,7 @@ var Minimatch = class {
 minimatch.AST = AST;
 minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
-minimatch.unescape = unescape$1;
+minimatch.unescape = unescape;
 
 //#endregion
 //#region ../../node_modules/.pnpm/lru-cache@11.2.2/node_modules/lru-cache/dist/esm/index.js
@@ -1331,8 +1366,8 @@ const warned = /* @__PURE__ */ new Set();
 /* c8 ignore start */
 const PROCESS = typeof process === "object" && !!process ? process : {};
 /* c8 ignore start */
-const emitWarning = (msg, type, code, fn$1) => {
-	typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn$1) : console.error(`[${code}] ${type}: ${msg}`);
+const emitWarning = (msg, type, code, fn) => {
+	typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
 };
 let AC = globalThis.AbortController;
 let AS = globalThis.AbortSignal;
@@ -1343,8 +1378,8 @@ if (typeof AC === "undefined") {
 		_onabort = [];
 		reason;
 		aborted = false;
-		addEventListener(_, fn$1) {
-			this._onabort.push(fn$1);
+		addEventListener(_, fn) {
+			this._onabort.push(fn);
 		}
 	};
 	AC = class AbortController {
@@ -1356,7 +1391,7 @@ if (typeof AC === "undefined") {
 			if (this.signal.aborted) return;
 			this.signal.reason = reason;
 			this.signal.aborted = true;
-			for (const fn$1 of this.signal._onabort) fn$1(reason);
+			for (const fn of this.signal._onabort) fn(reason);
 			this.signal.onabort?.(reason);
 		}
 	};
@@ -1869,12 +1904,12 @@ var LRUCache = class LRUCache {
 	* Find a value for which the supplied fn method returns a truthy value,
 	* similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
 	*/
-	find(fn$1, getOptions = {}) {
+	find(fn, getOptions = {}) {
 		for (const i of this.#indexes()) {
 			const v = this.#valList[i];
 			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
 			if (value === void 0) continue;
-			if (fn$1(value, this.#keyList[i], this)) return this.get(this.#keyList[i], getOptions);
+			if (fn(value, this.#keyList[i], this)) return this.get(this.#keyList[i], getOptions);
 		}
 	}
 	/**
@@ -1888,24 +1923,24 @@ var LRUCache = class LRUCache {
 	*
 	* Does not update age or recenty of use, or iterate over stale values.
 	*/
-	forEach(fn$1, thisp = this) {
+	forEach(fn, thisp = this) {
 		for (const i of this.#indexes()) {
 			const v = this.#valList[i];
 			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
 			if (value === void 0) continue;
-			fn$1.call(thisp, value, this.#keyList[i], this);
+			fn.call(thisp, value, this.#keyList[i], this);
 		}
 	}
 	/**
 	* The same as {@link LRUCache.forEach} but items are iterated over in
 	* reverse order.  (ie, less recently used items are iterated over first.)
 	*/
-	rforEach(fn$1, thisp = this) {
+	rforEach(fn, thisp = this) {
 		for (const i of this.#rindexes()) {
 			const v = this.#valList[i];
 			const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
 			if (value === void 0) continue;
-			fn$1.call(thisp, value, this.#keyList[i], this);
+			fn.call(thisp, value, this.#keyList[i], this);
 		}
 	}
 	/**
@@ -2552,8 +2587,8 @@ const ABORTED = Symbol("aborted");
 const SIGNAL = Symbol("signal");
 const DATALISTENERS = Symbol("dataListeners");
 const DISCARDED = Symbol("discarded");
-const defer = (fn$1) => Promise.resolve().then(fn$1);
-const nodefer = (fn$1) => fn$1();
+const defer = (fn) => Promise.resolve().then(fn);
+const nodefer = (fn) => fn();
 const isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
 const isArrayBufferLike = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
 const isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
@@ -2760,7 +2795,7 @@ var Minipass = class extends EventEmitter {
 			encoding = "utf8";
 		}
 		if (!encoding) encoding = "utf8";
-		const fn$1 = this[ASYNC] ? defer : nodefer;
+		const fn = this[ASYNC] ? defer : nodefer;
 		if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
 			if (isArrayBufferView(chunk)) chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
 			else if (isArrayBufferLike(chunk)) chunk = Buffer.from(chunk);
@@ -2773,12 +2808,12 @@ var Minipass = class extends EventEmitter {
 			if (this[FLOWING]) this.emit("data", chunk);
 			else this[BUFFERPUSH](chunk);
 			if (this[BUFFERLENGTH] !== 0) this.emit("readable");
-			if (cb) fn$1(cb);
+			if (cb) fn(cb);
 			return this[FLOWING];
 		}
 		if (!chunk.length) {
 			if (this[BUFFERLENGTH] !== 0) this.emit("readable");
-			if (cb) fn$1(cb);
+			if (cb) fn(cb);
 			return this[FLOWING];
 		}
 		if (typeof chunk === "string" && !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) chunk = Buffer.from(chunk, encoding);
@@ -2787,7 +2822,7 @@ var Minipass = class extends EventEmitter {
 		if (this[FLOWING]) this.emit("data", chunk);
 		else this[BUFFERPUSH](chunk);
 		if (this[BUFFERLENGTH] !== 0) this.emit("readable");
-		if (cb) fn$1(cb);
+		if (cb) fn(cb);
 		return this[FLOWING];
 	}
 	/**
@@ -3367,7 +3402,7 @@ const ENOCHILD = ENOENT | 576;
 const TYPEMASK = 1023;
 const entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
 const normalizeCache = /* @__PURE__ */ new Map();
-const normalize$1 = (s) => {
+const normalize = (s) => {
 	const c = normalizeCache.get(s);
 	if (c) return c;
 	const n = s.normalize("NFKD");
@@ -3378,7 +3413,7 @@ const normalizeNocaseCache = /* @__PURE__ */ new Map();
 const normalizeNocase = (s) => {
 	const c = normalizeNocaseCache.get(s);
 	if (c) return c;
-	const n = normalize$1(s.toLowerCase());
+	const n = normalize(s.toLowerCase());
 	normalizeNocaseCache.set(s, n);
 	return n;
 };
@@ -3563,9 +3598,9 @@ var PathBase = class {
 	*
 	* @internal
 	*/
-	constructor(name$1, type = UNKNOWN, root, roots, nocase, children, opts) {
-		this.name = name$1;
-		this.#matchName = nocase ? normalizeNocase(name$1) : normalize$1(name$1);
+	constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+		this.name = name;
+		this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
 		this.#type = type & TYPEMASK;
 		this.nocase = nocase;
 		this.roots = roots;
@@ -3641,8 +3676,8 @@ var PathBase = class {
 		if (pathPart === "" || pathPart === ".") return this;
 		if (pathPart === "..") return this.parent || this;
 		const children = this.children();
-		const name$1 = this.nocase ? normalizeNocase(pathPart) : normalize$1(pathPart);
-		for (const p of children) if (p.#matchName === name$1) return p;
+		const name = this.nocase ? normalizeNocase(pathPart) : normalize(pathPart);
+		for (const p of children) if (p.#matchName === name) return p;
 		const s = this.parent ? this.sep : "";
 		const fullpath = this.#fullpath ? this.#fullpath + s + pathPart : void 0;
 		const pchild = this.newChild(pathPart, UNKNOWN, {
@@ -3661,11 +3696,11 @@ var PathBase = class {
 	relative() {
 		if (this.isCWD) return "";
 		if (this.#relative !== void 0) return this.#relative;
-		const name$1 = this.name;
+		const name = this.name;
 		const p = this.parent;
 		if (!p) return this.#relative = this.name;
 		const pv = p.relative();
-		return pv + (!pv || !p.parent ? "" : this.sep) + name$1;
+		return pv + (!pv || !p.parent ? "" : this.sep) + name;
 	}
 	/**
 	* The relative path from the cwd, using / as the path separator.
@@ -3677,21 +3712,21 @@ var PathBase = class {
 		if (this.sep === "/") return this.relative();
 		if (this.isCWD) return "";
 		if (this.#relativePosix !== void 0) return this.#relativePosix;
-		const name$1 = this.name;
+		const name = this.name;
 		const p = this.parent;
 		if (!p) return this.#relativePosix = this.fullpathPosix();
 		const pv = p.relativePosix();
-		return pv + (!pv || !p.parent ? "" : "/") + name$1;
+		return pv + (!pv || !p.parent ? "" : "/") + name;
 	}
 	/**
 	* The fully resolved path string for this Path entry
 	*/
 	fullpath() {
 		if (this.#fullpath !== void 0) return this.#fullpath;
-		const name$1 = this.name;
+		const name = this.name;
 		const p = this.parent;
 		if (!p) return this.#fullpath = this.name;
-		return this.#fullpath = p.fullpath() + (!p.parent ? "" : this.sep) + name$1;
+		return this.#fullpath = p.fullpath() + (!p.parent ? "" : this.sep) + name;
 	}
 	/**
 	* On platforms other than windows, this is identical to fullpath.
@@ -3854,7 +3889,7 @@ var PathBase = class {
 	* directly.
 	*/
 	isNamed(n) {
-		return !this.nocase ? this.#matchName === normalize$1(n) : this.#matchName === normalizeNocase(n);
+		return !this.nocase ? this.#matchName === normalize(n) : this.#matchName === normalizeNocase(n);
 	}
 	/**
 	* Return the Path object corresponding to the target of a symbolic link.
@@ -3966,7 +4001,7 @@ var PathBase = class {
 	#readdirMaybePromoteChild(e, c) {
 		for (let p = c.provisional; p < c.length; p++) {
 			const pchild = c[p];
-			if ((this.nocase ? normalizeNocase(e.name) : normalize$1(e.name)) !== pchild.#matchName) continue;
+			if ((this.nocase ? normalizeNocase(e.name) : normalize(e.name)) !== pchild.#matchName) continue;
 			return this.#readdirPromoteChild(e, pchild, p, c);
 		}
 	}
@@ -4234,14 +4269,14 @@ var PathWin32 = class PathWin32 extends PathBase {
 	*
 	* @internal
 	*/
-	constructor(name$1, type = UNKNOWN, root, roots, nocase, children, opts) {
-		super(name$1, type, root, roots, nocase, children, opts);
+	constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+		super(name, type, root, roots, nocase, children, opts);
 	}
 	/**
 	* @internal
 	*/
-	newChild(name$1, type = UNKNOWN, opts = {}) {
-		return new PathWin32(name$1, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+	newChild(name, type = UNKNOWN, opts = {}) {
+		return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
 	}
 	/**
 	* @internal
@@ -4286,8 +4321,8 @@ var PathPosix = class PathPosix extends PathBase {
 	*
 	* @internal
 	*/
-	constructor(name$1, type = UNKNOWN, root, roots, nocase, children, opts) {
-		super(name$1, type, root, roots, nocase, children, opts);
+	constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+		super(name, type, root, roots, nocase, children, opts);
 	}
 	/**
 	* @internal
@@ -4304,8 +4339,8 @@ var PathPosix = class PathPosix extends PathBase {
 	/**
 	* @internal
 	*/
-	newChild(name$1, type = UNKNOWN, opts = {}) {
-		return new PathPosix(name$1, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+	newChild(name, type = UNKNOWN, opts = {}) {
+		return new PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
 	}
 };
 /**
@@ -5365,16 +5400,16 @@ var GlobUtil = class {
 		if (this.signal?.aborted) return;
 		/* c8 ignore stop */
 		this.paused = false;
-		let fn$1 = void 0;
-		while (!this.paused && (fn$1 = this.#onResume.shift())) fn$1();
+		let fn = void 0;
+		while (!this.paused && (fn = this.#onResume.shift())) fn();
 	}
-	onResume(fn$1) {
+	onResume(fn) {
 		if (this.signal?.aborted) return;
 		/* c8 ignore start */
-		if (!this.paused) fn$1();
+		if (!this.paused) fn();
 		else
  /* c8 ignore stop */
-		this.#onResume.push(fn$1);
+		this.#onResume.push(fn);
 	}
 	async matchCheck(e, ifDir) {
 		if (ifDir && this.opts.nodir) return void 0;
@@ -5840,7 +5875,7 @@ const glob = Object.assign(glob_, {
 	Glob,
 	hasMagic,
 	escape,
-	unescape: unescape$1
+	unescape
 });
 glob.glob = glob;
 
@@ -5883,16 +5918,16 @@ var require_parser = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/toml
 				type: "literal",
 				value: "]",
 				description: "\"]\""
-			}, peg$c11 = function(name$1) {
-				addNode(node("ObjectPath", name$1, line, column));
-			}, peg$c12 = function(name$1) {
-				addNode(node("ArrayPath", name$1, line, column));
-			}, peg$c13 = function(parts, name$1) {
-				return parts.concat(name$1);
-			}, peg$c14 = function(name$1) {
-				return [name$1];
-			}, peg$c15 = function(name$1) {
-				return name$1;
+			}, peg$c11 = function(name) {
+				addNode(node("ObjectPath", name, line, column));
+			}, peg$c12 = function(name) {
+				addNode(node("ArrayPath", name, line, column));
+			}, peg$c13 = function(parts, name) {
+				return parts.concat(name);
+			}, peg$c14 = function(name) {
+				return [name];
+			}, peg$c15 = function(name) {
+				return name;
 			}, peg$c16 = ".", peg$c17 = {
 				type: "literal",
 				value: ".",
@@ -5945,8 +5980,8 @@ var require_parser = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/toml
 				description: "\"E\""
 			}, peg$c42 = function(left, right) {
 				return node("Float", parseFloat(left + "e" + right), line, column);
-			}, peg$c43 = function(text$1) {
-				return node("Float", parseFloat(text$1), line, column);
+			}, peg$c43 = function(text) {
+				return node("Float", parseFloat(text), line, column);
 			}, peg$c44 = "+", peg$c45 = {
 				type: "literal",
 				value: "+",
@@ -5959,8 +5994,8 @@ var require_parser = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/toml
 				description: "\"-\""
 			}, peg$c49 = function(digits) {
 				return "-" + digits.join("");
-			}, peg$c50 = function(text$1) {
-				return node("Integer", parseInt(text$1, 10), line, column);
+			}, peg$c50 = function(text) {
+				return node("Integer", parseInt(text, 10), line, column);
 			}, peg$c51 = "true", peg$c52 = {
 				type: "literal",
 				value: "true",
@@ -9627,9 +9662,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.
@@ -9668,13 +9704,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
 	};
 }
@@ -9697,8 +9733,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;
@@ -9721,48 +9757,48 @@ function zip(as, bs) {
 //#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);
@@ -9770,1435 +9806,60 @@ 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("/");
 }
-/** @return WeslBundle instances referenced by wesl sources
+/**
+* Load 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.
+* 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
 */
-async function dependencyBundles(weslSrc, projectDir) {
+async function dependencyBundles(weslSrc, projectDir, packageName, includeCurrentPackage = false) {
 	const deps = parseDependencies(weslSrc, projectDir);
-	const projectURL = pathToFileURL(path.resolve(path.join(projectDir, "dummy.js"))).href;
-	const bundles = deps.map(async (dep) => {
+	const filteredDeps = includeCurrentPackage ? deps : otherPackages(deps, packageName);
+	const projectURL = projectDirURL(projectDir);
+	const bundles = filteredDeps.map(async (dep) => {
 		return (await import(resolve(dep, projectURL))).default;
 	});
 	return await Promise.all(bundles);
 }
-
-//#endregion
-//#region ../wesl-tooling/src/Version.ts
-/**
-* @param projectDir - e.g., file:// URL of the 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;
-}
-
-//#endregion
-//#region ../wesl/src/Util.ts
-/**
-* Maps an character position in a string to a 1-indexed line number, and 1-indexed column.
-*/
-function offsetToLineNumber(offset, text$1) {
-	const safeOffset = Math.min(text$1.length, Math.max(0, offset));
-	let lineStartOffset = 0;
-	let lineNum = 1;
-	while (true) {
-		const lineEnd = text$1.indexOf("\n", lineStartOffset);
-		if (lineEnd === -1 || safeOffset <= lineEnd) {
-			const linePos = 1 + (safeOffset - lineStartOffset);
-			return [lineNum, linePos];
-		} else {
-			lineStartOffset = lineEnd + 1;
-			lineNum += 1;
-		}
-	}
-}
-/** Highlights an error.
-*
-* Returns a string with the line, and a string with the ^^^^ carets
-*/
-function errorHighlight(source, span$1) {
-	let lineStartOffset = source.lastIndexOf("\n", span$1[0]);
-	if (lineStartOffset === -1) lineStartOffset = 0;
-	let lineEndOffset = source.indexOf("\n", span$1[0]);
-	if (lineEndOffset === -1) lineEndOffset = source.length;
-	const errorLength = span$1[1] - span$1[0];
-	const caretCount = Math.max(1, errorLength);
-	const linePos = span$1[0] - lineStartOffset;
-	return [source.slice(lineStartOffset, lineEndOffset), " ".repeat(linePos) + "^".repeat(caretCount)];
-}
-
-//#endregion
-//#region ../wesl/src/vlq/vlq.ts
-/*!
-Copyright (c) 2017-2021 [these people](https://github.com/Rich-Harris/vlq/graphs/contributors)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-const char_to_integer = {};
-const integer_to_char = {};
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach((char, i) => {
-	char_to_integer[char] = i;
-	integer_to_char[i] = char;
-});
-function encodeVlq(value) {
-	if (typeof value === "number") return encode_integer(value);
-	let result = "";
-	for (let i = 0; i < value.length; i += 1) result += encode_integer(value[i]);
-	return result;
-}
-function encode_integer(num) {
-	let result = "";
-	let enc;
-	if (num < 0) enc = -num << 1 | 1;
-	else enc = num << 1;
-	do {
-		let clamped = enc & 31;
-		enc >>>= 5;
-		if (enc > 0) clamped |= 32;
-		result += integer_to_char[clamped];
-	} while (enc > 0);
-	return result;
-}
-
-//#endregion
-//#region ../wesl/src/ClickableError.ts
-/** Throw an error with an embedded source map so that browser users can
-*  click on the error in the browser debug console and see the wesl source code.  */
-function throwClickableError(params) {
-	const { url, text: text$1, lineNumber, lineColumn, length, error } = params;
-	const mappings = encodeVlq([
-		0,
-		0,
-		Math.max(0, lineNumber - 1),
-		Math.max(0, lineColumn - 1)
-	]) + "," + encodeVlq([
-		18,
-		0,
-		Math.max(0, lineNumber - 1),
-		Math.max(0, lineColumn - 1) + length
-	]);
-	const sourceMap = {
-		version: 3,
-		file: null,
-		sources: [url],
-		sourcesContent: [text$1 ?? null],
-		names: [],
-		mappings
-	};
-	let generatedCode = `throw new Error(${JSON.stringify(error.message + "")})`;
-	generatedCode += "\n//# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
-	generatedCode += "\n//# sourceURL=" + sourceMap.sources[0];
-	let oldLimit = 0;
-	if ("stackTraceLimit" in Error) {
-		oldLimit = Error.stackTraceLimit;
-		Error.stackTraceLimit = 1;
-	}
-	try {
-		(0, eval)(generatedCode);
-	} catch (e) {
-		if ("stackTraceLimit" in Error) Error.stackTraceLimit = oldLimit;
-		error.message = "";
-		if (tracing) e.cause = error;
-		throw e;
-	}
-}
-
-//#endregion
-//#region ../wesl/src/Assertions.ts
-/** checks whether a condition is true, otherwise throws */
-function assertThat(condition, msg) {
-	if (!condition) throw new Error(msg);
-}
-/** when debug testing is enabled, checks whether a condition is true, otherwise throws */
-function assertThatDebug(condition, msg) {
-	if (tracing) assertThat(condition, msg);
-}
-/**
-* Useful to validate that all cases are handled,
-* TypeScript should complain if this statement could possibly be executed.
-*
-* If this is somehow executed at runtime, throw an exception.
-*/
-function assertUnreachable(value) {
-	throw new ErrorWithData("Unreachable value", { data: value });
-}
-var ErrorWithData = class extends Error {
-	data;
-	constructor(message, options) {
-		super(message, options);
-		this.data = options?.data;
-	}
-};
-
-//#endregion
-//#region ../wesl/src/Conditions.ts
-/** Extract @if, @elif, or @else attribute from an array of attributes */
-function findConditional(attributes) {
-	if (!attributes) return;
-	for (const attr of attributes) {
-		const kind$1 = attr.attribute.kind;
-		if (kind$1 === "@if" || kind$1 === "@elif" || kind$1 === "@else") return attr.attribute;
-	}
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/berry-pretty@0.0.5/node_modules/berry-pretty/dist/index.js
-var spaces = memoize((nesting) => {
-	return " ".repeat(nesting);
-});
-var defaultCallerSize = 20;
-var multiLinePad = "\n" + spaces(defaultCallerSize + 3);
-function memoize(fn$1) {
-	const cache = /* @__PURE__ */ new Map();
-	return function(...args) {
-		const key = JSON.stringify(args);
-		if (cache.has(key)) return cache.get(key);
-		else {
-			const value = fn$1(...args);
-			cache.set(key, value);
-			return value;
-		}
-	};
-}
-if (typeof DOMRect === "undefined") globalThis.DOMRect = function() {};
-
-//#endregion
-//#region ../wesl/src/Scope.ts
-/** Combine two scope siblings.
-* The first scope is mutated to append the contents of the second.  */
-function mergeScope(a, b) {
-	if (!b) return;
-	assertThatDebug(a.kind === b.kind);
-	assertThatDebug(a.parent === b.parent);
-	assertThatDebug(!b.condAttribute);
-	a.contents = a.contents.concat(b.contents);
-}
-/** reset scope and ident debugging ids */
-function resetScopeIds() {
-	scopeId = 0;
-	identId = 0;
+/** Exclude current package from dependency list. */
+function otherPackages(deps, packageName) {
+	if (!packageName) return deps;
+	return deps.filter((dep) => dep !== packageName && !dep.startsWith(`${packageName}/`));
 }
-let scopeId = 0;
-let identId = 0;
-function nextIdentId() {
-	return identId++;
-}
-/** make a new Scope object */
-function emptyScope(parent, kind$1 = "scope") {
-	return {
-		id: scopeId++,
-		kind: kind$1,
-		parent,
-		contents: []
-	};
+/** 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/src/WESLCollect.ts
-function importElem(cc) {
-	const importElems = cc.tags.owo?.[0];
-	for (const importElem$1 of importElems) {
-		cc.app.stable.imports.push(importElem$1.imports);
-		addToOpenElem(cc, importElem$1);
-	}
-}
-/** add an elem to the .contents array of the currently containing element */
-function addToOpenElem(cc, elem) {
-	const { openElems } = cc.app.context;
-	if (openElems?.length) openElems[openElems.length - 1].contents.push(elem);
-}
-/** create reference Ident and add to context */
-function refIdent(cc) {
-	const { src, start, end } = cc;
-	const { srcModule } = cc.app.stable;
-	const originalName = src.slice(start, end);
-	const kind$1 = "ref";
-	const ident$1 = {
-		kind: kind$1,
-		originalName,
-		ast: cc.app.stable,
-		id: nextIdentId(),
-		refIdentElem: null
-	};
-	const identElem = {
-		kind: kind$1,
-		start,
-		end,
-		srcModule,
-		ident: ident$1
-	};
-	ident$1.refIdentElem = identElem;
-	saveIdent(cc, identElem);
-	addToOpenElem(cc, identElem);
-	return identElem;
-}
-/** create declaration Ident and add to context */
-function declCollect(cc) {
-	return declCollectInternal(cc, false);
-}
-/** create global declaration Ident and add to context */
-function globalDeclCollect(cc) {
-	return declCollectInternal(cc, true);
-}
-function declCollectInternal(cc, isGlobal) {
-	const { src, start, end } = cc;
-	const app = cc.app;
-	const { scope: containingScope } = app.context;
-	const { srcModule } = app.stable;
-	const originalName = src.slice(start, end);
-	const kind$1 = "decl";
-	const identElem = {
-		kind: kind$1,
-		start,
-		end,
-		srcModule,
-		ident: {
-			declElem: null,
-			kind: kind$1,
-			originalName,
-			containingScope,
-			isGlobal,
-			id: nextIdentId(),
-			srcModule
-		}
-	};
-	saveIdent(cc, identElem);
-	addToOpenElem(cc, identElem);
-	return identElem;
-}
-const typedDecl = collectElem("typeDecl", (cc, openElem) => {
-	const decl = cc.tags.decl_elem?.[0];
-	const typeRef = cc.tags.typeRefElem?.[0];
-	const typeScope = cc.tags.decl_type?.[0];
-	return withTextCover({
-		...openElem,
-		decl,
-		typeScope,
-		typeRef
-	}, cc);
-});
-/** add Ident to current open scope, add IdentElem to current open element */
-function saveIdent(cc, identElem) {
-	const { ident: ident$1 } = identElem;
-	ident$1.id = nextIdentId();
-	cc.app.context.scope.contents.push(ident$1);
-}
-/** start a new child lexical Scope */
-function startScope(cc) {
-	startSomeScope("scope", cc);
-}
-/** start a new child partial Scope */
-function startPartialScope(cc) {
-	startSomeScope("partial", cc);
-}
-/** start a new lexical or partial scope */
-function startSomeScope(kind$1, cc) {
-	const { scope } = cc.app.context;
-	const newScope = emptyScope(scope, kind$1);
-	scope.contents.push(newScope);
-	cc.app.context.scope = newScope;
-}
-function completeScope(cc) {
-	return completeScopeInternal(cc, true);
-}
-function completeScopeNoIf(cc) {
-	return completeScopeInternal(cc, false);
-}
-function completeScopeInternal(cc, attachIfs) {
-	const weslContext = cc.app.context;
-	const completedScope = weslContext.scope;
-	const { parent } = completedScope;
-	if (parent) weslContext.scope = parent;
-	else if (tracing) console.log("ERR: completeScope, no parent scope", completedScope.contents);
-	if (attachIfs) completedScope.condAttribute = collectConditionalAttribute(cc, completedScope);
-	return completedScope;
-}
-/** return @if, @elif, or @else attribute from the 'attribute' or 'fn_attributes' tag */
-function collectConditionalAttribute(cc, completedScope) {
-	if (completedScope.kind === "partial" && cc.tags.fn_name !== void 0) {
-		const flatAttrs = cc.tags.fn_attributes?.flat?.();
-		return findConditional(flatAttrs);
-	}
-	const attributes = cc.tags.attribute;
-	return findConditional(attributes);
-}
-function collectVarLike(kind$1) {
-	return collectElem(kind$1, (cc, openElem) => {
-		const name$1 = cc.tags.var_name?.[0];
-		const decl_scope = cc.tags.decl_scope?.[0];
-		const attributes = cc.tags.attribute;
-		const varElem = withTextCover({
-			...openElem,
-			name: name$1,
-			attributes
-		}, cc);
-		const declIdent = name$1.decl.ident;
-		declIdent.declElem = varElem;
-		if (name$1.typeScope) {
-			mergeScope(name$1.typeScope, decl_scope);
-			declIdent.dependentScope = name$1.typeScope;
-		} else declIdent.dependentScope = decl_scope;
-		return varElem;
-	});
-}
-const aliasCollect = collectElem("alias", (cc, openElem) => {
-	const name$1 = cc.tags.alias_name?.[0];
-	const alias_scope = cc.tags.alias_scope?.[0];
-	const typeRef = cc.tags.typeRefElem?.[0];
-	const attributes = cc.tags.attributes?.flat() ?? [];
-	const aliasElem = withTextCover({
-		...openElem,
-		name: name$1,
-		attributes,
-		typeRef
-	}, cc);
-	name$1.ident.dependentScope = alias_scope;
-	name$1.ident.declElem = aliasElem;
-	return aliasElem;
-});
-/**
-* Collect a FnElem and associated scopes.
-*
-* Scope definition is a bit complicated in wgsl and wesl for fns.
-* Here's what we collect for scopes for this example function:
-*    @if(true) fn foo(a: u32) -> @location(x) R { let y = a; }
-*
-* -{ // partial scope in case the whole shebang is prefixed by an `@if`
-*   %foo
-*
-*   {<=%foo // foo decl references this header+returnType+body scope (for tracing dependencies from decls)
-*      x  // for @location(x) (contains no decls, so ok to merge for tracing)
-*      %a u32 // merged from header scope
-*      R // merged from return type (contains no decls, so ok to merge for tracing)
-*      %y a // merged body scope
-*   }
-* }
-*/
-const fnCollect = collectElem("fn", (cc, openElem) => {
-	const ourTags = fnTags(cc);
-	const { name: name$1, headerScope, returnScope, bodyScope, body, params } = ourTags;
-	const { attributes, returnAttributes, returnType, fnScope } = ourTags;
-	const fnElem = {
-		...openElem,
-		name: name$1,
-		attributes,
-		params,
-		returnAttributes,
-		body,
-		returnType
-	};
-	const mergedScope = headerScope;
-	if (returnScope) mergeScope(mergedScope, returnScope);
-	mergeScope(mergedScope, bodyScope);
-	const filtered = [];
-	for (const e of fnScope.contents) if (e === headerScope || e === returnScope) continue;
-	else if (e === bodyScope) filtered.push(mergedScope);
-	else filtered.push(e);
-	fnScope.contents = filtered;
-	name$1.ident.declElem = fnElem;
-	name$1.ident.dependentScope = mergedScope;
-	return fnElem;
-});
-/** Fetch and cast the collection tags for fnCollect
-* LATER typechecking for collect! */
-function fnTags(cc) {
-	const { fn_attributes, fn_name, fn_param, return_attributes } = cc.tags;
-	const { return_type } = cc.tags;
-	const { header_scope, return_scope, body_scope, body_statement } = cc.tags;
-	const { fn_partial_scope } = cc.tags;
-	return {
-		name: fn_name?.[0],
-		headerScope: header_scope?.[0],
-		returnScope: return_scope?.[0],
-		bodyScope: body_scope?.[0],
-		body: body_statement?.[0],
-		params: fn_param?.flat(3) ?? [],
-		attributes: fn_attributes?.flat(),
-		returnAttributes: return_attributes?.flat(),
-		returnType: return_type?.flat(3)[0],
-		fnScope: fn_partial_scope?.[0]
-	};
-}
-const collectFnParam = collectElem("param", (cc, openElem) => {
-	const name$1 = cc.tags.param_name?.[0];
-	const attributes = cc.tags.attributes?.flat() ?? [];
-	const paramElem = withTextCover({
-		...openElem,
-		name: name$1,
-		attributes
-	}, cc);
-	name$1.decl.ident.declElem = paramElem;
-	return paramElem;
-});
-const collectStruct = collectElem("struct", (cc, openElem) => {
-	const name$1 = cc.tags.type_name?.[0];
-	const members = cc.tags.members;
-	const attributes = cc.tags.attributes?.flat() ?? [];
-	name$1.ident.dependentScope = cc.tags.struct_scope?.[0];
-	const elem = withTextCover({
-		...openElem,
-		name: name$1,
-		attributes,
-		members
-	}, cc);
-	name$1.ident.declElem = elem;
-	return elem;
-});
-const collectStructMember = collectElem("member", (cc, openElem) => {
-	const name$1 = cc.tags.nameElem?.[0];
-	const typeRef = cc.tags.typeRefElem?.[0];
-	const attributes = cc.tags.attribute?.flat(3);
-	return withTextCover({
-		...openElem,
-		name: name$1,
-		attributes,
-		typeRef
-	}, cc);
-});
-const specialAttribute = collectElem("attribute", (cc, openElem) => {
-	const attribute = cc.tags.attr_variant?.[0];
-	return {
-		...openElem,
-		attribute
-	};
-});
-const assertCollect = attrElemCollect("assert");
-const statementCollect = attrElemCollect("statement");
-const switchClauseCollect = attrElemCollect("switch-clause");
-/** @return a collector for container elem types that have only an attributes field */
-function attrElemCollect(kind$1) {
-	return collectElem(kind$1, (cc, openElem) => {
-		const attributes = cc.tags.attribute?.flat(3);
-		return withTextCover({
-			...openElem,
-			attributes
-		}, cc);
-	});
-}
-const collectAttribute = collectElem("attribute", (cc, openElem) => {
-	const params = cc.tags.attrParam;
-	const stdAttribute = {
-		kind: "@attribute",
-		name: cc.tags.name?.[0],
-		params
-	};
-	return {
-		...openElem,
-		attribute: stdAttribute
-	};
-});
-const typeRefCollect = collectElem("type", (cc, openElem) => {
-	const templateParamsTemp = cc.tags.templateParam?.flat(3);
-	const typeRef = cc.tags.typeRefName?.[0];
-	const name$1 = typeof typeRef === "string" ? typeRef : typeRef.ident;
-	return withTextCover({
-		...openElem,
-		name: name$1,
-		templateParams: templateParamsTemp
-	}, cc);
-});
-const expressionCollect = collectElem("expression", (cc, openElem) => {
-	return withTextCover({ ...openElem }, cc);
-});
-function globalAssertCollect(cc) {
-	const globalAssert = cc.tags.const_assert?.flat()[0];
-	const ast = cc.app.stable;
-	if (!ast.moduleAsserts) ast.moduleAsserts = [];
-	ast.moduleAsserts.push(globalAssert);
-}
-const stuffCollect = collectElem("stuff", (cc, openElem) => {
-	return withTextCover({ ...openElem }, cc);
-});
-const memberRefCollect = collectElem("memberRef", (cc, openElem) => {
-	const { component, structRef, extra_components } = cc.tags;
-	const member = component?.[0];
-	const name$1 = structRef?.flat()[0];
-	const extraComponents = extra_components?.flat()[0];
-	return withTextCover({
-		...openElem,
-		name: name$1,
-		member,
-		extraComponents
-	}, cc);
-});
-function nameCollect(cc) {
-	const { start, end, src } = cc;
-	const elem = {
-		kind: "name",
-		start,
-		end,
-		name: src.slice(start, end)
-	};
-	addToOpenElem(cc, elem);
-	return elem;
-}
-const collectModule = collectElem("module", (cc, openElem) => {
-	const moduleElem = withTextCover(openElem, {
-		...cc,
-		start: 0,
-		end: cc.src.length
-	});
-	const weslState = cc.app.stable;
-	weslState.moduleElem = moduleElem;
-	return moduleElem;
-});
-function directiveCollect(cc) {
-	const { start, end } = cc;
-	const directive = cc.tags.directive?.flat()[0];
-	const elem = {
-		kind: "directive",
-		attributes: cc.tags.attribute?.flat(),
-		start,
-		end,
-		directive
-	};
-	addToOpenElem(cc, elem);
-	return elem;
-}
-/**
-* Collect a LexicalScope.
-*
-* The scope starts encloses all idents and subscopes inside the parser to which
-* .collect is attached
-*/
-const scopeCollect = {
-	before: startScope,
-	after: completeScope
-};
-/**
-* Collect a LexicalScope.
-*
-* The scope starts encloses all idents and subscopes inside the parser to which
-* .collect is attached
-*
-* '@if' attributes are not attached to the scope.
-*/
-const scopeCollectNoIf = {
-	before: startScope,
-	after: completeScopeNoIf
-};
-/**
-* Collect a PartialScope.
-*
-* The scope starts encloses all idents and subscopes inside the parser to which
-* .collect is attached
-*/
-const partialScopeCollect = {
-	before: startPartialScope,
-	after: completeScope
-};
-/** utility to collect an ElemWithContents
-* starts the new element as the collection point corresponding
-* to the start of the attached grammar and completes
-* the element in the at the end of the grammar.
-*
-* In between the start and the end, the new element is available
-* as an 'open' element in the collection context. While this element
-* is 'open', other collected are added to the 'contents' field of this
-* open element.
-*/
-function collectElem(kind$1, fn$1) {
-	return {
-		before: (cc) => {
-			const partialElem = {
-				kind: kind$1,
-				contents: []
-			};
-			cc.app.context.openElems.push(partialElem);
-		},
-		after: (cc) => {
-			const partialElem = cc.app.context.openElems.pop();
-			console.assert(partialElem && partialElem.kind === kind$1);
-			const elem = fn$1(cc, {
-				...partialElem,
-				start: cc.start,
-				end: cc.end
-			});
-			if (elem) addToOpenElem(cc, elem);
-			return elem;
-		}
-	};
-}
-/**
-* @return a copy of the element with contents extended
-* to include TextElems to cover the entire range.
-*/
-function withTextCover(elem, cc) {
-	const contents = coverWithText(cc, elem);
-	return {
-		...elem,
-		contents
-	};
-}
-/** cover the entire source range with Elems by creating TextElems to
-* cover any parts of the source that are not covered by other elems
-* @returns the existing elems combined with any new TextElems, in src order */
-function coverWithText(cc, elem) {
-	let { start: pos } = cc;
-	const ast = cc.app.stable;
-	const { contents, end } = elem;
-	const sorted = contents.sort((a, b) => a.start - b.start);
-	const elems = [];
-	for (const elem$1 of sorted) {
-		if (pos < elem$1.start) elems.push(makeTextElem(elem$1.start));
-		elems.push(elem$1);
-		pos = elem$1.end;
-	}
-	if (pos < end) elems.push(makeTextElem(end));
-	return elems;
-	function makeTextElem(end$1) {
-		return {
-			kind: "text",
-			start: pos,
-			end: end$1,
-			srcModule: ast.srcModule
-		};
-	}
-}
-
-//#endregion
-//#region ../wesl/src/parse/Keywords.ts
-/** https://www.w3.org/TR/WGSL/#keyword-summary */
-const keywords = `alias break case const const_assert continue continuing 
-  default diagnostic discard else enable false fn for if 
-  let loop override requires return struct switch true var while`.split(/\s+/);
-/** https://www.w3.org/TR/WGSL/#reserved-words */
-const reservedWords = `NULL Self abstract active alignas alignof as asm asm_fragment async attribute auto await 
-  become binding_array cast catch class co_await co_return co_yield coherent column_major 
-  common compile compile_fragment concept const_cast consteval constexpr constinit crate 
-  debugger decltype delete demote demote_to_helper do dynamic_cast 
-  enum explicit export extends extern external fallthrough filter final finally friend from fxgroup 
-  get goto groupshared highp impl implements import inline instanceof interface layout lowp 
-  macro macro_rules match mediump meta mod module move mut mutable 
-  namespace new nil noexcept noinline nointerpolation non_coherent noncoherent noperspective null nullptr 
-  of operator package packoffset partition pass patch pixelfragment precise precision premerge 
-  priv protected pub public readonly ref regardless register reinterpret_cast require resource restrict 
-  self set shared sizeof smooth snorm static static_assert static_cast std subroutine super 
-  target template this thread_local throw trait try type typedef typeid typename typeof 
-  union unless unorm unsafe unsized use using varying virtual volatile wgsl where with writeonly yield`.split(/\s+/);
-
-//#endregion
-//#region ../wesl/src/parse/WeslStream.ts
-/** Whitespaces including new lines */
-const blankspaces = /[ \t\n\v\f\r\u{0085}\u{200E}\u{200F}\u{2028}\u{2029}]+/u;
-const symbolSet = "& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _";
-const ident = /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u;
-const keywordOrReserved = new Set(keywords.concat(reservedWords));
-const weslMatcher = new RegexMatchers({
-	word: ident,
-	number: new RegExp(/(?:0[fh])|(?:[1-9][0-9]*[fh])/.source + /|(?:[0-9]*\.[0-9]+(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+\.[0-9]*(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+[eE][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]+[iu]?)/.source + /|(?:0[iu]?)|(?:[1-9][0-9]*[iu]?)/.source),
-	blankspaces,
-	commentStart: /\/\/|\/\*/,
-	symbol: matchOneOf(symbolSet),
-	invalid: /[^]/
-});
-/** To mark parts of the grammar implementation that are WESL specific extensions */
-function weslExtension(combinator) {
-	return combinator;
-}
-/** A stream that produces WESL tokens, skipping over comments and white space */
-var WeslStream = class {
-	stream;
-	/** New line */
-	eolPattern = /[\n\v\f\u{0085}\u{2028}\u{2029}]|\r\n?/gu;
-	/** Block comments */
-	blockCommentPattern = /\/\*|\*\//g;
-	src;
-	constructor(src) {
-		this.src = src;
-		this.stream = new CachingStream(new MatchersStream(src, weslMatcher));
-	}
-	checkpoint() {
-		return this.stream.checkpoint();
-	}
-	reset(position) {
-		this.stream.reset(position);
-	}
-	nextToken() {
-		while (true) {
-			const token$1 = this.stream.nextToken();
-			if (token$1 === null) return null;
-			const kind$1 = token$1.kind;
-			if (kind$1 === "blankspaces") continue;
-			else if (kind$1 === "commentStart") if (token$1.text === "//") this.stream.reset(this.skipToEol(token$1.span[1]));
-			else this.stream.reset(this.skipBlockComment(token$1.span[1]));
-			else if (kind$1 === "word") {
-				const returnToken = token$1;
-				if (keywordOrReserved.has(token$1.text)) returnToken.kind = "keyword";
-				return returnToken;
-			} else if (kind$1 === "invalid") throw new ParseError("Invalid token " + token$1.text, token$1.span);
-			else return token$1;
-		}
-	}
-	skipToEol(position) {
-		this.eolPattern.lastIndex = position;
-		if (this.eolPattern.exec(this.src) === null) return this.src.length;
-		else return this.eolPattern.lastIndex;
-	}
-	skipBlockComment(start) {
-		let position = start;
-		while (true) {
-			this.blockCommentPattern.lastIndex = position;
-			const result = this.blockCommentPattern.exec(this.src);
-			if (result === null) throw new ParseError("Unclosed block comment!", [position, position]);
-			else if (result[0] === "*/") return this.blockCommentPattern.lastIndex;
-			else if (result[0] === "/*") position = this.skipBlockComment(this.blockCommentPattern.lastIndex);
-			else throw new Error("Unreachable, invalid block comment pattern");
-		}
-	}
-	/**
-	* Only matches the `<` token if it is a template
-	* Precondition: An ident was parsed right before this.
-	* Runs the [template list discovery algorithm](https://www.w3.org/TR/WGSL/#template-list-discovery).
-	*/
-	nextTemplateStartToken() {
-		const startPosition = this.stream.checkpoint();
-		const token$1 = this.nextToken();
-		this.stream.reset(startPosition);
-		if (token$1 === null) return null;
-		if (token$1.kind !== "symbol") return null;
-		if (token$1.text === "<") if (this.isTemplateStart(token$1.span[1])) {
-			this.stream.reset(token$1.span[1]);
-			return token$1;
-		} else {
-			this.stream.reset(startPosition);
-			return null;
-		}
-		else return null;
-	}
-	nextTemplateEndToken() {
-		const startPosition = this.stream.checkpoint();
-		const token$1 = this.nextToken();
-		this.stream.reset(startPosition);
-		if (token$1 === null) return null;
-		if (token$1.kind === "symbol" && token$1.text[0] === ">") {
-			const tokenPosition = token$1.span[0];
-			this.stream.reset(tokenPosition + 1);
-			return {
-				kind: "symbol",
-				span: [tokenPosition, tokenPosition + 1],
-				text: ">"
-			};
-		} else return null;
-	}
-	isTemplateStart(afterToken) {
-		this.stream.reset(afterToken);
-		let pendingCounter = 1;
-		while (true) {
-			const nextToken = this.stream.nextToken();
-			if (nextToken === null) return false;
-			if (nextToken.kind !== "symbol") continue;
-			if (nextToken.text === "<") pendingCounter += 1;
-			else if (nextToken.text[0] === ">") {
-				if (nextToken.text === ">" || nextToken.text === ">=") pendingCounter -= 1;
-				else if (nextToken.text === ">>=" || nextToken.text === ">>") pendingCounter -= 2;
-				else throw new Error("This case should never be reached, looks like we forgot one of the tokens that start with >");
-				if (pendingCounter <= 0) return true;
-			} else if (nextToken.text === "(") this.skipBracketsTo(")");
-			else if (nextToken.text === "[") this.skipBracketsTo("]");
-			else if (nextToken.text === "==" || nextToken.text === "!=" || nextToken.text === ";" || nextToken.text === "{" || nextToken.text === ":" || nextToken.text === "&&" || nextToken.text === "||") return false;
-		}
-	}
-	/**
-	* Call this after consuming an opening bracket.
-	* Skips until a closing bracket. This also consumes the closing bracket.
-	*/
-	skipBracketsTo(closingBracket) {
-		while (true) {
-			const nextToken = this.stream.nextToken();
-			if (nextToken === null) {
-				const after = this.stream.checkpoint();
-				throw new ParseError("Unclosed bracket!", [after, after]);
-			}
-			if (nextToken.kind !== "symbol") continue;
-			if (nextToken.text === "(") this.skipBracketsTo(")");
-			else if (nextToken.text === "[") this.skipBracketsTo("]");
-			else if (nextToken.text === closingBracket) return;
-		}
-	}
-};
-const templateOpen = withStreamAction((stream$1) => {
-	return stream$1.nextTemplateStartToken();
-});
-const templateClose = withStreamAction((stream$1) => {
-	return stream$1.nextTemplateEndToken();
-});
-
-//#endregion
-//#region ../wesl/src/parse/AttributeGrammar.ts
-const attribute_if_primary_expression = or(tokenOf("keyword", ["true", "false"]).map(makeLiteral), delimited(token("symbol", "("), fn(() => attribute_if_expression), token("symbol", ")")).map(makeParenthesizedExpression), tokenKind("word").map(makeTranslateTimeFeature));
-const attribute_if_unary_expression = or(seq(token("symbol", "!").map(makeUnaryOperator), fn(() => attribute_if_unary_expression)).map(makeUnaryExpression), attribute_if_primary_expression);
-const attribute_if_expression = weslExtension(seq(attribute_if_unary_expression, or(repeatPlus(seq(token("symbol", "||").map(makeBinaryOperator), req(attribute_if_unary_expression, "invalid expression, expected expression"))), repeatPlus(seq(token("symbol", "&&").map(makeBinaryOperator), req(attribute_if_unary_expression, "invalid expression, expected expression"))), yes().map(() => []))).map(makeRepeatingBinaryExpression));
-/** Base parser for @if attributes without collection - use in seq() compositions */
-const if_attribute_base = preceded(seq("@", weslExtension("if")), span(delimited("(", fn(() => attribute_if_expression), seq(opt(","), ")"))).map(makeTranslateTimeExpressionElem)).map(makeIfAttribute).ptag("attr_variant");
-/** Base parser for @elif attributes without collection - use in seq() compositions */
-const elif_attribute_base = preceded(seq("@", weslExtension("elif")), span(delimited("(", fn(() => attribute_if_expression), seq(opt(","), ")"))).map(makeTranslateTimeExpressionElem)).map(makeElifAttribute).ptag("attr_variant");
-/** Base parser for @else attributes without collection - use in seq() compositions */
-const else_attribute_base = preceded(seq("@", weslExtension("else")), yes).map(makeElseAttribute).ptag("attr_variant");
-/** Collected parser for @if attributes - use standalone, not in seq() */
-const if_attribute = tagScope(if_attribute_base.collect(specialAttribute));
-/** Collected parser for @elif attributes - use standalone, not in seq() */
-const elif_attribute = tagScope(elif_attribute_base.collect(specialAttribute));
-/** Collected parser for @else attributes - use standalone, not in seq() */
-const else_attribute = tagScope(else_attribute_base.collect(specialAttribute));
-function makeIfAttribute(param) {
-	return {
-		kind: "@if",
-		param
-	};
-}
-function makeElifAttribute(param) {
-	return {
-		kind: "@elif",
-		param
-	};
-}
-function makeElseAttribute() {
-	return { kind: "@else" };
-}
-function makeTranslateTimeExpressionElem(args) {
-	return {
-		kind: "translate-time-expression",
-		expression: args.value,
-		span: args.span
-	};
-}
-function makeLiteral(token$1) {
-	return {
-		kind: "literal",
-		value: token$1.text,
-		span: token$1.span
-	};
-}
-function makeTranslateTimeFeature(token$1) {
-	return {
-		kind: "translate-time-feature",
-		name: token$1.text,
-		span: token$1.span
-	};
-}
-function makeParenthesizedExpression(expression$1) {
-	return {
-		kind: "parenthesized-expression",
-		expression: expression$1
-	};
-}
-function makeUnaryOperator(token$1) {
-	return {
-		value: token$1.text,
-		span: token$1.span
-	};
-}
-function makeBinaryOperator(token$1) {
-	return {
-		value: token$1.text,
-		span: token$1.span
-	};
-}
-function makeUnaryExpression([operator, expression$1]) {
-	return {
-		kind: "unary-expression",
-		operator,
-		expression: expression$1
-	};
-}
-function makeRepeatingBinaryExpression([start, repeating]) {
-	let result = start;
-	for (const [op, left] of repeating) result = {
-		kind: "binary-expression",
-		operator: op,
-		left: result,
-		right: left
-	};
-	return result;
-}
-
-//#endregion
-//#region ../wesl/src/parse/WeslBaseGrammar.ts
-const word = kind("word");
-const keyword = kind("keyword");
-const qualified_ident = withSepPlus("::", or(word, keyword, "package", "super"));
-const number = kind("number");
-
-//#endregion
-//#region ../wesl/src/parse/ImportGrammar.ts
-function makeStatement(segments, finalSegment) {
-	return {
-		kind: "import-statement",
-		segments,
-		finalSegment
-	};
-}
-function makeSegment(name$1) {
-	return {
-		kind: "import-segment",
-		name: name$1
-	};
-}
-function makeCollection(subtrees) {
-	return {
-		kind: "import-collection",
-		subtrees
-	};
-}
-function makeItem(name$1, as) {
-	return {
-		kind: "import-item",
-		name: name$1,
-		as
-	};
-}
-function prependSegments(segments, statement$1) {
-	statement$1.segments = segments.concat(statement$1.segments);
-	return statement$1;
-}
-let import_collection = null;
-const import_path_or_item = seq(preceded(not(or("super", "package", "import", "as")), or(word, keyword)), or(preceded("::", req(or(fn(() => import_collection), fn(() => import_path_or_item)), "invalid import, expected '{' or name")), preceded("as", req(word, "invalid alias, expected name")).map((v) => makeItem("", v)), yes().map(() => makeItem("")))).map(([name$1, next]) => {
-	if (next.kind === "import-collection") return makeStatement([makeSegment(name$1)], next);
-	else if (next.kind === "import-statement") return prependSegments([makeSegment(name$1)], next);
-	else if (next.kind === "import-item") {
-		next.name = name$1;
-		return makeStatement([], next);
-	} else assertUnreachable(next);
-});
-import_collection = delimited("{", withSepPlus(",", () => import_path_or_item).map(makeCollection), req("}", "invalid import collection, expected }"));
-const import_relative = or(terminated("package", req("::", "invalid import, expected '::'")).map((v) => [makeSegment(v)]), repeatPlus(terminated("super", req("::", "invalid import, expected '::'")).map(makeSegment)));
-const import_statement_base = delimited("import", seqObj({
-	relative: opt(import_relative),
-	collection_or_statement: req(or(import_collection, import_path_or_item), "invalid import, expected { or name")
-}).map(({ relative, collection_or_statement }) => {
-	if (collection_or_statement.kind === "import-statement") return prependSegments(relative ?? [], collection_or_statement);
-	else return makeStatement(relative ?? [], collection_or_statement);
-}), req(";", "invalid import, expected ';'"));
-function wrapAttributes(rawAttributes) {
-	return rawAttributes.map((attribute) => ({
-		kind: "attribute",
-		attribute,
-		contents: [],
-		start: 0,
-		end: 0
-	}));
-}
-const import_statement = span(seq(repeat(or(if_attribute_base, elif_attribute_base, else_attribute_base)), import_statement_base)).map(({ value: [rawAttributes, imports], span: span$1 }) => {
-	const importElem$1 = {
-		kind: "import",
-		imports,
-		start: span$1[0],
-		end: span$1[1]
-	};
-	if (rawAttributes.length > 0) return {
-		...importElem$1,
-		attributes: wrapAttributes(rawAttributes)
-	};
-	return importElem$1;
-});
-/** parse a WESL style wgsl import statement. */
-const weslImports = tagScope(repeat(import_statement).ptag("owo").collect(importElem));
-if (tracing) {
-	const names = {
-		import_collection,
-		import_path_or_item,
-		import_relative,
-		import_statement,
-		weslImports
-	};
-	Object.entries(names).forEach(([name$1, parser$1]) => {
-		parser$1.setTraceName(name$1);
-	});
-}
-
-//#endregion
-//#region ../wesl/src/parse/WeslExpression.ts
-const opt_template_list = opt(seq(templateOpen, withSepPlus(",", () => template_parameter), req(templateClose, "invalid template, expected '>'")));
-const other_address_space = or("private", "workgroup", "uniform", "function");
-const storage_address_space = seq("storage", opt(seq(",", or("read", "read_write"))));
-const var_template_list = opt(seq(templateOpen, or(storage_address_space, other_address_space), req(templateClose, "invalid template, expected '>'")));
-const template_elaborated_ident = seq(qualified_ident.collect(refIdent), opt_template_list);
-const literal = or("true", "false", number);
-const paren_expression = seq("(", () => expression, req(")", "invalid expression, expected ')'"));
-const primary_expression = or(literal, paren_expression, seq(template_elaborated_ident, opt(fn(() => argument_expression_list))));
-const component_or_swizzle = repeatPlus(or(preceded(".", word), collectArray(delimited("[", () => expression, req("]", "invalid expression, expected ']'")))));
-/** parse simple struct.member style references specially, for binding struct lowering */
-const simple_component_reference = tagScope(seq(qualified_ident.collect(refIdent, "structRef"), seq(".", word.collect(nameCollect, "component")), opt(component_or_swizzle.collect(stuffCollect, "extra_components"))).collect(memberRefCollect));
-const unary_expression = or(seq(tokenOf("symbol", [
-	"!",
-	"&",
-	"*",
-	"-",
-	"~"
-]), () => unary_expression), or(simple_component_reference, seq(primary_expression, opt(component_or_swizzle))));
-const bitwise_post_unary = or(repeatPlus(seq("&", unary_expression)), repeatPlus(seq("^", unary_expression)), repeatPlus(seq("|", unary_expression)));
-const multiplicative_operator = or("%", "*", "/");
-const additive_operator = or("+", "-");
-const shift_post_unary = (inTemplate) => {
-	const shift_left = seq("<<", unary_expression);
-	const shift_right = seq(">>", unary_expression);
-	const mul_add = seq(repeat(seq(multiplicative_operator, unary_expression)), repeat(seq(additive_operator, unary_expression, repeat(seq(multiplicative_operator, unary_expression)))));
-	return inTemplate ? or(shift_left, mul_add) : or(shift_left, shift_right, mul_add);
-};
-const relational_post_unary = (inTemplate) => {
-	return seq(shift_post_unary(inTemplate), opt(seq(inTemplate ? tokenOf("symbol", [
-		"<",
-		"<=",
-		"!=",
-		"=="
-	]) : tokenOf("symbol", [
-		">",
-		">=",
-		"<",
-		"<=",
-		"!=",
-		"=="
-	]), unary_expression, shift_post_unary(inTemplate))));
-};
-/** The expression parser exists in two variants
-* `true` is template-expression: Refuses to parse parse symbols like `&&` and `||`.
-* `false` is maybe-template-expression: Does the template disambiguation.
-*/
-const expressionParser = (inTemplate) => {
-	return seq(unary_expression, or(bitwise_post_unary, seq(relational_post_unary(inTemplate), inTemplate ? yes() : or(repeatPlus(seq("||", seq(unary_expression, relational_post_unary(false)))), repeatPlus(seq("&&", seq(unary_expression, relational_post_unary(false)))), yes().map(() => [])))));
-};
-const maybe_template = false;
-const expression = expressionParser(maybe_template);
-const template_arg_expression = expressionParser(true);
-const std_type_specifier = seq(qualified_ident.collect(refIdent, "typeRefName"), () => opt_template_list).collect(typeRefCollect);
-const type_specifier = tagScope(std_type_specifier).ctag("typeRefElem");
-/** a template_arg_expression with additional collection for parameters
-* that are types like array<f32> vs. expressions like 1+2 */
-const template_parameter = or(type_specifier.ctag("templateParam"), template_arg_expression.collect(expressionCollect, "templateParam"));
-const argument_expression_list = seq("(", withSep(",", expression), req(")", "invalid fn arguments, expected ')'"));
-if (tracing) {
-	const names = {
-		opt_template_list,
-		other_address_space,
-		storage_address_space,
-		var_template_list,
-		template_elaborated_ident,
-		primary_expression,
-		literal,
-		paren_expression,
-		component_or_swizzle,
-		simple_component_reference,
-		unary_expression,
-		bitwise_post_unary,
-		multiplicative_operator,
-		additive_operator,
-		expression,
-		template_arg_expression,
-		std_type_specifier,
-		type_specifier,
-		template_parameter,
-		argument_expression_list
-	};
-	Object.entries(names).forEach(([name$1, parser$1]) => {
-		parser$1.setTraceName(name$1);
-	});
-}
-
-//#endregion
-//#region ../wesl/src/parse/WeslGrammar.ts
-const name = tokenKind("word").map(makeName);
-const diagnostic_rule_name = seq(name, opt(preceded(".", req(name, "invalid diagnostic rule name, expected name"))));
-const diagnostic_control = delimited("(", req(separated_pair(name, ",", diagnostic_rule_name), "invalid diagnostic control, expected rule name"), seq(opt(","), req(")", "invalid diagnostic control, expected ')'")));
-/** list of words that aren't identifiers (e.g. for @interpolate) */
-const name_list = withSep(",", name, { requireOne: true });
-const special_attribute = tagScope(preceded("@", or(or("compute", "const", "fragment", "invariant", "must_use", "vertex").map((name$1) => makeStandardAttribute([name$1, []])), preceded("interpolate", req(delimited("(", name_list, ")"), "invalid @interpolate, expected '('")).map(makeInterpolateAttribute), preceded("builtin", req(delimited("(", name, ")"), "invalid @builtin, expected '('")).map(makeBuiltinAttribute), preceded("diagnostic", req(diagnostic_control, "invalid @diagnostic, expected '('")).map(makeDiagnosticAttribute)).ptag("attr_variant")).collect(specialAttribute));
-const normal_attribute = tagScope(preceded("@", or(seq(or("workgroup_size", "align", "binding", "blend_src", "group", "id", "location", "size").ptag("name"), req(() => attribute_argument_list, "invalid attribute, expected '('")), seq(word.ptag("name"), opt(() => attribute_argument_list)))).collect(collectAttribute));
-const attribute_argument_list = delimited("(", withSep(",", span(fn(() => expression)).collect(expressionCollect, "attrParam")), req(")", "invalid attribute arguments, expected ')'"));
-const attribute_no_if = or(special_attribute, normal_attribute).ctag("attribute");
-const attribute_incl_if = or(if_attribute, elif_attribute, else_attribute, special_attribute, normal_attribute).ctag("attribute");
-const opt_attributes = repeat(attribute_incl_if);
-const opt_attributes_no_if = repeat(attribute_no_if);
-const globalTypeNameDecl = req(word.collect(globalDeclCollect, "type_name"), "invalid type name, expected a name");
-const fnNameDecl = req(word.collect(globalDeclCollect, "fn_name"), "missing fn name");
-const optionally_typed_ident = tagScope(seq(word.collect(declCollect, "decl_elem"), opt(seq(":", type_specifier))).collect(typedDecl)).ctag("var_name");
-const req_optionally_typed_ident = req(optionally_typed_ident, "invalid ident");
-const global_ident = tagScope(req(seq(word.collect(globalDeclCollect, "decl_elem"), opt(seq(":", type_specifier.collect(scopeCollectNoIf, "decl_type")))).collect(typedDecl), "expected identifier")).ctag("var_name");
-const struct_member = tagScope(seq(opt_attributes, word.collect(nameCollect, "nameElem"), req(":", "invalid struct member, expected ':'"), req(type_specifier, "invalid struct member, expected type specifier")).collect(collectStructMember)).ctag("members");
-const struct_decl = seq(weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"), "struct", req(globalTypeNameDecl, "invalid struct, expected name"), seq(req("{", "invalid struct, expected '{'"), withSepPlus(",", struct_member), req("}", "invalid struct, expected '}'")).collect(scopeCollect, "struct_scope")).collect(collectStruct);
-/** Also covers func_call_statement.post.ident */
-const fn_call = seq(qualified_ident.collect(refIdent), () => opt_template_list, argument_expression_list);
-const fnParam = tagScope(seq(opt_attributes.collect((cc) => cc.tags.attribute, "attributes"), word.collect(declCollect, "decl_elem"), opt(seq(":", req(type_specifier, "invalid fn parameter, expected type specifier"))).collect(typedDecl, "param_name")).collect(collectFnParam)).ctag("fn_param");
-const fnParamList = seq("(", withSep(",", fnParam), ")");
-const local_variable_decl = seq("var", () => var_template_list, req_optionally_typed_ident, opt(seq("=", () => expression))).collect(collectVarLike("var"));
-const global_variable_decl = seq(opt_attributes, "var", () => var_template_list, global_ident, opt(seq("=", () => expression.collect(scopeCollectNoIf, "decl_scope"))), ";").collect(collectVarLike("gvar")).collect(partialScopeCollect);
-const unscoped_compound_statement = seq(opt_attributes, text("{"), repeat(() => statement), req("}", "invalid block, expected }")).collect(statementCollect);
-const compound_statement = tagScope(seq(opt_attributes, seq(text("{"), repeat(() => statement), req("}", "invalid block, expected '}'")).collect(scopeCollect)).collect(statementCollect));
-const for_init = seq(opt_attributes, or(fn_call, () => variable_or_value_statement, () => variable_updating_statement));
-const for_update = seq(opt_attributes, or(fn_call, () => variable_updating_statement));
-const for_statement = seq("for", seq(req("(", "invalid for loop, expected '('"), opt(for_init), req(";", "invalid for loop, expected ';'"), opt(expression), req(";", "invalid for loop, expected ';'"), opt(for_update), req(")", "invalid for loop, expected ')'"), unscoped_compound_statement).collect(scopeCollect));
-const if_statement = seq("if", req(seq(expression, compound_statement), "invalid if statement"), repeat(seq("else", "if", req(seq(expression, compound_statement), "invalid else if branch"))), opt(seq("else", req(compound_statement, "invalid else branch, expected '{'"))));
-const loop_statement = seq("loop", opt_attributes_no_if, req(seq("{", repeat(() => statement), opt(tagScope(seq(opt_attributes, "continuing", opt_attributes_no_if, "{", repeat(() => statement), tagScope(opt(seq(opt_attributes, seq("break", "if", expression, ";")).collect(statementCollect))), "}").collect(statementCollect).collect(scopeCollect))), "}"), "invalid loop statement")).collect(scopeCollect);
-const case_selector = or("default", expression);
-const switch_clause = tagScope(seq(opt_attributes, or(seq("case", withSep(",", case_selector, { requireOne: true }), opt(":"), compound_statement), seq("default", opt(":"), compound_statement)).collect(switchClauseCollect)));
-const switch_body = seq(opt_attributes, "{", repeatPlus(switch_clause), "}");
-const switch_statement = seq("switch", expression, switch_body);
-const while_statement = seq("while", expression, compound_statement);
-const regular_statement = or(for_statement, if_statement, loop_statement, switch_statement, while_statement, seq("break", ";"), seq("continue", req(";", "invalid statement, expected ';'")), seq(";"), () => const_assert, seq("discard", req(";", "invalid statement, expected ';'")), seq("return", opt(expression), req(";", "invalid statement, expected ';'")), seq(fn_call, req(";", "invalid statement, expected ';'")), seq(() => variable_or_value_statement, req(";", "invalid statement, expected ';'")), seq(() => variable_updating_statement, req(";", "invalid statement, expected ';'")));
-const conditional_statement = tagScope(seq(opt_attributes, regular_statement).collect(statementCollect).collect(partialScopeCollect));
-const statement = or(compound_statement, tagScope(seq(opt_attributes_no_if, regular_statement)), conditional_statement);
-const lhs_expression = or(simple_component_reference, seq(qualified_ident.collect(refIdent), opt(component_or_swizzle)), seq("(", () => lhs_expression, ")", opt(component_or_swizzle)), seq("&", () => lhs_expression), seq("*", () => lhs_expression));
-const variable_or_value_statement = tagScope(or(local_variable_decl, seq("const", req_optionally_typed_ident, req("=", "invalid const declaration, expected '='"), expression), seq("let", req_optionally_typed_ident, req("=", "invalid let declaration, expected '='"), expression)));
-const variable_updating_statement = or(seq(lhs_expression, or("=", "<<=", ">>=", "%=", "&=", "*=", "+=", "-=", "/=", "^=", "|="), expression), seq(lhs_expression, or("++", "--")), seq("_", "=", expression));
-const fn_decl = seq(tagScope(opt_attributes.collect((cc) => cc.tags.attribute || [])).ctag("fn_attributes"), text("fn"), req(fnNameDecl, "invalid fn, expected function name"), seq(req(fnParamList, "invalid fn, expected function parameters").collect(scopeCollectNoIf, "header_scope"), opt(seq("->", opt_attributes.collect((cc) => cc.tags.attribute, "return_attributes"), type_specifier.ctag("return_type").collect(scopeCollectNoIf, "return_scope"))), req(unscoped_compound_statement, "invalid fn, expected function body").ctag("body_statement").collect(scopeCollectNoIf, "body_scope"))).collect(partialScopeCollect, "fn_partial_scope").collect(fnCollect);
-const global_value_decl = or(seq(opt_attributes, "override", global_ident, seq(opt(seq("=", expression.collect(scopeCollectNoIf, "decl_scope")))), ";").collect(collectVarLike("override")), seq(opt_attributes, "const", global_ident, "=", seq(expression).collect(scopeCollectNoIf, "decl_scope"), ";").collect(collectVarLike("const"))).collect(partialScopeCollect);
-const global_alias = seq(weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"), "alias", req(word, "invalid alias, expected name").collect(globalDeclCollect, "alias_name"), req("=", "invalid alias, expected '='"), req(type_specifier, "invalid alias, expected type").collect(scopeCollect, "alias_scope"), req(";", "invalid alias, expected ';'")).collect(aliasCollect);
-const const_assert = tagScope(seq(opt_attributes, "const_assert", req(expression, "invalid const_assert, expected expression"), req(";", "invalid statement, expected ';'")).collect(assertCollect)).ctag("const_assert");
-const global_directive = tagScope(seq(opt_attributes, terminated(or(preceded("diagnostic", diagnostic_control).map(makeDiagnosticDirective), preceded("enable", name_list).map(makeEnableDirective), preceded("requires", name_list).map(makeRequiresDirective)).ptag("directive"), ";")).collect(directiveCollect));
-const global_decl = tagScope(or(fn_decl, global_variable_decl, global_value_decl, ";", global_alias, const_assert.collect(globalAssertCollect), struct_decl));
-const weslRoot = seq(weslExtension(weslImports), repeat(global_directive), repeat(global_decl), req(eof(), "invalid WESL, expected EOF")).collect(collectModule, "collectModule");
-function makeDiagnosticDirective([severity, rule]) {
-	return {
-		kind: "diagnostic",
-		severity,
-		rule
-	};
-}
-function makeEnableDirective(extensions) {
-	return {
-		kind: "enable",
-		extensions
-	};
-}
-function makeRequiresDirective(extensions) {
-	return {
-		kind: "requires",
-		extensions
-	};
-}
-function makeStandardAttribute([name$1, params]) {
-	return {
-		kind: "@attribute",
-		name: name$1,
-		params
-	};
-}
-function makeInterpolateAttribute(params) {
-	return {
-		kind: "@interpolate",
-		params
-	};
-}
-function makeBuiltinAttribute(param) {
-	return {
-		kind: "@builtin",
-		param
-	};
-}
-function makeDiagnosticAttribute([severity, rule]) {
-	return {
-		kind: "@diagnostic",
-		severity,
-		rule
-	};
-}
-function makeName(token$1) {
-	return {
-		kind: "name",
-		name: token$1.text,
-		start: token$1.span[0],
-		end: token$1.span[1]
-	};
-}
-if (tracing) {
-	const names = {
-		name,
-		diagnostic_rule_name,
-		diagnostic_control,
-		name_list,
-		special_attribute,
-		if_attribute,
-		elif_attribute,
-		else_attribute,
-		normal_attribute,
-		attribute_argument_list,
-		attribute_no_if,
-		attribute_incl_if,
-		opt_attributes,
-		opt_attributes_no_if,
-		globalTypeNameDecl,
-		fnNameDecl,
-		optionally_typed_ident,
-		req_optionally_typed_ident,
-		global_ident,
-		struct_member,
-		struct_decl,
-		fn_call,
-		fnParam,
-		fnParamList,
-		local_variable_decl,
-		global_variable_decl,
-		unscoped_compound_statement,
-		compound_statement,
-		for_init,
-		for_update,
-		for_statement,
-		if_statement,
-		loop_statement,
-		case_selector,
-		switch_clause,
-		switch_body,
-		switch_statement,
-		while_statement,
-		regular_statement,
-		conditional_statement,
-		statement,
-		lhs_expression,
-		variable_or_value_statement,
-		variable_updating_statement,
-		fn_decl,
-		global_value_decl,
-		global_alias,
-		const_assert,
-		global_directive,
-		global_decl,
-		weslRoot,
-		qualified_ident,
-		word
-	};
-	Object.entries(names).forEach(([name$1, parser$1]) => {
-		parser$1.setTraceName(name$1);
-	});
-}
-
-//#endregion
-//#region ../wesl/src/ParseWESL.ts
-/**
-* An error when parsing WESL fails. Designed to be human-readable.
-*/
-var WeslParseError$1 = class extends Error {
-	span;
-	src;
-	constructor(opts) {
-		const source = opts.src.src;
-		const [lineNum, linePos] = offsetToLineNumber(opts.cause.span[0], source);
-		let message = `${opts.src.debugFilePath}:${lineNum}:${linePos}`;
-		message += ` error: ${opts.cause.message}\n`;
-		message += errorHighlight(source, opts.cause.span).join("\n");
-		super(message, { cause: opts.cause });
-		this.span = opts.cause.span;
-		this.src = opts.src;
-	}
-};
-/** Parse a WESL file. Throws on error. */
-function parseSrcModule(srcModule) {
-	const stream$1 = new WeslStream(srcModule.src);
-	const appState = blankWeslParseState(srcModule);
-	const init = {
-		stream: stream$1,
-		appState
-	};
-	try {
-		if (weslRoot.parse(init) === null) throw new Error("parseWESL failed");
-	} catch (e) {
-		if (e instanceof ParseError) {
-			const [lineNumber, lineColumn] = offsetToLineNumber(e.span[0], srcModule.src);
-			const error = new WeslParseError$1({
-				cause: e,
-				src: srcModule
-			});
-			throwClickableError({
-				url: srcModule.debugFilePath,
-				text: srcModule.src,
-				error,
-				lineNumber,
-				lineColumn,
-				length: e.span[1] - e.span[0]
-			});
-		} else throw e;
-	}
-	return appState.stable;
-}
-function blankWeslParseState(srcModule) {
-	const rootScope = emptyScope(null);
-	return {
-		context: {
-			scope: rootScope,
-			openElems: []
-		},
-		stable: {
-			srcModule,
-			imports: [],
-			rootScope,
-			moduleElem: null
-		}
-	};
-}
-
-//#endregion
-//#region ../wesl/src/PathUtil.ts
-/** simplistic path manipulation utilities */
-/** return path with ./ and foo/.. elements removed */
-function normalize(path$2) {
-	const noDots = path$2.split("/").filter((s) => s !== ".");
-	const noDbl = [];
-	noDots.forEach((s) => {
-		if (s !== "") if (s === ".." && noDbl.length && noDbl[noDbl.length - 1] !== "..") noDbl.pop();
-		else noDbl.push(s);
-	});
-	return noDbl.join("/");
-}
-/** return path w/o a suffix.
-* e.g. /foo/bar.wgsl => /foo/bar */
-function noSuffix(path$2) {
-	const lastSlash = path$2.lastIndexOf("/");
-	const lastStart = lastSlash === -1 ? 0 : lastSlash + 1;
-	const suffix = path$2.indexOf(".", lastStart);
-	const suffixStart = suffix === -1 ? path$2.length : suffix;
-	return path$2.slice(0, suffixStart);
-}
-
-//#endregion
-//#region ../wesl/src/ParsedRegistry.ts
-function parsedRegistry$1() {
-	resetScopeIds();
-	return { modules: {} };
+//#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 srcFiles    map of source strings by file path
-*                    key is '/' separated relative path (relative to srcRoot, not absolute file path )
-*                    value is wesl source string
-* @param registry    add parsed modules to this registry
-* @param packageName name of package
+* @param projectDir - file:// URL string to directory containing package.json
+* @returns the 'version' field from the package.json in the `projectDir`
 */
-function parseIntoRegistry$1(srcFiles, registry, packageName = "package", debugWeslRoot) {
-	let weslRoot$1 = debugWeslRoot;
-	if (weslRoot$1 === void 0) weslRoot$1 = "";
-	else if (!weslRoot$1.endsWith("/")) weslRoot$1 += "/";
-	Object.entries(srcFiles).map(([filePath, src]) => {
-		return {
-			modulePath: fileToModulePath(filePath, packageName),
-			debugFilePath: weslRoot$1 + filePath,
-			src
-		};
-	}).forEach((mod) => {
-		const parsed = parseSrcModule(mod);
-		if (registry.modules[mod.modulePath]) return;
-		registry.modules[mod.modulePath] = parsed;
-	});
-}
-const libRegex = /^lib\.w[eg]sl$/i;
-/** convert a file path (./foo/bar.wesl)
-*  to a module path (package::foo::bar) */
-function fileToModulePath(filePath, packageName) {
-	if (filePath.includes("::")) return filePath;
-	if (packageName !== "package" && libRegex.test(filePath)) return packageName;
-	const moduleSuffix = noSuffix(normalize(filePath)).replaceAll("/", "::");
-	return packageName + "::" + moduleSuffix;
+async function versionFromPackageJson(projectDir) {
+	return (await readPackageJson(projectDir)).version;
 }
 
 //#endregion
@@ -11208,7 +9869,8 @@ async function cli(rawArgs) {
 	await linkNormally(await parseArgs(rawArgs));
 }
 async function parseArgs(args) {
-	const appVersion = await versionFromPackageJson(new URL("..", import.meta.url));
+	const toolDir = new URL("..", import.meta.url).href;
+	const appVersion = await versionFromPackageJson(toolDir);
 	return yargs(args).version(appVersion).command("$0 [module]", false, (yargs$1) => {
 		yargs$1.positional("module", {
 			type: "string",
@@ -11261,20 +9923,15 @@ async function linkNormally(argv) {
 		conditions
 	})).dest);
 	if (argv.details) {
-		const registry = parsedRegistry$1();
-		try {
-			parseIntoRegistry$1(weslSrc, registry, "package");
-		} catch (e) {
-			console.error(e);
-		}
-		Object.entries(registry.modules).forEach(([modulePath, ast]) => {
+		const resolver = new RecordResolver(weslSrc);
+		for (const [modulePath, ast] of resolver.allModules()) {
 			log(`---\n${modulePath}`);
 			log(`\n->ast`);
 			log(astToString(ast.moduleElem));
 			log(`\n->scope`);
 			log(scopeToString(ast.rootScope));
 			log();
-		});
+		}
 	}
 }
 /** load the weslbundle containing the root module (if we haven't already loaded it) */