@barefootjs/jsx 0.23.0 → 0.25.0

package/dist/index.js

@@ -5243,7 +5243,9 @@ var ErrorCodes = {
   INLINE_JSX_CALLBACK_CAPTURE: "BF080",
   UNRECOGNIZED_REACTIVE_FACTORY: "BF110",
   REACTIVE_FACTORY_RENAME_UNSUPPORTED: "BF111",
-  REACTIVE_FACTORY_MODULE_CAPTURE: "BF112"
+  REACTIVE_FACTORY_MODULE_CAPTURE: "BF112",
+  REACTIVE_FACTORY_IMPORT_COLLISION: "BF113",
+  REACTIVE_FACTORY_PARAM_SHADOWED: "BF114"
 };
 var errorMessages = {
   [ErrorCodes.MISSING_USE_CLIENT]: "'use client' directive required for components with createSignal or event handlers",
@@ -5269,7 +5271,9 @@ var errorMessages = {
   [ErrorCodes.INLINE_JSX_CALLBACK_CAPTURE]: "Inline JSX-returning arrow function captures a non-module identifier. Extract the callback into a top-level 'use client' component (e.g. `function MyNode(n) { return <div/> }` then `renderNode={MyNode}`) or pass captured values via component props.",
   [ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY]: "Tuple destructuring of a non-reactive factory call. The compiler only recognizes createSignal / createMemo calls and same-file helpers that wrap them with a single `return [a, b]` exit.",
   [ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED]: "Reactive factory object return/destructure must use shorthand properties only. " + "Property renames (`{ lists: myLists }`), defaults, and rest elements are not " + "supported — destructure with the factory's own property names.",
-  [ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE]: "Imported reactive factory references bindings from its own module scope, so its " + "body cannot be inlined into the component file. Move those helpers into the " + "component file, pass them to the factory as parameters, or define the factory " + "in the component file."
+  [ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE]: "Imported reactive factory references bindings from its own module scope, so its " + "body cannot be inlined into the component file. Move those helpers into the " + "component file, pass them to the factory as parameters, or define the factory " + "in the component file.",
+  [ErrorCodes.REACTIVE_FACTORY_IMPORT_COLLISION]: "Inlining an imported reactive factory requires re-importing one of its helper " + "imports into this file, but that name is already bound here to something else. " + "Rename the conflicting binding in this file, or alias the import in the factory's own file.",
+  [ErrorCodes.REACTIVE_FACTORY_PARAM_SHADOWED]: "Reactive factory parameter is shadowed by a nested declaration inside the factory body, so argument substitution at the inline site would be ambiguous. Rename the inner binding so it does not collide with the parameter."
 };
 function createError(code, loc, options) {
   if (code === undefined || !(code in errorMessages)) {
@@ -7780,6 +7784,75 @@ function prescanReactiveFactoriesInSource(source, filePath) {
   prescanImportedReactiveFactories(sourceFile, filePath, result);
   return result;
 }
+function toComponentRelativeSpecifier(resolvedAbs, componentFilePath) {
+  let rel = path_default.relative(path_default.dirname(componentFilePath), resolvedAbs).split(path_default.sep).join("/");
+  rel = rel.replace(/\.(tsx|ts|jsx|js)$/, "");
+  if (rel === "")
+    rel = ".";
+  if (!rel.startsWith("."))
+    rel = "./" + rel;
+  return rel;
+}
+function buildEntryImportIndex(sf, filePath) {
+  const index = new Map;
+  for (const stmt of sf.statements) {
+    if (!ts8.isImportDeclaration(stmt))
+      continue;
+    if (!ts8.isStringLiteral(stmt.moduleSpecifier))
+      continue;
+    if (stmt.importClause?.isTypeOnly)
+      continue;
+    const src = stmt.moduleSpecifier.text;
+    const targetKey = src.startsWith("./") || src.startsWith("../") ? resolveRelativeImportToFile(src, filePath) ?? "unresolved:" + src : src;
+    const namedBindings = stmt.importClause?.namedBindings;
+    if (namedBindings && ts8.isNamedImports(namedBindings)) {
+      for (const el of namedBindings.elements) {
+        if (el.isTypeOnly)
+          continue;
+        index.set(el.name.text, { targetKey, exportedName: (el.propertyName ?? el.name).text });
+      }
+    }
+  }
+  return index;
+}
+function collectEntryBindingNames(sf) {
+  const names = new Set;
+  function visit2(node) {
+    if (ts8.isImportDeclaration(node) && node.importClause) {
+      if (node.importClause.name)
+        names.add(node.importClause.name.text);
+      const namedBindings = node.importClause.namedBindings;
+      if (namedBindings && ts8.isNamedImports(namedBindings)) {
+        for (const el of namedBindings.elements)
+          names.add(el.name.text);
+      }
+      if (namedBindings && ts8.isNamespaceImport(namedBindings)) {
+        names.add(namedBindings.name.text);
+      }
+    }
+    if (ts8.isVariableDeclaration(node)) {
+      const out = [];
+      addBindingNames(node.name, out);
+      for (const n of out)
+        names.add(n);
+    }
+    if ((ts8.isFunctionDeclaration(node) || ts8.isClassDeclaration(node) || ts8.isEnumDeclaration(node)) && node.name) {
+      names.add(node.name.text);
+    }
+    if (ts8.isFunctionLike(node)) {
+      for (const p of node.parameters) {
+        const out = [];
+        addBindingNames(p.name, out);
+        for (const n of out)
+          names.add(n);
+      }
+    }
+    ts8.forEachChild(node, visit2);
+  }
+  visit2(sf);
+  return names;
+}
+var MAX_REEXPORT_HOPS = 1;
 function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
   const candidateCallees = new Set;
   function collectCandidates(node) {
@@ -7820,29 +7893,31 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
   }
   if (importsToCheck.length === 0)
     return;
-  for (const { src, specs } of importsToCheck) {
-    const resolved = resolveRelativeImportToFile(src, filePath);
-    if (!resolved)
-      continue;
+  const entryBindingNames = collectEntryBindingNames(entrySourceFile);
+  const entryImportIndex = buildEntryImportIndex(entrySourceFile, filePath);
+  const plannedInjections = new Map;
+  const helperCache = new Map;
+  function loadHelperFile(abs) {
+    const cached = helperCache.get(abs);
+    if (cached !== undefined)
+      return cached;
     let content;
     try {
-      content = fs.readFileSync(resolved, "utf8");
+      content = fs.readFileSync(abs, "utf8");
     } catch {
-      continue;
+      helperCache.set(abs, null);
+      return null;
     }
-    const alreadyKnown = (name) => result.factories.has(name) || result.declined.has(name) || result.reactiveShaped.has(name);
     const hasAnyPrimitiveText = [...REACTIVE_PRIMITIVES].some((p) => content.includes(p));
-    if (!hasAnyPrimitiveText) {
-      for (const spec of specs) {
-        if (!alreadyKnown(spec.local))
-          result.cleanFactoryImports.add(spec.local);
-      }
-      continue;
+    const hasReexportText = content.includes("export") && content.includes("from");
+    if (!hasAnyPrimitiveText && !hasReexportText) {
+      helperCache.set(abs, "clean");
+      return "clean";
     }
-    const helperSf = ts8.createSourceFile(resolved + ".prescan", content, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TSX);
+    const sf = ts8.createSourceFile(abs + ".prescan", content, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TSX);
     const localFns = new Map;
     const exportedFns = new Map;
-    for (const stmt of helperSf.statements) {
+    for (const stmt of sf.statements) {
       if (ts8.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
         localFns.set(stmt.name.text, stmt);
         const hasExportModifier = stmt.modifiers?.some((m) => m.kind === ts8.SyntaxKind.ExportKeyword) ?? false;
@@ -7852,27 +7927,89 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
         }
       }
     }
-    for (const stmt of helperSf.statements) {
-      if (ts8.isExportDeclaration(stmt) && stmt.exportClause && ts8.isNamedExports(stmt.exportClause) && !stmt.moduleSpecifier && !stmt.isTypeOnly) {
+    const reexports = new Map;
+    let hasStarReexport = false;
+    for (const stmt of sf.statements) {
+      if (!ts8.isExportDeclaration(stmt) || stmt.isTypeOnly)
+        continue;
+      if (!stmt.moduleSpecifier) {
+        if (stmt.exportClause && ts8.isNamedExports(stmt.exportClause)) {
+          for (const el of stmt.exportClause.elements) {
+            if (el.isTypeOnly)
+              continue;
+            const fn = localFns.get((el.propertyName ?? el.name).text);
+            if (fn)
+              exportedFns.set(el.name.text, fn);
+          }
+        }
+        continue;
+      }
+      if (!ts8.isStringLiteral(stmt.moduleSpecifier))
+        continue;
+      if (stmt.exportClause && ts8.isNamedExports(stmt.exportClause)) {
         for (const el of stmt.exportClause.elements) {
           if (el.isTypeOnly)
             continue;
-          const fn = localFns.get((el.propertyName ?? el.name).text);
-          if (fn)
-            exportedFns.set(el.name.text, fn);
+          reexports.set(el.name.text, {
+            source: stmt.moduleSpecifier.text,
+            innerName: (el.propertyName ?? el.name).text
+          });
         }
-      }
-    }
-    const moduleBindings = collectHelperModuleValueBindings(helperSf);
+      } else if (!stmt.exportClause) {
+        hasStarReexport = true;
+      }
+    }
+    const moduleBindings = collectHelperModuleValueBindings(sf);
+    const info = { sf, exportedFns, reexports, hasStarReexport, moduleBindings };
+    helperCache.set(abs, info);
+    return info;
+  }
+  function lookupExportedFactory(abs, exportedName, visited, hopsLeft) {
+    if (visited.has(abs))
+      return { kind: "unknown" };
+    visited.add(abs);
+    const file = loadHelperFile(abs);
+    if (file === null)
+      return { kind: "unknown" };
+    if (file === "clean")
+      return { kind: "clean" };
+    const fn = file.exportedFns.get(exportedName);
+    if (fn)
+      return { kind: "fn", fn, file, definingPath: abs };
+    const re = file.reexports.get(exportedName);
+    if (re) {
+      if (hopsLeft <= 0)
+        return { kind: "unknown" };
+      if (!re.source.startsWith("./") && !re.source.startsWith("../"))
+        return { kind: "unknown" };
+      const target = resolveRelativeImportToFile(re.source, abs);
+      if (!target)
+        return { kind: "unknown" };
+      return lookupExportedFactory(target, re.innerName, visited, hopsLeft - 1);
+    }
+    if (file.hasStarReexport)
+      return { kind: "unknown" };
+    return { kind: "clean" };
+  }
+  for (const { src, specs } of importsToCheck) {
+    const resolved = resolveRelativeImportToFile(src, filePath);
+    if (!resolved)
+      continue;
+    const alreadyKnown = (name) => result.factories.has(name) || result.declined.has(name) || result.reactiveShaped.has(name);
     for (const spec of specs) {
       if (alreadyKnown(spec.local))
         continue;
-      const fn = exportedFns.get(spec.exported);
-      if (!fn) {
+      const found = lookupExportedFactory(resolved, spec.exported, new Set, MAX_REEXPORT_HOPS);
+      if (found.kind === "clean") {
         result.cleanFactoryImports.add(spec.local);
         continue;
       }
-      const det = detectReactiveFactory(fn, helperSf, resolved);
+      if (found.kind === "unknown")
+        continue;
+      const { fn, file, definingPath } = found;
+      const helperSf = file.sf;
+      const moduleBindings = file.moduleBindings;
+      const det = detectReactiveFactory(fn, helperSf, definingPath);
       if (!det) {
         result.cleanFactoryImports.add(spec.local);
         continue;
@@ -7885,17 +8022,64 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
           result.declined.set(spec.local, det.declined);
           break;
         case "factory": {
-          const offending = moduleCaptureCheck(fn, det.info, moduleBindings, fn.name.text);
-          if (offending.length > 0) {
+          const capture = moduleCaptureCheck(fn, det.info, moduleBindings, fn.name.text);
+          if (capture.captured.length > 0) {
             result.declined.set(spec.local, {
               code: "BF112",
-              detail: `'${offending.join("', '")}'`,
+              detail: `'${capture.captured.join("', '")}'`,
               loc: det.info.loc
             });
-          } else {
-            det.info.sourceFilePath = resolved;
-            result.factories.set(spec.local, det.info);
+            break;
+          }
+          const required = [];
+          const pending = [];
+          let declinedEntry = null;
+          for (const ref of capture.importedRefs) {
+            let specifier;
+            let targetKey;
+            if (ref.source.startsWith("./") || ref.source.startsWith("../")) {
+              const abs = resolveRelativeImportToFile(ref.source, definingPath);
+              if (!abs) {
+                declinedEntry = {
+                  code: "BF112",
+                  detail: `'${ref.localName}' (import '${ref.source}' did not resolve from the helper file)`,
+                  loc: det.info.loc
+                };
+                break;
+              }
+              specifier = toComponentRelativeSpecifier(abs, filePath);
+              targetKey = abs;
+            } else {
+              specifier = ref.source;
+              targetKey = ref.source;
+            }
+            const existing = entryImportIndex.get(ref.localName);
+            if (existing && existing.targetKey === targetKey && existing.exportedName === ref.exportedName) {
+              continue;
+            }
+            const planned = plannedInjections.get(ref.localName);
+            const collides = existing !== undefined || planned !== undefined && (planned.targetKey !== targetKey || planned.exportedName !== ref.exportedName) || planned === undefined && entryBindingNames.has(ref.localName);
+            if (collides) {
+              declinedEntry = {
+                code: "BF113",
+                detail: `'${ref.localName}' from '${specifier}'`,
+                loc: det.info.loc
+              };
+              break;
+            }
+            pending.push([ref.localName, { targetKey, exportedName: ref.exportedName }]);
+            required.push({ localName: ref.localName, exportedName: ref.exportedName, specifier });
+          }
+          if (declinedEntry) {
+            result.declined.set(spec.local, declinedEntry);
+            break;
           }
+          for (const [name, id] of pending)
+            plannedInjections.set(name, id);
+          det.info.sourceFilePath = definingPath;
+          if (required.length > 0)
+            det.info.requiredImports = required;
+          result.factories.set(spec.local, det.info);
           break;
         }
       }
@@ -7903,7 +8087,8 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
   }
 }
 function collectHelperModuleValueBindings(sf) {
-  const names = new Set;
+  const local = new Set;
+  const imported = new Map;
   for (const stmt of sf.statements) {
     if (ts8.isVariableStatement(stmt)) {
       const out = [];
@@ -7911,11 +8096,11 @@ function collectHelperModuleValueBindings(sf) {
         addBindingNames(decl.name, out);
       }
       for (const n of out)
-        names.add(n);
+        local.add(n);
       continue;
     }
     if ((ts8.isFunctionDeclaration(stmt) || ts8.isClassDeclaration(stmt) || ts8.isEnumDeclaration(stmt)) && stmt.name) {
-      names.add(stmt.name.text);
+      local.add(stmt.name.text);
       continue;
     }
     if (ts8.isImportDeclaration(stmt)) {
@@ -7927,25 +8112,25 @@ function collectHelperModuleValueBindings(sf) {
       if (src === "@barefootjs/client" || src === "@barefootjs/client/runtime")
         continue;
       if (stmt.importClause?.name)
-        names.add(stmt.importClause.name.text);
+        local.add(stmt.importClause.name.text);
       const namedBindings = stmt.importClause?.namedBindings;
       if (namedBindings && ts8.isNamedImports(namedBindings)) {
         for (const el of namedBindings.elements) {
           if (el.isTypeOnly)
             continue;
-          names.add(el.name.text);
+          imported.set(el.name.text, { source: src, exportedName: (el.propertyName ?? el.name).text });
         }
       }
       if (namedBindings && ts8.isNamespaceImport(namedBindings)) {
-        names.add(namedBindings.name.text);
+        local.add(namedBindings.name.text);
       }
     }
   }
-  return names;
+  return { local, imported };
 }
 function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
   if (!fn.body)
-    return [];
+    return { captured: [], importedRefs: [] };
   const free = extractFreeIdentifiersFromNode(fn.body);
   const exclude = new Set(info.params);
   for (const b of info.localBindings)
@@ -7955,14 +8140,22 @@ function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
   for (const p of REACTIVE_PRIMITIVES)
     exclude.add(p);
   exclude.add(selfName);
-  const offending = [];
+  const captured = [];
+  const importedRefs = [];
   for (const id of free) {
     if (exclude.has(id))
       continue;
-    if (moduleBindings.has(id))
-      offending.push(id);
+    if (moduleBindings.local.has(id)) {
+      captured.push(id);
+      continue;
+    }
+    const imp = moduleBindings.imported.get(id);
+    if (imp)
+      importedRefs.push({ localName: id, source: imp.source, exportedName: imp.exportedName });
   }
-  return offending.sort();
+  captured.sort();
+  importedRefs.sort((a, b) => a.localName < b.localName ? -1 : 1);
+  return { captured, importedRefs };
 }
 function detectReactiveFactory(node, sourceFile, filePath) {
   if (!node.body || !node.name)
@@ -7981,6 +8174,17 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   if (!hasReactiveCall)
     return null;
   const loc = getSourceLocation(node, sourceFile, filePath);
+  let totalReturnCount = 0;
+  function countReturns(n) {
+    if (ts8.isFunctionLike(n))
+      return;
+    if (ts8.isReturnStatement(n)) {
+      totalReturnCount++;
+      return;
+    }
+    ts8.forEachChild(n, countReturns);
+  }
+  ts8.forEachChild(node.body, countReturns);
   let returnExpr = null;
   let returnCount = 0;
   for (const stmt of node.body.statements) {
@@ -7998,7 +8202,7 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       expr = expr.expression;
     returnExpr = expr;
   }
-  if (returnCount !== 1 || !returnExpr)
+  if (totalReturnCount !== 1 || returnCount !== 1 || !returnExpr)
     return { kind: "reactive-shaped" };
   const returnTupleIdentifiers = [];
   let returnKind;
@@ -8032,6 +8236,14 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   } else {
     return { kind: "reactive-shaped" };
   }
+  const params = [];
+  for (const p of node.parameters) {
+    if (ts8.isIdentifier(p.name)) {
+      params.push(p.name.text);
+      continue;
+    }
+    return { kind: "reactive-shaped" };
+  }
   const localBindings = [];
   for (const stmt of node.body.statements) {
     if (ts8.isVariableStatement(stmt)) {
@@ -8042,15 +8254,95 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       localBindings.push(stmt.name.text);
     }
   }
-  const bodyStatements = node.body.statements.filter((s) => !ts8.isReturnStatement(s)).map((s) => s.getText(sourceFile)).join(`
+  const relevantNames = new Set([...params, ...localBindings, ...returnTupleIdentifiers]);
+  const renameSites = [];
+  let shadowedParam = null;
+  function collectRenameSites(root, toBodyOffset) {
+    function push(id, form) {
+      renameSites.push({
+        name: id.text,
+        start: toBodyOffset(id.getStart(sourceFile)),
+        end: toBodyOffset(id.getEnd()),
+        form
+      });
+    }
+    function classify(id) {
+      if (!relevantNames.has(id.text))
+        return;
+      const p = id.parent;
+      if (ts8.isPropertyAccessExpression(p) && p.name === id)
+        return;
+      if (ts8.isPropertyAssignment(p) && p.name === id)
+        return;
+      if (ts8.isBindingElement(p) && p.propertyName === id)
+        return;
+      if ((ts8.isMethodDeclaration(p) || ts8.isGetAccessorDeclaration(p) || ts8.isSetAccessorDeclaration(p) || ts8.isPropertyDeclaration(p) || ts8.isEnumMember(p)) && p.name === id)
+        return;
+      if (ts8.isJsxAttribute(p) && p.name === id)
+        return;
+      if (ts8.isLabeledStatement(p) && p.label === id || (ts8.isBreakStatement(p) || ts8.isContinueStatement(p)) && p.label === id)
+        return;
+      if ((ts8.isJsxOpeningElement(p) || ts8.isJsxSelfClosingElement(p) || ts8.isJsxClosingElement(p)) && p.tagName === id && /^[a-z]/.test(id.text))
+        return;
+      if (ts8.isShorthandPropertyAssignment(p) && p.name === id) {
+        push(id, "shorthand");
+        return;
+      }
+      if (ts8.isBindingElement(p) && p.name === id && !p.propertyName && ts8.isObjectBindingPattern(p.parent)) {
+        if (params.includes(id.text))
+          shadowedParam = id.text;
+        push(id, "shorthand");
+        return;
+      }
+      const isDecl = (ts8.isVariableDeclaration(p) || ts8.isParameter(p) || ts8.isBindingElement(p) || ts8.isFunctionDeclaration(p) || ts8.isFunctionExpression(p) || ts8.isClassDeclaration(p) || ts8.isClassExpression(p)) && p.name === id;
+      if (isDecl && params.includes(id.text))
+        shadowedParam = id.text;
+      push(id, "plain");
+    }
+    function visit2(n) {
+      if (ts8.isTypeNode(n) || ts8.isTypeParameterDeclaration(n) || ts8.isTypeAliasDeclaration(n) || ts8.isInterfaceDeclaration(n))
+        return;
+      if (ts8.isIdentifier(n)) {
+        classify(n);
+        return;
+      }
+      ts8.forEachChild(n, visit2);
+    }
+    visit2(root);
+  }
+  const keptStatements = node.body.statements.filter((s) => !ts8.isReturnStatement(s));
+  const pieces = [];
+  let base = 0;
+  for (const stmt of keptStatements) {
+    const text = stmt.getText(sourceFile);
+    const stmtStart = stmt.getStart(sourceFile);
+    collectRenameSites(stmt, (pos) => pos - stmtStart + base);
+    pieces.push(text);
+    base += text.length + 1;
+  }
+  const bodyStatements = pieces.join(`
 `);
-  const params = [];
-  for (const p of node.parameters) {
-    if (ts8.isIdentifier(p.name)) {
-      params.push(p.name.text);
-      continue;
+  if (shadowedParam !== null) {
+    return {
+      kind: "declined",
+      declined: {
+        code: "BF114",
+        detail: `parameter '${shadowedParam}' of '${node.name.text}' is shadowed by a nested declaration inside the factory body`,
+        loc
+      }
+    };
+  }
+  for (const site of renameSites) {
+    if (bodyStatements.slice(site.start, site.end) !== site.name) {
+      return {
+        kind: "declined",
+        declined: {
+          code: "BF111",
+          detail: `internal rename-site offset mismatch for '${site.name}' — this is a compiler bug, ` + `please report it`,
+          loc
+        }
+      };
     }
-    return { kind: "reactive-shaped" };
   }
   return {
     kind: "factory",
@@ -8060,7 +8352,8 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       returnTupleIdentifiers,
       returnKind,
       localBindings,
-      loc
+      loc,
+      renameSites
     }
   };
 }
@@ -8086,6 +8379,7 @@ function rewriteFactoryCallsInSource(source, prescan) {
   const { factories, sourceFile } = prescan;
   const edits = [];
   let callSiteIndex = 0;
+  const inlinedFactories = new Set;
   function visitStmt(node, inComponent) {
     if (ts8.isVariableStatement(node) && inComponent) {
       for (const decl of node.declarationList.declarations) {
@@ -8163,34 +8457,65 @@ function rewriteFactoryCallsInSource(source, prescan) {
     const argTexts = args.map((a) => a.getText(sourceFile));
     const thisCallIndex = callSiteIndex++;
     const suffix = `_bf${thisCallIndex}`;
-    let body = factory.bodySource;
-    const internalRenames = new Set(factory.localBindings);
-    for (const ex of excludeFromSuffixRename)
-      internalRenames.delete(ex);
-    for (const name of internalRenames) {
-      body = body.replace(new RegExp(`\\b${escapeRegex(name)}\\b`, "g"), name + suffix);
+    const renames = new Map;
+    for (const name of factory.localBindings) {
+      if (!excludeFromSuffixRename.has(name))
+        renames.set(name, name + suffix);
+    }
+    if (renameReturnToCallerNames) {
+      for (const [n, caller] of renameReturnToCallerNames) {
+        if (caller !== n)
+          renames.set(n, caller);
+      }
     }
     const atomicArg = /^(?:[\w$.]+|'[^'\\]*'|"[^"\\]*"|-?\d+(?:\.\d+)?)$/;
     for (let i = 0;i < factory.params.length; i++) {
       const p = factory.params[i];
-      const a = argTexts[i] ?? "undefined";
-      const wrapped = atomicArg.test(a.trim()) ? a.trim() : `(${a})`;
-      body = body.replace(new RegExp(`\\b${escapeRegex(p)}\\b`, "g"), wrapped);
+      const a = (argTexts[i] ?? "undefined").trim();
+      renames.set(p, atomicArg.test(a) ? a : `(${a})`);
     }
-    if (renameReturnToCallerNames) {
-      for (const [n, caller] of renameReturnToCallerNames) {
-        body = body.replace(new RegExp(`\\b${escapeRegex(n)}\\b`, "g"), caller);
-      }
+    let body = factory.bodySource;
+    for (let i = factory.renameSites.length - 1;i >= 0; i--) {
+      const site = factory.renameSites[i];
+      const repl = renames.get(site.name);
+      if (repl === undefined)
+        continue;
+      const text = site.form === "shorthand" ? `${site.name}: ${repl}` : repl;
+      body = body.slice(0, site.start) + text + body.slice(site.end);
     }
     edits.push({
       start: stmt.getStart(sourceFile),
       end: stmt.getEnd(),
       replacement: body
     });
+    inlinedFactories.add(factory);
   }
   visitStmt(sourceFile, false);
   if (edits.length === 0)
     return source;
+  const importsBySpecifier = new Map;
+  for (const f of inlinedFactories) {
+    for (const r of f.requiredImports ?? []) {
+      let names = importsBySpecifier.get(r.specifier);
+      if (!names) {
+        names = new Map;
+        importsBySpecifier.set(r.specifier, names);
+      }
+      names.set(r.localName, r.exportedName);
+    }
+  }
+  if (importsBySpecifier.size > 0) {
+    const lines = [...importsBySpecifier].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([spec, names]) => {
+      const specifiers = [...names].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([local, exported]) => exported === local ? local : `${exported} as ${local}`);
+      return `import { ${specifiers.join(", ")} } from '${spec}'`;
+    });
+    const at = factoryImportInsertionOffset(sourceFile);
+    edits.push({ start: at, end: at, replacement: at === 0 ? lines.join(`
+`) + `
+` : `
+` + lines.join(`
+`) });
+  }
   edits.sort((a, b) => b.start - a.start);
   let out = source;
   for (const e of edits) {
@@ -8198,6 +8523,20 @@ function rewriteFactoryCallsInSource(source, prescan) {
   }
   return out;
 }
+function factoryImportInsertionOffset(sf) {
+  let lastImportEnd = -1;
+  let directiveEnd = -1;
+  for (const stmt of sf.statements) {
+    if (ts8.isImportDeclaration(stmt)) {
+      lastImportEnd = stmt.getEnd();
+      continue;
+    }
+    if (directiveEnd === -1 && ts8.isExpressionStatement(stmt) && ts8.isStringLiteral(stmt.expression) && stmt.expression.text === "use client") {
+      directiveEnd = stmt.getEnd();
+    }
+  }
+  return lastImportEnd >= 0 ? lastImportEnd : directiveEnd >= 0 ? directiveEnd : 0;
+}
 function isPascalCaseComponentFn(node) {
   if (ts8.isFunctionDeclaration(node) && node.name) {
     return /^[A-Z]/.test(node.name.text);
@@ -8207,15 +8546,27 @@ function isPascalCaseComponentFn(node) {
   }
   return false;
 }
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function declinedFactoryMessage(callee, d) {
   if (d.code === "BF112") {
     return `Reactive factory '${callee}' references ${d.detail} from its own module ` + `scope and cannot be inlined. Move the referenced helper(s) into this file, ` + `pass them as factory arguments, or inline the factory here.`;
   }
+  if (d.code === "BF113") {
+    return `Reactive factory '${callee}' cannot be inlined: it needs ${d.detail} ` + `imported into this file, but that name is already bound here to something ` + `else. Rename the conflicting binding in this file, or alias the import in ` + `the factory's own file (import { x as y }).`;
+  }
   return `Reactive factory '${callee}' cannot be inlined: ${d.detail}.`;
 }
+function declinedFactoryErrorCode(code) {
+  switch (code) {
+    case "BF112":
+      return ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE;
+    case "BF113":
+      return ErrorCodes.REACTIVE_FACTORY_IMPORT_COLLISION;
+    case "BF114":
+      return ErrorCodes.REACTIVE_FACTORY_PARAM_SHADOWED;
+    default:
+      return ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED;
+  }
+}
 function validateReactiveFactoryCalls(ctx) {
   if (!ctx.componentNode)
     return;
@@ -8239,7 +8590,7 @@ function validateReactiveFactoryCalls(ctx) {
           continue;
         const declinedEntry = ctx.declinedReactiveFactories.get(callee);
         if (declinedEntry) {
-          ctx.errors.push(createError(declinedEntry.code === "BF112" ? ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE : ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED, loc, { severity: "error", message: declinedFactoryMessage(callee, declinedEntry) }));
+          ctx.errors.push(createError(declinedFactoryErrorCode(declinedEntry.code), loc, { severity: "error", message: declinedFactoryMessage(callee, declinedEntry) }));
           continue;
         }
         const objectFactory = ctx.reactiveFactories.get(callee);
@@ -8296,7 +8647,7 @@ function validateObjectFactoryDestructure(ctx, pattern, callee, loc) {
   }
   const declinedEntry = ctx.declinedReactiveFactories.get(callee);
   if (declinedEntry) {
-    ctx.errors.push(createError(declinedEntry.code === "BF112" ? ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE : ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED, loc, { severity: "error", message: declinedFactoryMessage(callee, declinedEntry) }));
+    ctx.errors.push(createError(declinedFactoryErrorCode(declinedEntry.code), loc, { severity: "error", message: declinedFactoryMessage(callee, declinedEntry) }));
     return;
   }
   if (ctx.reactiveShapedHelpers.has(callee)) {
@@ -8848,19 +9199,83 @@ function resolveFreeRefs(node, env) {
 // src/to-locale-date-lowering.ts
 var TO_LOCALE_TZ_RE = /^(?:UTC|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
 var PROBE_UTC = new Date(Date.UTC(2001, 1, 3));
-var patternCache = new Map;
-function resolveLocaleDatePattern(locale) {
-  const cached = patternCache.get(locale);
+var formatCache = new Map;
+var namesCache = new Map;
+function deriveMonthNames(locale, ctx) {
+  return deriveNamesCached(`${locale}|m|${ctx}`, () => {
+    const months = (width) => Array.from({ length: 12 }, (_, m) => probePart(locale, ctx === "formatting" ? { month: width, day: "numeric" } : { month: width }, Date.UTC(2001, m, 15), "month"));
+    return [...months("long"), ...months("short")];
+  });
+}
+function deriveWeekdayNames(locale, ctx) {
+  return deriveNamesCached(`${locale}|w|${ctx}`, () => {
+    const weekdays = (width) => Array.from({ length: 7 }, (_, d) => probePart(locale, ctx === "formatting" ? { weekday: width, month: "numeric", day: "numeric" } : { weekday: width }, Date.UTC(2023, 0, 1 + d), "weekday"));
+    return [...weekdays("long"), ...weekdays("short")];
+  });
+}
+function probePart(locale, options, utc, type) {
+  const parts = new Intl.DateTimeFormat(locale, { ...options, timeZone: "UTC" }).formatToParts(new Date(utc));
+  const found = parts.find((p) => p.type === type);
+  if (!found || !found.value)
+    throw new Error("missing part");
+  return found.value;
+}
+function deriveNamesCached(key, derive) {
+  const cached = namesCache.get(key);
   if (cached !== undefined)
     return cached;
-  const derived = derivePattern(locale);
-  patternCache.set(locale, derived);
+  let derived;
+  try {
+    derived = derive();
+  } catch {
+    derived = null;
+  }
+  namesCache.set(key, derived);
   return derived;
 }
-function derivePattern(locale) {
+function resolveLocaleDateFormat(locale, probeOptions) {
+  const key = `${locale}|${JSON.stringify(probeOptions, Object.keys(probeOptions).sort())}`;
+  const cached = formatCache.get(key);
+  if (cached !== undefined)
+    return cached;
+  const derived = deriveFormat(locale, probeOptions);
+  formatCache.set(key, derived);
+  return derived;
+}
+var VERIFY_UTC = new Date(Date.UTC(2001, 4, 13));
+function renderPatternAt(pattern, names, y, m, d, wd) {
+  const pad2 = (n) => String(n).padStart(2, "0");
+  return pattern.replace(/YYYY|MMMM|MMM|MM|DD|dddd|ddd|M|D/g, (token) => {
+    switch (token) {
+      case "YYYY":
+        return String(y).padStart(4, "0");
+      case "MMMM":
+        return names[m - 1] ?? "";
+      case "MMM":
+        return names[12 + m - 1] ?? "";
+      case "MM":
+        return pad2(m);
+      case "M":
+        return String(m);
+      case "DD":
+        return pad2(d);
+      case "D":
+        return String(d);
+      case "dddd":
+        return names[24 + wd] ?? "";
+      default:
+        return names[31 + wd] ?? "";
+    }
+  });
+}
+function deriveFormat(locale, probeOptions) {
+  let dtf;
   let parts;
   try {
-    const dtf = new Intl.DateTimeFormat(locale, { timeZone: "UTC" });
+    dtf = new Intl.DateTimeFormat(locale, {
+      ...probeOptions,
+      timeZone: "UTC"
+    });
     const resolved = dtf.resolvedOptions();
     if (resolved.calendar !== "gregory" || resolved.numberingSystem !== "latn")
       return null;
@@ -8868,7 +9283,18 @@ function derivePattern(locale) {
   } catch {
     return null;
   }
+  const monthTables = [
+    deriveMonthNames(locale, "formatting"),
+    deriveMonthNames(locale, "standalone")
+  ];
+  const weekdayTables = [
+    deriveWeekdayNames(locale, "formatting"),
+    deriveWeekdayNames(locale, "standalone")
+  ];
+  let monthTable = null;
+  let weekdayTable = null;
   let pattern = "";
+  let usesNames = false;
   for (const part of parts) {
     switch (part.type) {
       case "year":
@@ -8876,14 +9302,27 @@ function derivePattern(locale) {
           return null;
         pattern += "YYYY";
         break;
-      case "month":
-        if (part.value === "2")
+      case "month": {
+        if (part.value === "2") {
           pattern += "M";
-        else if (part.value === "02")
+          break;
+        }
+        if (part.value === "02") {
           pattern += "MM";
+          break;
+        }
+        const wide = monthTables.find((t) => t && part.value === t[1]) ?? null;
+        const abbr = wide ? null : monthTables.find((t) => t && part.value === t[12 + 1]) ?? null;
+        if (wide)
+          pattern += "MMMM";
+        else if (abbr)
+          pattern += "MMM";
         else
           return null;
+        monthTable = wide ?? abbr;
+        usesNames = true;
         break;
+      }
       case "day":
         if (part.value === "3")
           pattern += "D";
@@ -8892,8 +9331,21 @@ function derivePattern(locale) {
         else
           return null;
         break;
+      case "weekday": {
+        const wide = weekdayTables.find((t) => t && part.value === t[6]) ?? null;
+        const abbr = wide ? null : weekdayTables.find((t) => t && part.value === t[7 + 6]) ?? null;
+        if (wide)
+          pattern += "dddd";
+        else if (abbr)
+          pattern += "ddd";
+        else
+          return null;
+        weekdayTable = wide ?? abbr;
+        usesNames = true;
+        break;
+      }
       case "literal":
-        if (/[YMD]/.test(part.value))
+        if (/[YMD]/.test(part.value) || /ddd/.test(part.value))
           return null;
         pattern += part.value;
         break;
@@ -8901,9 +9353,73 @@ function derivePattern(locale) {
         return null;
     }
   }
-  if (!pattern.includes("YYYY") || !/M/.test(pattern) || !/D/.test(pattern))
+  if (!/YYYY|MMMM|MMM|MM|M/.test(pattern) && !/DD|D/.test(pattern))
+    return null;
+  if (!usesNames)
+    return { pattern, names: null };
+  const names = [
+    ...monthTable ?? monthTables[0] ?? monthTables[1] ?? Array(24).fill(""),
+    ...weekdayTable ?? weekdayTables[0] ?? weekdayTables[1] ?? Array(14).fill("")
+  ];
+  if (renderPatternAt(pattern, names, 2001, 5, 13, 0) !== dtf.format(VERIFY_UTC))
     return null;
-  return pattern;
+  return { pattern, names };
+}
+function unionMemberLiteral(member) {
+  const m = /^'([^'\\]*)'$|^"([^"\\]*)"$/.exec(member.raw.trim());
+  return m ? m[1] ?? m[2] : null;
+}
+function resolveLocaleUnionMembers(locale, metadata) {
+  let sourcePropName = null;
+  if (metadata.propsObjectName) {
+    if (locale.kind === "member" && !locale.computed && locale.object.kind === "identifier" && locale.object.name === metadata.propsObjectName) {
+      sourcePropName = locale.property;
+    }
+  } else if (locale.kind === "identifier") {
+    const name = locale.name;
+    const param = metadata.propsParams?.find((pp) => pp.name === name);
+    if (param)
+      sourcePropName = param.sourceName ?? param.name;
+  }
+  if (!sourcePropName)
+    return null;
+  const target = sourcePropName;
+  const prop = metadata.propsType?.properties?.find((p) => p.name === target);
+  if (!prop || prop.optional)
+    return null;
+  const type = prop.type;
+  if (type.kind !== "union" || !type.unionTypes || type.unionTypes.length === 0)
+    return null;
+  const members = [];
+  for (const member of type.unionTypes) {
+    const value = unionMemberLiteral(member);
+    if (value === null)
+      return null;
+    members.push(value);
+  }
+  return members;
+}
+var strLit = (value) => ({ kind: "literal", value, literalType: "string" });
+function strArr(values) {
+  return {
+    kind: "array-literal",
+    elements: values.map((v) => strLit(v)),
+    raw: JSON.stringify(values)
+  };
+}
+function foldMembers(locale, members, leaves, allEqual) {
+  let expr = leaves[leaves.length - 1];
+  if (allEqual)
+    return expr;
+  for (let i = leaves.length - 2;i >= 0; i--) {
+    expr = {
+      kind: "conditional",
+      test: { kind: "binary", op: "===", left: locale, right: strLit(members[i]) },
+      consequent: leaves[i],
+      alternate: expr
+    };
+  }
+  return expr;
 }
 function matchToLocaleDateStringCall(callee, args, metadata) {
   if (callee.kind !== "member" || callee.computed)
@@ -8911,17 +9427,23 @@ function matchToLocaleDateStringCall(callee, args, metadata) {
   if (callee.property !== "toLocaleDateString" || args.length !== 2)
     return null;
   const [locale, options] = args;
-  if (locale.kind !== "literal" || locale.literalType !== "string")
-    return null;
-  if (options.kind !== "object-literal" || options.properties.length !== 1)
-    return null;
-  const prop = options.properties[0];
-  if (prop.key !== "timeZone")
-    return null;
-  if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
+  if (options.kind !== "object-literal")
     return null;
-  const tz = String(prop.value.value);
-  if (!TO_LOCALE_TZ_RE.test(tz))
+  let tz = null;
+  const probeOptions = {};
+  for (const prop of options.properties) {
+    if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
+      return null;
+    const value = String(prop.value.value);
+    if (prop.key === "timeZone") {
+      if (!TO_LOCALE_TZ_RE.test(value))
+        return null;
+      tz = value;
+    } else {
+      probeOptions[prop.key] = value;
+    }
+  }
+  if (tz === null)
     return null;
   const receiverType = resolveReceiverType(callee.object, metadata, new Map);
   if (!receiverType || receiverType.kind !== "interface")
@@ -8931,19 +9453,64 @@ function matchToLocaleDateStringCall(callee, args, metadata) {
     return null;
   if (metadata.typeDefinitions.some((d) => d.name === typeName))
     return null;
-  const pattern = resolveLocaleDatePattern(String(locale.value));
-  if (pattern === null)
+  if (locale.kind === "literal" && locale.literalType === "string") {
+    const format2 = resolveLocaleDateFormat(String(locale.value), probeOptions);
+    if (format2 === null)
+      return null;
+    return {
+      kind: "helper-call",
+      helper: "format_date",
+      args: [callee.object, strLit(format2.pattern), strLit(tz), strArr(format2.names ?? [])]
+    };
+  }
+  const members = resolveLocaleUnionMembers(locale, metadata);
+  if (!members)
     return null;
+  const formats = [];
+  for (const member of members) {
+    const format2 = resolveLocaleDateFormat(member, probeOptions);
+    if (format2 === null)
+      return null;
+    formats.push(format2);
+  }
+  const patterns = formats.map((f) => f.pattern);
+  const nameTables = formats.map((f) => JSON.stringify(f.names ?? []));
   return {
     kind: "helper-call",
     helper: "format_date",
     args: [
       callee.object,
-      { kind: "literal", value: pattern, literalType: "string" },
-      { kind: "literal", value: tz, literalType: "string" }
+      foldMembers(locale, members, patterns.map(strLit), new Set(patterns).size === 1),
+      strLit(tz),
+      foldMembers(locale, members, formats.map((f) => strArr(f.names ?? [])), new Set(nameTables).size === 1)
     ]
   };
 }
+function foldedArgToClientJs(arg, localeText) {
+  if (arg.kind === "literal")
+    return JSON.stringify(arg.value);
+  if (arg.kind === "array-literal") {
+    const values = [];
+    for (const el of arg.elements) {
+      if (el.kind !== "literal")
+        return null;
+      values.push(String(el.value));
+    }
+    return JSON.stringify(values);
+  }
+  if (arg.kind !== "conditional")
+    return null;
+  const t = arg.test;
+  if (t.kind !== "binary" || t.op !== "===" || t.right.kind !== "literal")
+    return null;
+  if (arg.consequent.kind !== "literal" && arg.consequent.kind !== "array-literal")
+    return null;
+  const cons = foldedArgToClientJs(arg.consequent, localeText);
+  const rest = foldedArgToClientJs(arg.alternate, localeText);
+  if (cons === null || rest === null)
+    return null;
+  return `${localeText} === ${JSON.stringify(t.right.value)} ? ${cons} : ${rest}`;
+}
 var toLocaleDatePlugin = {
   name: "toLocaleDateString",
   prepare(metadata) {
@@ -9110,12 +9677,22 @@ function lowerToLocaleDateCalls(text, expr, ctx) {
     const node = matcher(tsNodeToParsedExpr(propAccess), call.arguments.map((a) => tsNodeToParsedExpr(a)));
     if (!node || node.kind !== "helper-call" || node.helper !== "format_date")
       continue;
-    const [, patternArg, tzArg] = node.args;
-    if (patternArg?.kind !== "literal" || tzArg?.kind !== "literal")
+    const [, patternArg, tzArg, namesArg] = node.args;
+    if (!patternArg || tzArg?.kind !== "literal")
+      continue;
+    const localeText = ctx.getJS(call.arguments[0]);
+    const patternJs = foldedArgToClientJs(patternArg, localeText);
+    if (patternJs === null)
       continue;
+    let namesJs = null;
+    if (namesArg && !(namesArg.kind === "array-literal" && namesArg.elements.length === 0)) {
+      namesJs = foldedArgToClientJs(namesArg, localeText);
+      if (namesJs === null)
+        continue;
+    }
     const receiverText = ctx.getJS(propAccess.expression);
     const matchText = ctx.getJS(call);
-    result = replaceProtectedCall(result, matchText, () => `formatDate(${receiverText}, ${JSON.stringify(patternArg.value)}, ${JSON.stringify(tzArg.value)})`);
+    result = replaceProtectedCall(result, matchText, () => `formatDate(${receiverText}, ${patternJs}, ${JSON.stringify(tzArg.value)}${namesJs !== null ? `, ${namesJs}` : ""})`);
   }
   return restore(result);
 }
@@ -17194,12 +17771,22 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
     const node = matcher(tsNodeToParsedExpr(propAccess), call.arguments.map((a) => tsNodeToParsedExpr(a)));
     if (!node || node.kind !== "helper-call" || node.helper !== "format_date")
       continue;
-    const [, patternArg, tzArg] = node.args;
-    if (patternArg?.kind !== "literal" || tzArg?.kind !== "literal")
+    const [, patternArg, tzArg, namesArg] = node.args;
+    if (!patternArg || tzArg?.kind !== "literal")
       continue;
+    const localeText = call.arguments[0].getText(sourceFile);
+    const patternJs = foldedArgToClientJs(patternArg, localeText);
+    if (patternJs === null)
+      continue;
+    let namesJs = null;
+    if (namesArg && !(namesArg.kind === "array-literal" && namesArg.elements.length === 0)) {
+      namesJs = foldedArgToClientJs(namesArg, localeText);
+      if (namesJs === null)
+        continue;
+    }
     const receiverText = propAccess.expression.getText(sourceFile);
     const matchText = call.getText(sourceFile);
-    result = replaceProtectedCall(result, matchText, () => `formatDate(${receiverText}, ${JSON.stringify(patternArg.value)}, ${JSON.stringify(tzArg.value)})`);
+    result = replaceProtectedCall(result, matchText, () => `formatDate(${receiverText}, ${patternJs}, ${JSON.stringify(tzArg.value)}${namesJs !== null ? `, ${namesJs}` : ""})`);
   }
   return restore(result);
 }
@@ -22002,15 +22589,16 @@ function isOmitBranch(node) {
 }
 // src/format-date-lowering.ts
 var UTC_LITERAL = { kind: "literal", value: "UTC", literalType: "string" };
+var EMPTY_NAMES = { kind: "array-literal", elements: [], raw: "[]" };
 function matchFormatDateCall(callee, args, locals) {
   if (callee.kind !== "identifier" || !locals.has(callee.name))
     return null;
-  if (args.length < 2 || args.length > 3)
+  if (args.length < 2 || args.length > 4)
     return null;
   return {
     kind: "helper-call",
     helper: "format_date",
-    args: [args[0], args[1], args[2] ?? UTC_LITERAL]
+    args: [args[0], args[1], args[2] ?? UTC_LITERAL, args[3] ?? EMPTY_NAMES]
   };
 }
 var formatDatePlugin = {