wesl-tooling 0.6.21 → 0.6.22

package/dist/index.d.ts

@@ -0,0 +1,186 @@
+import { ModuleResolver, WeslAST, WeslBundle } from "wesl";
+
+//#region src/FileModuleResolver.d.ts
+
+/**
+ * Loads WESL modules from the filesystem on demand with caching.
+ *
+ * Resolves module paths like `package::foo::bar` to filesystem paths
+ * like `baseDir/foo/bar.wesl` or `baseDir/foo/bar.wgsl`.
+ */
+declare class FileModuleResolver implements ModuleResolver {
+  /** Cached parsed ASTs to avoid re-parsing the same module */
+  readonly astCache: Map<string, WeslAST>;
+  /** Root directory containing shader source files */
+  readonly baseDir: string;
+  /** Package name that this resolver handles (in addition to generic "package") */
+  readonly packageName: string;
+  /** Optional root path for debug file paths (for browser-clickable errors) */
+  readonly debugWeslRoot?: string;
+  /**
+   * @param baseDir - Root directory containing shader source files
+   * @param packageName - Package name to resolve (defaults to "package")
+   * @param debugWeslRoot - Optional root path for debug file paths. If provided, error messages
+   *   will show paths relative to this root (e.g., "shaders/foo.wesl") instead of absolute
+   *   filesystem paths. This is needed for clickable errors in browser dev tools.
+   */
+  constructor(baseDir: string, packageName?: string, debugWeslRoot?: string);
+  /**
+   * Resolves and parses a module by its import path.
+   *
+   * Returns cached AST if available, otherwise loads from filesystem,
+   * parses, caches, and returns the AST. Returns undefined if module
+   * cannot be found.
+   *
+   * @param modulePath - Module path like "package::foo::bar"
+   * @returns Parsed AST or undefined if module not found
+   */
+  resolveModule(modulePath: string): WeslAST | undefined;
+  /** Try .wesl first, then .wgsl */
+  private tryExtensions;
+  private loadSource;
+  /** Convert module path (package::foo::bar) to filesystem path (baseDir/foo/bar) */
+  private moduleToFilePath;
+  /** Convert module path to debug path for error messages */
+  private modulePathToDebugPath;
+}
+//#endregion
+//#region src/LoadModules.d.ts
+/**
+ * Load the wesl/wgsl shader sources.
+ *
+ * If baseDir or srcGlob are not provided, this function will attempt to read
+ * configuration from wesl.toml in the projectDir. If no wesl.toml exists,
+ * default values will be used.
+ *
+ * @param projectDir The project directory (typically cwd or directory containing package.json)
+ * @param baseDir Optional base directory for shaders (overrides wesl.toml if provided)
+ * @param srcGlob Optional glob pattern for shader files (overrides wesl.toml if provided)
+ */
+declare function loadModules(projectDir: string, baseDir?: string, srcGlob?: string): Promise<Record<string, string>>;
+declare function zip<A, B>(as: A[], bs: B[]): [A, B][];
+//#endregion
+//#region src/LoadProject.d.ts
+interface ProjectInfo {
+  weslSrc: Record<string, string>;
+  rootModuleName: string;
+  packageName: string;
+  libs: WeslBundle[];
+}
+interface LoadProjectOptions {
+  /** Libraries provided at runtime, don't resolve from npm (e.g., ["test"]) */
+  virtualLibs?: string[];
+}
+/**
+ * Load everything needed to link a shader file.
+ *
+ * Discovers the project root, loads wesl.toml config, reads all shader modules,
+ * and resolves external library dependencies from npm.
+ *
+ * @returns ProjectInfo with sources, libs, and module paths, or null if not in a project.
+ */
+declare function loadProject(filePath: string, opts?: LoadProjectOptions): Promise<ProjectInfo | null>;
+/** Read package name from package.json, sanitized for WESL identifiers. */
+declare function getPackageName(projectDir: string): Promise<string>;
+//#endregion
+//#region src/LoadWeslToml.d.ts
+/** Configuration from wesl.toml */
+interface WeslToml {
+  /** WESL edition (e.g. "unstable_2025") */
+  edition: string;
+  /** glob patterns to find .wesl/.wgsl files. Relative to the toml directory. */
+  include: string[];
+  /** base directory for wesl files. Relative to the toml directory. */
+  root: string;
+  /** glob patterns to exclude directories. */
+  exclude?: string[];
+  /** package manager ("npm" or "cargo") */
+  "package-manager"?: string;
+  /** names of directly referenced wesl shader packages (e.g. npm package names), or "auto" for auto-detection */
+  dependencies?: string[] | string;
+}
+/** Information about the loaded wesl.toml file and its location */
+interface WeslTomlInfo {
+  /** The path to the toml file, relative to the cwd, undefined if no toml file */
+  tomlFile: string | undefined;
+  /** The absolute path to the directory that contains the toml.
+   * Paths inside the toml are relative to this. */
+  tomlDir: string;
+  /** The wesl root, relative to the projectDir.
+   * This lets loadModules do `path.resolve(projectDir, resolvedRoot)` */
+  resolvedRoot: string;
+  /** The underlying toml file */
+  toml: WeslToml;
+}
+/** Default configuration when no wesl.toml is found */
+declare const defaultWeslToml: WeslToml;
+/**
+ * Load and parse a wesl.toml file from the fs.
+ * Provide default values for any required WeslToml fields.
+ */
+declare function loadWeslToml(tomlFile: string): Promise<WeslToml>;
+/**
+ * Find and load the wesl.toml file, or use defaults if not found
+ *
+ * @param projectDir The directory to search for wesl.toml (typically cwd or project root)
+ * @param specifiedToml Optional explicit path to a toml file
+ * @returns Information about the loaded TOML configuration
+ */
+declare function findWeslToml(projectDir: string, specifiedToml?: string): Promise<WeslTomlInfo>;
+//#endregion
+//#region src/ParseDependencies.d.ts
+/**
+ * Find package dependencies in WESL source files.
+ *
+ * Parses sources and partially binds identifiers to reveal unresolved package
+ * references. Returns the longest resolvable npm subpath for each dependency.
+ *
+ * For example, 'foo::bar::baz' could resolve to:
+ *   - 'foo/bar' (package foo, export './bar' bundle)
+ *   - 'foo' (package foo, default export)
+ *
+ * @param weslSrc - Record of WESL source files by path
+ * @param projectDir - Project directory for resolving package imports
+ * @param virtualLibNames - Virtual lib names to exclude (e.g., ['test', 'constants'])
+ * @returns Dependency paths in npm format (e.g., 'foo/bar', 'foo')
+ */
+declare function parseDependencies(weslSrc: Record<string, string>, projectDir: string, virtualLibNames?: string[]): string[];
+/**
+ * Load WeslBundle instances referenced by WESL sources.
+ *
+ * Parses sources to find external module references, then dynamically imports
+ * the corresponding weslBundle.js files.
+ *
+ * @param weslSrc - Record of WESL source files by path
+ * @param projectDir - Project directory for resolving imports
+ * @param packageName - Optional current package name
+ * @param includeCurrentPackage - Include current package in results (default: false)
+ * @param virtualLibNames - Virtual lib names to exclude from resolution
+ * @returns Loaded WeslBundle instances
+ */
+declare function dependencyBundles(weslSrc: Record<string, string>, projectDir: string, packageName?: string, includeCurrentPackage?: boolean, virtualLibNames?: string[]): Promise<WeslBundle[]>;
+//#endregion
+//#region src/ResolveProjectDir.d.ts
+/**
+ * Resolves a project directory by searching upward for package.json or wesl.toml.
+ *
+ * @param startPath - Optional starting path (file:// URL or filesystem path).
+ *   If a file URL is provided, uses its directory.
+ *   If omitted or falsy, defaults to process.cwd().
+ * @returns file:// URL string pointing to the project directory
+ *   (the first ancestor containing package.json or wesl.toml, or the start directory)
+ */
+declare function resolveProjectDir(startPath?: string): Promise<string>;
+//#endregion
+//#region src/Version.d.ts
+/** Read package.json from a directory.
+ * @param projectDir - file:// URL string to directory containing package.json
+ * @returns the parsed package.json contents */
+declare function readPackageJson(projectDir: string): Promise<Record<string, any>>;
+/**
+ * @param projectDir - file:// URL string to directory containing package.json
+ * @returns the 'version' field from the package.json in the `projectDir`
+ */
+declare function versionFromPackageJson(projectDir: string): Promise<string>;
+//#endregion
+export { FileModuleResolver, LoadProjectOptions, ProjectInfo, WeslToml, WeslTomlInfo, defaultWeslToml, dependencyBundles, findWeslToml, getPackageName, loadModules, loadProject, loadWeslToml, parseDependencies, readPackageJson, resolveProjectDir, versionFromPackageJson, zip };

