wesl-packager 0.6.1 → 0.6.2

package/bin/wesl-packager

@@ -723,13 +723,13 @@ var YargsParser = class {
     function applyEnvVars(argv2, configOnly) {
       if (typeof envPrefix === "undefined")
         return;
-      const prefix = typeof envPrefix === "string" ? envPrefix : "";
+      const prefix2 = typeof envPrefix === "string" ? envPrefix : "";
       const env2 = mixin.env();
       Object.keys(env2).forEach(function(envVar) {
-        if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
+        if (prefix2 === "" || envVar.lastIndexOf(prefix2, 0) === 0) {
           const keys = envVar.split("__").map(function(key, i) {
             if (i === 0) {
-              key = key.substring(prefix.length);
+              key = key.substring(prefix2.length);
             }
             return camelCase(key);
           });
@@ -2461,9 +2461,9 @@ function usage(yargs, shim3) {
       if (yargs.getInternalMethods().getParserConfiguration()["sort-commands"] === true) {
         commands = commands.sort((a, b) => a[0].localeCompare(b[0]));
       }
-      const prefix = base$0 ? `${base$0} ` : "";
+      const prefix2 = base$0 ? `${base$0} ` : "";
       commands.forEach((command2) => {
-        const commandString = `${prefix}${parentCommands}${command2[0].replace(/^\$0 ?/, "")}`;
+        const commandString = `${prefix2}${parentCommands}${command2[0].replace(/^\$0 ?/, "")}`;
         ui2.span({
           text: commandString,
           padding: [0, 2, 0, 2],
@@ -3762,12 +3762,12 @@ var YargsInstance = class {
     __classPrivateFieldSet(this, _YargsInstance_detectLocale, detect, "f");
     return this;
   }
-  env(prefix) {
-    argsert("[string|boolean]", [prefix], arguments.length);
-    if (prefix === false)
+  env(prefix2) {
+    argsert("[string|boolean]", [prefix2], arguments.length);
+    if (prefix2 === false)
       delete __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix;
     else
-      __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix = prefix || "";
+      __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix = prefix2 || "";
     return this;
   }
   epilogue(msg) {
@@ -4963,12 +4963,10 @@ function logInternalSrc(log2, src, pos, ...msgs) {
   log2(caret);
 }
 function carets(linePos, linePos2) {
-  const firstCaret = " ".repeat(linePos) + "^";
-  let secondCaret = "";
-  if (linePos2 && linePos2 > linePos) {
-    secondCaret = " ".repeat(linePos2 - linePos - 1) + "^";
-  }
-  return firstCaret + secondCaret;
+  const indent = " ".repeat(linePos);
+  const numCarets = linePos2 ? linePos2 - linePos : 1;
+  const carets2 = "^".repeat(numCarets);
+  return indent + carets2;
 }
 var startCache = /* @__PURE__ */ new Map();
 function srcLine(src, position) {
@@ -5224,6 +5222,18 @@ function opt(arg) {
     }
   );
 }
+function not(arg) {
+  const p = parserArg(arg);
+  return parser2("not", function _not(state) {
+    const pos = state.stream.checkpoint();
+    const result = p._run(state);
+    if (result === null) {
+      state.stream.reset(pos);
+      return { value: true };
+    }
+    return null;
+  });
+}
 function repeat(arg) {
   const p = parserArg(arg);
   return parser2("repeat", repeatWhileFilter(p));
@@ -5930,6 +5940,110 @@ function errorHighlight(source, span2) {
   ];
 }
 
+// ../wesl/src/vlq/vlq.ts
+var char_to_integer = {};
+var 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 = "";
+  if (num < 0) {
+    num = -num << 1 | 1;
+  } else {
+    num <<= 1;
+  }
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) {
+      clamped |= 32;
+    }
+    result += integer_to_char[clamped];
+  } while (num > 0);
+  return result;
+}
+
+// ../wesl/src/ClickableError.ts
+function throwClickableError(params) {
+  const { url, text: text2, lineNumber, lineColumn, length, error } = params;
+  const mappings = encodeVlq([
+    0,
+    0,
+    Math.max(0, lineNumber - 1),
+    Math.max(0, lineColumn - 1)
+  ]) + "," + // Sadly no browser makes use of this info to map the error properly
+  encodeVlq([
+    18,
+    // Arbitrary number that is high enough
+    0,
+    Math.max(0, lineNumber - 1),
+    Math.max(0, lineColumn - 1) + length
+  ]);
+  const sourceMap = {
+    version: 3,
+    file: null,
+    sources: [url],
+    sourcesContent: [text2 ?? 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;
+  }
+}
+function failIdent(ident2, msg) {
+  const { refIdentElem, originalName } = ident2;
+  const baseMessage = msg ?? `'${originalName}'`;
+  if (refIdentElem) {
+    failIdentElem(refIdentElem, baseMessage);
+  } else {
+    throw new Error(baseMessage);
+  }
+}
+function failIdentElem(identElem, msg = "") {
+  const { srcModule, start, end } = identElem;
+  const { debugFilePath, src } = srcModule;
+  const detailedMessage = `${msg} in file: ${debugFilePath}`;
+  srcLog(src, [start, end], detailedMessage);
+  const [lineNumber, lineColumn] = offsetToLineNumber(start, src);
+  const length = end - start;
+  throwClickableError({
+    url: debugFilePath,
+    text: src,
+    lineNumber,
+    lineColumn,
+    length,
+    error: new Error(detailedMessage)
+  });
+}
+
 // ../wesl/src/Conditions.ts
 function elementValid(elem, conditions) {
   const attributes = elem.attributes;
@@ -5952,10 +6066,10 @@ function evaluateIfAttribute(ifAttribute, conditions) {
 }
 function evaluateIfExpression(expression2, conditions) {
   const { kind: kind2 } = expression2;
-  if (kind2 == "unary-expression") {
+  if (kind2 === "unary-expression") {
     assertThatDebug(expression2.operator.value === "!");
     return !evaluateIfExpression(expression2.expression, conditions);
-  } else if (kind2 == "binary-expression") {
+  } else if (kind2 === "binary-expression") {
     const op = expression2.operator.value;
     assertThatDebug(op === "||" || op === "&&");
     const leftResult = evaluateIfExpression(expression2.left, conditions);
@@ -5966,11 +6080,11 @@ function evaluateIfExpression(expression2, conditions) {
     } else {
       assertUnreachable(op);
     }
-  } else if (kind2 == "literal") {
+  } else if (kind2 === "literal") {
     const { value } = expression2;
     assertThatDebug(value === "true" || value === "false");
     return value === "true";
-  } else if (kind2 == "parenthesized-expression") {
+  } else if (kind2 === "parenthesized-expression") {
     return evaluateIfExpression(expression2.expression, conditions);
   } else if (kind2 === "translate-time-feature") {
     return conditions[expression2.name];
@@ -6110,7 +6224,7 @@ function importElem(cc) {
 function addToOpenElem(cc, elem) {
   const weslContext = cc.app.context;
   const { openElems } = weslContext;
-  if (openElems && openElems.length) {
+  if (openElems?.length) {
     const open = openElems[openElems.length - 1];
     open.contents.push(elem);
   }
@@ -6272,7 +6386,7 @@ var fnCollect = collectElem(
     mergeScope(mergedScope, bodyScope);
     const filtered = [];
     for (const e of fnScope.contents) {
-      if (e === headerScope || e == returnScope) {
+      if (e === headerScope || e === returnScope) {
         continue;
       } else if (e === bodyScope) {
         filtered.push(mergedScope);
@@ -6373,7 +6487,7 @@ var typeRefCollect = collectElem(
   "type",
   // @ts-ignore
   (cc, openElem) => {
-    let templateParamsTemp = cc.tags.templateParam?.flat(3);
+    const templateParamsTemp = cc.tags.templateParam?.flat(3);
     const typeRef = cc.tags.typeRefName?.[0];
     const name2 = typeof typeRef === "string" ? typeRef : typeRef.ident;
     const partElem = {
@@ -6408,7 +6522,7 @@ var memberRefCollect = collectElem(
   "memberRef",
   (cc, openElem) => {
     const { component, structRef, extra_components } = cc.tags;
-    const member = component[0];
+    const member = component?.[0];
     const name2 = structRef?.flat()[0];
     const extraComponents = extra_components?.flat()[0];
     const partElem = {
@@ -6504,7 +6618,10 @@ function coverWithText(cc, elem) {
 // ../wesl/src/parse/WeslBaseGrammar.ts
 var word = kind("word");
 var keyword = kind("keyword");
-var qualified_ident = withSepPlus("::", or(word, "package", "super"));
+var qualified_ident = withSepPlus(
+  "::",
+  or(word, keyword, "package", "super")
+);
 var number = kind("number");
 
 // ../wesl/src/parse/ImportGrammar.ts
@@ -6528,8 +6645,10 @@ function prependSegments(segments, statement2) {
   return statement2;
 }
 var import_collection = null;
+var segment_blacklist = or("super", "package", "import", "as");
+var packageWord = preceded(not(segment_blacklist), or(word, keyword));
 var import_path_or_item = seq(
-  word,
+  packageWord,
   or(
     preceded(
       "::",
@@ -6689,7 +6808,7 @@ var WeslStream = class {
           this.stream.reset(this.skipBlockComment(token2.span[1]));
         }
       } else if (kind2 === "word") {
-        let returnToken = token2;
+        const returnToken = token2;
         if (keywordOrReserved.has(token2.text)) {
           returnToken.kind = "keyword";
         }
@@ -6777,7 +6896,7 @@ var WeslStream = class {
       if (nextToken.text === "<") {
         pendingCounter += 1;
       } else if (nextToken.text[0] === ">") {
-        if (nextToken.text === ">" || nextToken.text == ">=") {
+        if (nextToken.text === ">" || nextToken.text === ">=") {
           pendingCounter -= 1;
         } else if (nextToken.text === ">>=" || nextToken.text === ">>") {
           pendingCounter -= 2;
@@ -7017,11 +7136,25 @@ var special_attribute = tagScope(
     "@",
     or(
       // These attributes have no arguments
-      or("compute", "const", "fragment", "invariant", "must_use", "vertex").map((name2) => makeStandardAttribute([name2, []])),
+      or("compute", "const", "fragment", "invariant", "must_use", "vertex").map(
+        (name2) => makeStandardAttribute([name2, []])
+      ),
       // These attributes have arguments, but the argument doesn't have any identifiers
-      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)
+      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)
 );
@@ -7057,7 +7190,7 @@ var normal_attribute = tagScope(
       ),
       // Everything else is also a normal attribute, optional expression list
       seq(
-        // we don't want this to interfere with if_attribute, 
+        // we don't want this to interfere with if_attribute,
         // but not("if") isn't necessary for now, since 'if' is a keyword, not a word
         word.ptag("name"),
         opt(() => attribute_argument_list)
@@ -7074,10 +7207,9 @@ var attribute_argument_list = delimited(
   ),
   req(")", "invalid attribute arguments, expected ')'")
 );
-var attribute_no_if = or(
-  special_attribute,
-  normal_attribute
-).ctag("attribute");
+var attribute_no_if = or(special_attribute, normal_attribute).ctag(
+  "attribute"
+);
 var attribute_incl_if = or(
   if_attribute,
   special_attribute,
@@ -7118,7 +7250,10 @@ var struct_member = tagScope(
   ).collect(collectStructMember)
 ).ctag("members");
 var struct_decl = seq(
-  weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"),
+  weslExtension(opt_attributes).collect(
+    (cc) => cc.tags.attribute,
+    "attributes"
+  ),
   "struct",
   req(globalTypeNameDecl, "invalid struct, expected name"),
   seq(
@@ -7136,7 +7271,12 @@ var 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")
+    opt(
+      seq(
+        ":",
+        req(type_specifier, "invalid fn parameter, expected type specifier")
+      )
+    ).collect(typedDecl, "param_name")
   ).collect(collectFnParam)
 ).ctag("fn_param");
 var fnParamList = seq("(", withSep(",", fnParam), ")");
@@ -7328,16 +7468,10 @@ var regular_statement = or(
   )
 );
 var conditional_statement = tagScope(
-  seq(
-    opt_attributes,
-    regular_statement
-  ).collect(statementCollect).collect(partialScopeCollect)
+  seq(opt_attributes, regular_statement).collect(statementCollect).collect(partialScopeCollect)
 );
 var unconditional_statement = tagScope(
-  seq(
-    opt_attributes_no_if,
-    regular_statement
-  )
+  seq(opt_attributes_no_if, regular_statement)
 );
 var statement = or(
   compound_statement,
@@ -7346,10 +7480,7 @@ var statement = or(
 );
 var lhs_expression = or(
   simple_component_reference,
-  seq(
-    qualified_ident.collect(refIdent),
-    opt(component_or_swizzle)
-  ),
+  seq(qualified_ident.collect(refIdent), opt(component_or_swizzle)),
   seq(
     "(",
     () => lhs_expression,
@@ -7365,7 +7496,12 @@ var variable_or_value_statement = tagScope(
   or(
     // Also covers the = expression case
     local_variable_decl,
-    seq("const", req_optionally_typed_ident, req("=", "invalid const declaration, expected '='"), expression),
+    seq(
+      "const",
+      req_optionally_typed_ident,
+      req("=", "invalid const declaration, expected '='"),
+      expression
+    ),
     seq(
       "let",
       req_optionally_typed_ident,
@@ -7384,22 +7520,24 @@ var variable_updating_statement = or(
   seq("_", "=", expression)
 );
 var fn_decl = seq(
-  tagScope(
-    opt_attributes.collect((cc) => cc.tags.attribute || [])
-  ).ctag("fn_attributes"),
+  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(scopeCollect, "header_scope"),
-    opt(seq(
-      "->",
-      opt_attributes.collect((cc) => cc.tags.attribute, "return_attributes"),
-      type_specifier.ctag("return_type").collect(scopeCollect, "return_scope")
-    )),
-    req(
-      unscoped_compound_statement,
-      "invalid fn, expected function body"
-    ).ctag("body_statement").collect(scopeCollect, "body_scope")
+    req(fnParamList, "invalid fn, expected function parameters").collect(
+      scopeCollect,
+      "header_scope"
+    ),
+    opt(
+      seq(
+        "->",
+        opt_attributes.collect((cc) => cc.tags.attribute, "return_attributes"),
+        type_specifier.ctag("return_type").collect(scopeCollect, "return_scope")
+      )
+    ),
+    req(unscoped_compound_statement, "invalid fn, expected function body").ctag("body_statement").collect(scopeCollect, "body_scope")
   )
 ).collect(partialScopeCollect, "fn_partial_scope").collect(fnCollect);
 var global_value_decl = or(
@@ -7420,11 +7558,20 @@ var global_value_decl = or(
   ).collect(collectVarLike("const"))
 ).collect(partialScopeCollect);
 var global_alias = seq(
-  weslExtension(opt_attributes).collect((cc) => cc.tags.attribute, "attributes"),
+  weslExtension(opt_attributes).collect(
+    (cc) => cc.tags.attribute,
+    "attributes"
+  ),
   "alias",
-  req(word, "invalid alias, expected name").collect(globalDeclCollect, "alias_name"),
+  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(type_specifier, "invalid alias, expected type").collect(
+    scopeCollect,
+    "alias_scope"
+  ),
   req(";", "invalid alias, expected ';'")
 ).collect(aliasCollect);
 var const_assert = tagScope(
@@ -7562,17 +7709,17 @@ function makeUnaryExpression([operator, expression2]) {
 }
 function makeRepeatingBinaryExpression([start, repeating]) {
   let result = start;
-  for (const [op, left2] of repeating) {
-    result = makeBinaryExpression([result, op, left2]);
+  for (const [op, left3] of repeating) {
+    result = makeBinaryExpression([result, op, left3]);
   }
   return result;
 }
-function makeBinaryExpression([left2, operator, right2]) {
+function makeBinaryExpression([left3, operator, right3]) {
   return {
     kind: "binary-expression",
     operator,
-    left: left2,
-    right: right2
+    left: left3,
+    right: right3
   };
 }
 if (tracing) {
@@ -7639,91 +7786,6 @@ if (tracing) {
   });
 }
 
-// ../wesl/src/vlq/vlq.ts
-var char_to_integer = {};
-var integer_to_char = {};
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach(function(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 = "";
-  if (num < 0) {
-    num = -num << 1 | 1;
-  } else {
-    num <<= 1;
-  }
-  do {
-    let clamped = num & 31;
-    num >>>= 5;
-    if (num > 0) {
-      clamped |= 32;
-    }
-    result += integer_to_char[clamped];
-  } while (num > 0);
-  return result;
-}
-
-// ../wesl/src/WeslDevice.ts
-function throwClickableError({
-  url,
-  text: text2,
-  lineNumber,
-  lineColumn,
-  length,
-  error
-}) {
-  let mappings = encodeVlq([
-    0,
-    0,
-    Math.max(0, lineNumber - 1),
-    Math.max(0, lineColumn - 1)
-  ]) + "," + // Sadly no browser makes use of this info to map the error properly
-  encodeVlq([
-    18,
-    // Arbitrary number that is high enough
-    0,
-    Math.max(0, lineNumber - 1),
-    Math.max(0, lineColumn - 1) + length
-  ]);
-  const sourceMap = {
-    version: 3,
-    file: null,
-    sources: [url],
-    sourcesContent: [text2 ?? 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 = "";
-    e.cause = error;
-    throw e;
-  }
-}
-
 // ../wesl/src/ParseWESL.ts
 var WeslParseError = class extends Error {
   constructor(opts) {
@@ -7864,36 +7926,25 @@ function stdEnumerant(name2) {
 }
 
 // ../wesl/src/BindIdents.ts
-function bindIdents(params) {
-  const { rootAst, registry, virtuals, accumulateUnbound } = params;
-  const { conditions = {}, mangler = minimalMangle } = params;
-  const { rootScope } = rootAst;
-  const globalNames = /* @__PURE__ */ new Set();
-  const knownDecls = /* @__PURE__ */ new Set();
-  const validRootDecls = findValidRootDecls(rootScope, conditions);
-  validRootDecls.forEach((decl) => {
-    decl.mangledName = decl.originalName;
-    globalNames.add(decl.originalName);
-    knownDecls.add(decl);
-  });
-  const unbound = accumulateUnbound ? [] : void 0;
-  const globalStatements = /* @__PURE__ */ new Map();
+function findUnboundIdents(registry) {
   const bindContext = {
     registry,
-    conditions,
-    knownDecls,
+    conditions: {},
+    knownDecls: /* @__PURE__ */ new Set(),
     foundScopes: /* @__PURE__ */ new Set(),
-    globalNames,
-    globalStatements,
-    virtuals,
-    mangler,
-    unbound
+    globalNames: /* @__PURE__ */ new Set(),
+    globalStatements: /* @__PURE__ */ new Map(),
+    mangler: minimalMangle,
+    unbound: [],
+    dontFollowDecls: true
   };
-  const declEntries = validRootDecls.map((d) => [d.originalName, d]);
-  const liveDecls = { decls: new Map(declEntries), parent: null };
-  const decls = bindIdentsRecursive(rootScope, bindContext, liveDecls, true);
-  const newStatements = [...globalStatements.values()];
-  return { decls, globalNames, newStatements, unbound };
+  Object.entries(registry.modules).map(([module, ast]) => {
+    const rootDecls = findValidRootDecls(ast.rootScope, {});
+    const declEntries = rootDecls.map((d) => [d.originalName, d]);
+    const liveDecls = { decls: new Map(declEntries), parent: null };
+    bindIdentsRecursive(ast.rootScope, bindContext, liveDecls, true);
+  });
+  return bindContext.unbound;
 }
 function findValidRootDecls(rootScope, conditions) {
   const found = [];
@@ -7910,7 +7961,7 @@ function findValidRootDecls(rootScope, conditions) {
   return found;
 }
 function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
-  const { conditions, foundScopes } = bindContext;
+  const { dontFollowDecls, foundScopes } = bindContext;
   if (foundScopes.has(scope)) return [];
   foundScopes.add(scope);
   const newGlobals = [];
@@ -7930,7 +7981,12 @@ function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
       }
     }
   });
-  const newFromRefs = newGlobals.flatMap((decl) => {
+  const newFromRefs = dontFollowDecls ? [] : handleDecls(newGlobals, bindContext);
+  return [newGlobals, newFromChildren, newFromRefs].flat();
+}
+function handleDecls(newGlobals, bindContext) {
+  const { conditions } = bindContext;
+  return newGlobals.flatMap((decl) => {
     const foundsScope = decl.dependentScope;
     if (foundsScope) {
       const rootDecls = globalDeclToRootLiveDecls(decl, conditions);
@@ -7941,7 +7997,6 @@ function bindIdentsRecursive(scope, bindContext, liveDecls, isRoot = false) {
     }
     return [];
   });
-  return [newGlobals, newFromChildren, newFromRefs].flat();
 }
 function handleRef(ident2, liveDecls, bindContext) {
   const { registry, conditions, unbound } = bindContext;
@@ -7954,7 +8009,7 @@ function handleRef(ident2, liveDecls, bindContext) {
     } else if (stdWgsl(ident2.originalName)) {
       ident2.std = true;
     } else if (!unbound) {
-      failMissingIdent(ident2);
+      failIdent(ident2, `unresolved identifier '${ident2.originalName}'`);
     }
   }
 }
@@ -8003,16 +8058,6 @@ function globalDeclToRootLiveDecls(decl, conditions) {
   root._scopeDecls = liveDecls;
   return liveDecls;
 }
-function failMissingIdent(ident2) {
-  const { refIdentElem } = ident2;
-  if (refIdentElem) {
-    const { srcModule, start, end } = refIdentElem;
-    const { debugFilePath: filePath } = srcModule;
-    const msg = `unresolved identifier '${ident2.originalName}' in file: ${filePath}`;
-    srcLog(srcModule.src, [start, end], msg);
-    throw new Error(msg);
-  }
-}
 function setMangledName(proposedName, decl, globalNames, srcModule, mangler) {
   if (!decl.mangledName) {
     let mangledName;
@@ -8058,8 +8103,8 @@ function findQualifiedImport(refIdent2, parsed, conditions, virtuals, unbound) {
       if (unbound) {
         unbound.push(modulePathParts);
       } else {
-        const msg = `ident ${modulePathParts.join("::")}, but module not found`;
-        console.log(msg);
+        const msg = `module not found for '${modulePathParts.join("::")}'`;
+        failIdent(refIdent2, msg);
       }
     }
     return result;
@@ -8195,16 +8240,22 @@ var multiNames = matchOneOf(multisampledTextureTypes);
 // raw-loader:/Users/lee/wesl-js/tools/packages/wesl/src/WeslBundle.ts?raw
 var WeslBundle_default = 'export interface WeslBundle {\n  /** name of the package, e.g. random_wgsl */\n  name: string;\n\n  /** wesl edition of the code e.g. unstable_2025_1 */\n  edition: string;\n\n  /** map of wesl/wgsl modules:\n   *    keys are file paths, relative to package root (e.g. "./lib.wgsl")\n   *    values are wgsl/wesl code strings\n   */\n  modules: Record<string, string>;\n\n  /** packages referenced by this package */\n  dependencies?: WeslBundle[];\n}\n';
 
-// src/ParseDependencies.ts
+// ../wesl-tooling/src/ParseDependencies.ts
 import { resolve as resolve5 } from "import-meta-resolve";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 function parseDependencies(weslSrc, projectDir) {
   const registry = parsedRegistry();
-  parseIntoRegistry(weslSrc, registry);
-  const rootAst = Object.values(registry.modules)[0];
-  const bindResult = bindIdents({ registry, rootAst, accumulateUnbound: true });
-  const { unbound } = bindResult;
+  try {
+    parseIntoRegistry(weslSrc, registry);
+  } catch (e) {
+    if (e.cause instanceof WeslParseError) {
+      console.error(e.message, "\n");
+    } else {
+      throw e;
+    }
+  }
+  const unbound = findUnboundIdents(registry);
   if (!unbound) return [];
   const pkgRefs = unbound.filter((modulePath) => modulePath.length > 1);
   if (pkgRefs.length === 0) return [];
@@ -8218,18 +8269,161 @@ function parseDependencies(weslSrc, projectDir) {
   return uniqueDeps;
 }
 function unboundToDependency(mPath, importerURL) {
-  for (let i = mPath.length; i >= 0; i--) {
+  return exportSubpaths(mPath).find(
+    (subPath) => (
+      // Note that we're not checking here that the resolved file exists.
+      // The file (a weslBundle.js file somewhere in dist) may not have been built yet.
+      // LATER we could do save these paths and check that the resolved files exist.
+      tryResolve(subPath, importerURL)
+    )
+  );
+}
+function tryResolve(path3, importerURL) {
+  try {
+    return resolve5(path3, importerURL);
+  } catch (e) {
+    return void 0;
+  }
+}
+function* exportSubpaths(mPath) {
+  const longest = mPath.length - 1;
+  for (let i = longest; i >= 0; i--) {
     const subPath = mPath.slice(0, i).join("/");
-    try {
-      resolve5(subPath, importerURL);
-      return subPath;
-    } catch {
-      continue;
-    }
+    yield subPath;
   }
-  return void 0;
 }
 
+// ../../node_modules/.pnpm/berry-pretty@0.0.4/node_modules/berry-pretty/dist/index.js
+var spaces2 = memoize2((nesting) => {
+  return " ".repeat(nesting);
+});
+var defaultCallerSize2 = 20;
+var multiLinePad2 = "\n" + spaces2(defaultCallerSize2 + 3);
+function memoize2(fn2) {
+  const cache = /* @__PURE__ */ new Map();
+  return function(...args) {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    } else {
+      const value = fn2(...args);
+      cache.set(key, value);
+      return value;
+    }
+  };
+}
+if (typeof DOMRect === "undefined") {
+  globalThis.DOMRect = function() {
+  };
+}
+
+// ../../node_modules/.pnpm/thimbleberry@0.2.9/node_modules/thimbleberry/dist/thimbleberry.js
+function memoMemo(fn2, options) {
+  const memoizer = options?.memoCache || persistentMemoCache;
+  const keyFn = options?.keyFn || defaultKeyFn;
+  const cache = memoizer();
+  return function(...args) {
+    const key = keyFn(...args);
+    const found = cache.get(key);
+    if (found !== void 0) {
+      return found;
+    } else {
+      const value = fn2(...args);
+      cache.set(key, value);
+      return value;
+    }
+  };
+}
+function persistentMemoCache() {
+  return /* @__PURE__ */ new Map();
+}
+function defaultKeyFn(...args) {
+  return JSON.stringify(args[0] ?? "");
+}
+function memoizeWithDevice(fn2) {
+  const keyFn = cacheKeyWithDevice;
+  let memoFn;
+  return function(paramsObj, memoCache) {
+    if (!memoFn) {
+      memoFn = memoMemo(fn2, { keyFn, memoCache });
+    }
+    return memoFn(paramsObj);
+  };
+}
+function cacheKeyWithDevice(paramsObj) {
+  const deviceStr = `device: ${paramsObj.device?.label ?? "."}`;
+  const withoutDevice = { ...paramsObj };
+  delete withoutDevice["device"];
+  const mainStr = JSON.stringify({ ...withoutDevice });
+  const result = `${mainStr}; ${deviceStr}`;
+  return result;
+}
+function filledGPUBuffer(device, data, usage2 = GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE, label, ArrayConstructor = Float32Array) {
+  const buffer = device.createBuffer({
+    label,
+    size: data.length * ArrayConstructor.BYTES_PER_ELEMENT,
+    usage: usage2,
+    mappedAtCreation: true
+  });
+  new ArrayConstructor(buffer.getMappedRange()).set(data);
+  buffer.unmap();
+  return buffer;
+}
+var [top2, bottom2] = [1, -1];
+var [left2, right2] = [-1, 1];
+var fullFrameTriangleStrip = [
+  [left2, bottom2],
+  [left2, top2],
+  [right2, top2],
+  // upper left triangle
+  [right2, bottom2],
+  [left2, bottom2]
+  // lower right triangle
+];
+var resources = /* @__PURE__ */ new WeakMap();
+var autoContextStack = [];
+var trackCount = 0;
+function trackUse(target, context) {
+  const refCount = resources.get(target) || 0;
+  if (refCount === 0) {
+    trackCount++;
+  }
+  resources.set(target, refCount + 1);
+  last3(autoContextStack)?._addRef(target);
+  context?._addRef(target);
+  return target;
+}
+function last3(a) {
+  return a[a.length - 1];
+}
+var fullFrameVertexBuffer = memoizeWithDevice(createFrameVertexBuffer);
+function createFrameVertexBuffer(params) {
+  const { device } = params;
+  const verts = fullFrameTriangleStrip.flat();
+  const usage2 = GPUBufferUsage.VERTEX;
+  const buffer = filledGPUBuffer(device, verts, usage2, "full-screen-verts", Float32Array);
+  trackUse(buffer);
+  return buffer;
+}
+var placeholderTexture = memoMemo(makePlaceholderTexture);
+function makePlaceholderTexture(device) {
+  return device.createTexture({
+    label: "placeholder texture",
+    size: [50, 50],
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC
+  });
+}
+var prefix = /\s*/.source;
+var findUnquoted = /(?<findUnquoted>[\w-<>.]+)/.source;
+var findQuoted = /"(?<findQuoted>[^=]+)"/.source;
+var replaceKey = /\s*(?<replaceKey>[\w-]+)/.source;
+var replaceValue = /\s*"(?<replaceValue>[^"]+)"/.source;
+var parseRule = new RegExp(
+  `${prefix}(${findUnquoted}|${findQuoted})=(${replaceKey}|${replaceValue})`,
+  "g"
+);
+
 // src/PackageWesl.ts
 var biome = await setupBiome();
 async function packageWgsl(args) {
@@ -8271,7 +8465,8 @@ async function updatePackageJson(projectDir, outDir, multiBundle) {
     };
   }
   pkgJson.exports = exports;
-  await fs.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+  const jsonString = JSON.stringify(pkgJson, null, 2).concat("\n");
+  await fs.writeFile(pkgJsonPath, jsonString);
 }
 async function writeMultiBundle(modules, name2, edition, projectDir, outDir) {
   for (const [moduleName, moduleSrc] of Object.entries(modules)) {
@@ -8372,11 +8567,12 @@ async function setupBiome() {
 // src/PackagerCli.ts
 var cliArgs;
 async function packagerCli(rawArgs2) {
-  cliArgs = parseArgs(rawArgs2);
+  cliArgs = await parseArgs(rawArgs2);
   await packageWgsl(cliArgs);
 }
-function parseArgs(args) {
-  return yargs_default(args).command("$0", "create an npm package from WGSL/WESL files").option("src", {
+async function parseArgs(args) {
+  const appVersion = await versionFromPackageJson();
+  return yargs_default(args).command("$0", "create an npm package from WGSL/WESL files").version(appVersion).option("src", {
     type: "string",
     default: "./shaders/*.w[eg]sl",
     describe: "WGSL/WESL files to bundle in the package (glob syntax)"
@@ -8404,7 +8600,13 @@ function parseArgs(args) {
     type: "string",
     default: "dist",
     describe: "where to put bundled output files (relative to projectDir)"
-  }).help().parseSync();
+  }).help().parse();
+}
+async function versionFromPackageJson() {
+  const pkgJsonPath = new URL("../package.json", import.meta.url);
+  const pkgModule = await import(pkgJsonPath.href, { with: { type: "json" } });
+  const version = pkgModule.default.version;
+  return version;
 }
 
 // src/main.ts
@@ -8425,26 +8627,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 /*! Bundled license information:
 
 yargs-parser/build/lib/string-utils.js:
-  (**
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-
 yargs-parser/build/lib/tokenize-arg-string.js:
-  (**
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-
 yargs-parser/build/lib/yargs-parser-types.js:
-  (**
-   * @license
-   * Copyright (c) 2016, Contributors
-   * SPDX-License-Identifier: ISC
-   *)
-
 yargs-parser/build/lib/yargs-parser.js:
   (**
    * @license

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl-packager",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "type": "module",
   "files": [
     "bin"
@@ -9,16 +9,18 @@
   "dependencies": {
     "@biomejs/js-api": "^0.7.1",
     "@biomejs/wasm-nodejs": "^1.9.4",
-    "glob": "^11.0.1",
-    "import-meta-resolve": "^4.1.0"
+    "glob": "^11.0.2",
+    "import-meta-resolve": "^4.1.0",
+    "wesl-tooling": "0.6.2"
   },
   "devDependencies": {
-    "@types/diff": "^7.0.1",
-    "@types/node": "^22.13.10",
+    "@types/diff": "^7.0.2",
+    "@types/node": "^22.15.17",
+    "dependent_package": "x",
     "diff": "^7.0.0",
     "dir-compare": "^5.0.0",
     "picocolors": "^1.1.1",
-    "wesl": "0.6.1"
+    "wesl": "0.6.2"
   },
   "scripts": {
     "echo": "echo",