@barefootjs/jsx 0.30.6 → 0.31.0

package/dist/index.js

@@ -176,22 +176,6 @@ function findTopLevelTemplateLiterals(code) {
   return out;
 }
 
-// src/import-map.ts
-function escapeHtmlAttr(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
-}
-function renderImportMapHtml(manifest) {
-  const imports = manifest.importmap?.imports ?? {};
-  const json = JSON.stringify({ imports }).replace(/</g, "\\u003c");
-  const lines = [`<script type="importmap">${json}</script>`];
-  for (const href of manifest.preloads ?? []) {
-    lines.push(`<link rel="modulepreload" href="${escapeHtmlAttr(href)}" crossorigin>`);
-  }
-  return lines.join(`
-`) + `
-`;
-}
-
 // src/analyzer.ts
 import ts8 from "typescript";
 
@@ -5822,9 +5806,9 @@ function createProgramForFile(source, filePath) {
     return null;
   }
 }
-function analyzeComponent(source, filePath, targetComponentName, program, acceptsCallbackBody) {
+function analyzeComponent(source, filePath, targetComponentName, program, acceptsCallbackBody, programIsShared) {
   incrementCounter("filesAnalyzed");
-  const hadSharedProgram = program !== undefined;
+  const hadSharedProgram = programIsShared ?? program !== undefined;
   const prescan = prescanReactiveFactoriesInSource(source, filePath);
   const rewritten = prescan.factories.size > 0 ? rewriteFactoryCallsInSource(source, prescan) : null;
   if (rewritten) {
@@ -16738,6 +16722,9 @@ function emitRegistrationAndHydration(lines, ctx, _ir, graph, inlinability) {
     defParts.push("comment: true");
   }
   const registryKey = nameForRegistryRef(name);
+  if (registryKey !== name) {
+    defParts.push(`name: '${name}'`);
+  }
   const hydrateLine = `hydrate('${registryKey}', { ${defParts.join(", ")} })`;
   const shimLine = `export function ${name}(${PROPS_PARAM}, __bfKey) { return createComponent('${registryKey}', ${PROPS_PARAM}, __bfKey) }`;
   return `${hydrateLine}
@@ -17448,6 +17435,59 @@ function resolveFinalImports(generatedCode, ir, localImportPrefixes) {
 `);
 }
 
+// src/ir-to-client-js/prune-unused-prop-extractions.ts
+import ts15 from "typescript";
+function propExtractionName(stmt) {
+  if (!ts15.isVariableStatement(stmt))
+    return null;
+  const decls = stmt.declarationList.declarations;
+  if (decls.length !== 1)
+    return null;
+  const decl = decls[0];
+  if (!ts15.isIdentifier(decl.name) || !decl.initializer)
+    return null;
+  let core = decl.initializer;
+  if (ts15.isBinaryExpression(core) && core.operatorToken.kind === ts15.SyntaxKind.QuestionQuestionToken) {
+    core = core.left;
+  }
+  if (!ts15.isPropertyAccessExpression(core))
+    return null;
+  if (!ts15.isIdentifier(core.expression) || core.expression.text !== PROPS_PARAM)
+    return null;
+  if (core.name.text !== decl.name.text)
+    return null;
+  return decl.name.text;
+}
+function pruneUnusedPropExtractions(code) {
+  for (let round = 0;round < 10; round++) {
+    const referenced = collectValueReferencedNames(code);
+    if (referenced === null) {
+      console.warn("[barefootjs] pruneUnusedPropExtractions: generated code did not parse; skipping prune");
+      return code;
+    }
+    const sourceFile = ts15.createSourceFile("generated.js", code, ts15.ScriptTarget.Latest, false, ts15.ScriptKind.JS);
+    const spans = [];
+    for (const stmt of sourceFile.statements) {
+      if (!ts15.isFunctionDeclaration(stmt) || !stmt.name?.text.startsWith("init") || !stmt.body)
+        continue;
+      for (const inner of stmt.body.statements) {
+        const name = propExtractionName(inner);
+        if (name !== null && !referenced.has(name)) {
+          spans.push({ start: inner.getFullStart(), end: inner.getEnd() });
+        }
+      }
+    }
+    if (spans.length === 0)
+      return code;
+    let next = code;
+    for (const { start, end } of spans.sort((a, b) => b.start - a.start)) {
+      next = next.slice(0, start) + next.slice(end);
+    }
+    code = next;
+  }
+  return code;
+}
+
 // src/ir-to-client-js/phases/conditional-slot-ids.ts
 function collectConditionalSlotIds(ctx) {
   const slots = new Set;
@@ -18872,7 +18912,7 @@ function analyzeLazyConditional(cond, indexParam, arms) {
 }
 
 // src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -18892,12 +18932,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   if (text.trim().length === 0)
     return NO_PREAMBLE;
   const declaredNames = new Set;
-  const sf = ts15.createSourceFile("__lazy_preamble__.ts", text, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+  const sf = ts16.createSourceFile("__lazy_preamble__.ts", text, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
   for (const stmt of sf.statements) {
-    if (!ts15.isVariableStatement(stmt)) {
-      return NO2(`map-callback preamble has a non-declaration statement (${ts15.SyntaxKind[stmt.kind]})`);
+    if (!ts16.isVariableStatement(stmt)) {
+      return NO2(`map-callback preamble has a non-declaration statement (${ts16.SyntaxKind[stmt.kind]})`);
     }
-    const isConst = (stmt.declarationList.flags & ts15.NodeFlags.Const) !== 0;
+    const isConst = (stmt.declarationList.flags & ts16.NodeFlags.Const) !== 0;
     if (!isConst)
       return NO2("map-callback preamble declares a mutable binding (let/var)");
     for (const decl of stmt.declarationList.declarations) {
@@ -18926,12 +18966,12 @@ function analyzeLazyPreamble(preamble, indexParam, primableNames) {
   return { lazySafe: true, facts: { declaredNames, freeNames } };
 }
 function collectBindingNames3(name, out) {
-  if (ts15.isIdentifier(name)) {
+  if (ts16.isIdentifier(name)) {
     out.add(name.text);
     return;
   }
   for (const element of name.elements) {
-    if (ts15.isOmittedExpression(element))
+    if (ts16.isOmittedExpression(element))
       continue;
     collectBindingNames3(element.name, out);
   }
@@ -18941,56 +18981,56 @@ function findImpureNode(root, primableNames) {
   const visit3 = (node) => {
     if (found)
       return;
-    if (ts15.isCallExpression(node)) {
+    if (ts16.isCallExpression(node)) {
       const callee = node.expression;
-      const isSignalRead = ts15.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
+      const isSignalRead = ts16.isIdentifier(callee) && primableNames.has(callee.text) && node.arguments.length === 0 && node.questionDotToken === undefined;
       if (!isSignalRead) {
         found = `call to ${callee.getText(callee.getSourceFile())}`;
         return;
       }
     }
-    if (ts15.isNewExpression(node)) {
+    if (ts16.isNewExpression(node)) {
       found = "new expression";
       return;
     }
-    if (ts15.isTaggedTemplateExpression(node)) {
+    if (ts16.isTaggedTemplateExpression(node)) {
       found = "tagged template";
       return;
     }
-    if (ts15.isAwaitExpression(node)) {
+    if (ts16.isAwaitExpression(node)) {
       found = "await";
       return;
     }
-    if (ts15.isYieldExpression(node)) {
+    if (ts16.isYieldExpression(node)) {
       found = "yield";
       return;
     }
-    if (ts15.isPrefixUnaryExpression(node) || ts15.isPostfixUnaryExpression(node)) {
+    if (ts16.isPrefixUnaryExpression(node) || ts16.isPostfixUnaryExpression(node)) {
       const op = node.operator;
-      if (op === ts15.SyntaxKind.PlusPlusToken || op === ts15.SyntaxKind.MinusMinusToken) {
+      if (op === ts16.SyntaxKind.PlusPlusToken || op === ts16.SyntaxKind.MinusMinusToken) {
         found = "increment/decrement";
         return;
       }
     }
-    if (ts15.isDeleteExpression(node)) {
+    if (ts16.isDeleteExpression(node)) {
       found = "delete";
       return;
     }
-    if (ts15.isFunctionExpression(node) || ts15.isArrowFunction(node) || ts15.isClassExpression(node)) {
+    if (ts16.isFunctionExpression(node) || ts16.isArrowFunction(node) || ts16.isClassExpression(node)) {
       found = "function or class expression";
       return;
     }
-    if (ts15.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts16.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
       found = "assignment";
       return;
     }
-    ts15.forEachChild(node, visit3);
+    ts16.forEachChild(node, visit3);
   };
   visit3(root);
   return found;
 }
 function isAssignmentOperator(kind) {
-  return kind >= ts15.SyntaxKind.FirstAssignment && kind <= ts15.SyntaxKind.LastAssignment;
+  return kind >= ts16.SyntaxKind.FirstAssignment && kind <= ts16.SyntaxKind.LastAssignment;
 }
 
 // src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
@@ -19520,7 +19560,7 @@ function buildArmBody(branch, options) {
 }
 
 // src/ir-to-client-js/emit-reactive.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 
 // src/ir-to-client-js/control-flow/stringify/claim-plan.ts
 function slotSpecLiteral(slot) {
@@ -19623,20 +19663,20 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts16.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
+    sourceFile = ts17.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts17.ScriptTarget.Latest, true, ts17.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts16.isExpressionStatement(stmt))
+  if (!stmt || !ts17.isExpressionStatement(stmt))
     return expr;
-  const root = ts16.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts17.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts16.isCallExpression(n) && n.arguments.length === 2 && ts16.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts17.isCallExpression(n) && n.arguments.length === 2 && ts17.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -19672,20 +19712,20 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
     return expr;
   let sourceFile;
   try {
-    sourceFile = ts16.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
+    sourceFile = ts17.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts17.ScriptTarget.Latest, true, ts17.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts16.isExpressionStatement(stmt))
+  if (!stmt || !ts17.isExpressionStatement(stmt))
     return expr;
-  const root = ts16.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const root = ts17.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts16.isCallExpression(n) && n.arguments.length === 0 && ts16.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts17.isCallExpression(n) && n.arguments.length === 0 && ts17.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts16.forEachChild(n, visit3);
+    ts17.forEachChild(n, visit3);
   };
   visit3(root);
   if (candidates.length === 0)
@@ -21688,20 +21728,20 @@ var PHASES = [
 ];
 
 // src/ir-to-client-js/rewrite-props-object.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function rewritePropsObjectRef(code, propsObjectName) {
   const srcPropsName = propsObjectName ?? "props";
   if (srcPropsName === PROPS_PARAM)
     return code;
   if (!new RegExp(`\\b${srcPropsName}\\b`).test(code))
     return code;
-  const sourceFile = ts17.createSourceFile("init-body.ts", code, ts17.ScriptTarget.Latest, true, ts17.ScriptKind.TS);
+  const sourceFile = ts18.createSourceFile("init-body.ts", code, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TS);
   const spans = [];
   function visit3(node) {
-    if (ts17.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts18.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts17.forEachChild(node, visit3);
+    ts18.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0)
@@ -21717,17 +21757,17 @@ function shouldRewrite(node) {
   const parent = node.parent;
   if (!parent)
     return true;
-  if (ts17.isPropertyAccessExpression(parent) && parent.name === node)
+  if (ts18.isPropertyAccessExpression(parent) && parent.name === node)
     return false;
-  if (ts17.isPropertyAssignment(parent) && parent.name === node)
+  if (ts18.isPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts17.isShorthandPropertyAssignment(parent) && parent.name === node)
+  if (ts18.isShorthandPropertyAssignment(parent) && parent.name === node)
     return false;
-  if (ts17.isPropertySignature(parent) && parent.name === node)
+  if (ts18.isPropertySignature(parent) && parent.name === node)
     return false;
-  if (ts17.isPropertyDeclaration(parent) && parent.name === node)
+  if (ts18.isPropertyDeclaration(parent) && parent.name === node)
     return false;
-  if (ts17.isBindingElement(parent) && parent.name === node)
+  if (ts18.isBindingElement(parent) && parent.name === node)
     return false;
   return true;
 }
@@ -21765,7 +21805,7 @@ function generateInitFunction(ir, ctx, siblingComponents, localImportPrefixes) {
   generatedCode += `
 ` + hydrateLine;
   const moduleConstantsCode = emitModuleLevelDeclarations(classification.moduleLevelConstants, classification.moduleLevelFunctions, classification.moduleLevelSignals, classification.moduleLevelMemos);
-  const codeWithModuleConstants = generatedCode.replace(MODULE_CONSTANTS_PLACEHOLDER, () => moduleConstantsCode);
+  const codeWithModuleConstants = pruneUnusedPropExtractions(generatedCode.replace(MODULE_CONSTANTS_PLACEHOLDER, () => moduleConstantsCode));
   const allImportLines = resolveFinalImports(codeWithModuleConstants, ir, localImportPrefixes);
   return codeWithModuleConstants.replace(IMPORT_PLACEHOLDER, () => allImportLines);
 }
@@ -22083,7 +22123,8 @@ function generateTemplateOnlyMount(ir, ctx) {
   lines.push("");
   lines.push(`function init${name}() {}`);
   lines.push("");
-  lines.push(`hydrate('${registryKey}', { init: init${name}, template: (${PROPS_PARAM}) => \`${templateHtml}\` })`);
+  const nameField = registryKey !== name ? `, name: '${name}'` : "";
+  lines.push(`hydrate('${registryKey}', { init: init${name}, template: (${PROPS_PARAM}) => \`${templateHtml}\`${nameField} })`);
   lines.push(`export function ${name}(${PROPS_PARAM}, __bfKey) { return createComponent('${registryKey}', ${PROPS_PARAM}, __bfKey) }`);
   const generatedCode = lines.join(`
 `);
@@ -22357,7 +22398,7 @@ function walkIR2(node, visitor) {
 }
 
 // src/preprocess-inline-jsx-callbacks.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 var SYNTHETIC_PREFIX = "BFInlineJsxCallback";
 var MAX_FIXPOINT_ITERATIONS = 16;
 function preprocessInlineJsxCallbacks(source, filePath) {
@@ -22379,8 +22420,8 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts18.createSourceFile(filePath, source, ts18.ScriptTarget.Latest, true, ts18.ScriptKind.TSX);
-  const hasUseClient = sourceFile.statements.some((stmt) => ts18.isExpressionStatement(stmt) && ts18.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
+  const sourceFile = ts19.createSourceFile(filePath, source, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TSX);
+  const hasUseClient = sourceFile.statements.some((stmt) => ts19.isExpressionStatement(stmt) && ts19.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'"));
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
   }
@@ -22402,22 +22443,22 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts18.isJsxAttribute(node) && node.initializer && ts18.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts19.isJsxAttribute(node) && node.initializer && ts19.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts18.isPropertyAssignment(node) && node.initializer) {
+    if (ts19.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer))
         return;
     }
-    ts18.forEachChild(node, visit3);
+    ts19.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts18.isParenthesizedExpression(expr))
+    while (ts19.isParenthesizedExpression(expr))
       expr = expr.expression;
-    if (ts18.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    if (ts19.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -22454,7 +22495,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name });
     return true;
   }
-  ts18.forEachChild(sourceFile, visit3);
+  ts19.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -22477,11 +22518,11 @@ function errorMessageForCapture(captures) {
   return `Inline JSX-returning arrow function captures non-module identifier(s): ` + `${captures.sort().join(", ")}. ` + `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.`;
 }
 function arrowBodyContainsJsx(arrow) {
-  if (ts18.isBlock(arrow.body)) {
+  if (ts19.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body = arrow.body;
-  while (ts18.isParenthesizedExpression(body))
+  while (ts19.isParenthesizedExpression(body))
     body = body.expression;
   return isJsxLike(body);
 }
@@ -22490,24 +22531,24 @@ function blockReturnsJsx(block) {
   function visit3(n) {
     if (found)
       return;
-    if (ts18.isReturnStatement(n) && n.expression) {
+    if (ts19.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts18.isParenthesizedExpression(e))
+      while (ts19.isParenthesizedExpression(e))
         e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts18.isArrowFunction(n) || ts18.isFunctionDeclaration(n) || ts18.isFunctionExpression(n))
+    if (ts19.isArrowFunction(n) || ts19.isFunctionDeclaration(n) || ts19.isFunctionExpression(n))
       return;
-    ts18.forEachChild(n, visit3);
+    ts19.forEachChild(n, visit3);
   }
-  ts18.forEachChild(block, visit3);
+  ts19.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts18.isJsxElement(expr) || ts18.isJsxSelfClosingElement(expr) || ts18.isJsxFragment(expr);
+  return ts19.isJsxElement(expr) || ts19.isJsxSelfClosingElement(expr) || ts19.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = new Set;
@@ -22517,13 +22558,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames4(name, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts18.isIdentifier(name)) {
+  if (ts19.isIdentifier(name)) {
     push(name.text);
-  } else if (ts18.isObjectBindingPattern(name)) {
+  } else if (ts19.isObjectBindingPattern(name)) {
     name.elements.forEach((el) => collectBindingNames4(el.name, out));
-  } else if (ts18.isArrayBindingPattern(name)) {
+  } else if (ts19.isArrayBindingPattern(name)) {
     name.elements.forEach((el) => {
-      if (!ts18.isOmittedExpression(el))
+      if (!ts19.isOmittedExpression(el))
         collectBindingNames4(el.name, out);
     });
   }
@@ -22550,48 +22591,48 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name);
   }
   function visit3(node) {
-    if (ts18.isIdentifier(node)) {
+    if (ts19.isIdentifier(node)) {
       const parent = node.parent;
-      if (parent && ts18.isPropertyAccessExpression(parent) && parent.name === node)
+      if (parent && ts19.isPropertyAccessExpression(parent) && parent.name === node)
         return;
-      if (parent && ts18.isPropertyAssignment(parent) && parent.name === node)
+      if (parent && ts19.isPropertyAssignment(parent) && parent.name === node)
         return;
-      if (parent && ts18.isPropertySignature(parent) && parent.name === node)
+      if (parent && ts19.isPropertySignature(parent) && parent.name === node)
         return;
-      if (parent && ts18.isPropertyDeclaration(parent) && parent.name === node)
+      if (parent && ts19.isPropertyDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts18.isMethodDeclaration(parent) && parent.name === node)
+      if (parent && ts19.isMethodDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts18.isMethodSignature(parent) && parent.name === node)
+      if (parent && ts19.isMethodSignature(parent) && parent.name === node)
         return;
-      if (parent && ts18.isGetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts19.isGetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts18.isSetAccessorDeclaration(parent) && parent.name === node)
+      if (parent && ts19.isSetAccessorDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts18.isEnumMember(parent) && parent.name === node)
+      if (parent && ts19.isEnumMember(parent) && parent.name === node)
         return;
-      if (parent && ts18.isBindingElement(parent) && parent.propertyName === node)
+      if (parent && ts19.isBindingElement(parent) && parent.propertyName === node)
         return;
-      if (parent && ts18.isShorthandPropertyAssignment(parent) && parent.name === node) {
+      if (parent && ts19.isShorthandPropertyAssignment(parent) && parent.name === node) {
         if (!isBound(node.text))
           ids.add(node.text);
         return;
       }
-      if (parent && ts18.isParameter(parent) && parent.name === node)
+      if (parent && ts19.isParameter(parent) && parent.name === node)
         return;
-      if (parent && ts18.isVariableDeclaration(parent) && parent.name === node)
+      if (parent && ts19.isVariableDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts18.isFunctionDeclaration(parent) && parent.name === node)
+      if (parent && ts19.isFunctionDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts18.isClassDeclaration(parent) && parent.name === node)
+      if (parent && ts19.isClassDeclaration(parent) && parent.name === node)
         return;
-      if (parent && ts18.isJsxAttribute(parent) && parent.name === node)
+      if (parent && ts19.isJsxAttribute(parent) && parent.name === node)
         return;
-      if (parent && ts18.isJsxOpeningElement(parent) && parent.tagName === node) {
+      if (parent && ts19.isJsxOpeningElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
-      if (parent && ts18.isJsxClosingElement(parent) && parent.tagName === node) {
+      if (parent && ts19.isJsxClosingElement(parent) && parent.tagName === node) {
         if (/^[a-z]/.test(node.text))
           return;
       }
@@ -22600,43 +22641,43 @@ function collectFreeIdentifiers(arrow) {
       ids.add(node.text);
       return;
     }
-    if (ts18.isVariableDeclaration(node)) {
+    if (ts19.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer)
         visit3(node.initializer);
       return;
     }
-    if (ts18.isFunctionDeclaration(node)) {
+    if (ts19.isFunctionDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts18.isClassDeclaration(node)) {
+    if (ts19.isClassDeclaration(node)) {
       if (node.name)
         bound.push(node.name.text);
-      ts18.forEachChild(node, visit3);
+      ts19.forEachChild(node, visit3);
       return;
     }
-    if (ts18.isArrowFunction(node) || ts18.isFunctionExpression(node)) {
+    if (ts19.isArrowFunction(node) || ts19.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts18.isCatchClause(node)) {
+    if (ts19.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration)
         pushBindings(node.variableDeclaration.name);
-      ts18.forEachChild(node, visit3);
+      ts19.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts18.isBlock(node)) {
+    if (ts19.isBlock(node)) {
       const before = bound.length;
-      ts18.forEachChild(node, visit3);
+      ts19.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts18.forEachChild(node, visit3);
+    ts19.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -22659,29 +22700,29 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (ts18.isFunctionDeclaration(stmt) && stmt.name)
+    if (ts19.isFunctionDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts18.isClassDeclaration(stmt) && stmt.name)
+    else if (ts19.isClassDeclaration(stmt) && stmt.name)
       names.add(stmt.name.text);
-    else if (ts18.isVariableStatement(stmt)) {
+    else if (ts19.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations)
         collectBindingNames4(decl.name, names);
-    } else if (ts18.isImportDeclaration(stmt) && stmt.importClause) {
+    } else if (ts19.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name)
         names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts18.isNamespaceImport(ic.namedBindings))
+        if (ts19.isNamespaceImport(ic.namedBindings))
           names.add(ic.namedBindings.name.text);
         else
           for (const e of ic.namedBindings.elements)
             names.add(e.name.text);
       }
-    } else if (ts18.isTypeAliasDeclaration(stmt))
+    } else if (ts19.isTypeAliasDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts18.isInterfaceDeclaration(stmt))
+    else if (ts19.isInterfaceDeclaration(stmt))
       names.add(stmt.name.text);
-    else if (ts18.isEnumDeclaration(stmt))
+    else if (ts19.isEnumDeclaration(stmt))
       names.add(stmt.name.text);
   }
   return names;
@@ -22689,7 +22730,7 @@ function collectModuleScopeNames(sourceFile) {
 function buildSyntheticDeclaration(name, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts18.isBlock(arrow.body)) {
+  if (ts19.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -22699,7 +22740,7 @@ function buildSyntheticDeclaration(name, arrow, sourceFile) {
 }
 
 // src/ssr-defaults.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 function extractSsrDefaults(metadata) {
@@ -22776,11 +22817,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   if (!node)
     return;
   const visit3 = (n) => {
-    if (ts19.isPropertyAccessExpression(n) && ts19.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts19.isIdentifier(n.name)) {
+    if (ts20.isPropertyAccessExpression(n) && ts20.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts20.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts19.forEachChild(n, visit3);
+    ts20.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -22801,23 +22842,23 @@ function tryStaticEval(expr, ctx) {
 }
 function evalStatementsForReturn(statements, ctx) {
   for (const stmt of statements) {
-    if (ts19.isVariableStatement(stmt)) {
+    if (ts20.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts19.isIdentifier(d.name) || !d.initializer)
+        if (!ts20.isIdentifier(d.name) || !d.initializer)
           continue;
         const v = evalNode(d.initializer, ctx);
         if (v !== UNRESOLVED)
           ctx.bindings[d.name.text] = v;
       }
-    } else if (ts19.isReturnStatement(stmt)) {
+    } else if (ts20.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx) : UNRESOLVED;
-    } else if (ts19.isIfStatement(stmt)) {
+    } else if (ts20.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx);
       if (cond === UNRESOLVED)
         return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
-        const taken = evalStatementsForReturn(ts19.isBlock(branch) ? branch.statements : [branch], ctx);
+        const taken = evalStatementsForReturn(ts20.isBlock(branch) ? branch.statements : [branch], ctx);
         if (taken !== NO_RETURN)
           return taken;
       }
@@ -22828,45 +22869,45 @@ function evalStatementsForReturn(statements, ctx) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts19.createSourceFile("__ssr_default__.ts", `(${expr})`, ts19.ScriptTarget.Latest, false, ts19.ScriptKind.TS);
+  const sf = ts20.createSourceFile("__ssr_default__.ts", `(${expr})`, ts20.ScriptTarget.Latest, false, ts20.ScriptKind.TS);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isExpressionStatement(stmt))
+  if (!stmt || !ts20.isExpressionStatement(stmt))
     return null;
-  const inner = ts19.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  const inner = ts20.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx) {
-  if (ts19.isParenthesizedExpression(node))
+  if (ts20.isParenthesizedExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts19.isAsExpression(node))
+  if (ts20.isAsExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts19.isSatisfiesExpression(node))
+  if (ts20.isSatisfiesExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts19.isTypeAssertionExpression(node))
+  if (ts20.isTypeAssertionExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts19.isNonNullExpression(node))
+  if (ts20.isNonNullExpression(node))
     return evalNode(node.expression, ctx);
-  if (ts19.isArrowFunction(node)) {
+  if (ts20.isArrowFunction(node)) {
     if (node.parameters.length !== 0)
       return UNRESOLVED;
-    if (!ts19.isBlock(node.body))
+    if (!ts20.isBlock(node.body))
       return evalNode(node.body, ctx);
     const localBindings = { ...ctx.bindings };
     const localCtx = { ...ctx, bindings: localBindings };
     const result = evalStatementsForReturn(node.body.statements, localCtx);
     return result === NO_RETURN ? UNRESOLVED : result;
   }
-  if (ts19.isNumericLiteral(node))
+  if (ts20.isNumericLiteral(node))
     return Number(node.text);
-  if (ts19.isStringLiteralLike(node))
+  if (ts20.isStringLiteralLike(node))
     return node.text;
-  if (node.kind === ts19.SyntaxKind.TrueKeyword)
+  if (node.kind === ts20.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts19.SyntaxKind.FalseKeyword)
+  if (node.kind === ts20.SyntaxKind.FalseKeyword)
     return false;
-  if (node.kind === ts19.SyntaxKind.NullKeyword)
+  if (node.kind === ts20.SyntaxKind.NullKeyword)
     return null;
-  if (ts19.isIdentifier(node)) {
+  if (ts20.isIdentifier(node)) {
     if (node.text === "undefined")
       return;
     if (node.text in ctx.bindings)
@@ -22875,29 +22916,29 @@ function evalNode(node, ctx) {
       return;
     return UNRESOLVED;
   }
-  if (ts19.isPrefixUnaryExpression(node)) {
+  if (ts20.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx);
     if (arg === UNRESOLVED)
       return UNRESOLVED;
     switch (node.operator) {
-      case ts19.SyntaxKind.MinusToken:
+      case ts20.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts19.SyntaxKind.PlusToken:
+      case ts20.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts19.SyntaxKind.ExclamationToken:
+      case ts20.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts19.isObjectLiteralExpression(node)) {
+  if (ts20.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts19.isPropertyAssignment(prop))
+      if (!ts20.isPropertyAssignment(prop))
         return UNRESOLVED;
       let key;
-      if (ts19.isIdentifier(prop.name) || ts19.isStringLiteralLike(prop.name)) {
+      if (ts20.isIdentifier(prop.name) || ts20.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts19.isNumericLiteral(prop.name)) {
+      } else if (ts20.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -22909,10 +22950,10 @@ function evalNode(node, ctx) {
     }
     return obj;
   }
-  if (ts19.isArrayLiteralExpression(node)) {
+  if (ts20.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts19.isOmittedExpression(elem))
+      if (ts20.isOmittedExpression(elem))
         return UNRESOLVED;
       const v = evalNode(elem, ctx);
       if (v === UNRESOLVED)
@@ -22921,7 +22962,7 @@ function evalNode(node, ctx) {
     }
     return arr;
   }
-  if (ts19.isElementAccessExpression(node)) {
+  if (ts20.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx);
     if (base === undefined)
       return;
@@ -22935,17 +22976,17 @@ function evalNode(node, ctx) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : undefined;
   }
-  if (ts19.isPropertyAccessExpression(node)) {
+  if (ts20.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx);
     if (baseResult === undefined)
       return;
     return UNRESOLVED;
   }
-  if (ts19.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts19.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
+  if (ts20.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts20.isIdentifier(node.expression) && node.expression.text in ctx.bindings) {
       return ctx.bindings[node.expression.text];
     }
-    if (ts19.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts20.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx);
       if (Array.isArray(recv)) {
         let sep2 = ",";
@@ -22961,27 +23002,27 @@ function evalNode(node, ctx) {
     }
     return UNRESOLVED;
   }
-  if (ts19.isConditionalExpression(node)) {
+  if (ts20.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx);
     if (cond === UNRESOLVED)
       return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx) : evalNode(node.whenFalse, ctx);
   }
-  if (ts19.isBinaryExpression(node)) {
+  if (ts20.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts19.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts20.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== undefined)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts19.SyntaxKind.BarBarToken) {
+    if (op === ts20.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 !== UNRESOLVED && l2)
         return l2;
       return evalNode(node.right, ctx);
     }
-    if (op === ts19.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts20.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx);
       if (l2 === UNRESOLVED)
         return UNRESOLVED;
@@ -22994,30 +23035,30 @@ function evalNode(node, ctx) {
     if (l === UNRESOLVED || r === UNRESOLVED)
       return UNRESOLVED;
     switch (op) {
-      case ts19.SyntaxKind.PlusToken:
+      case ts20.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r === "string")
           return `${l}${r}`;
         if (typeof l === "number" && typeof r === "number")
           return l + r;
         return UNRESOLVED;
-      case ts19.SyntaxKind.MinusToken:
+      case ts20.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r === "number" ? l - r : UNRESOLVED;
-      case ts19.SyntaxKind.AsteriskToken:
+      case ts20.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r === "number" ? l * r : UNRESOLVED;
-      case ts19.SyntaxKind.SlashToken:
+      case ts20.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l / r : UNRESOLVED;
-      case ts19.SyntaxKind.PercentToken:
+      case ts20.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r === "number" && r !== 0 ? l % r : UNRESOLVED;
-      case ts19.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts19.SyntaxKind.EqualsEqualsToken:
+      case ts20.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts20.SyntaxKind.EqualsEqualsToken:
         return l === r;
-      case ts19.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts19.SyntaxKind.ExclamationEqualsToken:
+      case ts20.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts20.SyntaxKind.ExclamationEqualsToken:
         return l !== r;
     }
     return UNRESOLVED;
   }
-  if (ts19.isTemplateExpression(node)) {
+  if (ts20.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0)
       return node.head.text;
     let acc = node.head.text;
@@ -23029,13 +23070,13 @@ function evalNode(node, ctx) {
     }
     return acc;
   }
-  if (ts19.isNoSubstitutionTemplateLiteral(node))
+  if (ts20.isNoSubstitutionTemplateLiteral(node))
     return node.text;
   return UNRESOLVED;
 }
 
 // src/augment-inherited-props.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -23067,47 +23108,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts20.isCallExpression(expr))
+  if (!expr || !ts21.isCallExpression(expr))
     return null;
-  if (!ts20.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts21.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts20.isIdentifier(arg) ? arg.text : null;
+  return ts21.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts20.isCallExpression(expr))
+  if (!expr || !ts21.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts20.isStringLiteral(arg) || ts20.isNoSubstitutionTemplateLiteral(arg))
+  if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts20.isNumericLiteral(arg))
+  if (ts21.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts20.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts21.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts20.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts21.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts20.isCallExpression(expr))
+  if (!expr || !ts21.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts20.isObjectLiteralExpression(expr.arguments[0]);
+  return ts21.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts20.createSourceFile("__ctx.ts", `(${source})`, ts20.ScriptTarget.Latest, false);
+  const sf = ts21.createSourceFile("__ctx.ts", `(${source})`, ts21.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts20.isExpressionStatement(stmt))
+  if (!stmt || !ts21.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts20.isParenthesizedExpression(e))
+  while (ts21.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -23132,25 +23173,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts20.createSourceFile("__aug.ts", `(${s})`, ts20.ScriptTarget.Latest, false);
+    const sf = ts21.createSourceFile("__aug.ts", `(${s})`, ts21.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts20.isBinaryExpression(n) && (n.operatorToken.kind === ts20.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts20.SyntaxKind.BarBarToken)) {
+      if (ts21.isBinaryExpression(n) && (n.operatorToken.kind === ts21.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts21.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts20.isParenthesizedExpression(left))
+        while (ts21.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts20.isPropertyAccessExpression(left) && ts20.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts21.isPropertyAccessExpression(left) && ts21.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts20.isParenthesizedExpression(right))
+          while (ts21.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts20.isPrefixUnaryExpression(right))
+          if (ts21.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts20.isNumericLiteral(right) ? "number" : right.kind === ts20.SyntaxKind.TrueKeyword || right.kind === ts20.SyntaxKind.FalseKeyword ? "boolean" : ts20.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts21.isNumericLiteral(right) ? "number" : right.kind === ts21.SyntaxKind.TrueKeyword || right.kind === ts21.SyntaxKind.FalseKeyword ? "boolean" : ts21.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts20.forEachChild(n, visit3);
+      ts21.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -23261,33 +23302,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts20.createSourceFile("__const.ts", `const __x = (${source});`, ts20.ScriptTarget.Latest, false);
+  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts20.isVariableStatement(stmt))
+  if (!stmt || !ts21.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts20.isParenthesizedExpression(init))
+  while (init && ts21.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts20.isStringLiteral(init) || ts20.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts21.isStringLiteral(init) || ts21.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts20.createSourceFile("__const.ts", `const __x = (${source});`, ts20.ScriptTarget.Latest, false);
+  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts20.isVariableStatement(stmt))
+  if (!stmt || !ts21.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts20.isParenthesizedExpression(init))
+  while (init && ts21.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts20.isTemplateExpression(init))
+  if (!init || !ts21.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts20.isIdentifier(span.expression))
+    if (!ts21.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -23318,30 +23359,30 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts20.createSourceFile("__rec.ts", `(${constInfo.value})`, ts20.ScriptTarget.Latest, true);
+  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts20.isExpressionStatement(stmt))
+  if (!ts21.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts20.isParenthesizedExpression(parsed))
+  while (ts21.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts20.isObjectLiteralExpression(parsed))
+  if (!ts21.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts20.isPropertyAssignment(prop))
+    if (!ts21.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts20.isIdentifier(name) || ts20.isStringLiteral(name) || ts20.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts21.isIdentifier(name) || ts21.isStringLiteral(name) || ts21.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts20.isParenthesizedExpression(v))
+    while (ts21.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts20.isNumericLiteral(v))
+    if (ts21.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts20.isStringLiteral(v) || ts20.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -23349,28 +23390,28 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts20.createSourceFile("__join.ts", `const __x = (${source});`, ts20.ScriptTarget.Latest, false);
+  const sf = ts21.createSourceFile("__join.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts20.isVariableStatement(stmt))
+  if (!stmt || !ts21.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts20.isParenthesizedExpression(node))
+  while (node && ts21.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts20.isCallExpression(node))
+  if (!node || !ts21.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts20.isPropertyAccessExpression(callee))
+  if (!ts21.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts20.isParenthesizedExpression(recv))
+  while (ts21.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts20.isArrayLiteralExpression(recv))
+  if (!ts21.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts20.isStringLiteral(el) || ts20.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts21.isStringLiteral(el) || ts21.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -23379,7 +23420,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts20.isStringLiteral(arg) || ts20.isNoSubstitutionTemplateLiteral(arg))
+    if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -23387,11 +23428,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts20.isElementAccessExpression(val))
+  if (!ts21.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts20.isIdentifier(obj) || !ts20.isIdentifier(arg))
+  if (!ts21.isIdentifier(obj) || !ts21.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -23407,35 +23448,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 = ts20.createSourceFile("__rec.ts", `(${constInfo.value})`, ts20.ScriptTarget.Latest, true);
+  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts20.isExpressionStatement(stmt))
+  if (!ts21.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts20.isParenthesizedExpression(parsed))
+  while (ts21.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts20.isObjectLiteralExpression(parsed))
+  if (!ts21.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts20.isPropertyAssignment(prop))
+    if (!ts21.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts20.isIdentifier(prop.name)) {
+    if (ts21.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts20.isStringLiteral(prop.name) || ts20.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts21.isStringLiteral(prop.name) || ts21.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts20.isParenthesizedExpression(v))
+    while (ts21.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts20.isNumericLiteral(v)) {
+    if (ts21.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts20.isStringLiteral(v) || ts20.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -23751,9 +23792,11 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
   const errors = [];
   const adapter = options.adapter;
   const entries = [];
-  const program = options.program ?? (needsTypeBasedDetection(source) ? createProgramForFile(source, filePath)?.program : undefined);
+  const callerProgram = options.program?.getSourceFile(filePath)?.text === source ? options.program : undefined;
+  const program = callerProgram ?? (needsTypeBasedDetection(source) ? createProgramForFile(source, filePath)?.program : undefined);
+  const programIsShared = options.program !== undefined;
   for (const componentName of componentNames) {
-    const ctx = analyzeComponent(source, filePath, componentName, program, adapter.acceptsCallbackBody);
+    const ctx = analyzeComponent(source, filePath, componentName, program, adapter.acceptsCallbackBody, programIsShared);
     if (!ctx.jsxReturn) {
       errors.push(...ctx.errors);
       continue;
@@ -23776,6 +23819,19 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
     }
     entries.push({ componentIR, ctx });
   }
+  {
+    let seenBf050 = false;
+    const deduped = errors.filter((e) => {
+      if (e.code !== ErrorCodes.SHARED_PROGRAM_REQUIRED)
+        return true;
+      if (seenBf050)
+        return false;
+      seenBf050 = true;
+      return true;
+    });
+    errors.length = 0;
+    errors.push(...deduped);
+  }
   if (options.outputIR) {
     for (const { componentIR } of entries) {
       const componentName = componentIR.metadata.componentName;
@@ -23814,7 +23870,9 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
       const adapterOutput = adapter.generate(componentIR, {
         scriptBaseName,
         siblingTemplatesRegistered: options.siblingTemplatesRegistered,
-        rewriteRelativeImport: options.rewriteRelativeImport
+        rewriteRelativeImport: options.rewriteRelativeImport,
+        scriptAssets: options.scriptAssets,
+        preloadAssets: options.preloadAssets
       });
       const moduleExports = generateModuleExports(componentIR, fileWideInlineExported, options.rewriteRelativeImport);
       const s = adapterOutput.sections;
@@ -24146,7 +24204,9 @@ function compileJSX(source, filePath, options) {
   const adapterOutput = adapter.generate(componentIR, {
     scriptBaseName: options.scriptBaseName,
     siblingTemplatesRegistered: options.siblingTemplatesRegistered,
-    rewriteRelativeImport: options.rewriteRelativeImport
+    rewriteRelativeImport: options.rewriteRelativeImport,
+    scriptAssets: options.scriptAssets,
+    preloadAssets: options.preloadAssets
   });
   const s = adapterOutput.sections;
   let content;
@@ -24218,7 +24278,7 @@ function compileJSX(source, filePath, options) {
   return { files, errors };
 }
 // src/shared-program.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function commonParent(paths) {
   if (paths.length === 0)
     return process.cwd();
@@ -24239,10 +24299,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files, options = {}) {
   const baseUrl = options.baseUrl ?? commonParent(files);
   const compilerOptions = {
-    target: ts21.ScriptTarget.Latest,
-    module: ts21.ModuleKind.ESNext,
-    moduleResolution: ts21.ModuleResolutionKind.Bundler,
-    jsx: ts21.JsxEmit.ReactJSX,
+    target: ts22.ScriptTarget.Latest,
+    module: ts22.ModuleKind.ESNext,
+    moduleResolution: ts22.ModuleResolutionKind.Bundler,
+    jsx: ts22.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -24252,7 +24312,7 @@ function createProgramForCorpus(files, options = {}) {
     ...options.compilerOptions
   };
   const absolute = files.map((f) => path_default.resolve(f));
-  return ts21.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
+  return ts22.createProgram(absolute, compilerOptions, undefined, options.oldProgram);
 }
 // src/adapters/interface.ts
 class BaseAdapter {
@@ -25236,7 +25296,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // src/combine-client-js.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 var CHILD_PLACEHOLDER_RE = /import '\/\* @bf-child:(\w+) \*\/'/g;
 function combineParentChildClientJs(files) {
   const result = new Map;
@@ -25293,10 +25353,10 @@ function combineParentChildClientJs(files) {
   return result;
 }
 function parseAndMerge(content, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts22.createSourceFile("combine.js", content, ts22.ScriptTarget.Latest, false, ts22.ScriptKind.JS);
+  const sourceFile = ts23.createSourceFile("combine.js", content, ts23.ScriptTarget.Latest, false, ts23.ScriptKind.JS);
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts22.isImportDeclaration(stmt))
+    if (!ts23.isImportDeclaration(stmt))
       continue;
     const start = stmt.getStart(sourceFile);
     const end = stmt.getEnd();
@@ -25306,8 +25366,8 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
       continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts22.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts22.isNamedImports(bindings)) {
+    const specifier = ts23.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts23.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, new Set);
       }
@@ -25474,7 +25534,7 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // src/debug.ts
-import ts23 from "typescript";
+import ts24 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -26759,7 +26819,7 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts23.createSourceFile("__attr.tsx", `(${expr})`, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
+    sf = ts24.createSourceFile("__attr.tsx", `(${expr})`, ts24.ScriptTarget.Latest, true, ts24.ScriptKind.TSX);
   } catch {
     return false;
   }
@@ -26767,11 +26827,11 @@ function exprReadsPropMember(expr, propsObjectName) {
   const visit3 = (n) => {
     if (found)
       return;
-    if (ts23.isPropertyAccessExpression(n) && ts23.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts24.isPropertyAccessExpression(n) && ts24.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts23.forEachChild(n, visit3);
+    ts24.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -26841,7 +26901,7 @@ function findSourceFile2(meta) {
   return null;
 }
 // src/profiler.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 var PROFILE_SCHEMA_VERSION = 1;
 var DEFAULT_FANOUT_THRESHOLD = 8;
 function buildStaticBudget(source, filePath, componentName, options = {}) {
@@ -27111,15 +27171,15 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts24.createSourceFile(filePath, source, ts24.ScriptTarget.Latest, true, ts24.ScriptKind.TSX);
+  const sf = ts25.createSourceFile(filePath, source, ts25.ScriptTarget.Latest, true, ts25.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts24.isCallExpression(node) && ts24.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts25.isCallExpression(node) && ts25.isIdentifier(node.expression) && node.expression.text === "createEffect") {
       const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
       if (!instrumentedLines.has(line))
         out.push({ file: filePath, line });
     }
-    ts24.forEachChild(node, visit3);
+    ts25.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -27427,13 +27487,13 @@ function assessBatchSafety(args) {
   const signalGetters = new Set(args.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts24.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts24.ScriptTarget.Latest, true);
+    sf = ts25.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts25.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts24.isCallExpression(node) && ts24.isIdentifier(node.expression)) {
+    if (ts25.isCallExpression(node) && ts25.isIdentifier(node.expression)) {
       const name = node.expression.text;
       if (setters.has(name))
         calls.push({ pos: node.getStart(sf), kind: "write" });
@@ -27442,7 +27502,7 @@ function assessBatchSafety(args) {
       else if (!signalGetters.has(name) && !memoNames.has(name))
         calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts24.forEachChild(node, visit3);
+    ts25.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -28092,7 +28152,6 @@ export {
   resolveSetters,
   resolveDangerousInnerHtml,
   resetCompilerCounters,
-  renderImportMapHtml,
   registerLoweringPlugin,
   registerBuiltinLoweringPlugins,
   queryHrefPlugin,