@barefootjs/cli 0.28.0 → 0.28.1

package/dist/index.js

@@ -5553,6 +5553,13 @@ var init_errors = __esm({
       // so an unimported tag with the built-in name is either a forgotten import
       // or an undeclared component — fail loud with the import to add.
       BUILTIN_REQUIRES_IMPORT: "BF054",
+      // A relative `.ts` module inlined into a client bundle (`resolveRelativeImports`'s
+      // top-level IIFE wrap) was asked for a name it does not export. The IIFE's
+      // `return { … }` has no binding for that name, so the reference throws
+      // `ReferenceError: <name> is not defined` at load — killing the page's
+      // client JS before hydrate. Fail the build instead of shipping the
+      // dangling reference (#2432).
+      INLINED_IMPORT_MISSING_EXPORT: "BF055",
       // Init statement errors (BF052)
       UNDECLARED_INIT_STATEMENT_REFERENCE: "BF052",
       // Stripped-import diagnostics (BF053) — a relative import was removed
@@ -5614,6 +5621,7 @@ var init_errors = __esm({
       [ErrorCodes.BUILTIN_REQUIRES_IMPORT]: "Built-in <Async> / <Region> must be imported from '@barefootjs/client'. The compiler recognises these tags by their import (not by tag name), so an unimported tag with this name is treated as an undeclared component.",
       [ErrorCodes.UNDECLARED_INIT_STATEMENT_REFERENCE]: "Init statement references an undeclared identifier. Declare it at module scope, inside the component, or import it \u2014 otherwise ESM strict mode throws ReferenceError at runtime.",
       [ErrorCodes.STRIPPED_CLIENT_IMPORT_REFERENCED]: "Import was stripped from the client bundle but its binding is still referenced. Client components ('use client' .tsx) are not callable as plain functions from imperative .ts modules \u2014 render them as JSX from a 'use client' parent instead. If the flagged name is a local shadow rather than the stripped import, please file an issue.",
+      [ErrorCodes.INLINED_IMPORT_MISSING_EXPORT]: "An inlined relative import requests a name the target module does not export. The client bundle would throw ReferenceError at load.",
       [ErrorCodes.STAGE_REACTIVE_IN_TEMPLATE]: "Reactive binding (signal getter or memo) referenced from template scope. The template lambda runs at module scope without the reactive context, so the value cannot be evaluated at SSR. Wrap the JSX expression in /* @client */ to defer it to hydrate, or restructure so the template uses a prop or static value.",
       [ErrorCodes.STAGE_INIT_LOCAL_IN_TEMPLATE]: "Init-scope local referenced from template scope. The template lambda runs at module scope (via render() / renderChild()) and cannot reach init-body locals. Wrap the JSX expression in /* @client */, or lift the value to a prop or module-scope const.",
       [ErrorCodes.STAGE_AWAIT_IN_TEMPLATE]: "AwaitExpression in template scope. The generated template and init functions are synchronous \u2014 a bare `await` produces a SyntaxError at parse time. Move the await into the component body (before the return) or into an onMount/effect callback, and pass the resolved value to JSX.",
@@ -7874,6 +7882,7 @@ function importsBrowserOnlyClientApi(ctx2) {
     if (imp.source !== "@barefootjs/client") continue;
     if (imp.isTypeOnly) continue;
     for (const spec of imp.specifiers) {
+      if (spec.isTypeOnly) continue;
       const importedName = spec.name;
       if (BROWSER_ONLY_CLIENT_APIS.has(importedName)) return true;
     }
@@ -15274,6 +15283,64 @@ var init_compute_prop_usage = __esm({
   }
 });
 
+// ../jsx/src/value-references.ts
+import ts13 from "typescript";
+function isValueReferenceIdentifier(id2) {
+  const parent2 = id2.parent;
+  if (!parent2) return false;
+  if (ts13.isPropertyAccessExpression(parent2) && parent2.name === id2) return false;
+  if (ts13.isPropertyAssignment(parent2) && parent2.name === id2) return false;
+  if ((ts13.isMethodDeclaration(parent2) || ts13.isGetAccessorDeclaration(parent2) || ts13.isSetAccessorDeclaration(parent2)) && parent2.name === id2) {
+    return false;
+  }
+  if (ts13.isVariableDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts13.isFunctionDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts13.isFunctionExpression(parent2) && parent2.name === id2) return false;
+  if (ts13.isClassDeclaration(parent2) && parent2.name === id2) return false;
+  if (ts13.isClassExpression(parent2) && parent2.name === id2) return false;
+  if (ts13.isParameter(parent2) && parent2.name === id2) return false;
+  if (ts13.isBindingElement(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts13.isLabeledStatement(parent2) && parent2.label === id2) return false;
+  if (ts13.isBreakOrContinueStatement(parent2) && parent2.label === id2) return false;
+  if (ts13.isImportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts13.isExportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
+  if (ts13.isImportClause(parent2) && parent2.name === id2) return false;
+  if (ts13.isNamespaceImport(parent2) && parent2.name === id2) return false;
+  if (ts13.isQualifiedName(parent2) && parent2.right === id2) return false;
+  return true;
+}
+function collectValueReferencedNames(code) {
+  let sourceFile;
+  try {
+    sourceFile = ts13.createSourceFile(
+      "generated.js",
+      code,
+      ts13.ScriptTarget.Latest,
+      /*setParentNodes*/
+      true,
+      ts13.ScriptKind.JS
+    );
+  } catch {
+    return null;
+  }
+  const diagnostics = sourceFile.parseDiagnostics;
+  if (diagnostics && diagnostics.length > 0) return null;
+  const names = /* @__PURE__ */ new Set();
+  function visit3(node) {
+    if (ts13.isIdentifier(node) && isValueReferenceIdentifier(node)) {
+      names.add(node.text);
+    }
+    ts13.forEachChild(node, visit3);
+  }
+  visit3(sourceFile);
+  return names;
+}
+var init_value_references = __esm({
+  "../jsx/src/value-references.ts"() {
+    "use strict";
+  }
+});
+
 // ../jsx/src/ir-to-client-js/imports.ts
 function detectUsedImports(code) {
   const used = /* @__PURE__ */ new Set();
@@ -15299,7 +15366,7 @@ function collectUserDomImports(ir) {
   for (const imp of ir.metadata.imports) {
     if (runtimeSources.has(imp.source) && !imp.isTypeOnly) {
       for (const spec of imp.specifiers) {
-        if (!spec.isDefault && !spec.isNamespace) {
+        if (!spec.isDefault && !spec.isNamespace && !spec.isTypeOnly) {
           if (isClientBuiltinName(spec.name)) continue;
           userImports.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name);
         }
@@ -15308,9 +15375,22 @@ function collectUserDomImports(ir) {
   }
   return userImports;
 }
+function makeValueUsageTest(generatedCode) {
+  let referenced;
+  return (localName2) => {
+    if (referenced === void 0) {
+      referenced = collectValueReferencedNames(generatedCode);
+    }
+    if (referenced !== null) {
+      return referenced.has(localName2);
+    }
+    return generatedCode.includes(localName2);
+  };
+}
 function collectExternalImports(ir, generatedCode, localImportPrefixes) {
   const componentNames = collectComponentNames(ir.root);
   const importLines = [];
+  const isUsedAsValue = makeValueUsageTest(generatedCode);
   for (const imp of ir.metadata.imports) {
     if (imp.isTypeOnly) continue;
     if (imp.source === "@barefootjs/client" || imp.source === RUNTIME_MODULE) continue;
@@ -15321,9 +15401,10 @@ function collectExternalImports(ir, generatedCode, localImportPrefixes) {
     }
     const usedSpecs = [];
     for (const spec of imp.specifiers) {
+      if (spec.isTypeOnly) continue;
       const localName2 = spec.alias || spec.name;
       if (componentNames.has(localName2)) continue;
-      if (new RegExp(`\\b${localName2}\\b`).test(generatedCode)) {
+      if (isUsedAsValue(localName2)) {
         usedSpecs.push(spec.alias ? `${spec.name} as ${spec.alias}` : spec.name);
       }
     }
@@ -15363,6 +15444,7 @@ var init_imports = __esm({
   "../jsx/src/ir-to-client-js/imports.ts"() {
     "use strict";
     init_builtins();
+    init_value_references();
     RUNTIME_IMPORT_CANDIDATES = [
       "createSignal",
       "createMemo",
@@ -15475,23 +15557,23 @@ var init_lowering_registry = __esm({
 });
 
 // ../jsx/src/relocate.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function classify(name2, env) {
   return env.bindings.get(name2) ?? "global";
 }
 function collectFreeRefs(node) {
   const refs = /* @__PURE__ */ new Map();
   function visit3(n, parent2) {
-    if (ts13.isIdentifier(n)) {
-      if (parent2 && ts13.isPropertyAccessExpression(parent2) && parent2.name === n) return;
-      if (parent2 && ts13.isPropertyAssignment(parent2) && parent2.name === n) return;
-      if (parent2 && ts13.isShorthandPropertyAssignment(parent2) && parent2.name === n) return;
+    if (ts14.isIdentifier(n)) {
+      if (parent2 && ts14.isPropertyAccessExpression(parent2) && parent2.name === n) return;
+      if (parent2 && ts14.isPropertyAssignment(parent2) && parent2.name === n) return;
+      if (parent2 && ts14.isShorthandPropertyAssignment(parent2) && parent2.name === n) return;
       const list = refs.get(n.text) ?? [];
       list.push(n);
       refs.set(n.text, list);
       return;
     }
-    ts13.forEachChild(n, (child) => visit3(child, n));
+    ts14.forEachChild(n, (child) => visit3(child, n));
   }
   visit3(node);
   return refs;
@@ -15592,9 +15674,9 @@ function isInlinableInTemplate(value2, env) {
   return { ok: true, rewrittenValue: r2.text, decisions: r2.decisions };
 }
 function getCalleeIdentifierPath(callee) {
-  if (ts13.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression);
-  if (ts13.isIdentifier(callee)) return callee.text;
-  if (ts13.isPropertyAccessExpression(callee)) {
+  if (ts14.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression);
+  if (ts14.isIdentifier(callee)) return callee.text;
+  if (ts14.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression);
     if (left === null) return null;
     return `${left}.${callee.name.text}`;
@@ -15602,9 +15684,9 @@ function getCalleeIdentifierPath(callee) {
   return null;
 }
 function getCalleeLeftmostIdentifier(callee) {
-  if (ts13.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression);
-  if (ts13.isIdentifier(callee)) return callee.text;
-  if (ts13.isPropertyAccessExpression(callee)) {
+  if (ts14.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression);
+  if (ts14.isIdentifier(callee)) return callee.text;
+  if (ts14.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression);
   }
   return null;
@@ -15643,17 +15725,17 @@ function isCallAcceptedByAdapter(call, env) {
 }
 function parseExpressionNode(text) {
   try {
-    const sf = ts13.createSourceFile(
+    const sf = ts14.createSourceFile(
       "__inline_check__.ts",
       `(${text});`,
-      ts13.ScriptTarget.Latest,
+      ts14.ScriptTarget.Latest,
       false,
-      ts13.ScriptKind.TS
+      ts14.ScriptKind.TS
     );
     const stmt = sf.statements[0];
-    if (!stmt || !ts13.isExpressionStatement(stmt)) return null;
+    if (!stmt || !ts14.isExpressionStatement(stmt)) return null;
     const inner = stmt.expression;
-    return ts13.isParenthesizedExpression(inner) ? inner.expression : inner;
+    return ts14.isParenthesizedExpression(inner) ? inner.expression : inner;
   } catch {
     return null;
   }
@@ -15667,8 +15749,8 @@ function hasCallWithBridgedArg(node, decisions, env) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts13.isCallExpression(n) || ts13.isNewExpression(n)) {
-      const accepted = ts13.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
+    if (ts14.isCallExpression(n) || ts14.isNewExpression(n)) {
+      const accepted = ts14.isCallExpression(n) && isCallAcceptedByAdapter(n, env);
       if (!accepted) {
         const args2 = n.arguments;
         if (args2) {
@@ -15681,7 +15763,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts13.forEachChild(n, visit3);
+    ts14.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15690,13 +15772,13 @@ function hasZeroArgCall(node, env) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts13.isCallExpression(n) && n.arguments.length === 0) {
+    if (ts14.isCallExpression(n) && n.arguments.length === 0) {
       if (!isCallAcceptedByAdapter(n, env)) {
         found = true;
         return;
       }
     }
-    ts13.forEachChild(n, visit3);
+    ts14.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15705,25 +15787,25 @@ function containsAnyIdentifier(node, names) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts13.isPropertyAccessExpression(n)) {
+    if (ts14.isPropertyAccessExpression(n)) {
       visit3(n.expression);
       return;
     }
-    if (ts13.isPropertyAssignment(n)) {
+    if (ts14.isPropertyAssignment(n)) {
       visit3(n.initializer);
       return;
     }
-    if (ts13.isShorthandPropertyAssignment(n)) {
-      if (ts13.isIdentifier(n.name) && names.has(n.name.text)) {
+    if (ts14.isShorthandPropertyAssignment(n)) {
+      if (ts14.isIdentifier(n.name) && names.has(n.name.text)) {
         found = true;
       }
       return;
     }
-    if (ts13.isIdentifier(n) && names.has(n.text)) {
+    if (ts14.isIdentifier(n) && names.has(n.text)) {
       found = true;
       return;
     }
-    ts13.forEachChild(n, visit3);
+    ts14.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -19042,7 +19124,7 @@ var init_claim_plan = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 function bindingIdArg(ctx2, slotId) {
   if (!ctx2.profile || !slotId) return "";
   return `, ${JSON.stringify(`${ctx2.componentName}#binding:${slotId}`)}`;
@@ -19122,19 +19204,19 @@ function lowerToLocaleCallsInReactiveExpr(expr, matcher) {
   if (!matcher) return expr;
   let sourceFile;
   try {
-    sourceFile = ts14.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.TS);
+    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts14.isExpressionStatement(stmt)) return expr;
-  const root2 = ts14.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts15.isExpressionStatement(stmt)) return expr;
+  const root2 = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts14.isCallExpression(n) && n.arguments.length === 2 && ts14.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
+    if (ts15.isCallExpression(n) && n.arguments.length === 2 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && n.expression.name.text === "toLocaleDateString") {
       candidates.push(n);
     }
-    ts14.forEachChild(n, visit3);
+    ts15.forEachChild(n, visit3);
   };
   visit3(root2);
   if (candidates.length === 0) return expr;
@@ -19171,19 +19253,19 @@ function lowerDateCallsInReactiveExpr(expr, matcher) {
   if (!matcher) return expr;
   let sourceFile;
   try {
-    sourceFile = ts14.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.TS);
+    sourceFile = ts15.createSourceFile("__reactive_expr__.ts", `(${expr});`, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
   } catch {
     return expr;
   }
   const stmt = sourceFile.statements[0];
-  if (!stmt || !ts14.isExpressionStatement(stmt)) return expr;
-  const root2 = ts14.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts15.isExpressionStatement(stmt)) return expr;
+  const root2 = ts15.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   const candidates = [];
   const visit3 = (n) => {
-    if (ts14.isCallExpression(n) && n.arguments.length === 0 && ts14.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
+    if (ts15.isCallExpression(n) && n.arguments.length === 0 && ts15.isPropertyAccessExpression(n.expression) && !n.expression.questionDotToken && DATE_METHODS.has(n.expression.name.text)) {
       candidates.push(n);
     }
-    ts14.forEachChild(n, visit3);
+    ts15.forEachChild(n, visit3);
   };
   visit3(root2);
   if (candidates.length === 0) return expr;
@@ -21318,25 +21400,25 @@ var init_phases = __esm({
 });
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts15 from "typescript";
+import ts16 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 = ts15.createSourceFile(
+  const sourceFile = ts16.createSourceFile(
     "init-body.ts",
     code,
-    ts15.ScriptTarget.Latest,
+    ts16.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts15.ScriptKind.TS
+    ts16.ScriptKind.TS
   );
   const spans = [];
   function visit3(node) {
-    if (ts15.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
+    if (ts16.isIdentifier(node) && node.text === srcPropsName && shouldRewrite(node)) {
       spans.push([node.getStart(sourceFile), node.getEnd()]);
     }
-    ts15.forEachChild(node, visit3);
+    ts16.forEachChild(node, visit3);
   }
   visit3(sourceFile);
   if (spans.length === 0) return code;
@@ -21350,12 +21432,12 @@ function rewritePropsObjectRef(code, propsObjectName) {
 function shouldRewrite(node) {
   const parent2 = node.parent;
   if (!parent2) return true;
-  if (ts15.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
-  if (ts15.isPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts15.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
-  if (ts15.isPropertySignature(parent2) && parent2.name === node) return false;
-  if (ts15.isPropertyDeclaration(parent2) && parent2.name === node) return false;
-  if (ts15.isBindingElement(parent2) && parent2.name === node) return false;
+  if (ts16.isPropertyAccessExpression(parent2) && parent2.name === node) return false;
+  if (ts16.isPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts16.isShorthandPropertyAssignment(parent2) && parent2.name === node) return false;
+  if (ts16.isPropertySignature(parent2) && parent2.name === node) return false;
+  if (ts16.isPropertyDeclaration(parent2) && parent2.name === node) return false;
+  if (ts16.isBindingElement(parent2) && parent2.name === node) return false;
   return true;
 }
 var init_rewrite_props_object = __esm({
@@ -22039,7 +22121,7 @@ var init_css_layer_prefixer = __esm({
 });
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 function preprocessInlineJsxCallbacks(source, filePath) {
   const errors = [];
   const syntheticNames = [];
@@ -22059,15 +22141,15 @@ function preprocessInlineJsxCallbacks(source, filePath) {
   return { source: current, errors, syntheticNames };
 }
 function runSinglePass(source, filePath, startingCounter) {
-  const sourceFile = ts16.createSourceFile(
+  const sourceFile = ts17.createSourceFile(
     filePath,
     source,
-    ts16.ScriptTarget.Latest,
+    ts17.ScriptTarget.Latest,
     true,
-    ts16.ScriptKind.TSX
+    ts17.ScriptKind.TSX
   );
   const hasUseClient = sourceFile.statements.some(
-    (stmt) => ts16.isExpressionStatement(stmt) && ts16.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
+    (stmt) => ts17.isExpressionStatement(stmt) && ts17.isStringLiteral(stmt.expression) && (stmt.expression.text === "use client" || stmt.expression.text === "'use client'")
   );
   if (!hasUseClient) {
     return { source, errors: [], syntheticNames: [], counterAfter: startingCounter };
@@ -22090,20 +22172,20 @@ function runSinglePass(source, filePath, startingCounter) {
     }
   }
   function visit3(node) {
-    if (ts16.isJsxAttribute(node) && node.initializer && ts16.isJsxExpression(node.initializer) && node.initializer.expression) {
+    if (ts17.isJsxAttribute(node) && node.initializer && ts17.isJsxExpression(node.initializer) && node.initializer.expression) {
       if (tryHandleArrowValue(node.initializer.expression)) {
         return;
       }
     }
-    if (ts16.isPropertyAssignment(node) && node.initializer) {
+    if (ts17.isPropertyAssignment(node) && node.initializer) {
       if (tryHandleArrowValue(node.initializer)) return;
     }
-    ts16.forEachChild(node, visit3);
+    ts17.forEachChild(node, visit3);
   }
   function tryHandleArrowValue(initializer) {
     let expr = initializer;
-    while (ts16.isParenthesizedExpression(expr)) expr = expr.expression;
-    if (ts16.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
+    while (ts17.isParenthesizedExpression(expr)) expr = expr.expression;
+    if (ts17.isArrowFunction(expr) && arrowBodyContainsJsx(expr)) {
       return handleInlineArrow(expr);
     }
     return false;
@@ -22138,7 +22220,7 @@ function runSinglePass(source, filePath, startingCounter) {
     replacements.push({ start: arrowStart, end: arrowEnd, text: name2 });
     return true;
   }
-  ts16.forEachChild(sourceFile, visit3);
+  ts17.forEachChild(sourceFile, visit3);
   if (replacements.length === 0) {
     return { source, errors, syntheticNames, counterAfter: counter };
   }
@@ -22157,33 +22239,33 @@ 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 (ts16.isBlock(arrow.body)) {
+  if (ts17.isBlock(arrow.body)) {
     return blockReturnsJsx(arrow.body);
   }
   let body2 = arrow.body;
-  while (ts16.isParenthesizedExpression(body2)) body2 = body2.expression;
+  while (ts17.isParenthesizedExpression(body2)) body2 = body2.expression;
   return isJsxLike(body2);
 }
 function blockReturnsJsx(block) {
   let found = false;
   function visit3(n) {
     if (found) return;
-    if (ts16.isReturnStatement(n) && n.expression) {
+    if (ts17.isReturnStatement(n) && n.expression) {
       let e = n.expression;
-      while (ts16.isParenthesizedExpression(e)) e = e.expression;
+      while (ts17.isParenthesizedExpression(e)) e = e.expression;
       if (isJsxLike(e)) {
         found = true;
         return;
       }
     }
-    if (ts16.isArrowFunction(n) || ts16.isFunctionDeclaration(n) || ts16.isFunctionExpression(n)) return;
-    ts16.forEachChild(n, visit3);
+    if (ts17.isArrowFunction(n) || ts17.isFunctionDeclaration(n) || ts17.isFunctionExpression(n)) return;
+    ts17.forEachChild(n, visit3);
   }
-  ts16.forEachChild(block, visit3);
+  ts17.forEachChild(block, visit3);
   return found;
 }
 function isJsxLike(expr) {
-  return ts16.isJsxElement(expr) || ts16.isJsxSelfClosingElement(expr) || ts16.isJsxFragment(expr);
+  return ts17.isJsxElement(expr) || ts17.isJsxSelfClosingElement(expr) || ts17.isJsxFragment(expr);
 }
 function collectArrowParamNames(arrow) {
   const names = /* @__PURE__ */ new Set();
@@ -22192,13 +22274,13 @@ function collectArrowParamNames(arrow) {
 }
 function collectBindingNames2(name2, out) {
   const push = Array.isArray(out) ? (n) => out.push(n) : (n) => out.add(n);
-  if (ts16.isIdentifier(name2)) {
+  if (ts17.isIdentifier(name2)) {
     push(name2.text);
-  } else if (ts16.isObjectBindingPattern(name2)) {
+  } else if (ts17.isObjectBindingPattern(name2)) {
     name2.elements.forEach((el) => collectBindingNames2(el.name, out));
-  } else if (ts16.isArrayBindingPattern(name2)) {
+  } else if (ts17.isArrayBindingPattern(name2)) {
     name2.elements.forEach((el) => {
-      if (!ts16.isOmittedExpression(el)) collectBindingNames2(el.name, out);
+      if (!ts17.isOmittedExpression(el)) collectBindingNames2(el.name, out);
     });
   }
 }
@@ -22223,71 +22305,71 @@ function collectFreeIdentifiers(arrow) {
     return bound.includes(name2);
   }
   function visit3(node) {
-    if (ts16.isIdentifier(node)) {
+    if (ts17.isIdentifier(node)) {
       const parent2 = node.parent;
-      if (parent2 && ts16.isPropertyAccessExpression(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isPropertyAssignment(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isPropertySignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isPropertyDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isMethodDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isMethodSignature(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isEnumMember(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isBindingElement(parent2) && parent2.propertyName === node) return;
-      if (parent2 && ts16.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
+      if (parent2 && ts17.isPropertyAccessExpression(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isPropertyAssignment(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isPropertySignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isPropertyDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isMethodDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isMethodSignature(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isGetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isSetAccessorDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isEnumMember(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isBindingElement(parent2) && parent2.propertyName === node) return;
+      if (parent2 && ts17.isShorthandPropertyAssignment(parent2) && parent2.name === node) {
         if (!isBound(node.text)) ids.add(node.text);
         return;
       }
-      if (parent2 && ts16.isParameter(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isVariableDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isFunctionDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isClassDeclaration(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isJsxAttribute(parent2) && parent2.name === node) return;
-      if (parent2 && ts16.isJsxOpeningElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts17.isParameter(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isVariableDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isFunctionDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isClassDeclaration(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isJsxAttribute(parent2) && parent2.name === node) return;
+      if (parent2 && ts17.isJsxOpeningElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
-      if (parent2 && ts16.isJsxClosingElement(parent2) && parent2.tagName === node) {
+      if (parent2 && ts17.isJsxClosingElement(parent2) && parent2.tagName === node) {
         if (/^[a-z]/.test(node.text)) return;
       }
       if (isBound(node.text)) return;
       ids.add(node.text);
       return;
     }
-    if (ts16.isVariableDeclaration(node)) {
+    if (ts17.isVariableDeclaration(node)) {
       const declared = pushBindings(node.name);
       if (node.initializer) visit3(node.initializer);
       declared;
       return;
     }
-    if (ts16.isFunctionDeclaration(node)) {
+    if (ts17.isFunctionDeclaration(node)) {
       if (node.name) bound.push(node.name.text);
       visitInsideNewScope(node);
       return;
     }
-    if (ts16.isClassDeclaration(node)) {
+    if (ts17.isClassDeclaration(node)) {
       if (node.name) bound.push(node.name.text);
-      ts16.forEachChild(node, visit3);
+      ts17.forEachChild(node, visit3);
       return;
     }
-    if (ts16.isArrowFunction(node) || ts16.isFunctionExpression(node)) {
+    if (ts17.isArrowFunction(node) || ts17.isFunctionExpression(node)) {
       visitInsideNewScope(node);
       return;
     }
-    if (ts16.isCatchClause(node)) {
+    if (ts17.isCatchClause(node)) {
       const before = bound.length;
       if (node.variableDeclaration) pushBindings(node.variableDeclaration.name);
-      ts16.forEachChild(node, visit3);
+      ts17.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    if (ts16.isBlock(node)) {
+    if (ts17.isBlock(node)) {
       const before = bound.length;
-      ts16.forEachChild(node, visit3);
+      ts17.forEachChild(node, visit3);
       popN(bound.length - before);
       return;
     }
-    ts16.forEachChild(node, visit3);
+    ts17.forEachChild(node, visit3);
   }
   function visitInsideNewScope(fn) {
     const before = bound.length;
@@ -22307,27 +22389,27 @@ function collectFreeIdentifiers(arrow) {
 function collectModuleScopeNames(sourceFile) {
   const names = /* @__PURE__ */ new Set();
   for (const stmt of sourceFile.statements) {
-    if (ts16.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts16.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
-    else if (ts16.isVariableStatement(stmt)) {
+    if (ts17.isFunctionDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    else if (ts17.isClassDeclaration(stmt) && stmt.name) names.add(stmt.name.text);
+    else if (ts17.isVariableStatement(stmt)) {
       for (const decl of stmt.declarationList.declarations) collectBindingNames2(decl.name, names);
-    } else if (ts16.isImportDeclaration(stmt) && stmt.importClause) {
+    } else if (ts17.isImportDeclaration(stmt) && stmt.importClause) {
       const ic = stmt.importClause;
       if (ic.name) names.add(ic.name.text);
       if (ic.namedBindings) {
-        if (ts16.isNamespaceImport(ic.namedBindings)) names.add(ic.namedBindings.name.text);
+        if (ts17.isNamespaceImport(ic.namedBindings)) names.add(ic.namedBindings.name.text);
         else for (const e of ic.namedBindings.elements) names.add(e.name.text);
       }
-    } else if (ts16.isTypeAliasDeclaration(stmt)) names.add(stmt.name.text);
-    else if (ts16.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
-    else if (ts16.isEnumDeclaration(stmt)) names.add(stmt.name.text);
+    } else if (ts17.isTypeAliasDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts17.isInterfaceDeclaration(stmt)) names.add(stmt.name.text);
+    else if (ts17.isEnumDeclaration(stmt)) names.add(stmt.name.text);
   }
   return names;
 }
 function buildSyntheticDeclaration(name2, arrow, sourceFile) {
   const paramsText = arrow.parameters.length === 0 ? "" : arrow.parameters.map((p) => p.getText(sourceFile)).join(", ");
   let bodyText;
-  if (ts16.isBlock(arrow.body)) {
+  if (ts17.isBlock(arrow.body)) {
     bodyText = arrow.body.getText(sourceFile);
   } else {
     const expr = arrow.body.getText(sourceFile);
@@ -22346,7 +22428,7 @@ var init_preprocess_inline_jsx_callbacks = __esm({
 });
 
 // ../jsx/src/ssr-defaults.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function extractSsrDefaults(metadata) {
   const out = {};
   const propsLike = /* @__PURE__ */ new Set();
@@ -22406,11 +22488,11 @@ function collectPropRefs(expr, propsObjectName, out) {
   const node = parseExpression2(expr);
   if (!node) return;
   const visit3 = (n) => {
-    if (ts17.isPropertyAccessExpression(n) && ts17.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts17.isIdentifier(n.name)) {
+    if (ts18.isPropertyAccessExpression(n) && ts18.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts18.isIdentifier(n.name)) {
       out.add(n.name.text);
       return;
     }
-    ts17.forEachChild(n, visit3);
+    ts18.forEachChild(n, visit3);
   };
   visit3(node);
 }
@@ -22427,21 +22509,21 @@ function tryStaticEval(expr, ctx2) {
 }
 function evalStatementsForReturn(statements, ctx2) {
   for (const stmt of statements) {
-    if (ts17.isVariableStatement(stmt)) {
+    if (ts18.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
-        if (!ts17.isIdentifier(d.name) || !d.initializer) continue;
+        if (!ts18.isIdentifier(d.name) || !d.initializer) continue;
         const v = evalNode(d.initializer, ctx2);
         if (v !== UNRESOLVED) ctx2.bindings[d.name.text] = v;
       }
-    } else if (ts17.isReturnStatement(stmt)) {
+    } else if (ts18.isReturnStatement(stmt)) {
       return stmt.expression ? evalNode(stmt.expression, ctx2) : UNRESOLVED;
-    } else if (ts17.isIfStatement(stmt)) {
+    } else if (ts18.isIfStatement(stmt)) {
       const cond = evalNode(stmt.expression, ctx2);
       if (cond === UNRESOLVED) return UNRESOLVED;
       const branch = cond ? stmt.thenStatement : stmt.elseStatement;
       if (branch) {
         const taken = evalStatementsForReturn(
-          ts17.isBlock(branch) ? branch.statements : [branch],
+          ts18.isBlock(branch) ? branch.statements : [branch],
           ctx2
         );
         if (taken !== NO_RETURN) return taken;
@@ -22453,64 +22535,64 @@ function evalStatementsForReturn(statements, ctx2) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts17.createSourceFile(
+  const sf = ts18.createSourceFile(
     "__ssr_default__.ts",
     `(${expr})`,
-    ts17.ScriptTarget.Latest,
+    ts18.ScriptTarget.Latest,
     false,
-    ts17.ScriptKind.TS
+    ts18.ScriptKind.TS
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts17.isExpressionStatement(stmt)) return null;
-  const inner = ts17.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  if (!stmt || !ts18.isExpressionStatement(stmt)) return null;
+  const inner = ts18.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
   return inner;
 }
 function evalNode(node, ctx2) {
-  if (ts17.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts17.isAsExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts17.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts17.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts17.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
-  if (ts17.isArrowFunction(node)) {
+  if (ts18.isParenthesizedExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts18.isAsExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts18.isSatisfiesExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts18.isTypeAssertionExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts18.isNonNullExpression(node)) return evalNode(node.expression, ctx2);
+  if (ts18.isArrowFunction(node)) {
     if (node.parameters.length !== 0) return UNRESOLVED;
-    if (!ts17.isBlock(node.body)) return evalNode(node.body, ctx2);
+    if (!ts18.isBlock(node.body)) return evalNode(node.body, ctx2);
     const localBindings = { ...ctx2.bindings };
     const localCtx = { ...ctx2, bindings: localBindings };
     const result2 = evalStatementsForReturn(node.body.statements, localCtx);
     return result2 === NO_RETURN ? UNRESOLVED : result2;
   }
-  if (ts17.isNumericLiteral(node)) return Number(node.text);
-  if (ts17.isStringLiteralLike(node)) return node.text;
-  if (node.kind === ts17.SyntaxKind.TrueKeyword) return true;
-  if (node.kind === ts17.SyntaxKind.FalseKeyword) return false;
-  if (node.kind === ts17.SyntaxKind.NullKeyword) return null;
-  if (ts17.isIdentifier(node)) {
+  if (ts18.isNumericLiteral(node)) return Number(node.text);
+  if (ts18.isStringLiteralLike(node)) return node.text;
+  if (node.kind === ts18.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts18.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts18.SyntaxKind.NullKeyword) return null;
+  if (ts18.isIdentifier(node)) {
     if (node.text === "undefined") return void 0;
     if (node.text in ctx2.bindings) return ctx2.bindings[node.text];
     if (ctx2.propsLike.has(node.text)) return void 0;
     return UNRESOLVED;
   }
-  if (ts17.isPrefixUnaryExpression(node)) {
+  if (ts18.isPrefixUnaryExpression(node)) {
     const arg = evalNode(node.operand, ctx2);
     if (arg === UNRESOLVED) return UNRESOLVED;
     switch (node.operator) {
-      case ts17.SyntaxKind.MinusToken:
+      case ts18.SyntaxKind.MinusToken:
         return typeof arg === "number" ? -arg : UNRESOLVED;
-      case ts17.SyntaxKind.PlusToken:
+      case ts18.SyntaxKind.PlusToken:
         return typeof arg === "number" ? +arg : UNRESOLVED;
-      case ts17.SyntaxKind.ExclamationToken:
+      case ts18.SyntaxKind.ExclamationToken:
         return !arg;
     }
     return UNRESOLVED;
   }
-  if (ts17.isObjectLiteralExpression(node)) {
+  if (ts18.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const prop of node.properties) {
-      if (!ts17.isPropertyAssignment(prop)) return UNRESOLVED;
+      if (!ts18.isPropertyAssignment(prop)) return UNRESOLVED;
       let key;
-      if (ts17.isIdentifier(prop.name) || ts17.isStringLiteralLike(prop.name)) {
+      if (ts18.isIdentifier(prop.name) || ts18.isStringLiteralLike(prop.name)) {
         key = prop.name.text;
-      } else if (ts17.isNumericLiteral(prop.name)) {
+      } else if (ts18.isNumericLiteral(prop.name)) {
         key = prop.name.text;
       } else {
         return UNRESOLVED;
@@ -22521,17 +22603,17 @@ function evalNode(node, ctx2) {
     }
     return obj;
   }
-  if (ts17.isArrayLiteralExpression(node)) {
+  if (ts18.isArrayLiteralExpression(node)) {
     const arr = [];
     for (const elem of node.elements) {
-      if (ts17.isOmittedExpression(elem)) return UNRESOLVED;
+      if (ts18.isOmittedExpression(elem)) return UNRESOLVED;
       const v = evalNode(elem, ctx2);
       if (v === UNRESOLVED) return UNRESOLVED;
       arr.push(v === void 0 ? null : v);
     }
     return arr;
   }
-  if (ts17.isElementAccessExpression(node)) {
+  if (ts18.isElementAccessExpression(node)) {
     const base = evalNode(node.expression, ctx2);
     if (base === void 0) return void 0;
     if (base === UNRESOLVED || base === null || typeof base !== "object") return UNRESOLVED;
@@ -22541,16 +22623,16 @@ function evalNode(node, ctx2) {
     const k = String(key);
     return Object.prototype.hasOwnProperty.call(base, k) ? base[k] : void 0;
   }
-  if (ts17.isPropertyAccessExpression(node)) {
+  if (ts18.isPropertyAccessExpression(node)) {
     const baseResult = evalNode(node.expression, ctx2);
     if (baseResult === void 0) return void 0;
     return UNRESOLVED;
   }
-  if (ts17.isCallExpression(node)) {
-    if (node.arguments.length === 0 && ts17.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
+  if (ts18.isCallExpression(node)) {
+    if (node.arguments.length === 0 && ts18.isIdentifier(node.expression) && node.expression.text in ctx2.bindings) {
       return ctx2.bindings[node.expression.text];
     }
-    if (ts17.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
+    if (ts18.isPropertyAccessExpression(node.expression) && node.expression.name.text === "join") {
       const recv = evalNode(node.expression.expression, ctx2);
       if (Array.isArray(recv)) {
         let sep = ",";
@@ -22565,24 +22647,24 @@ function evalNode(node, ctx2) {
     }
     return UNRESOLVED;
   }
-  if (ts17.isConditionalExpression(node)) {
+  if (ts18.isConditionalExpression(node)) {
     const cond = evalNode(node.condition, ctx2);
     if (cond === UNRESOLVED) return UNRESOLVED;
     return cond ? evalNode(node.whenTrue, ctx2) : evalNode(node.whenFalse, ctx2);
   }
-  if (ts17.isBinaryExpression(node)) {
+  if (ts18.isBinaryExpression(node)) {
     const op = node.operatorToken.kind;
-    if (op === ts17.SyntaxKind.QuestionQuestionToken) {
+    if (op === ts18.SyntaxKind.QuestionQuestionToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 !== UNRESOLVED && l2 !== null && l2 !== void 0) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts17.SyntaxKind.BarBarToken) {
+    if (op === ts18.SyntaxKind.BarBarToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 !== UNRESOLVED && l2) return l2;
       return evalNode(node.right, ctx2);
     }
-    if (op === ts17.SyntaxKind.AmpersandAmpersandToken) {
+    if (op === ts18.SyntaxKind.AmpersandAmpersandToken) {
       const l2 = evalNode(node.left, ctx2);
       if (l2 === UNRESOLVED) return UNRESOLVED;
       if (!l2) return l2;
@@ -22592,28 +22674,28 @@ function evalNode(node, ctx2) {
     const r2 = evalNode(node.right, ctx2);
     if (l === UNRESOLVED || r2 === UNRESOLVED) return UNRESOLVED;
     switch (op) {
-      case ts17.SyntaxKind.PlusToken:
+      case ts18.SyntaxKind.PlusToken:
         if (typeof l === "string" || typeof r2 === "string") return `${l}${r2}`;
         if (typeof l === "number" && typeof r2 === "number") return l + r2;
         return UNRESOLVED;
-      case ts17.SyntaxKind.MinusToken:
+      case ts18.SyntaxKind.MinusToken:
         return typeof l === "number" && typeof r2 === "number" ? l - r2 : UNRESOLVED;
-      case ts17.SyntaxKind.AsteriskToken:
+      case ts18.SyntaxKind.AsteriskToken:
         return typeof l === "number" && typeof r2 === "number" ? l * r2 : UNRESOLVED;
-      case ts17.SyntaxKind.SlashToken:
+      case ts18.SyntaxKind.SlashToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l / r2 : UNRESOLVED;
-      case ts17.SyntaxKind.PercentToken:
+      case ts18.SyntaxKind.PercentToken:
         return typeof l === "number" && typeof r2 === "number" && r2 !== 0 ? l % r2 : UNRESOLVED;
-      case ts17.SyntaxKind.EqualsEqualsEqualsToken:
-      case ts17.SyntaxKind.EqualsEqualsToken:
+      case ts18.SyntaxKind.EqualsEqualsEqualsToken:
+      case ts18.SyntaxKind.EqualsEqualsToken:
         return l === r2;
-      case ts17.SyntaxKind.ExclamationEqualsEqualsToken:
-      case ts17.SyntaxKind.ExclamationEqualsToken:
+      case ts18.SyntaxKind.ExclamationEqualsEqualsToken:
+      case ts18.SyntaxKind.ExclamationEqualsToken:
         return l !== r2;
     }
     return UNRESOLVED;
   }
-  if (ts17.isTemplateExpression(node)) {
+  if (ts18.isTemplateExpression(node)) {
     if (node.templateSpans.length === 0) return node.head.text;
     let acc = node.head.text;
     for (const span of node.templateSpans) {
@@ -22623,7 +22705,7 @@ function evalNode(node, ctx2) {
     }
     return acc;
   }
-  if (ts17.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts18.isNoSubstitutionTemplateLiteral(node)) return node.text;
   return UNRESOLVED;
 }
 var UNRESOLVED, NO_RETURN;
@@ -22636,7 +22718,7 @@ var init_ssr_defaults = __esm({
 });
 
 // ../jsx/src/augment-inherited-props.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = /* @__PURE__ */ new Map();
@@ -22663,35 +22745,35 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts18.isCallExpression(expr)) return null;
-  if (!ts18.isIdentifier(expr.expression) || expr.expression.text !== "useContext") return null;
+  if (!expr || !ts19.isCallExpression(expr)) return null;
+  if (!ts19.isIdentifier(expr.expression) || expr.expression.text !== "useContext") return null;
   if (expr.arguments.length !== 1) return null;
   const arg = expr.arguments[0];
-  return ts18.isIdentifier(arg) ? arg.text : null;
+  return ts19.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts18.isCallExpression(expr)) return null;
+  if (!expr || !ts19.isCallExpression(expr)) return null;
   if (expr.arguments.length === 0) return null;
   const arg = expr.arguments[0];
-  if (ts18.isStringLiteral(arg) || ts18.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
-  if (ts18.isNumericLiteral(arg)) return Number(arg.text);
-  if (arg.kind === ts18.SyntaxKind.TrueKeyword) return true;
-  if (arg.kind === ts18.SyntaxKind.FalseKeyword) return false;
+  if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg)) return arg.text;
+  if (ts19.isNumericLiteral(arg)) return Number(arg.text);
+  if (arg.kind === ts19.SyntaxKind.TrueKeyword) return true;
+  if (arg.kind === ts19.SyntaxKind.FalseKeyword) return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts18.isCallExpression(expr)) return false;
+  if (!expr || !ts19.isCallExpression(expr)) return false;
   if (expr.arguments.length === 0) return false;
-  return ts18.isObjectLiteralExpression(expr.arguments[0]);
+  return ts19.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts18.createSourceFile("__ctx.ts", `(${source})`, ts18.ScriptTarget.Latest, false);
+  const sf = ts19.createSourceFile("__ctx.ts", `(${source})`, ts19.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isExpressionStatement(stmt)) return null;
+  if (!stmt || !ts19.isExpressionStatement(stmt)) return null;
   let e = stmt.expression;
-  while (ts18.isParenthesizedExpression(e)) e = e.expression;
+  while (ts19.isParenthesizedExpression(e)) e = e.expression;
   return e;
 }
 function augmentInheritedPropAccesses(ir) {
@@ -22712,21 +22794,21 @@ function augmentInheritedPropAccesses(ir) {
   const coalesceLiteralTypes = /* @__PURE__ */ new Map();
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj)) return;
-    const sf = ts18.createSourceFile("__aug.ts", `(${s})`, ts18.ScriptTarget.Latest, false);
+    const sf = ts19.createSourceFile("__aug.ts", `(${s})`, ts19.ScriptTarget.Latest, false);
     const visit3 = (n) => {
-      if (ts18.isBinaryExpression(n) && (n.operatorToken.kind === ts18.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts18.SyntaxKind.BarBarToken)) {
+      if (ts19.isBinaryExpression(n) && (n.operatorToken.kind === ts19.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts19.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts18.isParenthesizedExpression(left)) left = left.expression;
-        if (ts18.isPropertyAccessExpression(left) && ts18.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        while (ts19.isParenthesizedExpression(left)) left = left.expression;
+        if (ts19.isPropertyAccessExpression(left) && ts19.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name2 = left.name.text;
           let right = n.right;
-          while (ts18.isParenthesizedExpression(right)) right = right.expression;
-          if (ts18.isPrefixUnaryExpression(right)) right = right.operand;
-          const kind2 = ts18.isNumericLiteral(right) ? "number" : right.kind === ts18.SyntaxKind.TrueKeyword || right.kind === ts18.SyntaxKind.FalseKeyword ? "boolean" : ts18.isStringLiteralLike(right) ? "string" : null;
+          while (ts19.isParenthesizedExpression(right)) right = right.expression;
+          if (ts19.isPrefixUnaryExpression(right)) right = right.operand;
+          const kind2 = ts19.isNumericLiteral(right) ? "number" : right.kind === ts19.SyntaxKind.TrueKeyword || right.kind === ts19.SyntaxKind.FalseKeyword ? "boolean" : ts19.isStringLiteralLike(right) ? "string" : null;
           if (kind2 && !coalesceLiteralTypes.has(name2)) coalesceLiteralTypes.set(name2, kind2);
         }
       }
-      ts18.forEachChild(n, visit3);
+      ts19.forEachChild(n, visit3);
     };
     visit3(sf);
   };
@@ -22822,39 +22904,39 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts18.createSourceFile(
+  const sf = ts19.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts18.ScriptTarget.Latest,
+    ts19.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts19.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts18.isParenthesizedExpression(init)) init = init.expression;
+  while (init && ts19.isParenthesizedExpression(init)) init = init.expression;
   if (!init) return null;
-  if (ts18.isStringLiteral(init) || ts18.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts19.isStringLiteral(init) || ts19.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts18.createSourceFile(
+  const sf = ts19.createSourceFile(
     "__const.ts",
     `const __x = (${source});`,
-    ts18.ScriptTarget.Latest,
+    ts19.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts19.isVariableStatement(stmt)) return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts18.isParenthesizedExpression(init)) init = init.expression;
-  if (!init || !ts18.isTemplateExpression(init)) return null;
+  while (init && ts19.isParenthesizedExpression(init)) init = init.expression;
+  if (!init || !ts19.isTemplateExpression(init)) return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts18.isIdentifier(span.expression)) return null;
+    if (!ts19.isIdentifier(span.expression)) return null;
     const value2 = resolved.get(span.expression.text);
     if (value2 === void 0) return null;
     out += value2 + span.literal.text;
@@ -22883,28 +22965,28 @@ function collectModuleStringConsts(constants) {
 function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === void 0) return null;
-  const sf = ts18.createSourceFile(
+  const sf = ts19.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts18.ScriptTarget.Latest,
+    ts19.ScriptTarget.Latest,
     /*setParentNodes*/
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts18.isExpressionStatement(stmt)) return null;
+  if (!ts19.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts18.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts18.isObjectLiteralExpression(parsed)) return null;
+  while (ts19.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts19.isObjectLiteralExpression(parsed)) return null;
   for (const prop of parsed.properties) {
-    if (!ts18.isPropertyAssignment(prop)) continue;
+    if (!ts19.isPropertyAssignment(prop)) continue;
     const name2 = prop.name;
-    const propKey = ts18.isIdentifier(name2) || ts18.isStringLiteral(name2) || ts18.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
+    const propKey = ts19.isIdentifier(name2) || ts19.isStringLiteral(name2) || ts19.isNoSubstitutionTemplateLiteral(name2) ? name2.text : null;
     if (propKey !== key) continue;
     let v = prop.initializer;
-    while (ts18.isParenthesizedExpression(v)) v = v.expression;
-    if (ts18.isNumericLiteral(v)) return { kind: "number", text: v.text };
-    if (ts18.isStringLiteral(v) || ts18.isNoSubstitutionTemplateLiteral(v)) {
+    while (ts19.isParenthesizedExpression(v)) v = v.expression;
+    if (ts19.isNumericLiteral(v)) return { kind: "number", text: v.text };
+    if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -22912,27 +22994,27 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts18.createSourceFile(
+  const sf = ts19.createSourceFile(
     "__join.ts",
     `const __x = (${source});`,
-    ts18.ScriptTarget.Latest,
+    ts19.ScriptTarget.Latest,
     /*setParentNodes*/
     false
   );
   const stmt = sf.statements[0];
-  if (!stmt || !ts18.isVariableStatement(stmt)) return null;
+  if (!stmt || !ts19.isVariableStatement(stmt)) return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts18.isParenthesizedExpression(node)) node = node.expression;
-  if (!node || !ts18.isCallExpression(node)) return null;
+  while (node && ts19.isParenthesizedExpression(node)) node = node.expression;
+  if (!node || !ts19.isCallExpression(node)) return null;
   const callee = node.expression;
-  if (!ts18.isPropertyAccessExpression(callee)) return null;
+  if (!ts19.isPropertyAccessExpression(callee)) return null;
   if (callee.name.text !== "join") return null;
   let recv = callee.expression;
-  while (ts18.isParenthesizedExpression(recv)) recv = recv.expression;
-  if (!ts18.isArrayLiteralExpression(recv)) return null;
+  while (ts19.isParenthesizedExpression(recv)) recv = recv.expression;
+  if (!ts19.isArrayLiteralExpression(recv)) return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts18.isStringLiteral(el) || ts18.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts19.isStringLiteral(el) || ts19.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -22941,16 +23023,16 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts18.isStringLiteral(arg) || ts18.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
+    if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text;
     else return null;
   }
   return parts.join(sep);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts18.isElementAccessExpression(val)) return null;
+  if (!ts19.isElementAccessExpression(val)) return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts18.isIdentifier(obj) || !ts18.isIdentifier(arg)) return null;
+  if (!ts19.isIdentifier(obj) || !ts19.isIdentifier(arg)) return null;
   let indexPropName;
   let defaultKey;
   const resolved = resolveKey?.(arg.text);
@@ -22964,35 +23046,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   }
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === void 0) return null;
-  const sf = ts18.createSourceFile(
+  const sf = ts19.createSourceFile(
     "__rec.ts",
     `(${constInfo.value})`,
-    ts18.ScriptTarget.Latest,
+    ts19.ScriptTarget.Latest,
     /* setParentNodes */
     true
   );
   if (sf.statements.length !== 1) return null;
   const stmt = sf.statements[0];
-  if (!ts18.isExpressionStatement(stmt)) return null;
+  if (!ts19.isExpressionStatement(stmt)) return null;
   let parsed = stmt.expression;
-  while (ts18.isParenthesizedExpression(parsed)) parsed = parsed.expression;
-  if (!ts18.isObjectLiteralExpression(parsed)) return null;
+  while (ts19.isParenthesizedExpression(parsed)) parsed = parsed.expression;
+  if (!ts19.isObjectLiteralExpression(parsed)) return null;
   const entries2 = [];
   for (const prop of parsed.properties) {
-    if (!ts18.isPropertyAssignment(prop)) return null;
+    if (!ts19.isPropertyAssignment(prop)) return null;
     let key;
-    if (ts18.isIdentifier(prop.name)) {
+    if (ts19.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts18.isStringLiteral(prop.name) || ts18.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts19.isStringLiteral(prop.name) || ts19.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts18.isParenthesizedExpression(v)) v = v.expression;
-    if (ts18.isNumericLiteral(v)) {
+    while (ts19.isParenthesizedExpression(v)) v = v.expression;
+    if (ts19.isNumericLiteral(v)) {
       entries2.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts18.isStringLiteral(v) || ts18.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
       entries2.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -23627,6 +23709,7 @@ function compileJSX(source, filePath, options2) {
       const sortedRuntimeImports = [...runtimeImports].sort();
       const runtimeImportLine = sortedRuntimeImports.length > 0 ? `import { ${sortedRuntimeImports.join(", ")} } from '${RUNTIME_MODULE}'` : "";
       const externalImportLines = [];
+      const isUsedAsValue = makeValueUsageTest(body2);
       for (const imp of ctx2.imports) {
         if (imp.isTypeOnly) continue;
         if (imp.source === "@barefootjs/client" || imp.source === RUNTIME_MODULE) continue;
@@ -23634,7 +23717,7 @@ function compileJSX(source, filePath, options2) {
           externalImportLines.push(`import '${imp.source}'`);
           continue;
         }
-        const used = imp.specifiers.filter((s2) => !s2.isDefault && !s2.isNamespace && new RegExp(`\\b${s2.alias || s2.name}\\b`).test(body2)).map((s2) => s2.alias ? `${s2.name} as ${s2.alias}` : s2.name);
+        const used = imp.specifiers.filter((s2) => !s2.isDefault && !s2.isNamespace && !s2.isTypeOnly && isUsedAsValue(s2.alias || s2.name)).map((s2) => s2.alias ? `${s2.name} as ${s2.alias}` : s2.name);
         if (used.length > 0) {
           externalImportLines.push(`import { ${used.join(", ")} } from '${imp.source}'`);
         }
@@ -23665,6 +23748,7 @@ function compileJSX(source, filePath, options2) {
       if (imp.isTypeOnly) continue;
       if (!imp.source.startsWith("./") && !imp.source.startsWith("../")) continue;
       for (const spec of imp.specifiers) {
+        if (spec.isTypeOnly) continue;
         if (ctx2.importedClientSignalNames.has(spec.alias ?? spec.name)) {
           sources.add(imp.source);
           break;
@@ -23794,7 +23878,7 @@ var init_compiler = __esm({
 });
 
 // ../jsx/src/shared-program.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 import path5 from "node:path";
 function commonParent(paths) {
   if (paths.length === 0) return process.cwd();
@@ -23812,10 +23896,10 @@ function commonParent(paths) {
 function createProgramForCorpus(files2, options2 = {}) {
   const baseUrl = options2.baseUrl ?? commonParent(files2);
   const compilerOptions = {
-    target: ts19.ScriptTarget.Latest,
-    module: ts19.ModuleKind.ESNext,
-    moduleResolution: ts19.ModuleResolutionKind.Bundler,
-    jsx: ts19.JsxEmit.ReactJSX,
+    target: ts20.ScriptTarget.Latest,
+    module: ts20.ModuleKind.ESNext,
+    moduleResolution: ts20.ModuleResolutionKind.Bundler,
+    jsx: ts20.JsxEmit.ReactJSX,
     strict: true,
     skipLibCheck: true,
     noEmit: true,
@@ -23825,7 +23909,7 @@ function createProgramForCorpus(files2, options2 = {}) {
     ...options2.compilerOptions
   };
   const absolute = files2.map((f) => path5.resolve(f));
-  return ts19.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
+  return ts20.createProgram(absolute, compilerOptions, void 0, options2.oldProgram);
 }
 var init_shared_program = __esm({
   "../jsx/src/shared-program.ts"() {
@@ -24894,7 +24978,7 @@ var init_dangerous_inner_html = __esm({
 });
 
 // ../jsx/src/combine-client-js.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 function combineParentChildClientJs(files2) {
   const result2 = /* @__PURE__ */ new Map();
   const lookup = /* @__PURE__ */ new Map();
@@ -24951,17 +25035,17 @@ function combineParentChildClientJs(files2) {
   return result2;
 }
 function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
-  const sourceFile = ts20.createSourceFile(
+  const sourceFile = ts21.createSourceFile(
     "combine.js",
     content2,
-    ts20.ScriptTarget.Latest,
+    ts21.ScriptTarget.Latest,
     /*setParentNodes*/
     false,
-    ts20.ScriptKind.JS
+    ts21.ScriptKind.JS
   );
   const importSpans = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts20.isImportDeclaration(stmt)) continue;
+    if (!ts21.isImportDeclaration(stmt)) continue;
     const start2 = stmt.getStart(sourceFile);
     const end2 = stmt.getEnd();
     importSpans.push([start2, end2]);
@@ -24969,8 +25053,8 @@ function parseAndMerge(content2, importsBySource, otherImports, codeSections) {
     if (stmtText.includes("@bf-child:")) continue;
     const clause = stmt.importClause;
     const bindings = clause?.namedBindings;
-    const specifier = ts20.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
-    if (clause && !clause.name && bindings && ts20.isNamedImports(bindings)) {
+    const specifier = ts21.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
+    if (clause && !clause.name && bindings && ts21.isNamedImports(bindings)) {
       if (!importsBySource.has(specifier)) {
         importsBySource.set(specifier, /* @__PURE__ */ new Set());
       }
@@ -25164,7 +25248,7 @@ var init_loop_destructure = __esm({
 });
 
 // ../jsx/src/debug.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx2 = analyzeComponent(source, filePath, componentName);
   if (!ctx2.jsxReturn) {
@@ -26376,18 +26460,18 @@ function truncateExpr(expr, max = 40) {
 function exprReadsPropMember(expr, propsObjectName) {
   let sf;
   try {
-    sf = ts21.createSourceFile("__attr.tsx", `(${expr})`, ts21.ScriptTarget.Latest, true, ts21.ScriptKind.TSX);
+    sf = ts22.createSourceFile("__attr.tsx", `(${expr})`, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
   } catch {
     return false;
   }
   let found = false;
   const visit3 = (n) => {
     if (found) return;
-    if (ts21.isPropertyAccessExpression(n) && ts21.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+    if (ts22.isPropertyAccessExpression(n) && ts22.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
       found = true;
       return;
     }
-    ts21.forEachChild(n, visit3);
+    ts22.forEachChild(n, visit3);
   };
   visit3(sf);
   return found;
@@ -26464,7 +26548,7 @@ var init_debug = __esm({
 });
 
 // ../jsx/src/profiler.ts
-import ts22 from "typescript";
+import ts23 from "typescript";
 function buildStaticBudget(source, filePath, componentName, options2 = {}) {
   const threshold = options2.fanOutThreshold ?? DEFAULT_FANOUT_THRESHOLD;
   const program = createProgramForFile(source, filePath)?.program;
@@ -26719,14 +26803,14 @@ function joinProfilerEvents(events, index) {
   return { joined, unattributed, diagnostics };
 }
 function findUninstrumentedEffects(source, filePath, instrumentedLines) {
-  const sf = ts22.createSourceFile(filePath, source, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TSX);
+  const sf = ts23.createSourceFile(filePath, source, ts23.ScriptTarget.Latest, true, ts23.ScriptKind.TSX);
   const out = [];
   const visit3 = (node) => {
-    if (ts22.isCallExpression(node) && ts22.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+    if (ts23.isCallExpression(node) && ts23.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 });
     }
-    ts22.forEachChild(node, visit3);
+    ts23.forEachChild(node, visit3);
   };
   visit3(sf);
   out.sort((a, b) => a.line - b.line);
@@ -27012,19 +27096,19 @@ function assessBatchSafety(args2) {
   const signalGetters = new Set(args2.graph.signals.map((s) => s.name));
   let sf;
   try {
-    sf = ts22.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts22.ScriptTarget.Latest, true);
+    sf = ts23.createSourceFile("__h.ts", `const __h = ${args2.handler}`, ts23.ScriptTarget.Latest, true);
   } catch {
     return "unverified";
   }
   const calls = [];
   const visit3 = (node) => {
-    if (ts22.isCallExpression(node) && ts22.isIdentifier(node.expression)) {
+    if (ts23.isCallExpression(node) && ts23.isIdentifier(node.expression)) {
       const name2 = node.expression.text;
       if (setters.has(name2)) calls.push({ pos: node.getStart(sf), kind: "write" });
       else if (D.has(name2) && node.arguments.length === 0) calls.push({ pos: node.getStart(sf), kind: "memoRead" });
       else if (!signalGetters.has(name2) && !memoNames.has(name2)) calls.push({ pos: node.getStart(sf), kind: "risky" });
     }
-    ts22.forEachChild(node, visit3);
+    ts23.forEachChild(node, visit3);
   };
   visit3(sf);
   calls.sort((a, b) => a.pos - b.pos);
@@ -27717,6 +27801,7 @@ __export(src_exports, {
   collectContextConsumers: () => collectContextConsumers,
   collectLoopBoundNames: () => collectLoopBoundNames,
   collectModuleStringConsts: () => collectModuleStringConsts,
+  collectValueReferencedNames: () => collectValueReferencedNames,
   combineParentChildClientJs: () => combineParentChildClientJs,
   compileJSX: () => compileJSX,
   computeSsrSeedPlan: () => computeSsrSeedPlan,
@@ -27791,6 +27876,7 @@ __export(src_exports, {
   isStringTypedOperand: () => isStringTypedOperand,
   isSupported: () => isSupported,
   isValidHelperId: () => isValidHelperId,
+  isValueReferenceIdentifier: () => isValueReferenceIdentifier,
   joinProfilerEvents: () => joinProfilerEvents,
   jsxToIR: () => jsxToIR,
   listComponentFunctions: () => listComponentFunctions,
@@ -27867,6 +27953,7 @@ var init_src2 = __esm({
     init_css_layer_prefixer();
     init_instrumentation();
     init_errors();
+    init_value_references();
     init_expression_parser();
     init_expression_parser();
     init_loop_chain();
@@ -27941,7 +28028,7 @@ var init_runtime = __esm({
 
 // src/lib/resolve-imports.ts
 import { dirname as dirname2, resolve as resolve2 } from "node:path";
-import ts23 from "typescript";
+import ts24 from "typescript";
 function shapeFromDecl(decl) {
   const clause = decl.importClause;
   if (!clause) return null;
@@ -27951,7 +28038,7 @@ function shapeFromDecl(decl) {
   }
   const bindings = clause.namedBindings;
   if (bindings) {
-    if (ts23.isNamespaceImport(bindings)) {
+    if (ts24.isNamespaceImport(bindings)) {
       shape.namespace = bindings.name.text;
     } else {
       for (const el of bindings.elements) {
@@ -27963,60 +28050,85 @@ function shapeFromDecl(decl) {
   }
   return shape;
 }
-function collectExportedNames(source) {
-  const names = /* @__PURE__ */ new Set();
-  const sourceFile = ts23.createSourceFile(
+function collectExportInfo(source) {
+  const localValueExports = /* @__PURE__ */ new Set();
+  const otherValueExports = /* @__PURE__ */ new Set();
+  const reExportedNames = /* @__PURE__ */ new Set();
+  let hasStarReExport = false;
+  const sourceFile = ts24.createSourceFile(
     "mod.ts",
     source,
-    ts23.ScriptTarget.Latest,
+    ts24.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts23.ScriptKind.TS
+    ts24.ScriptKind.TS
   );
   function hasExport(node) {
-    if (!ts23.canHaveModifiers(node)) return false;
-    const mods = ts23.getModifiers(node);
-    return mods?.some((m) => m.kind === ts23.SyntaxKind.ExportKeyword) ?? false;
+    if (!ts24.canHaveModifiers(node)) return false;
+    const mods = ts24.getModifiers(node);
+    return mods?.some((m) => m.kind === ts24.SyntaxKind.ExportKeyword) ?? false;
+  }
+  function isAmbient(node) {
+    if (!ts24.canHaveModifiers(node)) return false;
+    const mods = ts24.getModifiers(node);
+    return mods?.some((m) => m.kind === ts24.SyntaxKind.DeclareKeyword) ?? false;
   }
   function collectFromBindingName(name2) {
-    if (ts23.isIdentifier(name2)) {
-      names.add(name2.text);
+    if (ts24.isIdentifier(name2)) {
+      localValueExports.add(name2.text);
       return;
     }
     for (const el of name2.elements) {
-      if (ts23.isBindingElement(el)) collectFromBindingName(el.name);
+      if (ts24.isBindingElement(el)) collectFromBindingName(el.name);
     }
   }
   for (const stmt of sourceFile.statements) {
-    if (ts23.isVariableStatement(stmt) && hasExport(stmt)) {
+    if (ts24.isVariableStatement(stmt) && hasExport(stmt)) {
       for (const d of stmt.declarationList.declarations) {
         collectFromBindingName(d.name);
       }
-    } else if (ts23.isFunctionDeclaration(stmt) && hasExport(stmt) && stmt.name) {
-      names.add(stmt.name.text);
-    } else if (ts23.isClassDeclaration(stmt) && hasExport(stmt) && stmt.name) {
-      names.add(stmt.name.text);
-    } else if (ts23.isExportDeclaration(stmt) && !stmt.moduleSpecifier && stmt.exportClause && ts23.isNamedExports(stmt.exportClause)) {
+    } else if (ts24.isFunctionDeclaration(stmt) && hasExport(stmt) && stmt.name) {
+      localValueExports.add(stmt.name.text);
+    } else if (ts24.isClassDeclaration(stmt) && hasExport(stmt) && stmt.name) {
+      localValueExports.add(stmt.name.text);
+    } else if (ts24.isEnumDeclaration(stmt) && hasExport(stmt) && stmt.name) {
+      otherValueExports.add(stmt.name.text);
+    } else if (ts24.isModuleDeclaration(stmt) && hasExport(stmt) && ts24.isIdentifier(stmt.name)) {
+      if (!isAmbient(stmt)) otherValueExports.add(stmt.name.text);
+    } else if (ts24.isExportDeclaration(stmt)) {
       if (stmt.isTypeOnly) continue;
-      for (const el of stmt.exportClause.elements) {
-        if (el.isTypeOnly) continue;
-        names.add(el.name.text);
+      if (!stmt.moduleSpecifier) {
+        if (stmt.exportClause && ts24.isNamedExports(stmt.exportClause)) {
+          for (const el of stmt.exportClause.elements) {
+            if (el.isTypeOnly) continue;
+            localValueExports.add(el.name.text);
+          }
+        }
+      } else if (!stmt.exportClause) {
+        hasStarReExport = true;
+      } else if (ts24.isNamespaceExport(stmt.exportClause)) {
+        reExportedNames.add(stmt.exportClause.name.text);
+      } else if (ts24.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) {
+          if (el.isTypeOnly) continue;
+          reExportedNames.add(el.name.text);
+        }
       }
     }
   }
-  return [...names];
+  return { localValueExports, otherValueExports, reExportedNames, hasStarReExport };
 }
 function hasUseClientDirective(source) {
-  const sourceFile = ts23.createSourceFile(
+  const sourceFile = ts24.createSourceFile(
     "check.tsx",
     source,
-    ts23.ScriptTarget.Latest,
+    ts24.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts23.ScriptKind.TSX
+    ts24.ScriptKind.TSX
   );
   for (const stmt of sourceFile.statements) {
-    if (!ts23.isExpressionStatement(stmt) || !ts23.isStringLiteral(stmt.expression)) {
+    if (!ts24.isExpressionStatement(stmt) || !ts24.isStringLiteral(stmt.expression)) {
       return false;
     }
     if (stmt.expression.text === "use client") return true;
@@ -28025,53 +28137,53 @@ function hasUseClientDirective(source) {
 }
 function collectTopLevelBindings(source) {
   const names = /* @__PURE__ */ new Set();
-  const sourceFile = ts23.createSourceFile(
+  const sourceFile = ts24.createSourceFile(
     "bundle.ts",
     source,
-    ts23.ScriptTarget.Latest,
+    ts24.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts23.ScriptKind.TS
+    ts24.ScriptKind.TS
   );
   function collectFromBindingName(name2) {
-    if (ts23.isIdentifier(name2)) {
+    if (ts24.isIdentifier(name2)) {
       names.add(name2.text);
       return;
     }
     for (const el of name2.elements) {
-      if (ts23.isBindingElement(el)) collectFromBindingName(el.name);
+      if (ts24.isBindingElement(el)) collectFromBindingName(el.name);
     }
   }
   for (const stmt of sourceFile.statements) {
-    if (ts23.isVariableStatement(stmt)) {
+    if (ts24.isVariableStatement(stmt)) {
       for (const d of stmt.declarationList.declarations) {
         collectFromBindingName(d.name);
       }
-    } else if (ts23.isFunctionDeclaration(stmt) && stmt.name) {
+    } else if (ts24.isFunctionDeclaration(stmt) && stmt.name) {
       names.add(stmt.name.text);
-    } else if (ts23.isClassDeclaration(stmt) && stmt.name) {
+    } else if (ts24.isClassDeclaration(stmt) && stmt.name) {
       names.add(stmt.name.text);
     }
   }
   return names;
 }
 function stripImportsAndExports(body2) {
-  const sourceFile = ts23.createSourceFile(
+  const sourceFile = ts24.createSourceFile(
     "body.ts",
     body2,
-    ts23.ScriptTarget.Latest,
+    ts24.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts23.ScriptKind.TS
+    ts24.ScriptKind.TS
   );
   const spans = [];
   const hoistedImports = [];
   for (const stmt of sourceFile.statements) {
-    if (ts23.isImportDeclaration(stmt)) {
+    if (ts24.isImportDeclaration(stmt)) {
       const start2 = stmt.getStart(sourceFile);
       const end2 = stmt.getEnd();
       const specifier = stmt.moduleSpecifier;
-      if (ts23.isStringLiteral(specifier)) {
+      if (ts24.isStringLiteral(specifier)) {
         const path25 = specifier.text;
         const isRelative = path25.startsWith("./") || path25.startsWith("../");
         if (!isRelative) {
@@ -28081,24 +28193,24 @@ function stripImportsAndExports(body2) {
       spans.push([start2, end2]);
       continue;
     }
-    if (ts23.isExportDeclaration(stmt)) {
+    if (ts24.isExportDeclaration(stmt)) {
       spans.push([stmt.getStart(sourceFile), stmt.getEnd()]);
       continue;
     }
-    if (ts23.isExportAssignment(stmt)) {
-      const exportKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts23.SyntaxKind.ExportKeyword);
-      const defaultKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts23.SyntaxKind.DefaultKeyword);
-      const equalsKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts23.SyntaxKind.EqualsToken);
+    if (ts24.isExportAssignment(stmt)) {
+      const exportKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts24.SyntaxKind.ExportKeyword);
+      const defaultKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts24.SyntaxKind.DefaultKeyword);
+      const equalsKw = stmt.getChildren(sourceFile).find((c) => c.kind === ts24.SyntaxKind.EqualsToken);
       const start2 = exportKw?.getStart(sourceFile) ?? stmt.getStart(sourceFile);
       const end2 = (defaultKw ?? equalsKw)?.getEnd() ?? exportKw?.getEnd() ?? stmt.getStart(sourceFile);
       if (end2 > start2) spans.push([start2, end2]);
       continue;
     }
-    if (ts23.canHaveModifiers(stmt)) {
-      const mods = ts23.getModifiers(stmt);
+    if (ts24.canHaveModifiers(stmt)) {
+      const mods = ts24.getModifiers(stmt);
       if (!mods) continue;
       for (const mod of mods) {
-        if (mod.kind === ts23.SyntaxKind.ExportKeyword) {
+        if (mod.kind === ts24.SyntaxKind.ExportKeyword) {
           const start2 = mod.getStart(sourceFile);
           let end2 = mod.getEnd();
           while (end2 < body2.length && /\s/.test(body2[end2])) end2++;
@@ -28130,15 +28242,43 @@ function buildConsumerBinding(shape, topLevelId) {
   );
   return `const { ${entries2.join(", ")} } = ${topLevelId};`;
 }
-function buildTopLevelIIFE(topLevelId, body2, shapesNeeded, originalSource) {
+function buildMissingExportMessage(name2, modulePath) {
+  return {
+    message: `Import \`${name2}\` from '${modulePath}' has no matching export in that module. The client bundle would throw \`ReferenceError: ${name2} is not defined\` at load.`,
+    suggestion: `Either \`${name2}\` is a TYPE \u2014 import it with \`import type { ${name2} }\` or \`import { type ${name2} }\` (the compiler no longer emits type-only specifiers into the client bundle as of #2432) \u2014 or it's a typo / removed export: check '${modulePath}' actually exports \`${name2}\`.`
+  };
+}
+function buildTopLevelIIFE(topLevelId, body2, shapesNeeded, originalSource, modulePath) {
   const { body: stripped, hoistedImports } = stripImportsAndExports(body2);
   const wantsNamespace = shapesNeeded.some((s) => !!s.namespace);
   const namesNeeded = /* @__PURE__ */ new Set();
-  if (wantsNamespace) {
-    for (const n of collectExportedNames(originalSource)) namesNeeded.add(n);
-  }
+  const namedRequests = /* @__PURE__ */ new Set();
   for (const shape of shapesNeeded) {
-    for (const { imported } of shape.named) namesNeeded.add(imported);
+    for (const { imported } of shape.named) {
+      namesNeeded.add(imported);
+      namedRequests.add(imported);
+    }
+  }
+  const errors = [];
+  if (wantsNamespace || namedRequests.size > 0) {
+    const info = collectExportInfo(originalSource);
+    if (wantsNamespace) {
+      for (const n of info.localValueExports) namesNeeded.add(n);
+    }
+    if (namedRequests.size > 0 && !info.hasStarReExport) {
+      const surfaceNames = /* @__PURE__ */ new Set([...info.localValueExports, ...info.otherValueExports, ...info.reExportedNames]);
+      const loc = { file: modulePath, start: { line: 1, column: 0 }, end: { line: 1, column: 0 } };
+      for (const name2 of namedRequests) {
+        if (surfaceNames.has(name2)) continue;
+        const { message, suggestion } = buildMissingExportMessage(name2, modulePath);
+        errors.push(
+          createError(ErrorCodes.INLINED_IMPORT_MISSING_EXPORT, loc, {
+            message,
+            suggestion: { message: suggestion }
+          })
+        );
+      }
+    }
   }
   if (namesNeeded.size === 0) {
     return {
@@ -28146,7 +28286,8 @@ function buildTopLevelIIFE(topLevelId, body2, shapesNeeded, originalSource) {
 ${stripped}
 return {};
 })();`,
-      hoistedImports
+      hoistedImports,
+      errors
     };
   }
   const ret = `{ ${[...namesNeeded].join(", ")} }`;
@@ -28155,7 +28296,8 @@ return {};
 ${stripped}
 return ${ret};
 })();`,
-    hoistedImports
+    hoistedImports,
+    errors
   };
 }
 async function resolveSourceFile(importPath, searchDirs) {
@@ -28204,51 +28346,27 @@ function buildDanglingReferenceMessage(binding, s) {
       };
   }
 }
-function isValueReference(id2) {
-  const parent2 = id2.parent;
-  if (!parent2) return false;
-  if (ts23.isPropertyAccessExpression(parent2) && parent2.name === id2) return false;
-  if (ts23.isPropertyAssignment(parent2) && parent2.name === id2) return false;
-  if ((ts23.isMethodDeclaration(parent2) || ts23.isGetAccessorDeclaration(parent2) || ts23.isSetAccessorDeclaration(parent2)) && parent2.name === id2) {
-    return false;
-  }
-  if (ts23.isVariableDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts23.isFunctionDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts23.isFunctionExpression(parent2) && parent2.name === id2) return false;
-  if (ts23.isClassDeclaration(parent2) && parent2.name === id2) return false;
-  if (ts23.isClassExpression(parent2) && parent2.name === id2) return false;
-  if (ts23.isParameter(parent2) && parent2.name === id2) return false;
-  if (ts23.isBindingElement(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts23.isLabeledStatement(parent2) && parent2.label === id2) return false;
-  if (ts23.isBreakOrContinueStatement(parent2) && parent2.label === id2) return false;
-  if (ts23.isImportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts23.isExportSpecifier(parent2) && (parent2.name === id2 || parent2.propertyName === id2)) return false;
-  if (ts23.isImportClause(parent2) && parent2.name === id2) return false;
-  if (ts23.isNamespaceImport(parent2) && parent2.name === id2) return false;
-  if (ts23.isQualifiedName(parent2) && parent2.right === id2) return false;
-  return true;
-}
 function detectStrippedReferences(bundleSource, stripped) {
   if (stripped.length === 0) return [];
   let sf;
   try {
-    sf = ts23.createSourceFile(
+    sf = ts24.createSourceFile(
       "bundle.js",
       bundleSource,
-      ts23.ScriptTarget.Latest,
+      ts24.ScriptTarget.Latest,
       /*setParents*/
       true,
-      ts23.ScriptKind.JS
+      ts24.ScriptKind.JS
     );
   } catch {
     return [];
   }
   const firstReference = /* @__PURE__ */ new Map();
   function visit3(node) {
-    if (ts23.isIdentifier(node) && isValueReference(node)) {
+    if (ts24.isIdentifier(node) && isValueReferenceIdentifier(node)) {
       if (!firstReference.has(node.text)) firstReference.set(node.text, node);
     }
-    ts23.forEachChild(node, visit3);
+    ts24.forEachChild(node, visit3);
   }
   visit3(sf);
   const errors = [];
@@ -28278,18 +28396,18 @@ function detectStrippedReferences(bundleSource, stripped) {
   return errors;
 }
 async function walkAndCollect(content2, searchDirs, modules2, visiting, loggingPath, stripped, stubDeps, nextId) {
-  const sourceFile = ts23.createSourceFile(
+  const sourceFile = ts24.createSourceFile(
     "walk.js",
     content2,
-    ts23.ScriptTarget.Latest,
+    ts24.ScriptTarget.Latest,
     /*setParents*/
     false,
-    ts23.ScriptKind.JS
+    ts24.ScriptKind.JS
   );
   const sites = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts23.isImportDeclaration(stmt)) continue;
-    if (!ts23.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts24.isImportDeclaration(stmt)) continue;
+    if (!ts24.isStringLiteral(stmt.moduleSpecifier)) continue;
     const spec = stmt.moduleSpecifier.text;
     if (!spec.startsWith("./") && !spec.startsWith("../")) continue;
     const start2 = stmt.getStart(sourceFile);
@@ -28438,14 +28556,16 @@ async function inlineRelativeImports(content2, searchDirs, loggingPath, hoistedA
   const ordered = topoSort(modules2);
   const iifes = [];
   for (const mod of ordered) {
-    const { wrapped, hoistedImports } = buildTopLevelIIFE(
+    const { wrapped, hoistedImports, errors } = buildTopLevelIIFE(
       mod.topLevelId,
       mod.transpiledBody,
       mod.consumerShapes,
-      mod.originalSource
+      mod.originalSource,
+      mod.path
     );
     iifes.push(wrapped);
     for (const h of hoistedImports) hoistedAcc.push(h);
+    for (const err of errors) errorAcc.push(err);
   }
   const finalContent = iifes.join("\n") + "\n" + parentContent;
   for (const err of detectStrippedReferences(finalContent, stripped)) errorAcc.push(err);
@@ -28741,7 +28861,7 @@ var init_assets_ignore = __esm({
 });
 
 // src/lib/runtime-treeshake.ts
-import ts24 from "typescript";
+import ts25 from "typescript";
 import { basename, dirname as dirname3 } from "node:path";
 import { build as esbuildBuild } from "esbuild";
 function isBarefootClientSpecifier(spec) {
@@ -28758,13 +28878,13 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
   if (!code.includes("@barefootjs/client") && !code.includes("barefoot.js")) return result2;
   let sourceFile;
   try {
-    sourceFile = ts24.createSourceFile(
+    sourceFile = ts25.createSourceFile(
       sourceLabel,
       code,
-      ts24.ScriptTarget.Latest,
+      ts25.ScriptTarget.Latest,
       /*setParentNodes*/
       false,
-      ts24.ScriptKind.JS
+      ts25.ScriptKind.JS
     );
   } catch (err) {
     result2.unsafe = true;
@@ -28772,13 +28892,13 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
     return result2;
   }
   const visit3 = (node) => {
-    if (ts24.isImportDeclaration(node)) {
+    if (ts25.isImportDeclaration(node)) {
       const spec = node.moduleSpecifier;
-      if (ts24.isStringLiteral(spec) && isEmittedRuntimeSpecifier(spec.text)) {
+      if (ts25.isStringLiteral(spec) && isEmittedRuntimeSpecifier(spec.text)) {
         const clause = node.importClause;
         if (!clause) {
         } else if (clause.isTypeOnly) {
-        } else if (clause.namedBindings && ts24.isNamedImports(clause.namedBindings)) {
+        } else if (clause.namedBindings && ts25.isNamedImports(clause.namedBindings)) {
           for (const el of clause.namedBindings.elements) {
             if (el.isTypeOnly) continue;
             const imported = (el.propertyName ?? el.name).text;
@@ -28788,7 +28908,7 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
             result2.unsafe = true;
             result2.reasons.push(`default import of "${spec.text}" in ${sourceLabel}`);
           }
-        } else if (clause.namedBindings && ts24.isNamespaceImport(clause.namedBindings)) {
+        } else if (clause.namedBindings && ts25.isNamespaceImport(clause.namedBindings)) {
           result2.unsafe = true;
           result2.reasons.push(`namespace import (* as ${clause.namedBindings.name.text}) of "${spec.text}" in ${sourceLabel}`);
         } else if (clause.name) {
@@ -28796,14 +28916,14 @@ function collectUsedRuntimeExports(code, sourceLabel = "<input>") {
           result2.reasons.push(`default import of "${spec.text}" in ${sourceLabel}`);
         }
       }
-    } else if (ts24.isCallExpression(node) && node.expression.kind === ts24.SyntaxKind.ImportKeyword) {
+    } else if (ts25.isCallExpression(node) && node.expression.kind === ts25.SyntaxKind.ImportKeyword) {
       const arg = node.arguments[0];
-      if (arg && ts24.isStringLiteral(arg) && isEmittedRuntimeSpecifier(arg.text)) {
+      if (arg && ts25.isStringLiteral(arg) && isEmittedRuntimeSpecifier(arg.text)) {
         result2.unsafe = true;
         result2.reasons.push(`dynamic import("${arg.text}") in ${sourceLabel}`);
       }
     }
-    ts24.forEachChild(node, visit3);
+    ts25.forEachChild(node, visit3);
   };
   visit3(sourceFile);
   return result2;
@@ -28876,7 +28996,7 @@ var init_runtime_treeshake = __esm({
 });
 
 // src/lib/build.ts
-import ts25 from "typescript";
+import ts26 from "typescript";
 import { mkdir, readdir, stat, unlink } from "node:fs/promises";
 import { resolve as resolve6, basename as basename2, relative as relative2, dirname as dirname4, isAbsolute as isAbsolute2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -29524,7 +29644,7 @@ async function build(config, options2 = {}) {
   };
 }
 function extractBareImports(code) {
-  const { importedFiles } = ts25.preProcessFile(code, true, true);
+  const { importedFiles } = ts26.preProcessFile(code, true, true);
   const specifiers = /* @__PURE__ */ new Set();
   for (const { fileName } of importedFiles) {
     if (!fileName.startsWith(".") && !fileName.startsWith("/") && !fileName.includes("://")) {
@@ -29591,16 +29711,16 @@ function effectiveOutName(tplPath, entryBaseNoExt) {
 }
 function topLevelImportLines(content2) {
   const lines = /* @__PURE__ */ new Set();
-  const sourceFile = ts25.createSourceFile(
+  const sourceFile = ts26.createSourceFile(
     "merge.js",
     content2,
-    ts25.ScriptTarget.Latest,
+    ts26.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts25.ScriptKind.JS
+    ts26.ScriptKind.JS
   );
   for (const stmt of sourceFile.statements) {
-    if (ts25.isImportDeclaration(stmt)) {
+    if (ts26.isImportDeclaration(stmt)) {
       const { line } = sourceFile.getLineAndCharacterOfPosition(stmt.getStart(sourceFile));
       lines.add(line);
     }
@@ -29609,29 +29729,29 @@ function topLevelImportLines(content2) {
 }
 function rewriteBarefootClientSpecifiers(content2, rel) {
   if (!content2.includes("@barefootjs/client")) return content2;
-  const sourceFile = ts25.createSourceFile(
+  const sourceFile = ts26.createSourceFile(
     "client.js",
     content2,
-    ts25.ScriptTarget.Latest,
+    ts26.ScriptTarget.Latest,
     /*setParentNodes*/
     true,
-    ts25.ScriptKind.JS
+    ts26.ScriptKind.JS
   );
   const isBarefootClient = (s) => s === "@barefootjs/client" || s.startsWith("@barefootjs/client/");
   const spans = [];
   const visit3 = (node) => {
-    if (ts25.isImportDeclaration(node) || ts25.isExportDeclaration(node)) {
+    if (ts26.isImportDeclaration(node) || ts26.isExportDeclaration(node)) {
       const ms = node.moduleSpecifier;
-      if (ms && ts25.isStringLiteral(ms) && isBarefootClient(ms.text)) {
+      if (ms && ts26.isStringLiteral(ms) && isBarefootClient(ms.text)) {
         spans.push([ms.getStart(sourceFile), ms.getEnd()]);
       }
-    } else if (ts25.isCallExpression(node) && node.expression.kind === ts25.SyntaxKind.ImportKeyword) {
+    } else if (ts26.isCallExpression(node) && node.expression.kind === ts26.SyntaxKind.ImportKeyword) {
       const arg = node.arguments[0];
-      if (arg && ts25.isStringLiteral(arg) && isBarefootClient(arg.text)) {
+      if (arg && ts26.isStringLiteral(arg) && isBarefootClient(arg.text)) {
         spans.push([arg.getStart(sourceFile), arg.getEnd()]);
       }
     }
-    ts25.forEachChild(node, visit3);
+    ts26.forEachChild(node, visit3);
   };
   visit3(sourceFile);
   if (spans.length === 0) return content2;
@@ -110894,7 +111014,7 @@ __export(scenario_driver_exports, {
 import { writeFileSync as writeFileSync9, mkdtempSync, rmSync, readFileSync as readFileSync19, existsSync as existsSync23, statSync as statSync3 } from "node:fs";
 import { join as join2, dirname as dirname7, resolve as resolve11 } from "node:path";
 import { tmpdir } from "node:os";
-import ts26 from "typescript";
+import ts27 from "typescript";
 function externalRuntimeImport(clientJs) {
   const chunks = Array.isArray(clientJs) ? clientJs : [clientJs];
   for (const chunk of chunks) {
@@ -110964,11 +111084,11 @@ function resolveLocalFile(spec) {
 }
 function rewriteLocalImports(js, chunkPath, inlined) {
   const chunkDir = dirname7(chunkPath);
-  const sf = ts26.createSourceFile("chunk.mjs", js, ts26.ScriptTarget.Latest, false, ts26.ScriptKind.JS);
+  const sf = ts27.createSourceFile("chunk.mjs", js, ts27.ScriptTarget.Latest, false, ts27.ScriptKind.JS);
   const edits = [];
   for (const stmt of sf.statements) {
-    if (!ts26.isImportDeclaration(stmt)) continue;
-    if (!ts26.isStringLiteral(stmt.moduleSpecifier)) continue;
+    if (!ts27.isImportDeclaration(stmt)) continue;
+    if (!ts27.isStringLiteral(stmt.moduleSpecifier)) continue;
     const spec = stmt.moduleSpecifier.text;
     if (!spec.startsWith(".")) continue;
     const resolved = resolveLocalFile(join2(chunkDir, spec.replace(/\.client\.js$/, "")));
@@ -110980,13 +111100,13 @@ function rewriteLocalImports(js, chunkPath, inlined) {
     const abs = resolve11(resolved);
     if (inlined.has(abs)) {
       const clause = stmt.importClause;
-      if (clause && (clause.name || clause.namedBindings && ts26.isNamespaceImport(clause.namedBindings))) {
+      if (clause && (clause.name || clause.namedBindings && ts27.isNamespaceImport(clause.namedBindings))) {
         throw new Error(
           `"${spec}" (imported by ${chunkPath}) uses a default or namespace import of a sibling client file, which the dynamic scenario runner cannot bind after inlining that file into the run. Import its exports by name, or use the static budget (\`bf debug profile <component>\`), which needs no run.`
         );
       }
       const shims = [];
-      if (clause?.namedBindings && ts26.isNamedImports(clause.namedBindings)) {
+      if (clause?.namedBindings && ts27.isNamedImports(clause.namedBindings)) {
         for (const el of clause.namedBindings.elements) {
           if (el.propertyName) shims.push(`var ${el.name.text} = ${el.propertyName.text}`);
         }
@@ -111495,9 +111615,9 @@ function findProjectConfig(startDir) {
   let dir = path.resolve(startDir);
   const { root: fsRoot } = path.parse(dir);
   while (true) {
-    const ts27 = path.join(dir, "barefoot.config.ts");
-    if (existsSync2(ts27)) {
-      return { dir, tsConfigPath: ts27 };
+    const ts28 = path.join(dir, "barefoot.config.ts");
+    if (existsSync2(ts28)) {
+      return { dir, tsConfigPath: ts28 };
     }
     if (dir === fsRoot) return null;
     dir = path.dirname(dir);