package/dist/index.js

@@ -0,0 +1,406 @@
+import * as fs$1 from "node:fs";
+import { RecordResolver, WeslParseError, filterMap, findUnboundIdents, moduleToRelativePath, normalizeDebugRoot, npmNameVariations, parseSrcModule, sanitizePackageName } from "wesl";
+import fs from "node:fs/promises";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { glob } from "glob";
+import toml from "toml";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolve } from "import-meta-resolve";
+
+//#region src/FileModuleResolver.ts
+/**
+* Loads WESL modules from the filesystem on demand with caching.
+*
+* Resolves module paths like `package::foo::bar` to filesystem paths
+* like `baseDir/foo/bar.wesl` or `baseDir/foo/bar.wgsl`.
+*/
+var FileModuleResolver = class {
+	/** Cached parsed ASTs to avoid re-parsing the same module */
+	astCache = /* @__PURE__ */ new Map();
+	/** Root directory containing shader source files */
+	baseDir;
+	/** Package name that this resolver handles (in addition to generic "package") */
+	packageName;
+	/** Optional root path for debug file paths (for browser-clickable errors) */
+	debugWeslRoot;
+	/**
+	* @param baseDir - Root directory containing shader source files
+	* @param packageName - Package name to resolve (defaults to "package")
+	* @param debugWeslRoot - Optional root path for debug file paths. If provided, error messages
+	*   will show paths relative to this root (e.g., "shaders/foo.wesl") instead of absolute
+	*   filesystem paths. This is needed for clickable errors in browser dev tools.
+	*/
+	constructor(baseDir, packageName = "package", debugWeslRoot) {
+		this.baseDir = baseDir;
+		this.packageName = packageName;
+		this.debugWeslRoot = debugWeslRoot;
+	}
+	/**
+	* Resolves and parses a module by its import path.
+	*
+	* Returns cached AST if available, otherwise loads from filesystem,
+	* parses, caches, and returns the AST. Returns undefined if module
+	* cannot be found.
+	*
+	* @param modulePath - Module path like "package::foo::bar"
+	* @returns Parsed AST or undefined if module not found
+	*/
+	resolveModule(modulePath) {
+		const cached = this.astCache.get(modulePath);
+		if (cached) return cached;
+		const sourceFile = this.tryExtensions(modulePath);
+		if (!sourceFile) return void 0;
+		const ast = parseSrcModule({
+			modulePath,
+			debugFilePath: this.debugWeslRoot ? this.modulePathToDebugPath(modulePath) : sourceFile.filePath,
+			src: sourceFile.source
+		});
+		this.astCache.set(modulePath, ast);
+		return ast;
+	}
+	/** Try .wesl first, then .wgsl */
+	tryExtensions(modulePath) {
+		const basePath = this.moduleToFilePath(modulePath);
+		if (!basePath) return void 0;
+		for (const ext of [".wesl", ".wgsl"]) {
+			const filePath = basePath + ext;
+			const source = this.loadSource(filePath);
+			if (source) return {
+				filePath,
+				source
+			};
+		}
+	}
+	loadSource(filePath) {
+		try {
+			return fs$1.readFileSync(filePath, "utf8");
+		} catch {
+			return;
+		}
+	}
+	/** Convert module path (package::foo::bar) to filesystem path (baseDir/foo/bar) */
+	moduleToFilePath(modulePath) {
+		const relativePath = moduleToRelativePath(modulePath, this.packageName);
+		if (!relativePath) return void 0;
+		return `${this.baseDir}/${relativePath}`;
+	}
+	/** Convert module path to debug path for error messages */
+	modulePathToDebugPath(modulePath) {
+		const relative = moduleToRelativePath(modulePath, this.packageName) ?? "";
+		return normalizeDebugRoot(this.debugWeslRoot) + relative + ".wesl";
+	}
+};
+
+//#endregion
+//#region src/LoadWeslToml.ts
+/** Default configuration when no wesl.toml is found */
+const defaultWeslToml = {
+	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 parsed = toml.parse(tomlString);
+	return {
+		...defaultWeslToml,
+		...parsed
+	};
+}
+/**
+* Find and load the wesl.toml file, or use defaults if not found
+*
+* @param projectDir The directory to search for wesl.toml (typically cwd or project root)
+* @param specifiedToml Optional explicit path to a toml file
+* @returns Information about the loaded TOML configuration
+*/
+async function findWeslToml(projectDir, specifiedToml) {
+	let tomlFile;
+	if (specifiedToml) {
+		await fs.access(specifiedToml);
+		tomlFile = specifiedToml;
+	} else {
+		const tomlPath = path.join(projectDir, "wesl.toml");
+		tomlFile = await fs.access(tomlPath).then(() => tomlPath).catch(() => {});
+	}
+	let parsedToml;
+	let tomlDir;
+	if (tomlFile) {
+		parsedToml = await loadWeslToml(tomlFile);
+		tomlDir = path.dirname(tomlFile);
+	} else {
+		parsedToml = defaultWeslToml;
+		tomlDir = projectDir;
+	}
+	const tomlToWeslRoot = path.resolve(tomlDir, parsedToml.root);
+	const projectDirAbs = path.resolve(projectDir);
+	const resolvedRoot = path.relative(projectDirAbs, tomlToWeslRoot);
+	return {
+		tomlFile,
+		tomlDir,
+		resolvedRoot,
+		toml: parsedToml
+	};
+}
+
+//#endregion
+//#region src/LoadModules.ts
+/**
+* Load the wesl/wgsl shader sources.
+*
+* If baseDir or srcGlob are not provided, this function will attempt to read
+* configuration from wesl.toml in the projectDir. If no wesl.toml exists,
+* default values will be used.
+*
+* @param projectDir The project directory (typically cwd or directory containing package.json)
+* @param baseDir Optional base directory for shaders (overrides wesl.toml if provided)
+* @param srcGlob Optional glob pattern for shader files (overrides wesl.toml if provided)
+*/
+async function loadModules(projectDir, baseDir, srcGlob) {
+	let resolvedBaseDir;
+	let resolvedSrcGlob;
+	if (!baseDir || !srcGlob) {
+		const tomlInfo = await findWeslToml(projectDir);
+		resolvedBaseDir = baseDir ?? tomlInfo.resolvedRoot;
+		resolvedSrcGlob = srcGlob ?? tomlInfo.toml.include[0];
+	} else {
+		resolvedBaseDir = baseDir;
+		resolvedSrcGlob = srcGlob;
+	}
+	const shaderFiles = (await glob(`${resolvedSrcGlob}`, {
+		cwd: projectDir,
+		ignore: "node_modules/**"
+	})).map((f) => path.resolve(projectDir, f));
+	const promisedSrcs = shaderFiles.map((f) => fs.readFile(f, { encoding: "utf8" }));
+	const src = await Promise.all(promisedSrcs);
+	if (src.length === 0) throw new Error(`no WGSL/WESL files found in ${resolvedSrcGlob}`);
+	const baseDirAbs = path.resolve(projectDir, resolvedBaseDir);
+	const moduleEntries = zip(shaderFiles.map((p) => path.relative(baseDirAbs, path.resolve(p))).map((p) => p.replace(/\\/g, "/")), src.map((s) => s.replace(/\r\n/g, "\n")));
+	return Object.fromEntries(moduleEntries);
+}
+function zip(as, bs) {
+	return as.map((a, i) => [a, bs[i]]);
+}
+
+//#endregion
+//#region src/NpmResolver.ts
+/** Find longest resolvable npm subpath from WESL module path segments.
+*
+* A WESL statement containing a WESL module path like 'import foo__bar::baz::elem;' references
+* an npm package, an export within that package, a module within the WeslBundle,
+* and an element within the WESL module.
+* This function returns the npm package and export portion from the module path.
+* The return value is usable to dynamically import the corresponding weslBundle.js file.
+*
+* Translation from a WESL module path to an npm package path involves:
+* - Mapping WESL package names to their npm counterparts (e.g., 'foo__bar' -> '@foo/bar')
+* - Probing to find the longest valid export subpath within the package
+*   - package.json allows export subpaths, so 'mypkg::gpu' could be 'mypkg/gpu' or just 'mypkg' in npm
+* - Probing to handle variations in package naming
+*   - foo_bar could be foo-bar in npm
+*
+* Note that the resolution is based on package.json.
+* The resolved file itself may not exist yet. (e.g. dist/weslBundle.js may not have been built yet)
+*
+* @param mPath - Module path segments
+* @param importerURL - Base URL for resolution (e.g., 'file:///path/to/project/')
+* @returns Longest resolvable subpath (e.g., 'foo/bar/baz' or 'foo')
+*/
+function npmResolveWESL(mPath, importerURL) {
+	for (const subPath of exportSubpaths(mPath)) for (const npmPath of npmNameVariations(subPath)) if (tryResolve(npmPath, importerURL)) return npmPath;
+}
+/** Try Node.js module resolution.
+* @return undefined if unresolvable. */
+function tryResolve(path$2, importerURL) {
+	try {
+		return resolve(path$2, importerURL);
+	} catch {
+		return;
+	}
+}
+/** 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("/");
+}
+
+//#endregion
+//#region src/ParseDependencies.ts
+/**
+* Find package dependencies in WESL source files.
+*
+* Parses sources and partially binds identifiers to reveal unresolved package
+* references. Returns the longest resolvable npm subpath for each dependency.
+*
+* For example, 'foo::bar::baz' could resolve to:
+*   - 'foo/bar' (package foo, export './bar' bundle)
+*   - 'foo' (package foo, default export)
+*
+* @param weslSrc - Record of WESL source files by path
+* @param projectDir - Project directory for resolving package imports
+* @param virtualLibNames - Virtual lib names to exclude (e.g., ['test', 'constants'])
+* @returns Dependency paths in npm format (e.g., 'foo/bar', 'foo')
+*/
+function parseDependencies(weslSrc, projectDir, virtualLibNames = []) {
+	let resolver;
+	try {
+		resolver = new RecordResolver(weslSrc);
+	} catch (e) {
+		if (e.cause instanceof WeslParseError) {
+			console.error(e.message, "\n");
+			return [];
+		}
+		throw e;
+	}
+	const unbound = findUnboundIdents(resolver);
+	if (!unbound) return [];
+	const excludeRoots = new Set(["constants", ...virtualLibNames]);
+	const pkgRefs = unbound.filter((modulePath) => modulePath.length > 1 && !excludeRoots.has(modulePath[0]));
+	if (pkgRefs.length === 0) return [];
+	const projectURL = projectDirURL(projectDir);
+	const deps = filterMap(pkgRefs, (mPath) => npmResolveWESL(mPath, projectURL));
+	return [...new Set(deps)];
+}
+/**
+* Load WeslBundle instances referenced by WESL sources.
+*
+* Parses sources to find external module references, then dynamically imports
+* the corresponding weslBundle.js files.
+*
+* @param weslSrc - Record of WESL source files by path
+* @param projectDir - Project directory for resolving imports
+* @param packageName - Optional current package name
+* @param includeCurrentPackage - Include current package in results (default: false)
+* @param virtualLibNames - Virtual lib names to exclude from resolution
+* @returns Loaded WeslBundle instances
+*/
+async function dependencyBundles(weslSrc, projectDir, packageName, includeCurrentPackage = false, virtualLibNames = []) {
+	const deps = parseDependencies(weslSrc, projectDir, virtualLibNames);
+	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);
+}
+/** Exclude current package from dependency list. */
+function otherPackages(deps, packageName) {
+	if (!packageName) return deps;
+	return deps.filter((dep) => dep !== packageName && !dep.startsWith(`${packageName}/`));
+}
+/** Normalize project directory to file:// URL with trailing slash. */
+function projectDirURL(projectDir) {
+	if (projectDir.startsWith("file://")) return projectDir.endsWith("/") ? projectDir : `${projectDir}/`;
+	const fileUrl = pathToFileURL(projectDir).href;
+	return fileUrl.endsWith("/") ? fileUrl : `${fileUrl}/`;
+}
+
+//#endregion
+//#region src/ResolveProjectDir.ts
+/**
+* Resolves a project directory by searching upward for package.json or wesl.toml.
+*
+* @param startPath - Optional starting path (file:// URL or filesystem path).
+*   If a file URL is provided, uses its directory.
+*   If omitted or falsy, defaults to process.cwd().
+* @returns file:// URL string pointing to the project directory
+*   (the first ancestor containing package.json or wesl.toml, or the start directory)
+*/
+async function resolveProjectDir(startPath) {
+	let dir;
+	if (!startPath) dir = process.cwd();
+	else if (startPath.startsWith("file://")) {
+		const fsPath = fileURLToPath(startPath);
+		dir = await isFile(fsPath) ? path.dirname(fsPath) : fsPath;
+	} else dir = await isFile(startPath) ? path.dirname(startPath) : startPath;
+	let current = path.resolve(dir);
+	while (true) {
+		const hasPkgJson = await fileExists(path.join(current, "package.json"));
+		const hasWeslToml = await fileExists(path.join(current, "wesl.toml"));
+		if (hasPkgJson || hasWeslToml) return pathToFileURL(current).href;
+		const parent = path.dirname(current);
+		if (parent === current) return pathToFileURL(dir).href;
+		current = parent;
+	}
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isFile(fsPath) {
+	try {
+		return (await fs.stat(fsPath)).isFile();
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region 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 - 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 readPackageJson(projectDir)).version;
+}
+
+//#endregion
+//#region src/LoadProject.ts
+/**
+* Load everything needed to link a shader file.
+*
+* Discovers the project root, loads wesl.toml config, reads all shader modules,
+* and resolves external library dependencies from npm.
+*
+* @returns ProjectInfo with sources, libs, and module paths, or null if not in a project.
+*/
+async function loadProject(filePath, opts = {}) {
+	const { virtualLibs = [] } = opts;
+	try {
+		const projectDir = fileURLToPath(await resolveProjectDir(filePath));
+		const tomlInfo = await findWeslToml(projectDir);
+		const packageName = await getPackageName(projectDir);
+		const weslSrc = await loadModules(projectDir);
+		const libs = (await dependencyBundles(weslSrc, projectDir, packageName, false, virtualLibs)).filter(Boolean);
+		const shaderRootAbs = path$1.resolve(projectDir, tomlInfo.resolvedRoot);
+		return {
+			weslSrc,
+			rootModuleName: path$1.relative(shaderRootAbs, filePath).replace(/\\/g, "/"),
+			packageName,
+			libs
+		};
+	} catch {
+		return null;
+	}
+}
+/** Read package name from package.json, sanitized for WESL identifiers. */
+async function getPackageName(projectDir) {
+	try {
+		const projectUrl = pathToFileURL(projectDir).href;
+		return sanitizePackageName((await readPackageJson(projectUrl)).name);
+	} catch {
+		return path$1.basename(projectDir);
+	}
+}
+
+//#endregion
+export { FileModuleResolver, defaultWeslToml, dependencyBundles, findWeslToml, getPackageName, loadModules, loadProject, loadWeslToml, parseDependencies, readPackageJson, resolveProjectDir, versionFromPackageJson, zip };

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "wesl-tooling",
-  "version": "0.6.21",
+  "version": "0.6.22",
   "type": "module",
   "files": [
+    "dist",
     "src"
   ],
   "repository": "github:wgsl-tooling-wg/wesl-js",
   "exports": {
     ".": {
-      "import": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "dependencies": {
@@ -20,11 +22,13 @@
     "dependent_package": "x"
   },
   "peerDependencies": {
-    "wesl": "^0.7.8"
+    "wesl": "^0.7.9"
   },
   "scripts": {
+    "build": "tsdown",
     "test": "cross-env FORCE_COLOR=1 vitest",
     "test:once": "vitest run",
     "typecheck": "tsgo"
-  }
+  },
+  "main": "dist/index.js"
 }