@barefootjs/test 0.17.0 → 0.18.0

package/dist/index.js

@@ -187348,6 +187348,7 @@ function tsNodeToParsedExpr(node) {
 }
 var CALLBACK_METHODS = new Set([
   "filter",
+  "map",
   "every",
   "some",
   "find",
@@ -187436,6 +187437,7 @@ function convertNode(node, raw) {
       if (callee.property === "flat") {
         const depthNode = node.arguments[0];
         let flatDepth;
+        let depthExpr;
         if (depthNode === undefined) {
           flatDepth = 1;
         } else if (import_typescript.default.isIdentifier(depthNode) && depthNode.text === "Infinity") {
@@ -187448,16 +187450,23 @@ function convertNode(node, raw) {
             n = -Number(depthNode.operand.text);
           }
           if (n === undefined || Number.isNaN(n)) {
-            return {
-              kind: "unsupported",
-              raw,
-              reason: `\`.flat(depth)\` needs a literal integer or \`Infinity\` depth — a computed depth can't be resolved at template time. Use a literal depth, or pre-compute the value before the template.`
-            };
+            const parsedDepth = convertNode(depthNode, raw);
+            if (checkSupport(parsedDepth).supported) {
+              depthExpr = parsedDepth;
+              flatDepth = 1;
+            } else {
+              return {
+                kind: "unsupported",
+                raw,
+                reason: `\`.flat(depth)\` needs a literal integer, \`Infinity\`, or a supported dynamic depth expression — this depth can't be resolved. Use a literal depth, a supported expression (prop/signal/arithmetic), or pre-compute the value before the template.`
+              };
+            }
+          } else {
+            const truncated = Math.trunc(n);
+            flatDepth = truncated < 0 ? 0 : truncated;
           }
-          const truncated = Math.trunc(n);
-          flatDepth = truncated < 0 ? 0 : truncated;
         }
-        return { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
+        return depthExpr !== undefined ? { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth, depthExpr } : { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
       }
       if (callee.property === "toLowerCase") {
         return { kind: "array-method", method: "toLowerCase", object: callee.object, args };
@@ -188002,6 +188011,8 @@ function validateRestUsage(expr, restName, excludedTopKeys) {
         walk(e.object);
         for (const a of e.args)
           walk(a);
+        if (e.method === "flat" && e.depthExpr)
+          walk(e.depthExpr);
         return;
       case "literal":
       case "unsupported":
@@ -188087,6 +188098,8 @@ function collectIdentifiers(expr, out) {
     case "array-method":
       collectIdentifiers(expr.object, out);
       expr.args.forEach((e) => collectIdentifiers(e, out));
+      if (expr.method === "flat" && expr.depthExpr)
+        collectIdentifiers(expr.depthExpr, out);
       return;
     case "literal":
     case "regex":
@@ -188144,7 +188157,14 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
         return { kind: "array-literal", elements: e.elements.map(walk) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object), args: e.args.map(walk) };
       case "literal":
@@ -188241,6 +188261,11 @@ function checkSupport(expr) {
         if (!argSupport.supported)
           return argSupport;
       }
+      if (expr.method === "flat" && expr.depthExpr) {
+        const depthSupport = checkSupport(expr.depthExpr);
+        if (!depthSupport.supported)
+          return depthSupport;
+      }
       return { supported: true, level: "L2" };
     }
     case "call": {
@@ -188340,6 +188365,9 @@ function checkSupport(expr) {
       const leftSupport = checkSupport(expr.left);
       if (!leftSupport.supported)
         return leftSupport;
+      if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
+        return { supported: true, level: "L4" };
+      }
       const rightSupport = checkSupport(expr.right);
       if (!rightSupport.supported)
         return rightSupport;
@@ -188534,7 +188562,10 @@ function usesPerPath(name, expr) {
       case "array-literal":
         return sum(e.elements);
       case "array-method":
-        return add(walk(e.object), e.method === "flat" ? { min: 0, max: 0 } : sum(e.args));
+        if (e.method === "flat") {
+          return add(walk(e.object), e.depthExpr ? walk(e.depthExpr) : { min: 0, max: 0 });
+        }
+        return add(walk(e.object), sum(e.args));
       case "object-literal":
         return sum(e.properties.map((p) => p.value));
       case "arrow":
@@ -188589,7 +188620,14 @@ function inlineBinding(expr, name, value) {
         return { kind: "array-literal", elements: e.elements.map((el) => walk(el, enclosing)) };
       case "array-method":
         if (e.method === "flat") {
-          return { kind: "array-method", method: "flat", object: walk(e.object, enclosing), args: [], flatDepth: e.flatDepth };
+          return {
+            kind: "array-method",
+            method: "flat",
+            object: walk(e.object, enclosing),
+            args: [],
+            flatDepth: e.flatDepth,
+            ...e.depthExpr ? { depthExpr: walk(e.depthExpr, enclosing) } : {}
+          };
         }
         return { kind: "array-method", method: e.method, object: walk(e.object, enclosing), args: e.args.map((a) => walk(a, enclosing)) };
       case "object-literal":
@@ -188725,6 +188763,9 @@ function stringifyParsedExpr(expr) {
       return `[${expr.elements.map(stringifyParsedExpr).join(", ")}]`;
     case "array-method":
       if (expr.method === "flat") {
+        if (expr.depthExpr) {
+          return `${stringifyParsedExpr(expr.object)}.flat(${stringifyParsedExpr(expr.depthExpr)})`;
+        }
         const d = expr.flatDepth;
         const depthSrc = d === "infinity" ? "Infinity" : String(d);
         return `${stringifyParsedExpr(expr.object)}.flat(${d === 1 ? "" : depthSrc})`;
@@ -189329,6 +189370,15 @@ function createAnalyzerContext(sourceFile, filePath) {
     checker: null,
     componentBodyBlock: null,
     getJS(node) {
+      let ownSourceFile;
+      try {
+        ownSourceFile = node.getSourceFile();
+      } catch {
+        ownSourceFile = undefined;
+      }
+      if (ownSourceFile && ownSourceFile !== sourceFile) {
+        return node.getText(ownSourceFile);
+      }
       return reconstructWithoutTypes(node, sourceFile, this.typeExcludeRanges);
     }
   };
@@ -191305,6 +191355,7 @@ function extractProps(param, ctx) {
       loc: getSourceLocation(param, ctx.sourceFile, ctx.filePath),
       hasIgnoreDirective: ignored
     };
+    const memberTypes = param.type ? collectMemberTypes(param.type, ctx) : null;
     for (const element of param.name.elements) {
       if (import_typescript8.default.isBindingElement(element) && import_typescript8.default.isIdentifier(element.name)) {
         const localName = element.name.text;
@@ -191313,10 +191364,12 @@ function extractProps(param, ctx) {
           ctx.restPropsName = localName;
           continue;
         }
+        const sourcePropName = element.propertyName && import_typescript8.default.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
+        const resolvedType = memberTypes?.get(sourcePropName) ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false;
         ctx.propsParams.push({
           name: localName,
-          type: { kind: "unknown", raw: "unknown" },
+          type: resolvedType,
           optional: !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined
@@ -191377,6 +191430,37 @@ function collectKeysFromMembers(members, ctx) {
   }
   return keys;
 }
+function collectMemberTypes(typeNode, ctx) {
+  const isResolvablePrimitive = (info) => info.kind === "primitive" && (info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean");
+  const fromMembers = (members) => {
+    const map = new Map;
+    for (const member of members) {
+      if (import_typescript8.default.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
+        const info = typeNodeToTypeInfo(member.type, ctx.sourceFile);
+        if (info && isResolvablePrimitive(info)) {
+          map.set(member.name.getText(ctx.sourceFile), info);
+        }
+      }
+    }
+    return map;
+  };
+  if (import_typescript8.default.isTypeLiteralNode(typeNode)) {
+    return fromMembers(typeNode.members);
+  }
+  if (import_typescript8.default.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(ctx.sourceFile);
+    const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile);
+    if (!typeDecl)
+      return null;
+    if (import_typescript8.default.isInterfaceDeclaration(typeDecl)) {
+      return fromMembers(typeDecl.members);
+    }
+    if (import_typescript8.default.isTypeAliasDeclaration(typeDecl) && import_typescript8.default.isTypeLiteralNode(typeDecl.type)) {
+      return fromMembers(typeDecl.type.members);
+    }
+  }
+  return null;
+}
 function extractPropsFromType(typeNode, ctx) {
   if (import_typescript8.default.isTypeLiteralNode(typeNode)) {
     extractPropsFromTypeMembers(typeNode.members, ctx);
@@ -192033,6 +192117,38 @@ var AttrValueOf = {
   }
 };
 
+// ../jsx/src/module-exports.ts
+function formatParamWithType(p) {
+  const rest = p.isRest ? "..." : "";
+  const optional = p.optional ? "?" : "";
+  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
+  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
+  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
+}
+function findReachableNames(primaryRefs, declarations) {
+  const allNames = new Set(declarations.map((d) => d.name));
+  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
+  const reachable = new Set;
+  const queue = [];
+  for (const name of allNames) {
+    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
+      reachable.add(name);
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const body = bodyMap.get(current) || "";
+    for (const name of allNames) {
+      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
+        reachable.add(name);
+        queue.push(name);
+      }
+    }
+  }
+  return reachable;
+}
+
 // ../jsx/src/builtins.ts
 var CLIENT_BUILTIN_SOURCE = "@barefootjs/client";
 function isClientBuiltinName(name) {
@@ -193140,6 +193256,7 @@ function transformExpression(node, ctx) {
   return transformExpressionInner(expr, ctx, node, isClientOnly);
 }
 function transformExpressionInner(expr, ctx, node, isClientOnly) {
+  expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
   checkBareSignalOrMemoIdentifier(expr, ctx);
   if (import_typescript11.default.isIdentifier(expr)) {
     const jsxNode = ctx.analyzer.jsxConstants.get(expr.text);
@@ -193681,11 +193798,10 @@ function isIteratorShapeCall(node) {
   return { array: node.expression.expression, shape: name };
 }
 function extractSortComparator(callback, _method, ctx) {
-  const unsupported = () => {
-    const raw = ctx.getJS(callback);
-    return {
-      result: null,
-      unsupportedReason: `Sort comparator '${raw}' is not a supported shape. Accepted:
+  const outerRaw = ctx.getJS(callback);
+  const unsupported = () => ({
+    result: null,
+    unsupportedReason: `Sort comparator '${outerRaw}' is not a supported shape. Accepted:
 ` + `  (a, b) => a - b
 ` + `  (a, b) => a.field - b.field
 ` + `  (a, b) => a.localeCompare(b)
@@ -193693,15 +193809,25 @@ function extractSortComparator(callback, _method, ctx) {
 ` + `  (a, b) => a.field > b.field ? 1 : a.field < b.field ? -1 : 0
 ` + `  any of the above '||'-chained for multi-key tie-breaks
 ` + `(reverse the operands for descending order).`
-    };
-  };
-  if (!import_typescript11.default.isArrowFunction(callback) && !import_typescript11.default.isFunctionExpression(callback)) {
+  });
+  let resolvedNode = callback;
+  if (import_typescript11.default.isIdentifier(callback)) {
+    const resolved = resolveSortComparatorIdentifier(callback.text, ctx);
+    if (!resolved) {
+      return {
+        result: null,
+        unsupportedReason: `Sort comparator '${outerRaw}' could not be resolved to a local function — ` + `declare it in the same file or inline it.`
+      };
+    }
+    resolvedNode = resolved;
+  }
+  if (!import_typescript11.default.isArrowFunction(resolvedNode) && !import_typescript11.default.isFunctionExpression(resolvedNode)) {
     return {
       result: null,
       unsupportedReason: "Sort comparator must be an arrow function or function expression"
     };
   }
-  const arrow = tsNodeToParsedExpr(callback);
+  const arrow = tsNodeToParsedExpr(resolvedNode);
   if (arrow.kind !== "arrow" || arrow.params.length !== 2)
     return unsupported();
   if (sortComparatorFromArrow(arrow) === null)
@@ -193715,6 +193841,21 @@ function extractSortComparator(callback, _method, ctx) {
     }
   };
 }
+function resolveSortComparatorIdentifier(name, ctx) {
+  const constInfo = findLocalConst(name, ctx);
+  const fnInfo = findLocalFunction(name, ctx);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
 function extractFilterPredicate(callback, ctx) {
   if (!import_typescript11.default.isArrowFunction(callback))
     return { result: null };
@@ -193787,7 +193928,7 @@ function extractLoopParamBindings(pattern) {
   const appendDotAccess = (prefix, key) => {
     return isIdent(key) ? `${prefix}.${key}` : `${prefix}[${JSON.stringify(key)}]`;
   };
-  const walk = (p, prefix) => {
+  const walk = (p, prefix, segments) => {
     if (unsupported)
       return;
     if (import_typescript11.default.isArrayBindingPattern(p)) {
@@ -193804,15 +193945,17 @@ function extractLoopParamBindings(pattern) {
           bindings.push({
             name: el.name.text,
             path: prefix,
-            rest: { kind: "array", from: index }
+            rest: { kind: "array", from: index },
+            segments
           });
           return;
         }
         const path = `${prefix}[${index}]`;
+        const nextSegments = [...segments, { kind: "index", index }];
         if (import_typescript11.default.isIdentifier(el.name)) {
-          bindings.push({ name: el.name.text, path });
+          bindings.push({ name: el.name.text, path, segments: nextSegments });
         } else {
-          walk(el.name, path);
+          walk(el.name, path, nextSegments);
         }
       }
       return;
@@ -193829,7 +193972,8 @@ function extractLoopParamBindings(pattern) {
         bindings.push({
           name: el.name.text,
           path: prefix,
-          rest: { kind: "object", exclude: collectedKeys }
+          rest: { kind: "object", exclude: collectedKeys },
+          segments
         });
         return;
       }
@@ -193852,17 +193996,19 @@ function extractLoopParamBindings(pattern) {
         unsupported = true;
         return;
       }
-      collectedKeys.push({ key: keyText, isIdent: isIdent(keyText) });
+      const keyIsIdent = isIdent(keyText);
+      collectedKeys.push({ key: keyText, isIdent: keyIsIdent });
       const path = appendDotAccess(prefix, keyText);
+      const nextSegments = [...segments, { kind: "field", key: keyText, isIdent: keyIsIdent }];
       if (import_typescript11.default.isIdentifier(el.name)) {
-        bindings.push({ name: el.name.text, path });
+        bindings.push({ name: el.name.text, path, segments: nextSegments });
       } else {
-        walk(el.name, path);
+        walk(el.name, path, nextSegments);
       }
     }
   };
   if (import_typescript11.default.isArrayBindingPattern(pattern) || import_typescript11.default.isObjectBindingPattern(pattern)) {
-    walk(pattern, "");
+    walk(pattern, "", []);
     if (unsupported)
       return { unsupported: true };
     return bindings;
@@ -194631,6 +194777,7 @@ function getAttributeValue(attr, ctx) {
         expr = branchInit;
       }
     }
+    expr = tryDesugarInterleaveTaggedTemplate(expr, ctx);
     if (import_typescript11.default.isAwaitExpression(expr)) {
       ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
       return AttrValueOf.expression("undefined");
@@ -194766,6 +194913,14 @@ function findLocalConst(name, ctx) {
   const pool = fnScoped.length > 0 ? fnScoped : matches;
   return pool[pool.length - 1];
 }
+function findLocalFunction(name, ctx) {
+  const matches = ctx.analyzer.localFunctions.filter((f) => f.name === name);
+  if (matches.length === 0)
+    return;
+  const fnScoped = matches.filter((f) => !f.isModule);
+  const pool = fnScoped.length > 0 ? fnScoped : matches;
+  return pool[pool.length - 1];
+}
 function isDynamicTagLocal(name, ctx) {
   if (!hasDynamicTagBinding(name, ctx.sourceFile))
     return false;
@@ -194860,6 +195015,147 @@ function parseConstInitializerImpl(c) {
 function astText(node) {
   return node.getText(node.getSourceFile());
 }
+var functionInfoExprCache = new WeakMap;
+function parseFunctionInfoAsExpr(fn) {
+  const cached = functionInfoExprCache.get(fn);
+  if (cached !== undefined)
+    return cached;
+  const result = parseFunctionInfoAsExprImpl(fn);
+  functionInfoExprCache.set(fn, result);
+  return result;
+}
+function parseFunctionInfoAsExprImpl(fn) {
+  if (!fn.body)
+    return null;
+  const params = fn.typedParams !== undefined ? fn.typedParams : fn.params.map(formatParamWithType).join(", ");
+  const body = fn.typedBody ?? fn.body;
+  const wrapped = `const __bf_resolve_fn__ = function(${params}) ${body}`;
+  const sf = import_typescript11.default.createSourceFile("__bf_resolve_fn.ts", wrapped, import_typescript11.default.ScriptTarget.Latest, true, import_typescript11.default.ScriptKind.TS);
+  const stmt = sf.statements[0];
+  if (!stmt || !import_typescript11.default.isVariableStatement(stmt))
+    return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer)
+    return null;
+  return decl.initializer;
+}
+function tryDesugarInterleaveTaggedTemplate(expr, ctx) {
+  if (!import_typescript11.default.isTaggedTemplateExpression(expr))
+    return expr;
+  if (!import_typescript11.default.isIdentifier(expr.tag))
+    return expr;
+  const resolvedTag = resolveInterleaveTagIdentifier(expr.tag.text, ctx);
+  if (!resolvedTag)
+    return expr;
+  if (!isInterleaveTagFunction(resolvedTag))
+    return expr;
+  const rewritten = buildUntaggedTemplateLiteral(expr, ctx);
+  return rewritten ?? expr;
+}
+function resolveInterleaveTagIdentifier(name, ctx) {
+  const constInfo = findLocalConst(name, ctx);
+  const fnInfo = findLocalFunction(name, ctx);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
+function isInterleaveTagFunction(fn) {
+  if (!import_typescript11.default.isArrowFunction(fn) && !import_typescript11.default.isFunctionExpression(fn))
+    return false;
+  if (fn.parameters.length !== 2)
+    return false;
+  const [partsParam, argsParam] = fn.parameters;
+  if (!import_typescript11.default.isIdentifier(partsParam.name) || partsParam.dotDotDotToken)
+    return false;
+  if (!import_typescript11.default.isIdentifier(argsParam.name) || !argsParam.dotDotDotToken)
+    return false;
+  const parsed = tsNodeToParsedExpr(fn);
+  if (parsed.kind !== "arrow")
+    return false;
+  return isInterleaveReduceCall(parsed.body, partsParam.name.text, argsParam.name.text);
+}
+function isInterleaveReduceCall(body, partsName, argsName) {
+  if (body.kind !== "call" || body.args.length !== 2)
+    return false;
+  const { callee, args } = body;
+  if (callee.kind !== "member" || callee.computed || callee.property !== "reduce")
+    return false;
+  if (callee.object.kind !== "identifier" || callee.object.name !== partsName)
+    return false;
+  const [callback, init] = args;
+  if (init.kind !== "literal" || init.literalType !== "string" || init.value !== "")
+    return false;
+  if (callback.kind !== "arrow" || callback.params.length !== 3)
+    return false;
+  const [acc, p, i2] = callback.params;
+  return isInterleaveReduceCallbackBody(callback.body, acc, p, i2, argsName);
+}
+function isInterleaveReduceCallbackBody(body, acc, p, i2, argsName) {
+  if (body.kind !== "binary" || body.op !== "+")
+    return false;
+  const { left, right } = body;
+  if (left.kind !== "binary" || left.op !== "+")
+    return false;
+  if (left.left.kind !== "identifier" || left.left.name !== acc)
+    return false;
+  if (left.right.kind !== "identifier" || left.right.name !== p)
+    return false;
+  return isInterleaveSpanExpr(right, i2, argsName);
+}
+function isInterleaveSpanExpr(expr, i2, argsName) {
+  let inner = expr;
+  if (inner.kind === "call" && inner.args.length === 1 && inner.callee.kind === "identifier" && inner.callee.name === "String") {
+    inner = inner.args[0];
+  }
+  if (inner.kind !== "logical" || inner.op !== "??")
+    return false;
+  if (inner.right.kind !== "literal" || inner.right.literalType !== "string" || inner.right.value !== "") {
+    return false;
+  }
+  const idx = inner.left;
+  if (idx.kind !== "index-access")
+    return false;
+  if (idx.object.kind !== "identifier" || idx.object.name !== argsName)
+    return false;
+  if (idx.index.kind !== "identifier" || idx.index.name !== i2)
+    return false;
+  return true;
+}
+function buildUntaggedTemplateLiteral(node, ctx) {
+  const template = node.template;
+  let text;
+  if (import_typescript11.default.isNoSubstitutionTemplateLiteral(template)) {
+    text = "`" + (template.rawText ?? template.text) + "`";
+  } else {
+    let body = template.head.rawText ?? template.head.text;
+    for (const span of template.templateSpans) {
+      const spanText = ctx.getJS(span.expression);
+      body += "${(" + spanText + ") ?? ''}";
+      body += span.literal.rawText ?? span.literal.text;
+    }
+    text = "`" + body + "`";
+  }
+  const wrapped = `const __bf_resolve_tagged__ = (${text})`;
+  const sf = import_typescript11.default.createSourceFile("__bf_resolve_tagged.tsx", wrapped, import_typescript11.default.ScriptTarget.Latest, true, import_typescript11.default.ScriptKind.TSX);
+  const stmt = sf.statements[0];
+  if (!stmt || !import_typescript11.default.isVariableStatement(stmt))
+    return null;
+  const decl = stmt.declarationList.declarations[0];
+  if (!decl?.initializer)
+    return null;
+  const result = import_typescript11.default.isParenthesizedExpression(decl.initializer) ? decl.initializer.expression : decl.initializer;
+  if (!import_typescript11.default.isTemplateExpression(result) && !import_typescript11.default.isNoSubstitutionTemplateLiteral(result))
+    return null;
+  return result;
+}
 function parseTernary(expr, ctx) {
   const whenTrueValue = getStringValue(expr.whenTrue);
   const whenFalseValue = getStringValue(expr.whenFalse);
@@ -195335,6 +195631,18 @@ var import_typescript12 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/relocate.ts
 var import_typescript13 = __toESM(require_typescript(), 1);
+
+// ../jsx/src/lowering-registry.ts
+var plugins = [];
+function registerLoweringPlugin(plugin) {
+  const existing = plugins.findIndex((p) => p.name === plugin.name);
+  if (existing >= 0)
+    plugins[existing] = plugin;
+  else
+    plugins.push(plugin);
+}
+
+// ../jsx/src/relocate.ts
 var REGISTRY_SAFE_BINDING_KINDS = new Set([
   "global",
   "module-import",
@@ -195464,6 +195772,9 @@ var JS_BUILTINS = new Set([
 var ENV_SIGNAL_CLIENT_FACTORY = {
   search: "createSearchParams"
 };
+var ENV_SIGNAL_READERS = new Map([
+  ["search", { key: "search", canonicalName: "searchParams", methods: new Set(["get"]) }]
+]);
 function queryHrefLocalNames(metadata) {
   const names = new Set;
   for (const imp of metadata.imports) {
@@ -195629,38 +195940,6 @@ class SourceMapGenerator {
   }
 }
 
-// ../jsx/src/module-exports.ts
-function formatParamWithType(p) {
-  const rest = p.isRest ? "..." : "";
-  const optional = p.optional ? "?" : "";
-  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
-  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
-  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
-}
-function findReachableNames(primaryRefs, declarations) {
-  const allNames = new Set(declarations.map((d) => d.name));
-  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
-  const reachable = new Set;
-  const queue = [];
-  for (const name of allNames) {
-    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
-      reachable.add(name);
-      queue.push(name);
-    }
-  }
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const body = bodyMap.get(current) || "";
-    for (const name of allNames) {
-      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
-        reachable.add(name);
-        queue.push(name);
-      }
-    }
-  }
-  return reachable;
-}
-
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
 var import_typescript15 = __toESM(require_typescript(), 1);
 
@@ -195668,9 +195947,12 @@ var import_typescript15 = __toESM(require_typescript(), 1);
 var import_typescript16 = __toESM(require_typescript(), 1);
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
+
+// ../jsx/src/augment-inherited-props.ts
+var import_typescript17 = __toESM(require_typescript(), 1);
 // ../jsx/src/shared-program.ts
 init_path();
-var import_typescript17 = __toESM(require_typescript(), 1);
+var import_typescript18 = __toESM(require_typescript(), 1);
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
   renderChildren(children) {
@@ -196156,15 +196438,6 @@ function isOmitBranch(node) {
   }
   return false;
 }
-// ../jsx/src/lowering-registry.ts
-var plugins = [];
-function registerLoweringPlugin(plugin) {
-  const existing = plugins.findIndex((p) => p.name === plugin.name);
-  if (existing >= 0)
-    plugins[existing] = plugin;
-  else
-    plugins.push(plugin);
-}
 // ../jsx/src/builtin-lowering-plugins.ts
 var queryHrefPlugin = {
   name: "queryHref",
@@ -196184,9 +196457,9 @@ function registerBuiltinLoweringPlugins() {
     registerLoweringPlugin(plugin);
 }
 // ../jsx/src/combine-client-js.ts
-var import_typescript18 = __toESM(require_typescript(), 1);
-// ../jsx/src/debug.ts
 var import_typescript19 = __toESM(require_typescript(), 1);
+// ../jsx/src/debug.ts
+var import_typescript20 = __toESM(require_typescript(), 1);
 function escapeForIdBoundary(name) {
   return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -196278,8 +196551,6 @@ function resolveSetters(handler, setterToSignal, fnSetters) {
   return refs;
 }
 // ../jsx/src/profiler.ts
-var import_typescript20 = __toESM(require_typescript(), 1);
-// ../jsx/src/augment-inherited-props.ts
 var import_typescript21 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/index.ts
@@ -196378,6 +196649,7 @@ function irNodeToTestNode(node, constantMap, metadata) {
   const cmap = constantMap ?? new Map;
   const setterToSignal = new Map;
   const fnSetters = new Map;
+  const defaults = new Map;
   if (metadata) {
     for (const s of metadata.signals) {
       if (s.setter)
@@ -196386,8 +196658,24 @@ function irNodeToTestNode(node, constantMap, metadata) {
     for (const [k, v] of buildLocalFunctionSetterMap(metadata, setterToSignal)) {
       fnSetters.set(k, v);
     }
+    for (const p of metadata.propsParams) {
+      const lit = p.defaultValue !== undefined ? parseLiteralDefault(p.defaultValue) : null;
+      if (lit !== null)
+        defaults.set(p.name, lit);
+    }
   }
-  return convert(node, { cmap, setterToSignal, fnSetters });
+  return convert(node, { cmap, setterToSignal, fnSetters, defaults });
+}
+function parseLiteralDefault(js) {
+  const v = js.trim();
+  if (v.startsWith("'") && v.endsWith("'") && !v.slice(1, -1).includes("'") || v.startsWith('"') && v.endsWith('"') && !v.slice(1, -1).includes('"')) {
+    return v.slice(1, -1);
+  }
+  if (/^-?\d+(\.\d+)?$/.test(v))
+    return v;
+  if (v === "true" || v === "false")
+    return v;
+  return null;
 }
 function convert(node, ctx) {
   switch (node.type) {
@@ -196396,7 +196684,7 @@ function convert(node, ctx) {
     case "text":
       return convertText(node);
     case "expression":
-      return convertExpression(node);
+      return convertExpression(node, ctx);
     case "conditional":
       return convertConditional(node, ctx);
     case "loop":
@@ -196426,19 +196714,9 @@ function convertElement(node, ctx) {
   let dataState = null;
   let classes = [];
   for (const attr of node.attrs) {
-    const value = resolveAttrValue(attr);
+    const value = resolveAttrValue(attr, ctx);
     if (attr.name === "className" || attr.name === "class") {
-      if (typeof value === "string") {
-        const isDynamic = attr.value.kind === "expression" || attr.value.kind === "template" || attr.value.kind === "spread";
-        if (isDynamic && ctx.cmap.size > 0) {
-          const resolved = resolveClassValue(value, ctx.cmap);
-          if (resolved !== null) {
-            classes = resolved.split(/\s+/).filter(Boolean);
-            continue;
-          }
-        }
-        classes = value.split(/\s+/).filter(Boolean);
-      }
+      classes = collectClassTokens(attr.value, value, ctx);
       continue;
     }
     if (attr.name === "role") {
@@ -196501,12 +196779,13 @@ function convertText(node) {
     componentName: null
   });
 }
-function convertExpression(node) {
+function convertExpression(node, ctx) {
+  const text = ctx.defaults.get(node.expr.trim()) ?? node.expr;
   return new TestNode({
     tag: null,
     type: "expression",
     children: [],
-    text: node.expr,
+    text,
     props: {},
     classes: [],
     role: null,
@@ -196571,7 +196850,7 @@ function convertComponent(node, ctx) {
         props[prop.name] = prop.value.expr;
         break;
       case "template":
-        props[prop.name] = resolveTemplateAttr(prop.value);
+        props[prop.name] = resolveTemplateAttr(prop.value, ctx);
         break;
       case "boolean-shorthand":
       case "boolean-attr":
@@ -196711,41 +196990,69 @@ function refsToHandler(refs) {
   }
   return { setters, via };
 }
-function resolveClassValue(value, cmap) {
-  if (cmap.has(value)) {
-    return cmap.get(value);
+function splitClassTokens(value) {
+  return value.split(/\s+/).filter((t) => t && !t.includes("${"));
+}
+function collectClassTokens(attrValue, resolved, ctx) {
+  if (attrValue.kind === "template") {
+    const joined = attrValue.parts.map((part) => {
+      if (part.type === "string")
+        return substituteInterpolations(part.value, ctx);
+      if (part.type === "ternary")
+        return `${part.whenTrue} ${part.whenFalse}`;
+      return Object.values(part.cases).join(" ");
+    }).join("");
+    return splitClassTokens(joined);
+  }
+  if (typeof resolved !== "string")
+    return [];
+  const isDynamic = attrValue.kind === "expression" || attrValue.kind === "spread";
+  if (isDynamic) {
+    const value = resolveClassValue(resolved, ctx);
+    if (value !== null)
+      return splitClassTokens(value);
+  }
+  return splitClassTokens(resolved);
+}
+function substituteInterpolations(value, ctx) {
+  return value.replace(/\$\{([^}]+)\}/g, (raw, expr) => {
+    const trimmed = expr.trim();
+    return ctx.cmap.get(trimmed) ?? ctx.defaults.get(trimmed) ?? raw;
+  });
+}
+function resolveClassValue(value, ctx) {
+  if (ctx.cmap.has(value)) {
+    return ctx.cmap.get(value);
+  }
+  if (ctx.defaults.has(value)) {
+    return ctx.defaults.get(value);
   }
   if (value.startsWith("`") && value.endsWith("`")) {
-    const inner = value.slice(1, -1);
-    return inner.replace(/\$\{([^}]+)\}/g, (_, expr) => {
-      const trimmed = expr.trim();
-      return cmap.get(trimmed) ?? "";
-    });
+    return substituteInterpolations(value.slice(1, -1), ctx);
   }
   return null;
 }
-function resolveAttrValue(attr) {
+function resolveAttrValue(attr, ctx) {
   switch (attr.value.kind) {
     case "boolean-attr":
       return true;
     case "literal":
       return attr.value.value;
     case "expression":
-      return attr.value.expr;
     case "spread":
-      return attr.value.expr;
+      return ctx.defaults.get(attr.value.expr.trim()) ?? attr.value.expr;
     case "template":
-      return resolveTemplateAttr(attr.value);
+      return resolveTemplateAttr(attr.value, ctx);
     case "boolean-shorthand":
       return true;
     case "jsx-children":
       return null;
   }
 }
-function resolveTemplateAttr(tl) {
+function resolveTemplateAttr(tl, ctx) {
   return tl.parts.map((part) => {
     if (part.type === "string")
-      return part.value;
+      return substituteInterpolations(part.value, ctx);
     if (part.type === "ternary")
       return `{${part.condition}}`;
     return Object.values(part.cases).join(" ");

package/dist/ir-to-test-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir-to-test-node.d.ts","sourceRoot":"","sources":["../src/ir-to-test-node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAYN,UAAU,EACX,MAAM,iBAAiB,CAAA;AAMxB,OAAO,EAAE,QAAQ,EAAqB,MAAM,gBAAgB,CAAA;AAQ5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,UAAU,GAAG,QAAQ,CAajH"}
+{"version":3,"file":"ir-to-test-node.d.ts","sourceRoot":"","sources":["../src/ir-to-test-node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAYN,UAAU,EACX,MAAM,iBAAiB,CAAA;AAMxB,OAAO,EAAE,QAAQ,EAAqB,MAAM,gBAAgB,CAAA;AAU5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,EAAE,UAAU,GAAG,QAAQ,CAuBjH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Test utilities for BarefootJS - IR-based component testing without a browser",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "directory": "packages/test"
   },
   "dependencies": {
-    "@barefootjs/jsx": "0.17.0"
+    "@barefootjs/jsx": "0.18.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0"

package/src/ir-to-test-node.ts

@@ -30,12 +30,15 @@ interface ConvertContext {
   cmap: Map<string, string>
   setterToSignal: Map<string, string>
   fnSetters: Map<string, FnSetterResolution[]>
+  /** Prop name → literal destructure-default value (`{ size = 'md' }` → `size: 'md'`). */
+  defaults: Map<string, string>
 }
 
 export function irNodeToTestNode(node: IRNode, constantMap?: Map<string, string>, metadata?: IRMetadata): TestNode {
   const cmap = constantMap ?? new Map<string, string>()
   const setterToSignal = new Map<string, string>()
   const fnSetters = new Map<string, FnSetterResolution[]>()
+  const defaults = new Map<string, string>()
   if (metadata) {
     for (const s of metadata.signals) {
       if (s.setter) setterToSignal.set(s.setter, s.getter)
@@ -43,8 +46,35 @@ export function irNodeToTestNode(node: IRNode, constantMap?: Map<string, string>
     for (const [k, v] of buildLocalFunctionSetterMap(metadata, setterToSignal)) {
       fnSetters.set(k, v)
     }
+    // renderToTest models the component compiled with NO incoming props,
+    // so a literal destructure default IS the statically-known value of
+    // that prop (#2069). Non-literal defaults (arrows, objects, computed
+    // expressions) stay unresolved — surfacing a stale expression string
+    // would be worse than the raw reference.
+    for (const p of metadata.propsParams) {
+      const lit = p.defaultValue !== undefined ? parseLiteralDefault(p.defaultValue) : null
+      if (lit !== null) defaults.set(p.name, lit)
+    }
   }
-  return convert(node, { cmap, setterToSignal, fnSetters })
+  return convert(node, { cmap, setterToSignal, fnSetters, defaults })
+}
+
+/**
+ * Parse a `ParamInfo.defaultValue` JS-text into a plain string when it is
+ * a self-contained literal: quoted string, number, or boolean. Returns
+ * null for anything else.
+ */
+function parseLiteralDefault(js: string): string | null {
+  const v = js.trim()
+  if (
+    (v.startsWith("'") && v.endsWith("'") && !v.slice(1, -1).includes("'")) ||
+    (v.startsWith('"') && v.endsWith('"') && !v.slice(1, -1).includes('"'))
+  ) {
+    return v.slice(1, -1)
+  }
+  if (/^-?\d+(\.\d+)?$/.test(v)) return v
+  if (v === 'true' || v === 'false') return v
+  return null
 }
 
 function convert(node: IRNode, ctx: ConvertContext): TestNode {
@@ -54,7 +84,7 @@ function convert(node: IRNode, ctx: ConvertContext): TestNode {
     case 'text':
       return convertText(node)
     case 'expression':
-      return convertExpression(node)
+      return convertExpression(node, ctx)
     case 'conditional':
       return convertConditional(node, ctx)
     case 'loop':
@@ -90,20 +120,10 @@ function convertElement(node: IRElement, ctx: ConvertContext): TestNode {
   let classes: string[] = []
 
   for (const attr of node.attrs) {
-    const value = resolveAttrValue(attr)
+    const value = resolveAttrValue(attr, ctx)
 
     if (attr.name === 'className' || attr.name === 'class') {
-      if (typeof value === 'string') {
-        const isDynamic = attr.value.kind === 'expression' || attr.value.kind === 'template' || attr.value.kind === 'spread'
-        if (isDynamic && ctx.cmap.size > 0) {
-          const resolved = resolveClassValue(value, ctx.cmap)
-          if (resolved !== null) {
-            classes = resolved.split(/\s+/).filter(Boolean)
-            continue
-          }
-        }
-        classes = value.split(/\s+/).filter(Boolean)
-      }
+      classes = collectClassTokens(attr.value, value, ctx)
       continue
     }
 
@@ -178,12 +198,20 @@ function convertText(node: IRText): TestNode {
 // Expression
 // ---------------------------------------------------------------------------
 
-function convertExpression(node: IRExpression): TestNode {
+function convertExpression(node: IRExpression, ctx: ConvertContext): TestNode {
+  // A bare reference to a defaulted prop (`<div>{label}</div>` with
+  // `{ label = 'Hello' }`) resolves to its literal default, so
+  // `findByText('Hello')` sees the zero-props render (#2069). Prop refs
+  // are flagged reactive (they update on parent re-render), so this
+  // keys off defaults-map membership, not the reactive flag: signal /
+  // memo reads are call expressions (`count()`), never bare identifiers,
+  // and keep their source text — wiring is the assertion surface there.
+  const text = ctx.defaults.get(node.expr.trim()) ?? node.expr
   return new TestNode({
     tag: null,
     type: 'expression',
     children: [],
-    text: node.expr,
+    text,
     props: {},
     classes: [],
     role: null,
@@ -265,7 +293,7 @@ function convertComponent(node: IRComponent, ctx: ConvertContext): TestNode {
         props[prop.name] = prop.value.expr
         break
       case 'template':
-        props[prop.name] = resolveTemplateAttr(prop.value)
+        props[prop.name] = resolveTemplateAttr(prop.value, ctx)
         break
       case 'boolean-shorthand':
       case 'boolean-attr':
@@ -450,19 +478,77 @@ function refsToHandler(refs: SetterRef[]): EventHandler {
   return { setters, via }
 }
 
-function resolveClassValue(value: string, cmap: Map<string, string>): string | null {
-  // Simple identifier lookup
-  if (cmap.has(value)) {
-    return cmap.get(value)!
+/**
+ * Split a resolved className value into tokens, dropping any span that
+ * still carries an unresolved runtime interpolation (`${className}`,
+ * `foo-${x}`). Those are dynamic passthroughs the IR can't evaluate —
+ * they aren't real class tokens, and leaking them verbatim pollutes
+ * `.classes` for exact-match assertions.
+ */
+function splitClassTokens(value: string): string[] {
+  return value.split(/\s+/).filter(t => t && !t.includes('${'))
+}
+
+/**
+ * Resolve a className attribute value into its class tokens.
+ *
+ * For a structured template attr the parts are walked directly so class
+ * collection keeps union semantics per part kind:
+ *   - `lookup` (`${MAP[KEY]}`) → every case's tokens (PR #2000)
+ *   - `ternary` (`cond ? 'on' : 'off'`) → both branches' tokens,
+ *     matching the intermediate-const `valueBranches` union (#525)
+ *   - `string` spans → literal text, with `${ident}` interpolations
+ *     substituted from resolved consts / literal prop defaults
+ * For expression attrs the value resolves through local consts (cmap)
+ * and literal prop defaults. Anything still carrying a `${...}`
+ * interpolation is dropped by `splitClassTokens`.
+ */
+function collectClassTokens(attrValue: AttrValue, resolved: string | boolean | null, ctx: ConvertContext): string[] {
+  if (attrValue.kind === 'template') {
+    const joined = attrValue.parts
+      .map(part => {
+        if (part.type === 'string') return substituteInterpolations(part.value, ctx)
+        if (part.type === 'ternary') return `${part.whenTrue} ${part.whenFalse}`
+        return Object.values(part.cases).join(' ')
+      })
+      .join('')
+    return splitClassTokens(joined)
+  }
+
+  if (typeof resolved !== 'string') return []
+
+  const isDynamic = attrValue.kind === 'expression' || attrValue.kind === 'spread'
+  if (isDynamic) {
+    const value = resolveClassValue(resolved, ctx)
+    if (value !== null) return splitClassTokens(value)
+  }
+  return splitClassTokens(resolved)
+}
+
+/**
+ * Replace `${ident}` interpolations with a resolved const or a literal
+ * prop default; unresolvable spans are kept verbatim so the caller's
+ * token filter can drop them.
+ */
+function substituteInterpolations(value: string, ctx: ConvertContext): string {
+  return value.replace(/\$\{([^}]+)\}/g, (raw, expr) => {
+    const trimmed = expr.trim()
+    return ctx.cmap.get(trimmed) ?? ctx.defaults.get(trimmed) ?? raw
+  })
+}
+
+function resolveClassValue(value: string, ctx: ConvertContext): string | null {
+  // Simple identifier lookup: a local const or a literal prop default.
+  if (ctx.cmap.has(value)) {
+    return ctx.cmap.get(value)!
+  }
+  if (ctx.defaults.has(value)) {
+    return ctx.defaults.get(value)!
   }
 
   // Template literal: `...${var}...`
   if (value.startsWith('`') && value.endsWith('`')) {
-    const inner = value.slice(1, -1)
-    return inner.replace(/\$\{([^}]+)\}/g, (_, expr) => {
-      const trimmed = expr.trim()
-      return cmap.get(trimmed) ?? ''
-    })
+    return substituteInterpolations(value.slice(1, -1), ctx)
   }
 
   return null
@@ -472,18 +558,22 @@ function resolveClassValue(value: string, cmap: Map<string, string>): string | n
 // Attribute value resolution
 // ---------------------------------------------------------------------------
 
-function resolveAttrValue(attr: IRAttribute): string | boolean | null {
+function resolveAttrValue(attr: IRAttribute, ctx: ConvertContext): string | boolean | null {
   switch (attr.value.kind) {
     case 'boolean-attr':
       return true
     case 'literal':
       return attr.value.value
     case 'expression':
-      return attr.value.expr
     case 'spread':
-      return attr.value.expr
+      // A bare reference to a defaulted prop (`type={type}` with
+      // `{ type = 'button' }`) resolves to its literal default —
+      // renderToTest models the zero-props render, where the default
+      // IS the value (#2069). Anything non-bare keeps the expression
+      // text (the wiring-visible representation).
+      return ctx.defaults.get(attr.value.expr.trim()) ?? attr.value.expr
     case 'template':
-      return resolveTemplateAttr(attr.value)
+      return resolveTemplateAttr(attr.value, ctx)
     case 'boolean-shorthand':
       return true
     case 'jsx-children':
@@ -491,10 +581,12 @@ function resolveAttrValue(attr: IRAttribute): string | boolean | null {
   }
 }
 
-function resolveTemplateAttr(tl: TemplateAttr): string {
+function resolveTemplateAttr(tl: TemplateAttr, ctx: ConvertContext): string {
   return tl.parts
     .map(part => {
-      if (part.type === 'string') return part.value
+      // `${ident}` interpolations against a literal prop default
+      // resolve like local consts do (#2069).
+      if (part.type === 'string') return substituteInterpolations(part.value, ctx)
       if (part.type === 'ternary') return `{${part.condition}}`
       // `lookup` (`Record<T, string>[key]`) — the test framework
       // doesn't render against a specific key, so concatenate every