wesl 0.7.19 → 0.7.21

package/dist/index.d.ts

@@ -994,6 +994,8 @@ interface BindContext {
   /** Construct unique identifier names for global declarations. */
   mangler: ManglerFn;
   virtuals?: VirtualLibrarySet;
+  /** Host package name for resolving package:: in virtual modules. */
+  packageName: string;
   /** Unbound identifiers if accumulateUnbound is true. */
   unbound?: UnboundRef[];
   /** Don't follow references from declarations (for library dependency detection). */

package/dist/index.js

@@ -3701,6 +3701,7 @@ const wgslStandardAttributes = new Set([
 function bindIdents(params) {
 	const { rootAst, resolver, virtuals, accumulateUnbound } = params;
 	const { conditions = {}, mangler = minimalMangle } = params;
+	const packageName = rootAst.srcModule.modulePath.split("::")[0];
 	const validRootDecls = findValidRootDecls(rootAst.rootScope, conditions);
 	const { globalNames, knownDecls } = initRootDecls(validRootDecls);
 	const bindContext = {
@@ -3709,6 +3710,7 @@ function bindIdents(params) {
 		knownDecls,
 		virtuals,
 		mangler,
+		packageName,
 		foundScopes: /* @__PURE__ */ new Set(),
 		globalNames,
 		globalStatements: /* @__PURE__ */ new Map(),
@@ -3883,25 +3885,25 @@ function matchingImport(identParts, imports) {
 }
 /** @return an exported root declIdent for the provided path. */
 function findExport(pathParts, srcModule, ctx) {
-	const { resolver, conditions, virtuals } = ctx;
 	const modulePath = resolveModulePath(pathParts, srcModule.modulePath.split("::")).slice(0, -1).join("::");
-	const moduleAst = resolver.resolveModule(modulePath) ?? virtualModule(pathParts[0], conditions, virtuals);
+	const moduleAst = ctx.resolver.resolveModule(modulePath) ?? virtualModule(pathParts[0], ctx);
 	if (!moduleAst) return void 0;
-	const decl = publicDecl(moduleAst.rootScope, last(pathParts), conditions);
+	const decl = publicDecl(moduleAst.rootScope, last(pathParts), ctx.conditions);
 	if (decl) return {
 		decl,
 		moduleAst
 	};
 }
 /** @return AST for a virtual module. */
-function virtualModule(moduleName, conditions = {}, virtuals) {
-	const found = virtuals?.[moduleName];
+function virtualModule(moduleName, ctx) {
+	const found = ctx.virtuals?.[moduleName];
 	if (!found) return void 0;
 	if (found.ast) return found.ast;
+	const src = found.fn(ctx.conditions);
 	found.ast = parseSrcModule({
-		modulePath: moduleName,
+		modulePath: ctx.packageName + "::" + moduleName,
 		debugFilePath: moduleName,
-		src: found.fn(conditions)
+		src
 	});
 	return found.ast;
 }
@@ -3971,6 +3973,7 @@ function findUnboundRefs(resolver) {
 		globalNames: /* @__PURE__ */ new Set(),
 		globalStatements: /* @__PURE__ */ new Map(),
 		mangler: minimalMangle,
+		packageName: "package",
 		unbound: [],
 		dontFollowDecls: true
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl",
-  "version": "0.7.19",
+  "version": "0.7.21",
   "type": "module",
   "files": [
     "dist",
@@ -27,7 +27,7 @@
     "wrangler": "^4.22.0"
   },
   "peerDependencies": {
-    "random_wgsl": "^0.6.67"
+    "random_wgsl": "^0.6.69"
   },
   "peerDependenciesMeta": {
     "random_wgsl": {

package/src/BindIdents.ts

@@ -118,6 +118,7 @@ export interface BindIdentsParams
 export function bindIdents(params: BindIdentsParams): BindResults {
   const { rootAst, resolver, virtuals, accumulateUnbound } = params;
   const { conditions = {}, mangler = minimalMangle } = params;
+  const packageName = rootAst.srcModule.modulePath.split("::")[0];
 
   const validRootDecls = findValidRootDecls(rootAst.rootScope, conditions);
   const { globalNames, knownDecls } = initRootDecls(validRootDecls);
@@ -128,6 +129,7 @@ export function bindIdents(params: BindIdentsParams): BindResults {
     knownDecls,
     virtuals,
     mangler,
+    packageName,
     foundScopes: new Set<Scope>(),
     globalNames,
     globalStatements: new Map<AbstractElem, EmittableElem>(),
@@ -234,6 +236,9 @@ interface BindContext {
 
   virtuals?: VirtualLibrarySet;
 
+  /** Host package name for resolving package:: in virtual modules. */
+  packageName: string;
+
   /** Unbound identifiers if accumulateUnbound is true. */
   unbound?: UnboundRef[];
 
@@ -428,32 +433,33 @@ function findExport(
   srcModule: SrcModule,
   ctx: BindContext,
 ): FoundDecl | undefined {
-  const { resolver, conditions, virtuals } = ctx;
   const srcParts = srcModule.modulePath.split("::");
   const fqParts = resolveModulePath(pathParts, srcParts);
   const modulePath = fqParts.slice(0, -1).join("::");
 
   const moduleAst =
-    resolver.resolveModule(modulePath) ??
-    virtualModule(pathParts[0], conditions, virtuals);
+    ctx.resolver.resolveModule(modulePath) ?? virtualModule(pathParts[0], ctx);
   if (!moduleAst) return undefined;
 
-  const decl = publicDecl(moduleAst.rootScope, last(pathParts)!, conditions);
+  const decl = publicDecl(
+    moduleAst.rootScope,
+    last(pathParts)!,
+    ctx.conditions,
+  );
   if (decl) return { decl, moduleAst };
 }
 
 /** @return AST for a virtual module. */
 function virtualModule(
   moduleName: string,
-  conditions: Conditions = {},
-  virtuals?: VirtualLibrarySet,
+  ctx: BindContext,
 ): WeslAST | undefined {
-  const found = virtuals?.[moduleName];
+  const found = ctx.virtuals?.[moduleName];
   if (!found) return undefined;
   if (found.ast) return found.ast;
 
-  const src = found.fn(conditions);
-  const modulePath = moduleName;
+  const src = found.fn(ctx.conditions);
+  const modulePath = ctx.packageName + "::" + moduleName;
   const debugFilePath = moduleName;
   found.ast = parseSrcModule({ modulePath, debugFilePath, src });
   return found.ast;

package/src/discovery/FindUnboundIdents.ts

@@ -35,6 +35,7 @@ export function findUnboundRefs(resolver: BatchModuleResolver): UnboundRef[] {
     globalNames: new Set<string>(),
     globalStatements: new Map<AbstractElem, EmittableElem>(),
     mangler: minimalMangle,
+    packageName: "package",
     unbound: [] as UnboundRef[],
     dontFollowDecls: true,
   };

package/src/test/VirtualModules.test.ts

@@ -66,6 +66,25 @@ test("constant in @binding attribute", async () => {
   expect(result).toContain("@binding(slot)");
 });
 
+test("package:: import from virtual module", async () => {
+  const src = `
+    import virt::helper;
+    fn main() { let x = helper(); }
+  `;
+  const file1 = `fn util_fn() -> u32 { return 1; }`;
+  const opts = {
+    virtualLibs: {
+      virt: () => `
+        import package::file1::util_fn;
+        fn helper() -> u32 { return util_fn(); }
+      `,
+    },
+  };
+  const result = await linkTestOpts(opts, src, file1);
+  expect(result).toContain("fn helper()");
+  expect(result).toContain("fn util_fn()");
+});
+
 test("function call with inline ref in template param", async () => {
   const src = `
     fn main() {