wesl 0.6.46 → 0.6.47

package/dist/index.d.ts

@@ -924,6 +924,62 @@ declare function scopeToString(scope: Scope, indent?: number, shortIdents?: bool
 declare function scopeToStringLong(scope: Scope): string;
 declare function identToString(ident?: Ident): string;
 //#endregion
+//#region src/discovery/FindUnboundIdents.d.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']])
+ */
+declare function findUnboundIdents(resolver: BatchModuleResolver): string[][];
+//#endregion
+//#region src/discovery/PackageNameUtils.d.ts
+/** Package name sanitization for WESL.
+ *
+ * Converts typical npm package names to WGSL-safe identifiers using double-underscore encoding.
+ * NPM package names can contain `@`, `/`, and `-`, which are not allowed in WGSL identifiers.
+ *
+ * ## Encoding Scheme
+ *
+ * ```
+ * @     ==>  (remove)
+ * /     ==>  __  (double underscore)
+ * -     ==>  _   (single underscore)
+ * ```
+ *
+ * ## Forward Mapping (npm ==> WGSL identifier)
+ *
+ * ```
+ * my_package          ==>  my_package
+ * random-wgsl         ==>  random_wgsl
+ * @scope/my-pkg       ==>  scope__my_pkg
+ * ```
+ *
+ * ## Reverse Mapping (WGSL identifier ==> npm package)
+ *
+ * ```
+ * scope__my_pkg       ==>  try: @scope/my_pkg, @scope/my-pkg
+ * random_wgsl         ==>  try: random_wgsl, random-wgsl
+ * ```
+ */
+/** Convert npm package name to WGSL-safe identifier using double-underscore encoding. */
+declare function sanitizePackageName(npmName: string): string;
+/** Generate npm package name variations from sanitized WESL identifier.
+ *
+ * Uses double-underscore encoding to distinguish scoped vs unscoped packages:
+ * - Has __ → scoped package (try @scope/pkg variants)
+ * - No __ → unscoped package (try pkg variants)
+ *
+ * Examples:
+ *   "lygia__shader_utils" → ["@lygia/shader_utils", "@lygia/shader-utils"]
+ *   "random_wgsl" → ["random_wgsl", "random-wgsl"]
+ */
+declare function npmNameVariations(sanitizedPath: string): Generator<string>;
+//#endregion
 //#region src/PathUtil.d.ts
 /** simplistic path manipulation utilities */
 /** return path with ./ and foo/.. elements removed */
@@ -1063,4 +1119,4 @@ declare function offsetToLineNumber(offset: number, text: string): [lineNum: num
  */
 declare function errorHighlight(source: string, span: Span): [string, string];
 //#endregion
-export { AbstractElem, AbstractElemBase, AliasElem, Attribute, AttributeElem, BatchModuleResolver, BinaryExpression, BinaryOperator, BindIdentsParams, BindResults, BindingAST, BindingStructElem, BoundAndTransformed, BuiltinAttribute, BundleResolver, ComponentExpression, ComponentMemberExpression, CompositeResolver, Conditions, ConstAssertElem, ConstElem, ContainerElem, DeclIdent, DeclIdentElem, DeclarationElem, DiagnosticAttribute, DiagnosticDirective, DirectiveElem, DirectiveVariant, ElemWithAttributes, ElemWithContentsBase, ElifAttribute, ElseAttribute, EmittableElem, EnableDirective, ExpressionElem, ExtendedGPUValidationError, FnElem, FnParamElem, FunctionCallExpression, GlobalDeclarationElem, GlobalVarElem, GrammarElem, HasAttributes, Ident, IfAttribute, ImportCollection, ImportElem, ImportItem, ImportSegment, ImportStatement, InterpolateAttribute, LetElem, LexicalScope, LinkConfig, LinkParams, LinkRegistryParams, LinkedWesl, LinkerTransform, Literal, LiveDecls, ManglerFn, ModuleElem, ModuleResolver, NameElem, OverrideElem, ParenthesizedExpression, PartialScope, RecordResolver, RecordResolverOptions, RefIdent, RefIdentElem, RequiresDirective, Scope, SimpleMemberRef, SrcModule, StableState, StandardAttribute, StatementElem, StructElem, StructMemberElem, StuffElem, SwitchClauseElem, SyntheticElem, TerminalElem, TextElem, TransformedAST, TranslateTimeExpressionElem, TranslateTimeFeature, TypeRefElem, TypeTemplateParameter, TypedDeclElem, UnaryExpression, UnaryOperator, UnknownExpressionElem, VarElem, VirtualLibrary, VirtualLibraryFn, VirtualLibrarySet, WeslAST, WeslBundle, WeslDevice, WeslGPUCompilationInfo, WeslGPUCompilationMessage, WeslJsPlugin, WeslParseContext, WeslParseError, WeslParseState, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, blankWeslParseState, childIdent, childScope, containsScope, debugContentsToString, emptyScope, errorHighlight, filterMap, findMap, findRefsToBindingStructs, findValidRootDecls, flatImports, groupBy, grouped, identToString, isGlobal, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, multiKeySet, nextIdentId, noSuffix, normalize, normalizeModuleName, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, scan, scopeToString, scopeToStringLong, syntheticWeslParseState, transformBindingReference, transformBindingStruct, underscoreMangle };
+export { AbstractElem, AbstractElemBase, AliasElem, Attribute, AttributeElem, BatchModuleResolver, BinaryExpression, BinaryOperator, BindIdentsParams, BindResults, BindingAST, BindingStructElem, BoundAndTransformed, BuiltinAttribute, BundleResolver, ComponentExpression, ComponentMemberExpression, CompositeResolver, Conditions, ConstAssertElem, ConstElem, ContainerElem, DeclIdent, DeclIdentElem, DeclarationElem, DiagnosticAttribute, DiagnosticDirective, DirectiveElem, DirectiveVariant, ElemWithAttributes, ElemWithContentsBase, ElifAttribute, ElseAttribute, EmittableElem, EnableDirective, ExpressionElem, ExtendedGPUValidationError, FnElem, FnParamElem, FunctionCallExpression, GlobalDeclarationElem, GlobalVarElem, GrammarElem, HasAttributes, Ident, IfAttribute, ImportCollection, ImportElem, ImportItem, ImportSegment, ImportStatement, InterpolateAttribute, LetElem, LexicalScope, LinkConfig, LinkParams, LinkRegistryParams, LinkedWesl, LinkerTransform, Literal, LiveDecls, ManglerFn, ModuleElem, ModuleResolver, NameElem, OverrideElem, ParenthesizedExpression, PartialScope, RecordResolver, RecordResolverOptions, RefIdent, RefIdentElem, RequiresDirective, Scope, SimpleMemberRef, SrcModule, StableState, StandardAttribute, StatementElem, StructElem, StructMemberElem, StuffElem, SwitchClauseElem, SyntheticElem, TerminalElem, TextElem, TransformedAST, TranslateTimeExpressionElem, TranslateTimeFeature, TypeRefElem, TypeTemplateParameter, TypedDeclElem, UnaryExpression, UnaryOperator, UnknownExpressionElem, VarElem, VirtualLibrary, VirtualLibraryFn, VirtualLibrarySet, WeslAST, WeslBundle, WeslDevice, WeslGPUCompilationInfo, WeslGPUCompilationMessage, WeslJsPlugin, WeslParseContext, WeslParseError, WeslParseState, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, blankWeslParseState, childIdent, childScope, containsScope, debugContentsToString, emptyScope, errorHighlight, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, isGlobal, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, multiKeySet, nextIdentId, noSuffix, normalize, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, sanitizePackageName, scan, scopeToString, scopeToStringLong, syntheticWeslParseState, transformBindingReference, transformBindingStruct, underscoreMangle };

package/dist/index.js

@@ -2530,7 +2530,7 @@ function findQualifiedImport(refIdent$1, resolver, conditions, virtuals, unbound
 	const identParts = refIdent$1.originalName.split("::");
 	const modulePathParts = matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);
 	if (!modulePathParts) {
-		if (unbound) unbound.push(identParts);
+		if (unbound && !stdWgsl(refIdent$1.originalName)) unbound.push(identParts);
 		return;
 	}
 	const result = findExport(modulePathParts, refIdent$1.ast.srcModule, resolver, conditions, virtuals);
@@ -2623,6 +2623,105 @@ function collectDecls(scope, found) {
 	else if (item.kind === "partial") collectDecls(item, found);
 }
 
+//#endregion
+//#region src/discovery/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 src/discovery/PackageNameUtils.ts
+/** Package name sanitization for WESL.
+*
+* Converts typical npm package names to WGSL-safe identifiers using double-underscore encoding.
+* NPM package names can contain `@`, `/`, and `-`, which are not allowed in WGSL identifiers.
+*
+* ## Encoding Scheme
+*
+* ```
+* @     ==>  (remove)
+* /     ==>  __  (double underscore)
+* -     ==>  _   (single underscore)
+* ```
+*
+* ## Forward Mapping (npm ==> WGSL identifier)
+*
+* ```
+* my_package          ==>  my_package
+* random-wgsl         ==>  random_wgsl
+* @scope/my-pkg       ==>  scope__my_pkg
+* ```
+*
+* ## Reverse Mapping (WGSL identifier ==> npm package)
+*
+* ```
+* scope__my_pkg       ==>  try: @scope/my_pkg, @scope/my-pkg
+* random_wgsl         ==>  try: random_wgsl, random-wgsl
+* ```
+*/
+/** Convert npm package name to WGSL-safe identifier using double-underscore encoding. */
+function sanitizePackageName(npmName) {
+	return npmName.replace(/^@/, "").replaceAll("/", "__").replaceAll("-", "_");
+}
+/** Generate npm package name variations from sanitized WESL identifier.
+*
+* Uses double-underscore encoding to distinguish scoped vs unscoped packages:
+* - Has __ → scoped package (try @scope/pkg variants)
+* - No __ → unscoped package (try pkg variants)
+*
+* Examples:
+*   "lygia__shader_utils" → ["@lygia/shader_utils", "@lygia/shader-utils"]
+*   "random_wgsl" → ["random_wgsl", "random-wgsl"]
+*/
+function* npmNameVariations(sanitizedPath) {
+	const [pkg, sub] = breakAt(sanitizedPath, "/");
+	let pkgName = pkg;
+	let scopePrefix = "";
+	if (pkg.includes("__")) {
+		const [scope, ...rest] = pkg.split("__");
+		pkgName = rest.join("__");
+		scopePrefix = `@${scope}/`;
+	}
+	yield `${scopePrefix}${pkgName}${sub}`;
+	yield `${scopePrefix}${pkgName.replaceAll("_", "-")}${sub}`;
+}
+/** Break string at first occurrence of delimiter.
+* @returns [before, after] where after includes the delimiter */
+function breakAt(str, delimiter) {
+	const index = str.indexOf(delimiter);
+	if (index === -1) return [str, ""];
+	return [str.slice(0, index), str.slice(index)];
+}
+
 //#endregion
 //#region src/LinkedWesl.ts
 /**
@@ -3387,4 +3486,4 @@ function makeWeslDevice(device) {
 }
 
 //#endregion
-export { BundleResolver, CompositeResolver, LinkedWesl, RecordResolver, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, blankWeslParseState, childIdent, childScope, containsScope, debugContentsToString, emptyScope, errorHighlight, filterMap, findMap, findRefsToBindingStructs, findValidRootDecls, flatImports, groupBy, grouped, identToString, isGlobal, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, multiKeySet, nextIdentId, noSuffix, normalize, normalizeModuleName, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, scan, scopeToString, scopeToStringLong, syntheticWeslParseState, transformBindingReference, transformBindingStruct, underscoreMangle };
+export { BundleResolver, CompositeResolver, LinkedWesl, RecordResolver, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, blankWeslParseState, childIdent, childScope, containsScope, debugContentsToString, emptyScope, errorHighlight, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, isGlobal, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, multiKeySet, nextIdentId, noSuffix, normalize, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, sanitizePackageName, scan, scopeToString, scopeToStringLong, syntheticWeslParseState, transformBindingReference, transformBindingStruct, underscoreMangle };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl",
-  "version": "0.6.46",
+  "version": "0.6.47",
   "type": "module",
   "files": [
     "dist",
@@ -15,7 +15,7 @@
   },
   "types": "dist/index.d.ts",
   "dependencies": {
-    "mini-parse": "0.6.40"
+    "mini-parse": "0.6.41"
   },
   "devDependencies": {
     "@types/brotli": "^1.3.4",

package/src/BindIdents.ts

@@ -434,7 +434,7 @@ function findQualifiedImport(
     matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);
 
   if (!modulePathParts) {
-    if (unbound) unbound.push(identParts);
+    if (unbound && !stdWgsl(refIdent.originalName)) unbound.push(identParts);
     return undefined;
   }
 

package/src/ClickableError.ts

@@ -75,7 +75,7 @@ export function throwClickableError(params: ClickableErrorParams): void {
   let oldLimit = 0;
   // Supported on Chrome https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/stackTraceLimit
   if ("stackTraceLimit" in Error) {
-    oldLimit = Error.stackTraceLimit;
+    oldLimit = Error.stackTraceLimit as number;
     Error.stackTraceLimit = 1;
   }
 

package/src/discovery/FindUnboundIdents.ts

@@ -0,0 +1,43 @@
+import type { AbstractElem } from "../AbstractElems.ts";
+import {
+  bindIdentsRecursive,
+  type EmittableElem,
+  findValidRootDecls,
+} from "../BindIdents.ts";
+import type { LiveDecls } from "../LiveDeclarations.ts";
+import { minimalMangle } from "../Mangler.ts";
+import type { BatchModuleResolver } from "../ModuleResolver.ts";
+import type { DeclIdent, Scope } from "../Scope.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']])
+ */
+export function findUnboundIdents(resolver: BatchModuleResolver): string[][] {
+  const bindContext = {
+    resolver,
+    conditions: {},
+    knownDecls: new Set<DeclIdent>(),
+    foundScopes: new Set<Scope>(),
+    globalNames: new Set<string>(),
+    globalStatements: new Map<AbstractElem, EmittableElem>(),
+    mangler: minimalMangle,
+    unbound: [] as string[][],
+    dontFollowDecls: true,
+  };
+
+  for (const [_modulePath, ast] of resolver.allModules()) {
+    const rootDecls = findValidRootDecls(ast.rootScope, {});
+    const declEntries = rootDecls.map(d => [d.originalName, d] as const);
+    const liveDecls: LiveDecls = { decls: new Map(declEntries), parent: null };
+    bindIdentsRecursive(ast.rootScope, bindContext, liveDecls, true);
+  }
+
+  return bindContext.unbound;
+}

package/src/discovery/PackageNameUtils.ts

@@ -0,0 +1,71 @@
+/** Package name sanitization for WESL.
+ *
+ * Converts typical npm package names to WGSL-safe identifiers using double-underscore encoding.
+ * NPM package names can contain `@`, `/`, and `-`, which are not allowed in WGSL identifiers.
+ *
+ * ## Encoding Scheme
+ *
+ * ```
+ * @     ==>  (remove)
+ * /     ==>  __  (double underscore)
+ * -     ==>  _   (single underscore)
+ * ```
+ *
+ * ## Forward Mapping (npm ==> WGSL identifier)
+ *
+ * ```
+ * my_package          ==>  my_package
+ * random-wgsl         ==>  random_wgsl
+ * @scope/my-pkg       ==>  scope__my_pkg
+ * ```
+ *
+ * ## Reverse Mapping (WGSL identifier ==> npm package)
+ *
+ * ```
+ * scope__my_pkg       ==>  try: @scope/my_pkg, @scope/my-pkg
+ * random_wgsl         ==>  try: random_wgsl, random-wgsl
+ * ```
+ */
+
+/** Convert npm package name to WGSL-safe identifier using double-underscore encoding. */
+export function sanitizePackageName(npmName: string): string {
+  return npmName
+    .replace(/^@/, "") // Remove @ prefix
+    .replaceAll("/", "__") // Replace / with __ (double underscore)
+    .replaceAll("-", "_"); // Replace - with _ (single underscore)
+}
+
+/** Generate npm package name variations from sanitized WESL identifier.
+ *
+ * Uses double-underscore encoding to distinguish scoped vs unscoped packages:
+ * - Has __ → scoped package (try @scope/pkg variants)
+ * - No __ → unscoped package (try pkg variants)
+ *
+ * Examples:
+ *   "lygia__shader_utils" → ["@lygia/shader_utils", "@lygia/shader-utils"]
+ *   "random_wgsl" → ["random_wgsl", "random-wgsl"]
+ */
+export function* npmNameVariations(sanitizedPath: string): Generator<string> {
+  const [pkg, sub] = breakAt(sanitizedPath, "/");
+
+  let pkgName = pkg;
+  let scopePrefix = "";
+
+  if (pkg.includes("__")) {
+    // presume a scoped npm package (@scope/pkg)
+    const [scope, ...rest] = pkg.split("__");
+    pkgName = rest.join("__"); // Rejoin in case of __ in package name (rare)
+    scopePrefix = `@${scope}/`;
+  }
+
+  yield `${scopePrefix}${pkgName}${sub}`;
+  yield `${scopePrefix}${pkgName.replaceAll("_", "-")}${sub}`;
+}
+
+/** Break string at first occurrence of delimiter.
+ * @returns [before, after] where after includes the delimiter */
+function breakAt(str: string, delimiter: string): [string, string] {
+  const index = str.indexOf(delimiter);
+  if (index === -1) return [str, ""];
+  return [str.slice(0, index), str.slice(index)];
+}

package/src/index.ts

@@ -2,6 +2,8 @@ export * from "./AbstractElems.ts";
 export * from "./BindIdents.ts";
 export * from "./debug/ASTtoString.ts";
 export * from "./debug/ScopeToString.ts";
+export * from "./discovery/FindUnboundIdents.ts";
+export * from "./discovery/PackageNameUtils.ts";
 export * from "./LinkedWesl.ts";
 export * from "./Linker.ts";
 export * from "./LiveDeclarations.ts";

package/src/test/ConditionLinking.test.ts

@@ -3,7 +3,7 @@ import { testLink } from "./TestLink.ts";
 
 // LATER move these to cond cases? (or drop if duplicative)
 
-test("conditional statement", async () => {
+test("conditional declaration ", async () => {
   const app = `
     fn main() {
       @if(false) let x = 1;
@@ -17,6 +17,22 @@ test("conditional statement", async () => {
   await testLink({ app: app }, "app", expectWgsl);
 });
 
+test("conditional assignment", async () => {
+  const app = `
+    fn main() {
+      var x = 1;
+      @if(false) x = 2;
+    }
+  `;
+
+  const expectWgsl = `
+    fn main() {
+      var x = 1;
+    }
+  `;
+  await testLink({ app: app }, "app", expectWgsl);
+});
+
 test("conditional compound statement", async () => {
   const app = `
     fn main() {

package/src/test/PackageNameUtils.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from "vitest";
+import { sanitizePackageName } from "../discovery/PackageNameUtils.ts";
+
+test("my_package", () => {
+  expect(sanitizePackageName("my_package")).toBe("my_package");
+});
+
+test("my-package", () => {
+  expect(sanitizePackageName("my-package")).toBe("my_package");
+});
+
+test("my-cool-package", () => {
+  expect(sanitizePackageName("my-cool-package")).toBe("my_cool_package");
+});
+
+test("@scope/package", () => {
+  expect(sanitizePackageName("@scope/package")).toBe("scope__package");
+});
+
+test("@scope/my-package", () => {
+  expect(sanitizePackageName("@scope/my-package")).toBe("scope__my_package");
+});
+
+test("@scope/my_package", () => {
+  expect(sanitizePackageName("@scope/my_package")).toBe("scope__my_package");
+});
+
+test("@my-org/my-cool-package", () => {
+  expect(sanitizePackageName("@my-org/my-cool-package")).toBe(
+    "my_org__my_cool_package",
+  );
+});