@barefootjs/go-template 0.31.1 → 0.31.3

package/dist/vite.js

@@ -4,8 +4,11 @@ import { 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";
@@ -1920,6 +1923,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";
 function* iterateJsTokens(text, start = 0, end = text.length) {
@@ -2098,6 +2124,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/ir-to-client-js/html-template.ts
 var VOID_ELEMENTS = new Set([
@@ -2143,6 +2179,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() {
@@ -2156,14 +2213,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 = {
@@ -2179,6 +2236,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",
@@ -2208,6 +2266,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.",
@@ -2381,6 +2440,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",
@@ -2399,7 +2506,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 = {
@@ -2481,10 +2588,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
@@ -2802,6 +2909,83 @@ var toLocaleDatePlugin = {
   }
 };
 
+// ../jsx/src/scope/binding-scope.ts
+class BindingScope {
+  frames;
+  static EMPTY = new BindingScope([]);
+  constructor(frames) {
+    this.frames = frames;
+  }
+  enterLoopRow(loop) {
+    const bindings = new Map;
+    if (loop.paramBindings && loop.paramBindings.length > 0) {
+      for (const b of loop.paramBindings)
+        bindings.set(b.name, { source: "destructure" });
+    } else {
+      bindings.set(loop.param, { source: "item" });
+    }
+    if (loop.index != null)
+      bindings.set(loop.index, { source: "index" });
+    for (const name of loop.preamble?.declaredNames ?? [])
+      bindings.set(name, { source: "preamble" });
+    const frame = { kind: "loop-row", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  enterCallback(params) {
+    const bindings = new Map;
+    for (const name of params)
+      bindings.set(name, { source: "param" });
+    const frame = { kind: "callback", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  isBound(name) {
+    for (const frame of this.frames) {
+      if (frame.bindings.has(name))
+        return true;
+    }
+    return false;
+  }
+  lookup(name) {
+    for (let depth = 0;depth < this.frames.length; depth++) {
+      const frame = this.frames[depth];
+      const binding = frame.bindings.get(name);
+      if (binding)
+        return { depth, frame, binding };
+    }
+    return null;
+  }
+  boundNames() {
+    if (this.boundNamesCache)
+      return this.boundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const name of frame.bindings.keys())
+        names.add(name);
+    }
+    this.boundNamesCache = names;
+    return names;
+  }
+  boundNamesCache;
+  valueBoundNamesCache;
+  valueBoundNames() {
+    if (this.valueBoundNamesCache)
+      return this.valueBoundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const [name, binding] of frame.bindings) {
+        if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
+          names.add(name);
+        }
+      }
+    }
+    this.valueBoundNamesCache = names;
+    return names;
+  }
+  asShadowPredicate() {
+    return (name) => this.isBound(name);
+  }
+}
+
 // ../jsx/src/jsx-to-ir.ts
 var EMPTY_BOUND = new Set;
 var constInitializerCache = new WeakMap;
@@ -2898,13 +3082,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 = [];
@@ -3100,10 +3284,10 @@ function formatDateLocalNames(metadata) {
 }
 
 // ../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 }
@@ -3153,7 +3337,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([
@@ -3168,7 +3352,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+/";
@@ -3259,15 +3443,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;
@@ -3299,47 +3483,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;
 }
@@ -3364,25 +3548,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);
   };
@@ -3493,33 +3677,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)
@@ -3547,28 +3731,28 @@ function collectModuleStringConsts(constants) {
   return map;
 }
 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;
@@ -3577,7 +3761,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;
@@ -3585,11 +3769,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;
@@ -3605,35 +3789,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;
@@ -3689,7 +3873,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) {
@@ -3765,7 +3949,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 {
@@ -3784,12 +3968,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.typeAnnotation ?? constant.type) ? `: ${constant.typeAnnotation ?? constant.type?.raw}` : "";
+        lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`);
         continue;
       }
       const value = constant.value.trim();
@@ -3798,9 +3986,12 @@ class JsxAdapter extends BaseAdapter {
       if (!reachable.has(constant.name))
         continue;
       const constValue = preserveTypes ? constant.typedValue ?? constant.value : constant.value;
-      lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
+      const letTypeAnnotation = preserveTypes && keyword === "let" && constant.typeAnnotation ? `: ${constant.typeAnnotation}` : "";
+      lines.push(`  ${keyword} ${constant.name}${letTypeAnnotation} = ${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(", ");
@@ -3810,6 +4001,127 @@ 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) {
+        const typeAnnotation = preserveTypes && (c.typeAnnotation ?? c.type) ? `: ${c.typeAnnotation ?? c.type?.raw}` : "";
+        entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${typeAnnotation}` });
+        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;
+      const letTypeAnnotation = preserveTypes && keyword === "let" && c.typeAnnotation ? `: ${c.typeAnnotation}` : "";
+      entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${letTypeAnnotation} = ${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) {
@@ -3821,6 +4133,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}}`;
   }
@@ -3888,6 +4209,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 ? `
@@ -3896,9 +4218,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 {
@@ -3929,9 +4253,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("");
@@ -3954,7 +4275,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 = [];
@@ -4101,13 +4422,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 = [];
@@ -4575,7 +4890,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;
@@ -4715,9 +5030,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();
@@ -5647,15 +5962,43 @@ function collapseLiteralUnion(typeInfo) {
   }
   return { kind: "primitive", raw: typeInfo.raw, primitive: first };
 }
-function typeInfoToGo(ctx, _typeInfo, defaultValue) {
+function literalNumberValue(expr) {
+  if (expr.kind === "literal" && expr.literalType === "number" && typeof expr.value === "number") {
+    return expr.value;
+  }
+  if (expr.kind === "unary" && expr.op === "-" && expr.argument.kind === "literal" && expr.argument.literalType === "number" && typeof expr.argument.value === "number") {
+    return -expr.argument.value;
+  }
+  return null;
+}
+function inferGoTypeFromParsed(expr) {
+  const n = literalNumberValue(expr);
+  if (n !== null)
+    return Number.isInteger(n) ? "int" : "float64";
+  if (expr.kind === "literal") {
+    if (expr.literalType === "boolean")
+      return "bool";
+    if (expr.literalType === "string")
+      return "string";
+    return null;
+  }
+  if (expr.kind === "array-literal")
+    return "[]interface{}";
+  return null;
+}
+function typeInfoToGo(ctx, _typeInfo, defaultValue, preParsed) {
   const typeInfo = collapseLiteralUnion(_typeInfo);
   switch (typeInfo.kind) {
     case "primitive":
       switch (typeInfo.primitive) {
         case "string":
           return "string";
-        case "number":
+        case "number": {
+          const n = preParsed ? literalNumberValue(preParsed) : null;
+          if (n !== null)
+            return Number.isInteger(n) ? "int" : "float64";
           return defaultValue !== undefined ? numberPrimitiveGoType(defaultValue) : "int";
+        }
         case "boolean":
           return "bool";
         default:
@@ -5678,30 +6021,21 @@ function typeInfoToGo(ctx, _typeInfo, defaultValue) {
           return resolved;
       }
       return "interface{}";
-    case "unknown":
+    case "unknown": {
+      const inferred = preParsed ? inferGoTypeFromParsed(preParsed) : null;
+      if (inferred)
+        return inferred;
       if (defaultValue !== undefined) {
         return inferTypeFromValue(defaultValue);
       }
       return "interface{}";
+    }
     default:
       return "interface{}";
   }
 }
 function tsTypeStringToGo(ctx, tsType) {
   const t = tsType.trim();
-  if (t === "number")
-    return "int";
-  if (t === "string")
-    return "string";
-  if (t === "boolean" || t === "bool")
-    return "bool";
-  if (t.endsWith("[]")) {
-    const elem = t.slice(0, -2);
-    return `[]${tsTypeStringToGo(ctx, elem)}`;
-  }
-  const arrayMatch = t.match(/^Array<(.+)>$/);
-  if (arrayMatch)
-    return `[]${tsTypeStringToGo(ctx, arrayMatch[1])}`;
   if (ctx.state.localStructFields.has(t) || ctx.state.localTypeAliases.has(t))
     return t;
   return "interface{}";
@@ -5745,16 +6079,25 @@ function bakeInlineObjectAsGoMap(ctx, expr) {
   }
   return `map[string]interface{}{${entries.join(", ")}}`;
 }
-function parsedLiteralToGo(ctx, expr, typeInfo) {
+function numberLiteralRawGo(expr) {
   if (expr.kind === "unary" && expr.op === "-" && expr.argument.kind === "literal" && expr.argument.literalType === "number") {
     return expr.argument.raw !== undefined ? `-${expr.argument.raw}` : null;
   }
+  if (expr.kind === "literal" && expr.literalType === "number") {
+    return expr.raw ?? null;
+  }
+  return null;
+}
+function parsedLiteralToGo(ctx, expr, typeInfo) {
+  const numberGo = numberLiteralRawGo(expr);
+  if (numberGo !== null)
+    return numberGo;
   if (expr.kind === "literal") {
     switch (expr.literalType) {
       case "string":
         return JSON.stringify(expr.value);
       case "number":
-        return expr.raw ?? null;
+        return null;
       case "boolean":
         return expr.value ? "true" : "false";
       case "null":
@@ -5806,10 +6149,10 @@ function parsedLiteralToGo(ctx, expr, typeInfo) {
 
 // src/adapter/value/value-lowering.ts
 var EMPTY_PROP_FALLBACK_VARS = new Map;
-function nillableAwarePropRef(ctx, propName, expectedType) {
-  const fieldRef = `in.${capitalizeFieldName(propName)}`;
+function nillableAwarePropRef(ctx, param, expectedType) {
+  const fieldRef = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`;
   const scalar = expectedType.kind === "primitive" ? expectedType : expectedType.kind === "union" && expectedType.unionTypes?.length === 2 ? expectedType.unionTypes.find((t) => t.primitive !== "undefined" && t.primitive !== "null") : undefined;
-  if (ctx.state.nillablePropNames.has(propName) && scalar?.kind === "primitive") {
+  if (ctx.state.nillablePropNames.has(param.name) && scalar?.kind === "primitive") {
     const goType = scalar.primitive === "boolean" ? "bool" : scalar.primitive === "number" ? "float64" : scalar.primitive === "string" ? "string" : null;
     if (goType) {
       const zero = goType === "bool" ? "false" : goType === "string" ? '""' : "0";
@@ -5820,21 +6163,29 @@ function nillableAwarePropRef(ctx, propName, expectedType) {
 }
 function convertInitialValue(ctx, value, _typeInfo, propsParams, preParsed) {
   const typeInfo = collapseLiteralUnion(_typeInfo);
-  const propRef = (propName2) => nillableAwarePropRef(ctx, propName2, typeInfo);
+  const propRef = (param2) => nillableAwarePropRef(ctx, param2, typeInfo);
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
-    if (propsParams?.some((p) => p.name === value)) {
-      return propRef(value);
+    const param2 = propsParams?.find((p) => p.name === value);
+    if (param2) {
+      return propRef(param2);
     }
   }
   const propName = ctx.extractPropNameFromInitialValue(value, preParsed);
-  if (propName && propsParams?.some((p) => p.name === propName)) {
-    return propRef(propName);
+  const param = propName ? propsParams?.find((p) => p.name === propName) : undefined;
+  if (param) {
+    return propRef(param);
   }
   if (typeInfo.kind === "primitive") {
     if (typeInfo.primitive === "boolean") {
+      if (preParsed?.kind === "literal" && preParsed.literalType === "boolean" && typeof preParsed.value === "boolean") {
+        return preParsed.value ? "true" : "false";
+      }
       return value === "true" ? "true" : "false";
     }
     if (typeInfo.primitive === "number") {
+      const numGo = preParsed ? numberLiteralRawGo(preParsed) : null;
+      if (numGo !== null)
+        return numGo;
       if (/^-?\d+$/.test(value))
         return value;
       if (/^-?\d+\.\d+$/.test(value))
@@ -5842,7 +6193,10 @@ function convertInitialValue(ctx, value, _typeInfo, propsParams, preParsed) {
       return "0";
     }
     if (typeInfo.primitive === "string") {
-      if (value.startsWith("'") || value.endsWith("'")) {
+      if (preParsed?.kind === "literal" && preParsed.literalType === "string" && typeof preParsed.value === "string") {
+        return JSON.stringify(preParsed.value);
+      }
+      if (value.startsWith("'") && value.endsWith("'")) {
         return value.replace(/'/g, '"');
       }
       if (value.startsWith('"') && value.endsWith('"')) {
@@ -5904,19 +6258,21 @@ function objectLiteralToGoMap(ctx, expr) {
   return `map[string]interface{}{${entries.join(", ")}}`;
 }
 function getSignalInitialValueAsGo(ctx, initialValue, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS, signalType) {
-  const propRef = (propName2) => signalType ? nillableAwarePropRef(ctx, propName2, signalType) : `in.${capitalizeFieldName(propName2)}`;
-  if (propsParams.some((p) => p.name === initialValue)) {
+  const propRef = (param2) => signalType ? nillableAwarePropRef(ctx, param2, signalType) : `in.${capitalizeFieldName(param2.sourceName ?? param2.name)}`;
+  const directParam = propsParams.find((p) => p.name === initialValue);
+  if (directParam) {
     const hoisted = propFallbackVars.get(initialValue);
     if (hoisted)
       return hoisted.varName;
-    return propRef(initialValue);
+    return propRef(directParam);
   }
   const propName = ctx.extractPropNameFromInitialValue(initialValue);
-  if (propName && propsParams.some((p) => p.name === propName)) {
+  const param = propName ? propsParams.find((p) => p.name === propName) : undefined;
+  if (param) {
     const hoisted = propFallbackVars.get(propName);
     if (hoisted)
       return hoisted.varName;
-    return propRef(propName);
+    return propRef(param);
   }
   if (/^-?\d+$/.test(initialValue)) {
     return initialValue;
@@ -5950,8 +6306,9 @@ function resolveMapJoinBaseAsGo(ctx, object, signals, propsParams) {
     }
   }
   const propName = object.kind === "member" && !object.computed && object.object.kind === "identifier" && object.object.name === "props" ? object.property : object.kind === "identifier" ? object.name : null;
-  if (propName && propsParams.some((p) => p.name === propName)) {
-    return `in.${capitalizeFieldName(propName)}`;
+  const param = propName ? propsParams.find((p) => p.name === propName) : undefined;
+  if (param) {
+    return `in.${capitalizeFieldName(param.sourceName ?? param.name)}`;
   }
   if (object.kind === "array-literal") {
     if (object.elements.length === 0)
@@ -5982,11 +6339,12 @@ function mapJoinChainToGo(ctx, chain, signals, propsParams, propFallbackVars) {
   for (const name of freeVars) {
     const sig = signals.find((s) => s.getter === name);
     let goExpr = null;
+    const freeVarParam = propsParams.find((p) => p.name === name);
     if (sig) {
       goExpr = getSignalInitialValueAsGo(ctx, sig.initialValue, propsParams, propFallbackVars, sig.type);
-    } else if (propsParams.some((p) => p.name === name)) {
+    } else if (freeVarParam) {
       const hoisted = propFallbackVars.get(name);
-      goExpr = hoisted ? hoisted.varName : `in.${capitalizeFieldName(name)}`;
+      goExpr = hoisted ? hoisted.varName : `in.${capitalizeFieldName(freeVarParam.sourceName ?? name)}`;
     }
     if (goExpr === null)
       return null;
@@ -6028,14 +6386,14 @@ function isBooleanMemo(ctx, memo, signals, propsParamMap) {
         return true;
       if (/\?\?\s*(true|false)\b/.test(sig.initialValue))
         return true;
-      const propName = ctx.extractPropNameFromInitialValue(sig.initialValue) ?? sig.initialValue;
+      const propName = ctx.extractPropNameFromInitialValue(sig.initialValue, sig.parsed) ?? sig.initialValue;
       const prop2 = propsParamMap.get(propName);
-      if (prop2 && typeInfoToGo(ctx, prop2.type, prop2.defaultValue) === "bool")
+      if (prop2 && typeInfoToGo(ctx, prop2.type, prop2.defaultValue, prop2.parsed) === "bool")
         return true;
       return false;
     }
     const prop = propsParamMap.get(name);
-    return !!prop && typeInfoToGo(ctx, prop.type, prop.defaultValue) === "bool";
+    return !!prop && typeInfoToGo(ctx, prop.type, prop.defaultValue, prop.parsed) === "bool";
   };
   const ternary = c.match(/=>\s*\w+\(\)\s*\?\s*(\w+)\(\)\s*:\s*(\w+)\(\)/);
   if (ternary) {
@@ -6305,7 +6663,7 @@ function computeObjectMemoInitialValue(ctx, memo) {
 }
 
 // src/adapter/memo/template-interp.ts
-import ts26 from "typescript";
+import ts28 from "typescript";
 function computeTemplateLiteralMemoInitialValue(ctx, memo, propsParams) {
   const localKeyBindings = new Map;
   let templateValue;
@@ -6528,7 +6886,8 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
     const hoisted = propFallbackVars.get(propName);
     if (hoisted)
       return hoisted.varName;
-    return `in.${capitalizeFieldName(propName)}`;
+    const param = propsParams.find((p) => p.name === propName);
+    return `in.${capitalizeFieldName(param?.sourceName ?? propName)}`;
   };
   const envGetKey = (e) => {
     if (e.kind !== "call" || e.callee.kind !== "member" || e.callee.computed)
@@ -6620,7 +6979,7 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
       const param = propsParams.find((p) => p.name === propName);
       if (param && ctx.state.nillablePropNames.has(propName)) {
         const isNe = body.op === "!==" || body.op === "!=";
-        return `in.${capitalizeFieldName(propName)} ${isNe ? "!=" : "=="} nil`;
+        return `in.${capitalizeFieldName(param.sourceName ?? propName)} ${isNe ? "!=" : "=="} nil`;
       }
     }
   }
@@ -6692,7 +7051,7 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
           return `${hoisted.varName} ${operator} ${operand}`;
         const fieldName = capitalizeFieldName(propName);
         if (param.type) {
-          const goType = typeInfoToGo(ctx, param.type, param.defaultValue);
+          const goType = typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed);
           if (goType === "interface{}")
             return `in.${fieldName}.(int) ${operator} ${operand}`;
         }
@@ -6703,9 +7062,9 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
       const varName = body.left.name;
       const param = propsParams.find((p) => p.name === varName);
       if (param) {
-        const fieldName = capitalizeFieldName(varName);
+        const fieldName = capitalizeFieldName(param.sourceName ?? varName);
         if (param.type) {
-          const goType = typeInfoToGo(ctx, param.type, param.defaultValue);
+          const goType = typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed);
           if (goType === "interface{}")
             return `in.${fieldName}.(int) ${operator} ${operand}`;
         }
@@ -6729,7 +7088,7 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
   if (body.kind === "identifier") {
     const param = propsParams.find((p) => p.name === body.name);
     if (param)
-      return `in.${capitalizeFieldName(body.name)}`;
+      return `in.${capitalizeFieldName(param.sourceName ?? body.name)}`;
   }
   if (body.kind === "binary" && body.op === "+") {
     const concatGo = resolveStringConcatChainGo(ctx, body, signals, propsParams, propFallbackVars, propRef);
@@ -6791,7 +7150,8 @@ function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVar
     const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, "");
     const fb = ctx.extractPropFallback(stripped);
     if (fb && capitalizeFieldName(fb.propName) === capitalizeFieldName(memo.name)) {
-      const field = `in.${capitalizeFieldName(fb.propName)}`;
+      const fbParam = propsParams.find((p) => p.name === fb.propName);
+      const field = `in.${capitalizeFieldName(fbParam?.sourceName ?? fb.propName)}`;
       return `func() interface{} { v := interface{}(${field}); if v == nil || v == "" { return ${fb.goFallback} }; return v }()`;
     }
     return computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars, new Set([...resolving, memo.name]));
@@ -6799,7 +7159,7 @@ function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVar
   const param = propsParams.find((p) => p.name === name);
   if (param) {
     const hoisted = propFallbackVars.get(name);
-    return hoisted ? hoisted.varName : `in.${capitalizeFieldName(name)}`;
+    return hoisted ? hoisted.varName : `in.${capitalizeFieldName(param.sourceName ?? name)}`;
   }
   return null;
 }
@@ -6934,7 +7294,7 @@ function collectPropsReadByCtorInit(body, propsObjectName, propNames) {
 }
 
 // src/adapter/spread/spread-codegen.ts
-import ts27 from "typescript";
+import ts29 from "typescript";
 function collectSpreadSlots(ctx, node) {
   const result = [];
   collectSpreadSlotsRecursive(ctx, node, result);
@@ -7059,10 +7419,10 @@ function buildSpreadInitializer(ctx, spreadExpr, ir, parsed) {
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(trimmed)) {
     const param = ir.metadata.propsParams.find((p) => p.name === trimmed);
     if (param) {
-      return `in.${capitalizeFieldName(param.name)}`;
+      return `in.${capitalizeFieldName(param.sourceName ?? param.name)}`;
     }
     if (ir.metadata.propsObjectName === trimmed) {
-      const entries = ir.metadata.propsParams.map((p) => `${JSON.stringify(p.name)}: in.${capitalizeFieldName(p.name)}`);
+      const entries = ir.metadata.propsParams.map((p) => `${JSON.stringify(p.sourceName ?? p.name)}: in.${capitalizeFieldName(p.sourceName ?? p.name)}`);
       return `map[string]any{${entries.join(", ")}}`;
     }
     if (ir.metadata.restPropsName === trimmed) {
@@ -7116,7 +7476,7 @@ function conditionToGoBool(condition, ir) {
   const param = ir.metadata.propsParams.find((p) => p.name === node.name);
   if (!param)
     return null;
-  const field = `in.${capitalizeFieldName(param.name)}`;
+  const field = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`;
   const prim = param.type.kind === "primitive" ? param.type.primitive : undefined;
   let truthy;
   if (prim === "boolean") {
@@ -7154,7 +7514,7 @@ function objectLiteralToGoSpreadMap(ctx, obj, ir) {
       const param = ir.metadata.propsParams.find((p) => p.name === val.name);
       if (!param)
         return null;
-      goVal = `in.${capitalizeFieldName(param.name)}`;
+      goVal = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`;
     } else {
       const indexed = recordIndexAccessToGoMap(ctx, val, ir);
       if (indexed === null)
@@ -7169,7 +7529,7 @@ function recordIndexAccessToGoMap(ctx, val, ir) {
   if (val.kind !== "index-access" || val.object.kind !== "identifier" || val.index.kind !== "identifier") {
     return null;
   }
-  const tsVal = ts27.factory.createElementAccessExpression(ts27.factory.createIdentifier(val.object.name), ts27.factory.createIdentifier(val.index.name));
+  const tsVal = ts29.factory.createElementAccessExpression(ts29.factory.createIdentifier(val.object.name), ts29.factory.createIdentifier(val.index.name));
   const parsed = parseRecordIndexAccess(tsVal, ir.metadata.localConstants ?? [], ir.metadata.propsParams);
   if (!parsed)
     return null;
@@ -7178,7 +7538,8 @@ function recordIndexAccessToGoMap(ctx, val, ir) {
     return `${JSON.stringify(e.key)}: ${mapVal}`;
   });
   ctx.state.usesFmt = true;
-  const field = `in.${capitalizeFieldName(parsed.indexPropName)}`;
+  const indexParam = ir.metadata.propsParams.find((p) => p.name === parsed.indexPropName);
+  const field = `in.${capitalizeFieldName(indexParam?.sourceName ?? parsed.indexPropName)}`;
   return `map[string]any{${entries.join(", ")}}[fmt.Sprint(${field})]`;
 }
 
@@ -7194,9 +7555,9 @@ function buildPropTypeOverrides(ctx, ir) {
       const param = ir.metadata.propsParams.find((p) => p.name === propName);
       if (!param)
         continue;
-      const propGoType = typeInfoToGo(ctx, param.type, param.defaultValue);
+      const propGoType = typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed);
       if (propGoType.includes("interface{}")) {
-        const signalGoType = typeInfoToGo(ctx, signal.type, signal.initialValue);
+        const signalGoType = typeInfoToGo(ctx, signal.type, signal.initialValue, signal.parsed);
         if (!signalGoType.includes("interface{}")) {
           overrides.set(propName, signalGoType);
         }
@@ -7207,7 +7568,7 @@ function buildPropTypeOverrides(ctx, ir) {
     const param = ir.metadata.propsParams.find((p) => p.name === propName);
     if (!param)
       continue;
-    const resolved = overrides.get(propName) ?? typeInfoToGo(ctx, param.type, param.defaultValue);
+    const resolved = overrides.get(propName) ?? typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed);
     if (resolved === "int") {
       overrides.set(propName, "float64");
     }
@@ -7377,7 +7738,7 @@ function collectPresenceCheckedPropNames(ctx, ir) {
   return names;
 }
 function resolvePropGoType(ctx, param, propTypeOverrides) {
-  const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue);
+  const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue, param.parsed);
   if (param.optional && ctx.state.localStructFields.has(base)) {
     return "map[string]interface{}";
   }
@@ -7764,6 +8125,18 @@ ${scriptRegistrations}${templateBody}
   nonCollidingContextConsumers(taken) {
     return this.state.contextConsumers.filter((c) => !taken.has(this.contextFieldName(c)));
   }
+  isNestedArrayShadowed(param, nestedArrayFields) {
+    return nestedArrayFields.has(capitalizeFieldName(param.name)) || nestedArrayFields.has(capitalizeFieldName(param.sourceName ?? param.name));
+  }
+  propParamFieldNamesUnion(params) {
+    return params.flatMap((p) => [capitalizeFieldName(p.name), capitalizeFieldName(p.sourceName ?? p.name)]);
+  }
+  claimJsonTag(desired, taken) {
+    if (taken.has(desired))
+      return "-";
+    taken.add(desired);
+    return desired;
+  }
   generateTypes(ir) {
     this.state.usesHtmlTemplate = false;
     this.state.usesFmt = false;
@@ -7794,13 +8167,16 @@ ${scriptRegistrations}${templateBody}
     if (!this.childDerivedFieldDeps.has(componentName))
       return;
     const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
-    const params = (ir.metadata.propsParams ?? []).filter((p) => !nestedArrayFields.has(capitalizeFieldName(p.name)));
-    const takenInput = new Set((ir.metadata.propsParams ?? []).map((p) => capitalizeFieldName(p.name)));
+    const params = (ir.metadata.propsParams ?? []).filter((p) => !this.isNestedArrayShadowed(p, nestedArrayFields));
+    const takenInput = new Set(this.propParamFieldNamesUnion(ir.metadata.propsParams ?? []));
     const eligible = nestedComponents.every((n) => n.isDynamic && !n.isPropDerived) && spreadSlots.length === 0 && !ir.metadata.restPropsName && this.nonCollidingContextConsumers(takenInput).length === 0;
     if (!eligible)
       return;
     this.childRepropsReady.set(componentName, {
-      params: params.map((p) => capitalizeFieldName(p.name)),
+      params: params.map((p) => ({
+        propsField: capitalizeFieldName(p.name),
+        inputField: capitalizeFieldName(p.sourceName ?? p.name)
+      })),
       usesSearchParams: this.usesSearchParams(ir)
     });
   }
@@ -7836,17 +8212,17 @@ ${scriptRegistrations}${templateBody}
     lines.push("\t\t\tBfMount: b.BfMount,");
     if (usesSearchParams)
       lines.push("\t\t\tSearchParams: b.SearchParams,");
-    for (const field of params) {
-      lines.push(`			${field}: b.${field},`);
+    for (const { propsField, inputField } of params) {
+      lines.push(`			${inputField}: b.${propsField},`);
     }
     lines.push("\t\t}");
     lines.push("\t\tfor i := 0; i < len(kv); i += 2 {");
     lines.push("\t\t\tname, _ := kv[i].(string)");
     lines.push("\t\t\tvar err error");
     lines.push("\t\t\tswitch name {");
-    for (const field of params) {
-      lines.push(`			case ${JSON.stringify(field)}:`);
-      lines.push(`				err = bf.RepropsAssign(${q}, ${JSON.stringify(field)}, &in.${field}, kv[i+1])`);
+    for (const { propsField, inputField } of params) {
+      lines.push(`			case ${JSON.stringify(propsField)}:`);
+      lines.push(`				err = bf.RepropsAssign(${q}, ${JSON.stringify(propsField)}, &in.${inputField}, kv[i+1])`);
     }
     lines.push("\t\t\tdefault:");
     lines.push(`				err = bf.RepropsUnknownFieldError(${q}, name)`);
@@ -7984,6 +8360,7 @@ ${goFields.join(`
       return false;
     const taken = new Set([
       ...ir.metadata.propsParams.map((p) => capitalizeFieldName(p.name)),
+      ...ir.metadata.propsParams.map((p) => capitalizeFieldName(p.sourceName ?? p.name)),
       ...ir.metadata.signals.filter((s) => !s.envReader).map((s) => capitalizeFieldName(s.getter)),
       ...ir.metadata.memos.map((m) => capitalizeFieldName(m.name)),
       ...this.state.contextConsumers.map((c) => this.contextFieldName(c))
@@ -8006,8 +8383,8 @@ ${goFields.join(`
     const inputNested = nestedComponents.filter((n) => !n.isDynamic || n.isPropDerived);
     const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
     for (const param of ir.metadata.propsParams) {
-      const fieldName = capitalizeFieldName(param.name);
-      if (nestedArrayFields.has(fieldName))
+      const fieldName = capitalizeFieldName(param.sourceName ?? param.name);
+      if (this.isNestedArrayShadowed(param, nestedArrayFields))
         continue;
       const goType = resolvePropGoType(this.emitCtx, param, propTypeOverrides);
       lines.push(`	${fieldName} ${goType}`);
@@ -8017,7 +8394,7 @@ ${goFields.join(`
         continue;
       lines.push(`	${nested.name}s []${nested.name}Input`);
     }
-    const takenInput = new Set(ir.metadata.propsParams.map((p) => capitalizeFieldName(p.name)));
+    const takenInput = new Set(this.propParamFieldNamesUnion(ir.metadata.propsParams));
     for (const c of this.nonCollidingContextConsumers(takenInput)) {
       lines.push(`	${this.contextFieldName(c)} ${this.contextConsumerGoType(c)}`);
     }
@@ -8041,8 +8418,9 @@ ${goFields.join(`
   generatePropsStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots) {
     const propsTypeName = `${componentName}Props`;
     this.emitPropsStructHeader(lines, ir, propsTypeName, componentName);
-    this.emitPropsDataFields(lines, ir, nestedComponents, propTypeOverrides);
-    this.emitPropsAuxFields(lines, ir, componentName, nestedComponents, spreadSlots);
+    const takenJsonTags = new Set;
+    this.emitPropsDataFields(lines, ir, nestedComponents, propTypeOverrides, takenJsonTags);
+    this.emitPropsAuxFields(lines, ir, componentName, nestedComponents, spreadSlots, takenJsonTags);
     lines.push("}");
     lines.push("");
   }
@@ -8079,7 +8457,7 @@ ${goFields.join(`
   resolveLoopDatumFields(itemType) {
     if (!itemType)
       return [];
-    const typeName = itemType.raw?.replace(/\[\]$/, "") ?? itemType.raw;
+    const typeName = itemType.kind === "array" ? itemType.elementType?.raw ?? itemType.raw : itemType.raw;
     if (!typeName)
       return [];
     for (const td of this.state.currentTypeDefinitions) {
@@ -8242,7 +8620,8 @@ ${goFields.join(`
     const propFieldNames = new Set;
     for (const param of ir.metadata.propsParams) {
       const fieldName = capitalizeFieldName(param.name);
-      if (nestedArrayFields.has(fieldName))
+      const inputField = capitalizeFieldName(param.sourceName ?? param.name);
+      if (this.isNestedArrayShadowed(param, nestedArrayFields))
         continue;
       const hoisted = propFallbackVars.get(param.name);
       if (hoisted) {
@@ -8251,13 +8630,13 @@ ${goFields.join(`
         const paramDefault = goPropDefault(param.defaultValue);
         const memoFold = memoFallbacks.get(fieldName);
         if (paramDefault !== null) {
-          lines.push(`		${fieldName}: ${applyGoFallback(`in.${fieldName}`, paramDefault)},`);
+          lines.push(`		${fieldName}: ${applyGoFallback(`in.${inputField}`, paramDefault)},`);
         } else if (memoFold !== undefined && memoFold.goType === "string") {
-          lines.push(`		${fieldName}: ${applyGoFallback(`in.${fieldName}`, memoFold.goFallback)},`);
+          lines.push(`		${fieldName}: ${applyGoFallback(`in.${inputField}`, memoFold.goFallback)},`);
         } else if (memoFold !== undefined) {
-          lines.push(`		${fieldName}: func() interface{} { v := interface{}(in.${fieldName}); if v == nil || v == "" { return ${memoFold.goFallback} }; return v }(),`);
+          lines.push(`		${fieldName}: func() interface{} { v := interface{}(in.${inputField}); if v == nil || v == "" { return ${memoFold.goFallback} }; return v }(),`);
         } else {
-          lines.push(`		${fieldName}: in.${fieldName},`);
+          lines.push(`		${fieldName}: in.${inputField},`);
         }
       }
       propFieldNames.add(fieldName);
@@ -8310,7 +8689,7 @@ ${goFields.join(`
       lines.push(`		${f.name}: ${f.init},`);
     }
     const takenInit = new Set([
-      ...ir.metadata.propsParams.map((p) => capitalizeFieldName(p.name)),
+      ...this.propParamFieldNamesUnion(ir.metadata.propsParams),
       ...ir.metadata.signals.map((s) => capitalizeFieldName(s.getter)),
       ...ir.metadata.memos.map((m) => capitalizeFieldName(m.name))
     ]);
@@ -8349,7 +8728,7 @@ ${goFields.join(`
         }
         if (jsxName.includes("-"))
           return;
-        const fieldName = this.childPropFieldNames.get(child.name)?.get(jsxName) ?? capitalizeFieldName(jsxName);
+        const fieldName = capitalizeFieldName(jsxName);
         lines.push(`			${fieldName}: ${goValue},`);
       };
       for (const prop of child.props) {
@@ -8718,15 +9097,15 @@ ${goFields.join(`
       lines.push('\tSearchParams bf.SearchParams `json:"-"`');
     }
   }
-  emitPropsDataFields(lines, ir, nestedComponents, propTypeOverrides) {
+  emitPropsDataFields(lines, ir, nestedComponents, propTypeOverrides, takenJsonTags) {
     const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
     const propFieldNames = new Set;
     for (const param of ir.metadata.propsParams) {
       const fieldName = capitalizeFieldName(param.name);
-      if (nestedArrayFields.has(fieldName))
+      if (this.isNestedArrayShadowed(param, nestedArrayFields))
         continue;
       const goType = resolvePropGoType(this.emitCtx, param, propTypeOverrides);
-      const jsonTag = param.name === "children" ? "-" : this.toJsonTag(param.name);
+      const jsonTag = param.name === "children" ? "-" : this.claimJsonTag(this.toJsonTag(param.sourceName ?? param.name), takenJsonTags);
       lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
       propFieldNames.add(fieldName);
     }
@@ -8737,7 +9116,7 @@ ${goFields.join(`
       const fieldName = capitalizeFieldName(signal.getter);
       if (propFieldNames.has(fieldName))
         continue;
-      const jsonTag = this.toJsonTag(signal.getter);
+      const jsonTag = this.claimJsonTag(this.toJsonTag(signal.getter), takenJsonTags);
       const synthType = this.state.synthStructTypes.get(signal.getter);
       if (synthType) {
         lines.push(`	${fieldName} ${typeInfoToGo(this.emitCtx, synthType)} \`json:"${jsonTag}"\``);
@@ -8746,13 +9125,13 @@ ${goFields.join(`
       let goType;
       let referencedProp = propsParamMap.get(signal.initialValue);
       if (!referencedProp) {
-        const propName = this.extractPropNameFromInitialValue(signal.initialValue);
+        const propName = this.extractPropNameFromInitialValue(signal.initialValue, signal.parsed);
         if (propName)
           referencedProp = propsParamMap.get(propName);
       }
       if (referencedProp) {
-        const propGoType = typeInfoToGo(this.emitCtx, referencedProp.type, referencedProp.defaultValue);
-        const signalGoType = typeInfoToGo(this.emitCtx, signal.type, signal.initialValue);
+        const propGoType = typeInfoToGo(this.emitCtx, referencedProp.type, referencedProp.defaultValue, referencedProp.parsed);
+        const signalGoType = typeInfoToGo(this.emitCtx, signal.type, signal.initialValue, signal.parsed);
         if (propGoType.includes("interface{}")) {
           goType = signalGoType;
         } else if (!signalGoType.includes("interface{}") && signalGoType !== propGoType) {
@@ -8761,7 +9140,7 @@ ${goFields.join(`
           goType = propGoType;
         }
       } else {
-        goType = typeInfoToGo(this.emitCtx, signal.type, signal.initialValue);
+        goType = typeInfoToGo(this.emitCtx, signal.type, signal.initialValue, signal.parsed);
       }
       lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
     }
@@ -8769,12 +9148,12 @@ ${goFields.join(`
       const fieldName = capitalizeFieldName(memo.name);
       if (propFieldNames.has(fieldName))
         continue;
-      const jsonTag = this.toJsonTag(memo.name);
+      const jsonTag = this.claimJsonTag(this.toJsonTag(memo.name), takenJsonTags);
       const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap);
       lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
     }
   }
-  emitPropsAuxFields(lines, ir, componentName, nestedComponents, spreadSlots) {
+  emitPropsAuxFields(lines, ir, componentName, nestedComponents, spreadSlots, takenJsonTags) {
     const takenForDerivedConsts = new Set([
       ...ir.metadata.propsParams.map((p) => capitalizeFieldName(p.name)),
       ...ir.metadata.signals.map((s) => capitalizeFieldName(s.getter)),
@@ -8784,12 +9163,12 @@ ${goFields.join(`
       lines.push(`	${f.name} string \`json:"-"\``);
     }
     const takenProps = new Set([
-      ...ir.metadata.propsParams.map((p) => capitalizeFieldName(p.name)),
+      ...this.propParamFieldNamesUnion(ir.metadata.propsParams),
       ...ir.metadata.signals.map((s) => capitalizeFieldName(s.getter)),
       ...ir.metadata.memos.map((m) => capitalizeFieldName(m.name))
     ]);
     for (const c of this.nonCollidingContextConsumers(takenProps)) {
-      const jsonTag = this.toJsonTag(c.localName);
+      const jsonTag = this.claimJsonTag(this.toJsonTag(c.localName), takenJsonTags);
       lines.push(`	${this.contextFieldName(c)} ${this.contextConsumerGoType(c)} \`json:"${jsonTag}"\``);
     }
     for (const nested of nestedComponents) {
@@ -8797,7 +9176,7 @@ ${goFields.join(`
       if (nested.isDynamic && !nested.isPropDerived) {
         lines.push(`	${nested.name}s []${elemType} \`json:"-"\``);
       } else {
-        const jsonTag = this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`);
+        const jsonTag = this.claimJsonTag(this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`), takenJsonTags);
         lines.push(`	${nested.name}s []${elemType} \`json:"${jsonTag}"\``);
       }
     }
@@ -8806,7 +9185,7 @@ ${goFields.join(`
       lines.push(`	${child.fieldName} ${child.name}Props \`json:"-"\``);
     }
     for (const slot of spreadSlots) {
-      const jsonTag = this.toJsonTag(slot.slotId);
+      const jsonTag = this.claimJsonTag(this.toJsonTag(slot.slotId), takenJsonTags);
       lines.push(`	${slot.slotId} map[string]any \`json:"${jsonTag}"\``);
     }
   }
@@ -8982,8 +9361,9 @@ ${goFields.join(`
       return literal;
     if (node.kind === "logical" && node.op === "??" && node.right.kind === "object-literal" && node.right.properties.length === 0 && node.left.kind === "member" && !node.left.computed && node.left.object.kind === "identifier" && node.left.object.name === this.state.propsObjectName) {
       const propName = node.left.property;
-      if (propsParams.some((param) => param.name === propName)) {
-        const fieldRef = `in.${capitalizeFieldName(propName)}`;
+      const matchedParam = propsParams.find((param) => param.name === propName);
+      if (matchedParam) {
+        const fieldRef = `in.${capitalizeFieldName(matchedParam.sourceName ?? matchedParam.name)}`;
         return `func() map[string]interface{} { ` + `if m := bf.AsMap(${fieldRef}); m != nil { return m }; ` + `return map[string]interface{}{} }()`;
       }
     }
@@ -9001,7 +9381,7 @@ ${goFields.join(`
         const param = propsParams.find((p) => p.name === keyExpr);
         if (!param)
           return null;
-        const fieldName = capitalizeFieldName(keyExpr);
+        const fieldName = capitalizeFieldName(param.sourceName ?? keyExpr);
         const caseEntries = Object.entries(part.cases);
         if (caseEntries.length === 0) {
           segments.push('""');
@@ -9064,8 +9444,9 @@ ${goFields.join(`
     const localConst = this.state.localConstants.find((c) => c.name === passthroughName);
     const isPropsDestructureAlias = localConst !== undefined && propsObjectName !== null && localConst.value === `${propsObjectName}.${passthroughName}`;
     const shadowedByLocal = passthroughName !== null && (localConst !== undefined && !isPropsDestructureAlias || this.state.localHelperNames.has(passthroughName));
-    if (passthroughName && !shadowedByLocal && propsParams.some((p) => p.name === passthroughName)) {
-      return `in.${capitalizeFieldName(passthroughName)}`;
+    const passthroughParam = passthroughName && !shadowedByLocal ? propsParams.find((p) => p.name === passthroughName) : undefined;
+    if (passthroughParam) {
+      return `in.${capitalizeFieldName(passthroughParam.sourceName ?? passthroughParam.name)}`;
     }
     return null;
   }
@@ -9080,17 +9461,17 @@ ${goFields.join(`
         if (signal) {
           let referencedProp = propsParamMap.get(signal.initialValue);
           if (!referencedProp) {
-            const propName = this.extractPropNameFromInitialValue(signal.initialValue);
+            const propName = this.extractPropNameFromInitialValue(signal.initialValue, signal.parsed);
             if (propName)
               referencedProp = propsParamMap.get(propName);
           }
           if (referencedProp) {
-            const propType = typeInfoToGo(this.emitCtx, referencedProp.type, referencedProp.defaultValue);
+            const propType = typeInfoToGo(this.emitCtx, referencedProp.type, referencedProp.defaultValue, referencedProp.parsed);
             if (propType === "int" || propType === "float64") {
               return "int";
             }
           }
-          const signalType = typeInfoToGo(this.emitCtx, signal.type, signal.initialValue);
+          const signalType = typeInfoToGo(this.emitCtx, signal.type, signal.initialValue, signal.parsed);
           if (signalType === "int" || signalType === "float64") {
             return "int";
           }
@@ -9127,8 +9508,8 @@ ${goFields.join(`
         continue;
       if (goPropDefault(param.defaultValue) !== null)
         continue;
-      const fieldName = capitalizeFieldName(match.propName);
-      const concreteType = propTypeOverrides.get(param.name) ?? typeInfoToGo(this.emitCtx, param.type, param.defaultValue);
+      const fieldName = capitalizeFieldName(param.sourceName ?? match.propName);
+      const concreteType = propTypeOverrides.get(param.name) ?? typeInfoToGo(this.emitCtx, param.type, param.defaultValue, param.parsed);
       const nullishLowered = NULLISH_SCALAR_GO_TYPES.has(concreteType) && resolvePropGoType(this.emitCtx, param, propTypeOverrides) === "interface{}";
       let zeroLiteral;
       if (match.goFallback === "true" || match.goFallback === "false") {