@barefootjs/erb 0.31.0 → 0.31.2

package/dist/index.js

@@ -189284,9 +189284,7 @@ var conformancePins = {
   "date-method-uncatalogued": [{ code: "BF021", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2356" }]
 };
 // src/render-divergences.ts
-var renderDivergences = {
-  "aliased-destructured-prop": "aliased destructured prop `{ n: count }` loses its rename — template vars, ssr-defaults, and the props bridge all key off the local name, so the prop is always undefined (https://github.com/piconic-ai/barefootjs/issues/2524)"
-};
+var renderDivergences = {};
 export {
   renderDivergences,
   erbAdapter,

package/dist/render-divergences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAoB/B,CAAA"}
+{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAM/B,CAAA"}

package/dist/vite.js

@@ -4,8 +4,11 @@ import { dirname, resolve } from "node:path";
 import { barefoot as coreBarefoot } from "@barefootjs/vite";
 import { devModuleUrl, loadManifest, resolveDevOrigin, resolveScriptAssets, toPosixRelative } from "@barefootjs/vite";
 
+// ../jsx/src/compiler.ts
+import ts23 from "typescript";
+
 // ../jsx/src/analyzer.ts
-import ts8 from "typescript";
+import ts9 from "typescript";
 
 // ../jsx/src/expression-parser.ts
 import ts from "typescript";
@@ -1922,6 +1925,29 @@ import ts5 from "typescript";
 // ../jsx/src/ir-to-client-js/utils.ts
 import ts3 from "typescript";
 
+// ../jsx/src/template-parts.ts
+function lookupPartToJsExpr(part, opts) {
+  const key = opts?.useTemplate && part.templateKey ? part.templateKey : part.key;
+  const obj = "{" + Object.entries(part.cases).map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`).join(", ") + "}";
+  const typed = opts?.typed ? " as Record<string, string>" : "";
+  return `(${obj}${typed})[${key}]`;
+}
+function templatePartsToJsExpr(parts, opts) {
+  let result = "`";
+  for (const part of parts) {
+    if (part.type === "string") {
+      result += opts?.useTemplate && part.templateValue ? part.templateValue : part.value;
+    } else if (part.type === "ternary") {
+      const cond = opts?.useTemplate && part.templateCondition ? part.templateCondition : part.condition;
+      result += `\${${cond} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
+    } else if (part.type === "lookup") {
+      result += `\${${lookupPartToJsExpr(part, opts)}}`;
+    }
+  }
+  result += "`";
+  return result;
+}
+
 // ../jsx/src/scanner/js-scanner.ts
 import ts2 from "typescript";
 
@@ -2023,6 +2049,16 @@ function escapeHtml(text) {
 }
 // ../jsx/src/ir-to-client-js/csr-substitute.ts
 import ts4 from "typescript";
+function extractFreeIdentifiersFromText(text) {
+  if (!text || text.trim().length === 0)
+    return new Set;
+  const sf = ts4.createSourceFile("__free_ids__.ts", `(${text});`, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts4.isExpressionStatement(stmt))
+    return new Set;
+  const expr = ts4.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  return extractFreeIdentifiersFromNode(expr);
+}
 
 // ../jsx/src/adapters/child-scope.ts
 function derivesScopeFromSlot(comp) {
@@ -2073,6 +2109,27 @@ var SKELETON_PATH_FORCE_CLOSE_GROUPS = [
   new Set(["li"])
 ];
 
+// ../jsx/src/props-binding.ts
+import ts6 from "typescript";
+function isIdentifierName(key) {
+  if (key.length === 0)
+    return false;
+  for (let i = 0;i < key.length; ) {
+    const cp = key.codePointAt(i);
+    const ok = i === 0 ? ts6.isIdentifierStart(cp, ts6.ScriptTarget.Latest) : ts6.isIdentifierPart(cp, ts6.ScriptTarget.Latest);
+    if (!ok)
+      return false;
+    i += cp > 65535 ? 2 : 1;
+  }
+  return true;
+}
+function propsDestructureBinding(p) {
+  const callerKey = p.sourceName ?? p.name;
+  const localName = p.name;
+  const binding = callerKey === localName ? localName : `${isIdentifierName(callerKey) ? callerKey : JSON.stringify(callerKey)}: ${localName}`;
+  return p.defaultValue ? `${binding} = ${p.defaultValue}` : binding;
+}
+
 // ../jsx/src/instrumentation.ts
 var _counters = freshCounters();
 function freshCounters() {
@@ -2086,14 +2143,14 @@ function freshCounters() {
 }
 
 // ../jsx/src/analyzer-context.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 
 // ../jsx/src/strip-types.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 
 // ../jsx/src/analyzer-context.ts
-var _typePrinter = ts7.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-var _blankTypeSourceFile = ts7.createSourceFile("__bf_types__.ts", "", ts7.ScriptTarget.Latest);
+var _typePrinter = ts8.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+var _blankTypeSourceFile = ts8.createSourceFile("__bf_types__.ts", "", ts8.ScriptTarget.Latest);
 
 // ../jsx/src/errors.ts
 var ErrorCodes = {
@@ -2109,6 +2166,7 @@ var ErrorCodes = {
   JSX_IN_LOCAL_FUNCTION: "BF045",
   COMPONENT_REQUIRED_PROP_MISSING: "BF046",
   JSX_BRANCH_LOCAL_IN_CALLBACK: "BF047",
+  SIBLING_COMPONENT_NOT_COMPILED: "BF048",
   SHARED_PROGRAM_REQUIRED: "BF050",
   WRONG_PACKAGE_IMPORT: "BF051",
   BUILTIN_REQUIRES_IMPORT: "BF054",
@@ -2138,6 +2196,7 @@ var errorMessages = {
   [ErrorCodes.JSX_IN_LOCAL_FUNCTION]: "Local function returns JSX but cannot be inlined. Extract it as a top-level PascalCase component or use a single return statement.",
   [ErrorCodes.COMPONENT_REQUIRED_PROP_MISSING]: "Built-in component is missing a required prop.",
   [ErrorCodes.JSX_BRANCH_LOCAL_IN_CALLBACK]: "JSX-typed local declared inside an `if`-block cannot be referenced from a callback body (ref / event handler). " + "Render it as a child instead: `<div ref={...}>{local}</div>`.",
+  [ErrorCodes.SIBLING_COMPONENT_NOT_COMPILED]: "Referenced component did not compile to a template, so this reference would throw " + "`ReferenceError` at render time. Multi-return JSX dispatch (a `switch` or `if`/`else` " + "chain across multiple JSX-returning branches) cannot compile as a component in a " + `'use client' file. Extract it to a separate non-"use client" file (where it is preserved ` + "verbatim, see #932), or rewrite it as a single-return ternary/conditional chain so the " + "component pipeline can compile it.",
   [ErrorCodes.SHARED_PROGRAM_REQUIRED]: "Shared ts.Program required for type-based reactivity classification. This source imports a Reactive<T>-branded library (e.g. @barefootjs/form) whose getters cannot be classified by regex alone. Pass `options.program` (built via `createProgramForCorpus`) so the analyzer can resolve the brand through the TypeChecker.",
   [ErrorCodes.WRONG_PACKAGE_IMPORT]: "Import from wrong package.",
   [ErrorCodes.BUILTIN_REQUIRES_IMPORT]: "Built-in <Async> / <Region> must be imported from '@barefootjs/client'. " + "The compiler recognises these tags by their import (not by tag name), " + "so an unimported tag with this name is treated as an undeclared component.",
@@ -2311,6 +2370,54 @@ var CLIENT_EXPORTS = new Set([
   "Async",
   "Region"
 ]);
+function extractFreeIdentifiersFromNode(node) {
+  const ids = new Set;
+  const boundNames = new Set;
+  function addBindingNames(name, out) {
+    if (ts9.isIdentifier(name))
+      out.push(name.text);
+    else if (ts9.isObjectBindingPattern(name))
+      name.elements.forEach((e) => addBindingNames(e.name, out));
+    else if (ts9.isArrayBindingPattern(name))
+      name.elements.forEach((e) => {
+        if (!ts9.isOmittedExpression(e))
+          addBindingNames(e.name, out);
+      });
+  }
+  function visit(n) {
+    if (ts9.isTypeNode(n))
+      return;
+    if (ts9.isIdentifier(n)) {
+      const parent = n.parent;
+      if (parent && ts9.isPropertyAccessExpression(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isPropertyAssignment(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isParameter(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isVariableDeclaration(parent) && parent.name === n)
+        return;
+      if (boundNames.has(n.text))
+        return;
+      ids.add(n.text);
+      return;
+    }
+    if (ts9.isArrowFunction(n)) {
+      const params = [];
+      for (const p of n.parameters)
+        addBindingNames(p.name, params);
+      for (const name of params)
+        boundNames.add(name);
+      ts9.forEachChild(n, visit);
+      for (const name of params)
+        boundNames.delete(name);
+      return;
+    }
+    ts9.forEachChild(n, visit);
+  }
+  visit(node);
+  return ids;
+}
 var BROWSER_ONLY_CLIENT_APIS = new Set([
   "useContext",
   "provideContext",
@@ -2329,7 +2436,7 @@ var REACTIVE_PRIMITIVES = new Set([
 ]);
 
 // ../jsx/src/jsx-to-ir.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 
 // ../jsx/src/types.ts
 var SCOPE_FORBIDDEN = {
@@ -2411,10 +2518,10 @@ function findReachableNames(primaryRefs, declarations) {
 }
 
 // ../jsx/src/reactivity-checker.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // ../jsx/src/free-refs.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 var _bindingMapCache = new WeakMap;
 
 // ../jsx/src/to-locale-date-lowering.ts
@@ -2828,13 +2935,13 @@ var KEYWORDS_AND_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 // ../jsx/src/value-references.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 
 // ../jsx/src/relocate.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // ../jsx/src/lowering-registry.ts
 var plugins = [];
@@ -3051,10 +3158,10 @@ function matchSearchParamsMethodCall(callee, args, localNames) {
 }
 
 // ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -3104,7 +3211,7 @@ var INERT_BINDING_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts
 var NON_BUBBLING_EVENTS = new Set([
@@ -3119,7 +3226,7 @@ var NON_BUBBLING_EVENTS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 
 // ../jsx/src/ir-to-client-js/source-map.ts
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -3210,15 +3317,15 @@ class SourceMapGenerator {
 }
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 
 // ../jsx/src/ssr-defaults.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 
 // ../jsx/src/augment-inherited-props.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -3250,47 +3357,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
+  if (!expr || !ts22.isCallExpression(expr))
     return null;
-  if (!ts21.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts22.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts21.isIdentifier(arg) ? arg.text : null;
+  return ts22.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
+  if (!expr || !ts22.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
+  if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts21.isNumericLiteral(arg))
+  if (ts22.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts21.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts22.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts21.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts22.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
+  if (!expr || !ts22.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts21.isObjectLiteralExpression(expr.arguments[0]);
+  return ts22.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts21.createSourceFile("__ctx.ts", `(${source})`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__ctx.ts", `(${source})`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isExpressionStatement(stmt))
+  if (!stmt || !ts22.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts21.isParenthesizedExpression(e))
+  while (ts22.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -3315,25 +3422,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts21.createSourceFile("__aug.ts", `(${s})`, ts21.ScriptTarget.Latest, false);
+    const sf = ts22.createSourceFile("__aug.ts", `(${s})`, ts22.ScriptTarget.Latest, false);
     const visit = (n) => {
-      if (ts21.isBinaryExpression(n) && (n.operatorToken.kind === ts21.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts21.SyntaxKind.BarBarToken)) {
+      if (ts22.isBinaryExpression(n) && (n.operatorToken.kind === ts22.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts22.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts21.isParenthesizedExpression(left))
+        while (ts22.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts21.isPropertyAccessExpression(left) && ts21.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts22.isPropertyAccessExpression(left) && ts22.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts21.isParenthesizedExpression(right))
+          while (ts22.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts21.isPrefixUnaryExpression(right))
+          if (ts22.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts21.isNumericLiteral(right) ? "number" : right.kind === ts21.SyntaxKind.TrueKeyword || right.kind === ts21.SyntaxKind.FalseKeyword ? "boolean" : ts21.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts22.isNumericLiteral(right) ? "number" : right.kind === ts22.SyntaxKind.TrueKeyword || right.kind === ts22.SyntaxKind.FalseKeyword ? "boolean" : ts22.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts21.forEachChild(n, visit);
+      ts22.forEachChild(n, visit);
     };
     visit(sf);
   };
@@ -3444,33 +3551,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__const.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
+  if (!stmt || !ts22.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts21.isParenthesizedExpression(init))
+  while (init && ts22.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts21.isStringLiteral(init) || ts21.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts22.isStringLiteral(init) || ts22.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__const.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
+  if (!stmt || !ts22.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts21.isParenthesizedExpression(init))
+  while (init && ts22.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts21.isTemplateExpression(init))
+  if (!init || !ts22.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts21.isIdentifier(span.expression))
+    if (!ts22.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -3501,30 +3608,30 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
+  const sf = ts22.createSourceFile("__rec.ts", `(${constInfo.value})`, ts22.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts21.isExpressionStatement(stmt))
+  if (!ts22.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts21.isParenthesizedExpression(parsed))
+  while (ts22.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts21.isObjectLiteralExpression(parsed))
+  if (!ts22.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts21.isPropertyAssignment(prop))
+    if (!ts22.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts21.isIdentifier(name) || ts21.isStringLiteral(name) || ts21.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts22.isIdentifier(name) || ts22.isStringLiteral(name) || ts22.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts21.isParenthesizedExpression(v))
+    while (ts22.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts21.isNumericLiteral(v))
+    if (ts22.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -3532,28 +3639,28 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts21.createSourceFile("__join.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__join.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
+  if (!stmt || !ts22.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts21.isParenthesizedExpression(node))
+  while (node && ts22.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts21.isCallExpression(node))
+  if (!node || !ts22.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts21.isPropertyAccessExpression(callee))
+  if (!ts22.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts21.isParenthesizedExpression(recv))
+  while (ts22.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts21.isArrayLiteralExpression(recv))
+  if (!ts22.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts21.isStringLiteral(el) || ts21.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts22.isStringLiteral(el) || ts22.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -3562,7 +3669,7 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
+    if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg))
       sep = arg.text;
     else
       return null;
@@ -3570,11 +3677,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts21.isElementAccessExpression(val))
+  if (!ts22.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts21.isIdentifier(obj) || !ts21.isIdentifier(arg))
+  if (!ts22.isIdentifier(obj) || !ts22.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -3590,35 +3697,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
+  const sf = ts22.createSourceFile("__rec.ts", `(${constInfo.value})`, ts22.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts21.isExpressionStatement(stmt))
+  if (!ts22.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts21.isParenthesizedExpression(parsed))
+  while (ts22.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts21.isObjectLiteralExpression(parsed))
+  if (!ts22.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts21.isPropertyAssignment(prop))
+    if (!ts22.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts21.isIdentifier(prop.name)) {
+    if (ts22.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts21.isStringLiteral(prop.name) || ts21.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts22.isStringLiteral(prop.name) || ts22.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts21.isParenthesizedExpression(v))
+    while (ts22.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts21.isNumericLiteral(v)) {
+    if (ts22.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -3674,7 +3781,7 @@ function computeSsrSeedPlan(metadata) {
 // ../jsx/src/rich-type-refusal.ts
 var EMPTY_BINDINGS2 = new Map;
 // ../jsx/src/shared-program.ts
-import ts22 from "typescript";
+import ts24 from "typescript";
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
   renderChildren(children) {
@@ -3750,7 +3857,7 @@ class JsxAdapter extends BaseAdapter {
       }
       const rawInitialValue = preserveTypes ? signal.typedInitialValue ?? signal.initialValue : signal.initialValue;
       const initialValue = rawInitialValue.trim().startsWith("{") ? `(${rawInitialValue})` : rawInitialValue;
-      const needsTypeAssertion = preserveTypes && !signal.typedInitialValue && signal.type.kind !== "unknown" && signal.type.kind !== "primitive";
+      const needsTypeAssertion = preserveTypes && !signal.typedInitialValue && signal.type.kind !== "unknown" && signal.type.kind !== "primitive" && signal.type.raw !== "object";
       if (needsTypeAssertion) {
         lines.push(`  const ${signal.getter} = () => ${initialValue} as ${signal.type.raw}`);
       } else {
@@ -3769,12 +3876,16 @@ class JsxAdapter extends BaseAdapter {
       const computation = preserveTypes ? memo.typedComputation ?? memo.computation : memo.computation;
       lines.push(`  const ${memo.name} = ${computation}`);
     }
+    const moduleScopeNames = this.moduleScopeDeclarationNames(ir);
     for (const constant of ir.metadata.localConstants) {
       if (constant.isExported)
         continue;
+      if (moduleScopeNames.has(constant.name))
+        continue;
       const keyword = constant.declarationKind ?? "const";
       if (!constant.value) {
-        lines.push(`  ${keyword} ${constant.name}`);
+        const typeAnnotation = preserveTypes && constant.type ? `: ${constant.type.raw}` : "";
+        lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`);
         continue;
       }
       const value = constant.value.trim();
@@ -3786,6 +3897,8 @@ class JsxAdapter extends BaseAdapter {
       lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
     }
     for (const func of localFunctions) {
+      if (moduleScopeNames.has(func.name))
+        continue;
       if (!reachable.has(func.name))
         continue;
       const params = preserveTypes && func.typedParams !== undefined ? func.typedParams : func.params.map(formatParamWithType).join(", ");
@@ -3795,6 +3908,125 @@ class JsxAdapter extends BaseAdapter {
       lines.push(`  ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body}`);
     }
     return lines.join(`
+`);
+  }
+  moduleScopeNamesCache = new WeakMap;
+  moduleScopeDeclarationNames(ir) {
+    const cached = this.moduleScopeNamesCache.get(ir);
+    if (cached)
+      return cached;
+    const componentScope = new Set;
+    for (const sig of ir.metadata.signals) {
+      if (sig.isModule)
+        continue;
+      componentScope.add(sig.getter);
+      if (sig.setter)
+        componentScope.add(sig.setter);
+    }
+    for (const memo of ir.metadata.memos) {
+      if (!memo.isModule)
+        componentScope.add(memo.name);
+    }
+    for (const p of ir.metadata.propsParams)
+      componentScope.add(p.name);
+    if (ir.metadata.propsObjectName)
+      componentScope.add(ir.metadata.propsObjectName);
+    if (ir.metadata.restPropsName)
+      componentScope.add(ir.metadata.restPropsName);
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule)
+        componentScope.add(c.name);
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule)
+        componentScope.add(f.name);
+    }
+    const exported = new Set;
+    const candidates = new Map;
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule)
+        continue;
+      if (c.isJsx || c.isJsxFunction)
+        continue;
+      if (c.isExported) {
+        exported.add(c.name);
+        continue;
+      }
+      candidates.set(c.name, c.freeIdentifiers ?? extractFreeIdentifiersFromText(c.value ?? ""));
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule)
+        continue;
+      if (f.isJsxFunction || f.isMultiReturnJsxHelper)
+        continue;
+      if (f.isExported) {
+        exported.add(f.name);
+        continue;
+      }
+      const params = f.typedParams !== undefined ? f.typedParams : f.params.map(formatParamWithType).join(", ");
+      candidates.set(f.name, extractFreeIdentifiersFromText(`(${params}) => ${f.body}`));
+    }
+    const referencesAny = (refs, names) => {
+      for (const ref of refs) {
+        if (names.has(ref))
+          return true;
+      }
+      return false;
+    };
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const [name, refs] of candidates) {
+        if (referencesAny(refs, componentScope)) {
+          candidates.delete(name);
+          componentScope.add(name);
+          changed = true;
+        }
+      }
+    }
+    const result = new Set([...exported, ...candidates.keys()]);
+    this.moduleScopeNamesCache.set(ir, result);
+    return result;
+  }
+  generateModuleScopeDeclarations(ir) {
+    const { preserveTypes } = this.jsxConfig;
+    const moduleNames = this.moduleScopeDeclarationNames(ir);
+    const entries = [];
+    for (const t of ir.metadata.typeDefinitions) {
+      entries.push({ line: t.loc.start.line, text: t.definition });
+    }
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule || !moduleNames.has(c.name))
+        continue;
+      const keyword = c.declarationKind ?? "const";
+      const exportKw = c.isExported ? "export " : "";
+      if (!c.value) {
+        entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}` });
+        continue;
+      }
+      const trimmed = c.value.trim();
+      if (/^new WeakMap\b/.test(trimmed))
+        continue;
+      if (c.isExported && /^createContext\b/.test(trimmed))
+        continue;
+      const value = preserveTypes ? c.typedValue ?? c.value : c.value;
+      entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name} = ${value}` });
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule || !moduleNames.has(f.name))
+        continue;
+      const params = preserveTypes && f.typedParams !== undefined ? f.typedParams : f.params.map(formatParamWithType).join(", ");
+      const returnAnnotation = preserveTypes && f.typedReturnType ? `: ${f.typedReturnType}` : "";
+      const body = preserveTypes ? f.typedBody ?? f.body : f.body;
+      const asyncKw = f.isAsync ? "async " : "";
+      const exportKw = f.isExported ? "export " : "";
+      entries.push({
+        line: f.loc.start.line,
+        text: `${exportKw}${asyncKw}function ${f.name}(${params})${returnAnnotation} ${body}`
+      });
+    }
+    entries.sort((a, b) => a.line - b.line);
+    return entries.map((e) => e.text).join(`
 `);
   }
   renderNodeRaw(node) {
@@ -3806,6 +4038,15 @@ class JsxAdapter extends BaseAdapter {
     }
     return this.renderNode(node);
   }
+  renderTemplatePartsAsJs(parts) {
+    return templatePartsToJsExpr(parts, { typed: this.jsxConfig.preserveTypes });
+  }
+  expressionValueToJs(value) {
+    if (this.jsxConfig.preserveTypes && value.parts && value.expr === templatePartsToJsExpr(value.parts)) {
+      return this.renderTemplatePartsAsJs(value.parts);
+    }
+    return value.expr;
+  }
   renderScopeMarker(instanceIdExpr) {
     return `${BF_SCOPE}={${instanceIdExpr}}`;
   }
@@ -3873,6 +4114,7 @@ class TestAdapter extends JsxAdapter {
   generate(ir) {
     this.componentName = ir.metadata.componentName;
     const imports = this.generateImports(ir);
+    const moduleConstants = this.generateModuleScopeDeclarations(ir);
     const types = this.generateTypes(ir);
     const component = this.generateComponent(ir);
     const defaultExport = ir.metadata.hasDefaultExport ? `
@@ -3881,9 +4123,11 @@ export default ${this.componentName}` : "";
       imports,
       types: types || "",
       component,
-      defaultExport
+      defaultExport,
+      moduleConstants,
+      moduleConstantsIncludeExports: true
     };
-    const template = [imports, types, component].filter(Boolean).join(`
+    const template = [imports, moduleConstants, types, component].filter(Boolean).join(`
 
 `) + defaultExport;
     return {
@@ -3914,9 +4158,6 @@ export default ${this.componentName}` : "";
   }
   generateTypes(ir) {
     const lines = [];
-    for (const typeDef of ir.metadata.typeDefinitions) {
-      lines.push(typeDef.definition);
-    }
     const propsTypeName = ir.metadata.propsType?.raw;
     if (propsTypeName && !ir.metadata.propsObjectName) {
       lines.push("");
@@ -3939,7 +4180,7 @@ export default ${this.componentName}` : "";
     const bodyRefText = [jsxBody, signalInits, scopeIdLine].join(`
 `);
     const bfScopeAlias = /\b__bfScope\b/.test(bodyRefText) ? "__bfScope" : "__bfScope: _bfScope";
-    const propsParams = ir.metadata.propsParams.map((p) => p.defaultValue ? `${p.name} = ${p.defaultValue}` : p.name).join(", ");
+    const propsParams = ir.metadata.propsParams.map((p) => propsDestructureBinding(p)).join(", ");
     const restPropsName = ir.metadata.restPropsName;
     const hydrationProps = `__instanceId, ${bfScopeAlias}`;
     const parts = [];
@@ -4086,13 +4327,7 @@ export default ${this.componentName}` : "";
   }
   flattenTemplate(value) {
     const v = value;
-    return "`" + v.parts.map((p) => {
-      if (p.type === "string")
-        return p.value;
-      if (p.type === "ternary")
-        return `\${${p.condition} ? '${p.whenTrue}' : '${p.whenFalse}'}`;
-      return `\${(${JSON.stringify(p.cases)})[${p.key}]}`;
-    }).join("") + "`";
+    return this.renderTemplatePartsAsJs(v.parts);
   }
   renderComponentProps(comp) {
     const parts = [];
@@ -4497,7 +4732,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // ../jsx/src/combine-client-js.ts
-import ts23 from "typescript";
+import ts25 from "typescript";
 // ../jsx/src/loop-destructure.ts
 function isLowerableLoopDestructure(loop) {
   const bindings = loop.paramBindings;
@@ -4637,9 +4872,9 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // ../jsx/src/debug.ts
-import ts24 from "typescript";
+import ts26 from "typescript";
 // ../jsx/src/profiler.ts
-import ts25 from "typescript";
+import ts27 from "typescript";
 
 // ../jsx/src/index.ts
 registerBuiltinLoweringPlugins();
@@ -5510,7 +5745,7 @@ function collectImportedLoopChildComponentErrors(ir, componentName) {
 }
 
 // src/adapter/spread/spread-codegen.ts
-import ts26 from "typescript";
+import ts28 from "typescript";
 function conditionalSpreadToRuby(ctx, expr) {
   if (!expr || expr.kind !== "conditional")
     return null;
@@ -5565,7 +5800,7 @@ function recordIndexAccessToRuby(ctx, val) {
   if (val.kind !== "index-access" || val.object.kind !== "identifier" || val.index.kind !== "identifier") {
     return null;
   }
-  const tsVal = ts26.factory.createElementAccessExpression(ts26.factory.createIdentifier(val.object.name), ts26.factory.createIdentifier(val.index.name));
+  const tsVal = ts28.factory.createElementAccessExpression(ts28.factory.createIdentifier(val.object.name), ts28.factory.createIdentifier(val.index.name));
   const parsed = parseRecordIndexAccess(tsVal, ctx.localConstants, ctx.propsParams);
   if (!parsed)
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/erb",
-  "version": "0.31.0",
+  "version": "0.31.2",
   "description": "ERB (Embedded Ruby) adapter for BarefootJS — compiles IR to .erb templates and ships the Ruby rendering backend; runs under any Rack app (Sinatra, Rails)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
     "directory": "packages/adapter-erb"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.0"
+    "@barefootjs/shared": "0.31.2"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -71,9 +71,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.31.0",
-    "@barefootjs/vite": "0.31.0",
-    "@barefootjs/client": "0.31.0",
+    "@barefootjs/jsx": "0.31.2",
+    "@barefootjs/vite": "0.31.2",
+    "@barefootjs/client": "0.31.2",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

package/src/render-divergences.ts

@@ -20,18 +20,4 @@ export const renderDivergences: RenderDivergences = {
   // instead of a fixed regex-shape catalogue) now correctly seeds `todos`
   // from `(props.initialTodos ?? []).map(t => ({ ...t, editing: false }))`.
 
-  // Onboarding TSX-fidelity fixtures (PR #2461): `expectedHtml` was
-  // hand-authored to the CORRECT output while the emission bug lived in
-  // the shared compiler layer — every adapter, including the Hono
-  // reference, used to emit the broken form. That shared-layer defect
-  // (#2460) is now FIXED (b4f5075): `expectedHtml` is generated from the
-  // Hono reference like any other fixture. The remaining gap is
-  // per-template-adapter — this adapter still keys its template vars /
-  // ssr-defaults / props bridge off the local binding instead of
-  // `sourceName ?? name` — tracked by #2524 (the 7 silent template
-  // adapters). Graduate by applying the same `sourceName ?? name` fix to
-  // this adapter's emission path and deleting this line (and the
-  // matching hono `skipJsx` entries, already gone).
-  'aliased-destructured-prop':
-    'aliased destructured prop `{ n: count }` loses its rename — template vars, ssr-defaults, and the props bridge all key off the local name, so the prop is always undefined (https://github.com/piconic-ai/barefootjs/issues/2524)',
 }

package/src/test-render.ts

@@ -36,7 +36,7 @@
  * regression test.
  */
 
-import { compileJSX, extractSsrDefaults, importsSearchParams, evaluateSignalInit, tryEvaluateSignalInit } from '@barefootjs/jsx'
+import { compileJSX, extractSsrDefaults, deriveStashFromDefaults, importsSearchParams, evaluateSignalInit } from '@barefootjs/jsx'
 import type { ComponentIR, SsrDefault } from '@barefootjs/jsx'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
@@ -415,7 +415,11 @@ function buildChildRenderersRuby(
       // branch and JSX rest semantics: a caller prop the child didn't
       // destructure belongs in the bag, not as a top-level vars key the
       // template never reads.
-      const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.name)
+      // Caller-facing keys — `child_props` (below) is keyed by whatever the
+      // CALLING template passed (the JSX attribute name), so the keep-set
+      // must match that spelling, not an aliased child's local binding
+      // (#2524).
+      const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.sourceName ?? p.name)
       const keep = [...new Set([...paramNames, restPropsName, 'children', 'key', '_bf_slot'])]
       const keepList = keep.map(rubySymbol).join(', ')
       lines.push(`  keep = [${keepList}]`)
@@ -499,24 +503,29 @@ function buildRubyProps(
   obj.scope_id = explicitScope
 
   // Prop params with defaults (before signals, so signals can reference them).
+  // Seeded through the shared `deriveStashFromDefaults` (the TS twin of the
+  // production `derive_vars_from_defaults` this harness ALSO calls below for
+  // child components) so an aliased destructured prop's CALLER-facing key
+  // (`propName`, e.g. `n` for `{ n: count }`) is honoured, not just the
+  // local template var name (#2524 SSR half). `props` is keyed by the
+  // caller-facing name, exactly what `propName` resolves against.
+  const rootSsrDefaults = extractSsrDefaults(ir.metadata) ?? {}
+  const derivedProps = deriveStashFromDefaults(rootSsrDefaults, props ?? {})
   for (const param of ir.metadata.propsParams) {
-    if (props && param.name in props) continue
-    if (param.defaultValue) {
-      const result = tryEvaluateSignalInit(param.defaultValue.trim(), props)
-      if (result.ok) {
-        obj[param.name] = result.value
-        continue
-      }
-    }
+    if (param.isRest) continue
     // No default + no caller value: seed `nil` so a bare reference to an
     // optional prop's vars-Hash key resolves (to nil) instead of the key
     // being wholly absent — matches the Perl harnesses' explicit `undef`.
-    obj[param.name] = null
+    obj[param.name] = derivedProps[param.name] ?? null
   }
 
   // Route undeclared props into the rest bag (`spread_attrs(v[:<rest>])`).
   const restPropsName = ir.metadata.restPropsName
-  const declaredParams = new Set(ir.metadata.propsParams.map(p => p.name))
+  // Caller-facing keys, per prop — an aliased destructured prop's DECLARED
+  // set for rest-bag routing purposes must match what the caller actually
+  // sent (`n`), not the local binding (`count`), or the caller's own prop
+  // silently gets swept into the rest bag as an undeclared extra (#2524).
+  const declaredParams = new Set(ir.metadata.propsParams.map(p => p.sourceName ?? p.name))
   const restBagEntries: Array<[string, unknown]> = []
   if (restPropsName && props) {
     for (const [key, value] of Object.entries(props)) {
@@ -531,11 +540,20 @@ function buildRubyProps(
     obj[restPropsName] = Object.fromEntries(restBagEntries)
   }
 
-  // User props.
+  // User props. Skip a key that's already a declared param's LOCAL template
+  // var name — `derivedProps` above already resolved that var correctly
+  // (through `propName`, for an aliased prop); re-assigning the raw
+  // `props[key]` here would silently clobber it with an UNRELATED value
+  // whenever a caller happens to also pass a same-spelled-as-local-name prop
+  // that isn't this param's actual `propName` (#2524 — surfaced by the
+  // aliased-destructured-prop generated data points, which pass both `n`
+  // (the real propName) and an incidental `count` key).
+  const localParamNames = new Set(ir.metadata.propsParams.map(p => p.name))
   if (props) {
     for (const [key, value] of Object.entries(props)) {
       if (key.startsWith('__')) continue
       if (routedKeys.has(key)) continue
+      if (localParamNames.has(key)) continue
       obj[key] = value
     }
   }
@@ -553,9 +571,8 @@ function buildRubyProps(
 
   // Memo values seeded from the statically-evaluated ssrDefaults, same
   // as the production plugin's before_render hook.
-  const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {}
   for (const memo of ir.metadata.memos) {
-    obj[memo.name] = ssrDefaults[memo.name]?.value ?? 0
+    obj[memo.name] = rootSsrDefaults[memo.name]?.value ?? 0
   }
 
   const needsSearchParams = importsSearchParams(ir.metadata)