@barefootjs/cli 0.27.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;
     }
@@ -11161,7 +11170,8 @@ function transformConditionalBranch(node, ctx2) {
   const callsReactive = exprCallsReactiveGetters(node, ctx2);
   const hasCalls = exprHasFunctionCalls(node);
   const reactive = isReactiveExpression(exprText, ctx2, node) || isReactiveOrigin(branchOrigin);
-  const needsSlot = reactive || callsReactive;
+  const refsLoopParam = branchOrigin.freeRefs?.some((r2) => r2.kind === "render-item") ?? false;
+  const needsSlot = reactive || callsReactive || refsLoopParam;
   const slotId = needsSlot ? generateSlotId(ctx2) : null;
   return {
     type: "expression",
@@ -14761,19 +14771,54 @@ function summarizeLoopChildBranch(node, ctx2, siblingOffsets, loopParam, loopPar
     // on the branch root yields exactly this branch's direct bindings
     // without re-collecting what a nested arm already owns (#2347).
     reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx2, loopParam, loopParamBindings, true),
-    // Skip when the branch's ENTIRE content is a single bare `expression`
-    // (no wrapping element) — e.g. a hoisted `renderNode={(n) => <Pill/>}`
-    // callback (#1211/#1213). That value is already fully re-evaluated and
-    // spliced via `__bfSlot` whenever `insert()` (re-)mounts this branch;
-    // an *additional* nested createEffect for the same expression re-calls
-    // it and creates a second, independent live element (a JSX-callback
-    // result isn't idempotent to re-invoke the way a plain signal read is),
-    // and the loop-child arm's `$t()`-based anchor lookup — designed for
-    // text nodes — doesn't cleanly displace an already-mounted Element,
-    // so the second instance lands beside the first instead of replacing
-    // it. A text *nested inside* a static wrapper element in the branch
-    // (the element-descent case) is unaffected and still collected below.
-    reactiveTexts: node.type === "expression" ? [] : collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, true)
+    // Skip ONLY when the branch's entire content is a single bare
+    // `expression` (no wrapping element) that MAY yield a live DOM node —
+    // i.e. it contains a call anywhere (`node.hasFunctionCalls`, computed
+    // by the AST walk in `exprHasFunctionCalls`/jsx-to-ir.ts, recursively —
+    // catches a call nested in a template literal or a nested ternary, not
+    // just a top-level call). A call can return an Element (a hoisted
+    // `renderNode={(n) => <Pill/>}` callback lowered to a component call,
+    // #1211/#1213) and the compiler cannot tell from syntax whether it does
+    // — both `renderChild(...)` and `_p.renderCell(...)` are a
+    // `CallExpression` — so this stays conservative for ANY call, not just
+    // ones known to return JSX. Re-evaluating a non-idempotent call inside
+    // an *additional* nested createEffect (on top of the eval already done
+    // for the `__bfSlot`-wrapped splice whenever `insert()` (re-)mounts this
+    // branch) would call it again on every unrelated tick and discard the
+    // previous element's listeners/state.
+    //
+    // Everything else — a property access (`row.label`), an identifier, a
+    // literal, a template literal, string concatenation, or a nested
+    // ternary of those — cannot itself construct a DOM node (only a JSX
+    // literal or a call can, and a JSX literal branch is never `type:
+    // 'expression'` in the first place — see `transformJsxExpression`), so
+    // it is safe to collect. This is the fix for the loop-branch-stale-text
+    // defect: a keyed loop row whose branch is e.g. `row.done ? row.label :
+    // 'pending'` previously had NO update path at all when `row.label`
+    // changed without `row.done` flipping — `insert()` (runtime/insert.ts)
+    // correctly no-ops when its condition is unchanged (branch-internal
+    // updates are deliberately the effect system's job, not DOM
+    // replacement's), but with reactiveTexts always `[]` for this shape,
+    // no effect existed either, so the branch was frozen at its mount-time
+    // value. The stale rationale in a prior version of this comment blamed
+    // "the loop-child arm's `$t()`-based anchor lookup", but `$t()` no
+    // longer exists — it was one of four content mechanisms deleted by the
+    // slot-unification work. The current claim door
+    // (`stringifyLoopChildArm` → `lazySlots(..., kind: 'markup')` →
+    // `writeMarkup`, runtime/claim-slots.ts) clears the claimed range and
+    // splices the Node by identity, so "lands beside the first" cannot
+    // happen through it; only the call's non-idempotence still applies, and
+    // that alone is why the skip narrows rather than disappears.
+    //
+    // Collecting here is necessary but not sufficient: `n.slotId` must also
+    // be set for `collectLoopChildReactiveTexts` (ir-to-client-js/
+    // reactivity.ts) to do anything — see `transformConditionalBranch`'s
+    // `refsLoopParam` check (jsx-to-ir.ts) for the matching half of this fix
+    // that gives a bare loop-item-reading branch a slotId at all, which also
+    // makes `irToHtmlTemplate` emit its `<!--bf:sN-->…<!--/-->` marker (the
+    // same call builds both the SSR and the CSR/hydration template, so the
+    // two can't disagree on shape).
+    reactiveTexts: node.type === "expression" && node.hasFunctionCalls ? [] : collectLoopChildReactiveTexts(node, ctx2, loopParam, loopParamBindings, true)
   };
 }
 var EMPTY_RENDER_EXPRS, branchInnerLoopOptions;
@@ -15238,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();
@@ -15263,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);
         }
@@ -15272,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;
@@ -15285,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);
       }
     }
@@ -15327,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",
@@ -15339,6 +15457,7 @@ var init_imports = __esm({
       "getLoopNodes",
       "mapArray",
       "mapArrayAnchored",
+      "mapArrayLazy",
       "patchLeaf",
       "createDisposableEffect",
       "createComponent",
@@ -15370,8 +15489,16 @@ var init_imports = __esm({
       // Claim-plan interpreter (slot unification A2/A3, spec/slot-unification.md)
       // — the "one claim mechanism" that replaced `patchSlotRange` and
       // `updateClientMarker` (both deleted) as the content-slot update door.
+      // `lazyClaimSlots` is the read-capable twin of `lazySlots` over the same
+      // claim — emitted only by lazy loops that seed an outer-involving TEXT
+      // binding by read-compare-write (§9.3(1)).
+      // `textOrNode` is the 'text' door's Node guard: a child-position value that
+      // turns out to be a live Node must reach the writer as a Node so the claim
+      // can promote to 'markup', never as `String(node)`.
       "claimSlots",
       "lazySlots",
+      "lazyClaimSlots",
+      "textOrNode",
       // Profile mode (#1690, SR3) — turn-boundary markers around event handlers.
       "beginTurn",
       "endTurn",
@@ -15430,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;
@@ -15547,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}`;
@@ -15557,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;
@@ -15598,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;
   }
@@ -15622,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) {
@@ -15636,7 +15763,7 @@ function hasCallWithBridgedArg(node, decisions, env) {
         }
       }
     }
-    ts13.forEachChild(n, visit3);
+    ts14.forEachChild(n, visit3);
   }
   visit3(node);
   return found;
@@ -15645,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;
@@ -15660,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;
@@ -18494,8 +18621,340 @@ var init_build_event_delegation = __esm({
   }
 });
 
+// ../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
+function lazyRowEligibility(args2) {
+  const { shape, bindings, arraySourceIdentifiers, scope } = args2;
+  if (scope.profile) return NO("profile mode keeps the granular eager emission");
+  if (shape.callSite !== "plain" && shape.callSite !== "branch-plain") {
+    return NO(`call site '${shape.callSite}' is not a plain loop row`);
+  }
+  if (shape.flatMapLeafItem) return NO("flatMap descriptor loop (build-or-patch renderItem)");
+  if (shape.anchored) return NO("anchored whole-item-conditional loop");
+  if (shape.bodyIsMultiRoot) return NO("multi-root (Fragment) row");
+  if (!shape.hasExplicitKey) return NO("index-keyed loop (no explicit key)");
+  if (shape.conditionalCount > 0) return NO("row contains a reactive conditional");
+  if (shape.childRefCount > 0) return NO("row has imperative child refs");
+  if (shape.hasChildComponent) return NO("row body is a child component");
+  if (shape.nestedComponentCount > 0) return NO("row contains nested child components");
+  if (shape.innerLoopCount > 0) return NO("row contains an inner loop");
+  if (shape.hasMapPreamble) return NO("row has a map-callback preamble (may declare row-local reactivity)");
+  if (shape.preambleRegionCount > 0) return NO("row has preamble-patched regions");
+  if (shape.hasParamUnwrap) return NO("destructured loop param without param bindings");
+  for (const b of bindings) {
+    if (b.referencesIndex) {
+      return NO(`binding on slot ${b.slotId} references the loop index parameter`);
+    }
+    if (b.opaqueOuterNames.includes(UNKNOWN_IDENTIFIERS)) {
+      return NO(`binding on slot ${b.slotId} has no analyzable identifier set`);
+    }
+  }
+  if (!arraySourceIdentifiers) return NO("loop source free identifiers unavailable");
+  const sourceGate = checkSourceConsistency(arraySourceIdentifiers, scope);
+  if (sourceGate) return NO(`loop source is not provably hydration-consistent: ${sourceGate}`);
+  return { eligible: true };
+}
+function checkSourceConsistency(names, scope) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolve12 = (name2) => {
+    if (seen.has(name2)) return null;
+    seen.add(name2);
+    if (scope.props.has(name2)) return null;
+    if (PURE_SOURCE_GLOBALS.has(name2)) return null;
+    const constFree = scope.constants.get(name2);
+    if (constFree !== void 0) {
+      if (constFree === null) return `constant '${name2}' has no analyzable value`;
+      for (const inner of constFree) {
+        const failure = resolve12(inner);
+        if (failure) return failure;
+      }
+      return null;
+    }
+    const signal2 = scope.signals.get(name2);
+    if (signal2 !== void 0) {
+      if (signal2.initializerFreeIdentifiers === null) {
+        return `signal '${name2}' has no structured initializer to prove props/literal derivation`;
+      }
+      for (const inner of signal2.initializerFreeIdentifiers) {
+        const failure = resolve12(inner);
+        if (failure) return failure;
+      }
+      return null;
+    }
+    if (scope.memos.has(name2)) return `memo '${name2}' initializer is not analyzed by the v1 gate`;
+    if (scope.inert.has(name2)) return `'${name2}' is an import or local function`;
+    return `'${name2}' does not resolve to a prop, literal-derived const, or props/literal-derived signal`;
+  };
+  for (const name2 of names) {
+    const failure = resolve12(name2);
+    if (failure) return failure;
+  }
+  return null;
+}
+function classifyLazyBinding(args2) {
+  const { kind: kind2, slotId, free, rowLocalNames, indexParam, scope } = args2;
+  if (free === null) {
+    return {
+      kind: kind2,
+      slotId,
+      readsItem: true,
+      readsOuter: true,
+      reactiveOuterNames: [],
+      opaqueOuterNames: [UNKNOWN_IDENTIFIERS],
+      // An ASSUMPTION, not knowledge — which is precisely why
+      // `UNKNOWN_IDENTIFIERS` must keep refusing the loop: with no
+      // identifier set we cannot rule out an index read either, and
+      // `applyItem` / `applyOuter` have no index parameter to give it.
+      referencesIndex: false
+    };
+  }
+  let readsItem = false;
+  let referencesIndex = false;
+  const reactiveOuterNames = [];
+  const opaqueOuterNames = [];
+  for (const name2 of free) {
+    if (rowLocalNames.has(name2)) {
+      readsItem = true;
+      continue;
+    }
+    if (name2 === indexParam) {
+      referencesIndex = true;
+      continue;
+    }
+    if (INERT_BINDING_GLOBALS.has(name2)) continue;
+    if (scope.signals.has(name2) || scope.memos.has(name2)) {
+      if (!reactiveOuterNames.includes(name2)) reactiveOuterNames.push(name2);
+      continue;
+    }
+    const constFree = scope.constants.get(name2);
+    if (constFree !== void 0 && constFree !== null && constFree.size === 0) continue;
+    opaqueOuterNames.push(name2);
+  }
+  return {
+    kind: kind2,
+    slotId,
+    readsItem,
+    readsOuter: reactiveOuterNames.length > 0 || opaqueOuterNames.length > 0,
+    reactiveOuterNames,
+    opaqueOuterNames,
+    referencesIndex
+  };
+}
+var PURE_SOURCE_GLOBALS, INERT_BINDING_GLOBALS, UNKNOWN_IDENTIFIERS, NO;
+var init_lazy_row_eligibility = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts"() {
+    "use strict";
+    PURE_SOURCE_GLOBALS = /* @__PURE__ */ new Set([
+      "Object",
+      "Array",
+      "JSON",
+      "Number",
+      "String",
+      "Boolean"
+    ]);
+    INERT_BINDING_GLOBALS = /* @__PURE__ */ new Set([
+      "Object",
+      "Array",
+      "JSON",
+      "Number",
+      "String",
+      "Boolean",
+      "Math",
+      "Date",
+      "Intl",
+      "Symbol",
+      "Map",
+      "Set",
+      "WeakMap",
+      "WeakSet",
+      "Promise",
+      "RegExp",
+      "Error",
+      "BigInt",
+      "console",
+      "undefined",
+      "NaN",
+      "Infinity",
+      "globalThis",
+      "parseInt",
+      "parseFloat",
+      "isNaN",
+      "isFinite",
+      "encodeURIComponent",
+      "decodeURIComponent",
+      "encodeURI",
+      "decodeURI"
+    ]);
+    UNKNOWN_IDENTIFIERS = "<unknown>";
+    NO = (reason2) => ({ eligible: false, reason: reason2 });
+  }
+});
+
+// ../jsx/src/ir-to-client-js/control-flow/plan/build-lazy-row.ts
+function buildLazyRowPlan(args2) {
+  return decideLazyRow(args2).plan;
+}
+function decideLazyRow(args2) {
+  const { loop, scope } = args2;
+  if (!scope) {
+    return { plan: null, decision: { eligible: false, reason: "no component scope info supplied" } };
+  }
+  const wrap = (expr) => wrapLoopParamAsAccessor(expr, loop.param, loop.paramBindings);
+  const rowLocalNames = /* @__PURE__ */ new Set([loop.param]);
+  for (const b of loop.paramBindings ?? []) rowLocalNames.add(b.name);
+  const classified = [];
+  const attrClass = /* @__PURE__ */ new Map();
+  loop.bindings.reactiveAttrs.forEach((attr, i) => {
+    const c = classifyLazyBinding({
+      kind: "attr",
+      slotId: attr.childSlotId,
+      free: attrFreeIdentifiers2(attr.expression),
+      rowLocalNames,
+      indexParam: args2.indexParam,
+      scope
+    });
+    attrClass.set(i, c);
+    classified.push(c);
+  });
+  const textClass = /* @__PURE__ */ new Map();
+  loop.bindings.reactiveTexts.forEach((text, i) => {
+    const c = classifyLazyBinding({
+      kind: "text",
+      slotId: text.slotId,
+      free: text.freeIdentifiers ?? null,
+      rowLocalNames,
+      indexParam: args2.indexParam,
+      scope
+    });
+    textClass.set(i, c);
+    classified.push(c);
+  });
+  const shape = {
+    callSite: args2.callSite,
+    flatMapLeafItem: args2.flatMapLeafItem,
+    anchored: args2.anchored,
+    bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
+    hasExplicitKey: loop.key != null,
+    conditionalCount: loop.bindings.conditionals?.length ?? 0,
+    childRefCount: loop.bindings.refs?.length ?? 0,
+    nestedComponentCount: loop.nestedComponents?.length ?? 0,
+    innerLoopCount: loop.innerLoops?.length ?? 0,
+    hasChildComponent: "childComponent" in loop && loop.childComponent != null,
+    hasMapPreamble: args2.mapPreambleWrapped.length > 0,
+    preambleRegionCount: args2.preambleRegionCount,
+    hasParamUnwrap: args2.paramUnwrap.length > 0
+  };
+  const decision = lazyRowEligibility({
+    shape,
+    bindings: classified,
+    arraySourceIdentifiers: loopSourceIdentifiers(loop, args2.arrayExpr),
+    scope
+  });
+  if (!decision.eligible) return { plan: null, decision };
+  const attrSlotIds = [];
+  for (const attr of loop.bindings.reactiveAttrs) {
+    if (!attrSlotIds.includes(attr.childSlotId)) attrSlotIds.push(attr.childSlotId);
+  }
+  let ordinal = 0;
+  const attrs = loop.bindings.reactiveAttrs.map((attr, i) => {
+    const c = attrClass.get(i);
+    return {
+      slotId: attr.childSlotId,
+      attrName: attr.attrName,
+      wrappedExpression: wrap(attr.expression),
+      meta: pickAttrMeta(attr),
+      refIndex: attrSlotIds.indexOf(attr.childSlotId),
+      ordinal: ordinal++,
+      readsItem: c.readsItem,
+      readsOuter: c.readsOuter
+    };
+  });
+  const texts = loop.bindings.reactiveTexts.map((text, i) => {
+    const c = textClass.get(i);
+    return {
+      slotId: text.slotId,
+      wrappedExpression: wrap(text.expression),
+      ordinal: ordinal++,
+      // A text that classified as NEITHER item- nor outer-driven still gets
+      // applied on item change (harmless, dedup-guarded) rather than
+      // silently never being written. Anything the classifier did place in
+      // a list keeps exactly the classifier's answer.
+      readsItem: c.readsItem || !c.readsOuter,
+      readsOuter: c.readsOuter
+    };
+  });
+  const outerPrimeGetters = [];
+  for (const c of classified) {
+    for (const name2 of c.reactiveOuterNames) {
+      if (!outerPrimeGetters.includes(name2)) outerPrimeGetters.push(name2);
+    }
+  }
+  return {
+    plan: {
+      attrSlotIds,
+      attrs,
+      texts,
+      writerIndex: texts.length > 0 ? attrSlotIds.length : -1,
+      textNeedsRead: texts.some((t) => t.readsOuter),
+      lastCount: ordinal,
+      outerPrimeGetters,
+      hasOuter: attrs.some((a) => a.readsOuter) || texts.some((t) => t.readsOuter)
+    },
+    decision
+  };
+}
+function buildLazyRowScopeInfo(ctx2) {
+  const signals = /* @__PURE__ */ new Map();
+  for (const s of ctx2.signals) {
+    signals.set(s.getter, {
+      // `parsed` is the analyzer's structured initializer. Absent (or
+      // refused by `freeIdentifiers`) ⇒ unprovable, which the source gate
+      // treats as a hard stop rather than an assumption.
+      initializerFreeIdentifiers: s.parsed ? freeIdentifiers(s.parsed) : null
+    });
+  }
+  const memos = new Set(ctx2.memos.map((m) => m.name));
+  const props = /* @__PURE__ */ new Set([PROPS_PARAM]);
+  if (ctx2.propsObjectName) props.add(ctx2.propsObjectName);
+  for (const p of ctx2.propsParams) props.add(p.name);
+  const constants = /* @__PURE__ */ new Map();
+  for (const c of ctx2.localConstants) {
+    constants.set(c.name, c.freeIdentifiers ?? null);
+  }
+  const inert = /* @__PURE__ */ new Set();
+  for (const f of ctx2.localFunctions) inert.add(f.name);
+  for (const imp of ctx2.imports) {
+    if (imp.isTypeOnly) continue;
+    for (const spec of imp.specifiers) inert.add(spec.alias || spec.name);
+  }
+  return { signals, memos, props, constants, inert, profile: ctx2.profile };
+}
+function attrFreeIdentifiers2(expression) {
+  if (!expression || expression.trim().length === 0) return /* @__PURE__ */ new Set();
+  try {
+    return freeIdentifiers(parseExpression(expression));
+  } catch {
+    return null;
+  }
+}
+function loopSourceIdentifiers(loop, arrayExpr) {
+  if (!loop.arrayFreeIdentifiers) return null;
+  const names = new Set(loop.arrayFreeIdentifiers);
+  for (const name2 of extractFreeIdentifiersFromText(arrayExpr)) names.add(name2);
+  return names;
+}
+var init_build_lazy_row = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/plan/build-lazy-row.ts"() {
+    "use strict";
+    init_expression_parser();
+    init_types();
+    init_csr_substitute();
+    init_utils();
+    init_lazy_row_eligibility();
+  }
+});
+
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-branch-loop.ts
-function buildBranchLoopPlan(loop, profileComponentName) {
+function buildBranchLoopPlan(loop, profileComponentName, lazyScope) {
   const containerSlotId = loop.containerSlotId;
   const cv = varSlotId(containerSlotId);
   const containerVar = `__loop_${cv}`;
@@ -18511,6 +18970,13 @@ function buildBranchLoopPlan(loop, profileComponentName) {
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(loop.param, loop.paramBindings);
   const hasReactiveEffects = loop.bindings.reactiveAttrs.length > 0 || loop.bindings.reactiveTexts.length > 0 || loop.bindings.conditionals.length > 0;
   const fm = loop.flatMapClient;
+  const arrayExpr = fm ? `(${buildChainedArrayExpr(loop)}).flatMap(${fm.params} => ${fm.body})` : buildChainedArrayExpr(loop);
+  const indexParam = loop.index || "__idx";
+  const mapPreambleWrapped = loop.preamble ? renderPreamble(loop.preamble, {
+    transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
+    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0, true)
+  }) : "";
+  const preambleRegions = buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings);
   const plan = {
     kind: "plain",
     rowConstruction: "string-template",
@@ -18518,17 +18984,27 @@ function buildBranchLoopPlan(loop, profileComponentName) {
     containerVar,
     markerId: loop.markerId,
     flatMapLeafItem: fm ? true : void 0,
-    arrayExpr: fm ? `(${buildChainedArrayExpr(loop)}).flatMap(${fm.params} => ${fm.body})` : buildChainedArrayExpr(loop),
+    arrayExpr,
     keyFn: fm ? fm.keyed ? "(__bfD, __bfI) => String(__bfD.k ?? __bfI)" : "null" : loopKeyFn(loop),
     paramHead,
     paramUnwrap,
-    indexParam: loop.index || "__idx",
+    indexParam,
     // Wrap loop-param references to signal-accessor form so the preamble
     // matches the template literal's already-wrapped reads (#1065).
-    mapPreambleWrapped: loop.preamble ? renderPreamble(loop.preamble, {
-      transformJs: (t) => wrapLoopParamAsAccessor(t, loop.param, loop.paramBindings),
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: loop.param, bindings: loop.paramBindings }], void 0, true)
-    }) : "",
+    mapPreambleWrapped,
+    // Lazy row graph (§9, L3) — undefined for every ineligible loop.
+    lazyRow: buildLazyRowPlan({
+      loop,
+      arrayExpr,
+      indexParam,
+      paramUnwrap,
+      mapPreambleWrapped,
+      preambleRegionCount: preambleRegions.length,
+      callSite: "branch-plain",
+      flatMapLeafItem: Boolean(fm),
+      anchored: false,
+      scope: lazyScope
+    }) ?? void 0,
     template: loop.template,
     reactiveEffects: hasReactiveEffects ? buildReactiveEffectsPlan({
       attrs: loop.bindings.reactiveAttrs,
@@ -18540,7 +19016,7 @@ function buildBranchLoopPlan(loop, profileComponentName) {
     }) : null,
     eventDelegation: buildBranchLoopDelegationPlan(loop, cv, profileComponentName),
     childRefs: buildChildRefBindings(loop.bindings.refs, loop.param, loop.paramBindings),
-    preambleRegions: buildPreambleRegionPlans(loop.preambleRegions, loop.param, loop.paramBindings),
+    preambleRegions,
     bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
     profileLoopId: profileComponentName ? `${profileComponentName}#binding:${containerSlotId}` : void 0
   };
@@ -18553,6 +19029,7 @@ var init_build_branch_loop = __esm({
     init_build_composite_loop();
     init_build_event_delegation();
     init_build_reactive_effects();
+    init_build_lazy_row();
     init_shared();
     init_html_template();
   }
@@ -18609,13 +19086,13 @@ function buildArmBody(branch, options2) {
       expression: t.expression
     })),
     // Branch-scoped loops, fully Plan-built (Item 2 final migration).
-    loops: branch.loops.map((l) => buildBranchLoopPlan(l, pc)),
+    loops: branch.loops.map((l) => buildBranchLoopPlan(l, pc, options2.lazyScope)),
     // Nested conditionals are themselves InsertPlans — built recursively so
     // the same stringifier handles arbitrary depth. Their scope is always
     // `__branchScope` (the parent arm's bindEvents argument), regardless of
     // the outer scope; only the eventNameMode is inherited.
     conditionals: branch.conditionals.map(
-      (c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options2.eventNameMode, profileComponentName: pc })
+      (c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options2.eventNameMode, profileComponentName: pc, lazyScope: options2.lazyScope })
     )
   };
 }
@@ -18647,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}`)}`;
@@ -18727,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;
@@ -18776,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;
@@ -19008,7 +19485,7 @@ function stringifyBranchEventBindings(lines, plan, indent) {
 }
 function stringifyBranchChildComponentInits(lines, plan, indent) {
   for (const init of plan) {
-    lines.push(`${indent}{ let __c = qsa(__branchScope, ${init.selector}); if (!__c) { const __ph = __branchScope.querySelector('[${BF_PLACEHOLDER}="${init.placeholderId}"]'); if (__ph) { __c = createComponent('${nameForRegistryRef(init.name)}', ${init.propsExpr}); __ph.replaceWith(__c) } } if (__c) initChild('${nameForRegistryRef(init.name)}', __c, ${init.propsExpr}) }`);
+    lines.push(`${indent}{ let __c = qsa(__branchScope, ${init.selector}); if (!__c) { const __ph = __branchScope.querySelector('[${BF_PLACEHOLDER}="${init.placeholderId}"]'); if (__ph) { __c = createComponent('${nameForRegistryRef(init.name)}', ${init.propsExpr}, undefined, undefined, __ph) } } if (__c) initChild('${nameForRegistryRef(init.name)}', __c, ${init.propsExpr}) }`);
   }
 }
 function stringifyBranchInnerLoops(lines, plan, indent, pc) {
@@ -19356,6 +19833,179 @@ var init_component_loop = __esm({
   }
 });
 
+// ../jsx/src/ir-to-client-js/control-flow/stringify/lazy-row.ts
+function stringifyLazyRowLoop(lines, o) {
+  const { indent, lazyRow, paramHead } = o;
+  const mid = o.markerId.replace(/[^A-Za-z0-9_$]/g, "_");
+  const tplVar = `__tpl_${mid}`;
+  const claimVar = `__lzc_${mid}`;
+  const hasRefs = lazyRow.attrSlotIds.length > 0 || lazyRow.texts.length > 0;
+  const hasBindings = lazyRow.attrs.length > 0 || lazyRow.texts.length > 0;
+  const rwDoor = lazyRow.textNeedsRead;
+  const paths = o.skeletonPaths;
+  const useHoisted = Boolean(o.skeletonTemplate);
+  if (useHoisted) emitHoistedTemplateDecl(lines, indent, tplVar, o.skeletonTemplate);
+  const textPathVar = useHoisted && paths && lazyRow.texts.length > 0 ? `__lzp_${mid}` : null;
+  if (textPathVar) {
+    const arrays = lazyRow.texts.map((t) => `[${(paths.textMarkerPaths.get(t.slotId) ?? []).join(", ")}]`);
+    lines.push(`${indent}const ${textPathVar} = [${arrays.join(", ")}]`);
+  }
+  let adoptedPlanVar = null;
+  let freshPlanVar = null;
+  if (lazyRow.texts.length > 0) {
+    adoptedPlanVar = `__lzs_${mid}`;
+    const adoptedSlots = lazyRow.texts.map((t) => ({ id: t.slotId, kind: "text", path: [] }));
+    lines.push(`${indent}const ${adoptedPlanVar} = ${claimPlanLiteral(adoptedSlots)}`);
+    if (textPathVar) {
+      freshPlanVar = `__lzsc_${mid}`;
+      const freshSlots = lazyRow.texts.map((t, i) => ({
+        id: t.slotId,
+        kind: "text",
+        path: [],
+        pathExpr: `${textPathVar}[${i}]`
+      }));
+      lines.push(`${indent}const ${freshPlanVar} = ${claimPlanLiteral(freshSlots)}`);
+    } else {
+      freshPlanVar = adoptedPlanVar;
+    }
+  }
+  if (hasRefs) {
+    const parts = refParts(lazyRow, "__el", null, adoptedPlanVar, true);
+    lines.push(`${indent}const ${claimVar} = (__e) => {`);
+    if (parts.some((p) => p.includes("__el"))) lines.push(`${indent}  const __el = __e.primaryEl`);
+    lines.push(`${indent}  return [${parts.join(", ")}]`);
+    lines.push(`${indent}}`);
+  }
+  const call = `mapArrayLazy(() => ${o.arrayExpr}, ${o.containerVar}, ${o.keyFn}, {`;
+  lines.push(`${indent}${o.guardContainer ? `if (${o.containerVar}) ` : ""}${call}`);
+  const b1 = `${indent}  `;
+  const b2 = `${indent}    `;
+  lines.push(`${b1}createRow: (__e, ${o.indexParam}) => {`);
+  lines.push(`${b2}const ${paramHead} = () => __e.item`);
+  const cloneExpr = useHoisted ? hoistedCloneExpr(tplVar, o.skeletonTemplate) : `(() => { ${emitTemplateCloneInline(o.template)} })()`;
+  lines.push(`${b2}const __el = ${cloneExpr}`);
+  if (hasRefs) {
+    lines.push(`${b2}const __r = __e.refs = [${refParts(lazyRow, "__el", useHoisted ? paths ?? null : null, freshPlanVar).join(", ")}]`);
+  }
+  if (hasBindings) {
+    lines.push(`${b2}const __l = __e.last = []`);
+    for (const a of lazyRow.attrs) emitAttrBinding(lines, b2, a, "create");
+    const createDoor = `__r[${lazyRow.writerIndex}]`;
+    for (const t of lazyRow.texts) emitTextBinding(lines, b2, t, createDoor, "create", rwDoor);
+  }
+  lines.push(`${b2}return __el`);
+  lines.push(`${b1}},`);
+  const itemAttrs = lazyRow.attrs.filter((a) => a.readsItem);
+  const itemTexts = lazyRow.texts.filter((t) => t.readsItem);
+  if (itemAttrs.length === 0 && itemTexts.length === 0) {
+    lines.push(`${b1}applyItem: () => {},`);
+  } else {
+    lines.push(`${b1}applyItem: (__e) => {`);
+    lines.push(`${b2}const ${paramHead} = () => __e.item`);
+    lines.push(`${b2}const __r = __e.refs ?? (__e.refs = ${claimVar}(__e))`);
+    lines.push(`${b2}const __l = __e.last ?? (__e.last = [])`);
+    for (const a of itemAttrs) emitAttrBinding(lines, b2, a, "item");
+    if (itemTexts.length > 0) {
+      lines.push(`${b2}const __d = ${doorAccess(lazyRow, lazyRow.writerIndex, adoptedPlanVar)}`);
+      for (const t of itemTexts) emitTextBinding(lines, b2, t, "__d", "item", rwDoor);
+    }
+    lines.push(`${b1}},`);
+  }
+  const outerAttrs = lazyRow.attrs.filter((a) => a.readsOuter);
+  const outerTexts = lazyRow.texts.filter((t) => t.readsOuter);
+  if (outerAttrs.length > 0 || outerTexts.length > 0) {
+    const b3 = `${indent}      `;
+    lines.push(`${b1}applyOuter: (__es, __seed) => {`);
+    for (const g of lazyRow.outerPrimeGetters) lines.push(`${b2}${g}()`);
+    lines.push(`${b2}for (const __e of __es) {`);
+    lines.push(`${b3}const ${paramHead} = () => __e.item`);
+    lines.push(`${b3}const __r = __e.refs ?? (__e.refs = ${claimVar}(__e))`);
+    lines.push(`${b3}const __l = __e.last ?? (__e.last = [])`);
+    for (const a of outerAttrs) emitAttrBinding(lines, b3, a, "outer");
+    if (outerTexts.length > 0) {
+      lines.push(`${b3}const __d = ${doorAccess(lazyRow, lazyRow.writerIndex, adoptedPlanVar)}`);
+      for (const t of outerTexts) emitTextBinding(lines, b3, t, "__d", "outer", rwDoor);
+    }
+    lines.push(`${b2}}`);
+    lines.push(`${b1}},`);
+  }
+  lines.push(`${indent}}, '${o.markerId}')`);
+}
+function refParts(lazyRow, elVar, skeletonPaths, planVar, deferDoor = false) {
+  const parts = [];
+  for (const slotId of lazyRow.attrSlotIds) {
+    const path25 = skeletonPaths?.elementPaths.get(slotId);
+    parts.push(path25 ? pathExpr(elVar, path25) : `qsa(${elVar}, '[bf="${slotId}"]')`);
+  }
+  if (lazyRow.texts.length > 0) {
+    parts.push(deferDoor ? "null" : `${doorCtor(lazyRow)}(${elVar}, ${planVar})`);
+  }
+  return parts;
+}
+function doorCtor(lazyRow) {
+  return lazyRow.textNeedsRead ? "lazyClaimSlots" : "lazySlots";
+}
+function doorAccess(lazyRow, writerIndex, adoptedPlanVar) {
+  const slot = `__r[${writerIndex}]`;
+  return `${slot} ?? (${slot} = ${doorCtor(lazyRow)}(__e.primaryEl, ${adoptedPlanVar}))`;
+}
+function dedupGuard(ordinal) {
+  return `!(${ordinal} in __l) || !Object.is(__l[${ordinal}], __x)`;
+}
+function emitAttrBinding(lines, ind, a, mode2) {
+  lines.push(`${ind}{ const __t = __r[${a.refIndex}]`);
+  lines.push(`${ind}if (__t) {`);
+  lines.push(`${ind}  const __x = ${a.wrappedExpression}`);
+  const guard = mode2 === "create" ? null : mode2 === "item" ? dedupGuard(a.ordinal) : `__seed ? (${seedDiffersExpr("__t", a)}) : (${dedupGuard(a.ordinal)})`;
+  const writeIndent = guard ? `${ind}    ` : `${ind}  `;
+  if (guard) lines.push(`${ind}  if (${guard}) {`);
+  for (const stmt of emitAttrUpdate("__t", a.attrName, "__x", a.meta)) {
+    lines.push(`${writeIndent}${stmt}`);
+  }
+  if (guard) lines.push(`${ind}  }`);
+  lines.push(`${ind}  __l[${a.ordinal}] = __x`);
+  lines.push(`${ind}} }`);
+}
+function emitTextBinding(lines, ind, t, doorExpr, mode2, rwDoor) {
+  lines.push(`${ind}{ const __x = ${t.wrappedExpression}`);
+  const writeOf = (valueExpr) => rwDoor ? `${doorExpr}.write('${t.slotId}', ${valueExpr})` : `${doorExpr}('${t.slotId}', ${valueExpr})`;
+  if (mode2 === "outer") {
+    lines.push(`${ind}if (__seed) {`);
+    lines.push(`${ind}  const __s = textOrNode(__x)`);
+    lines.push(`${ind}  if (${doorExpr}.read('${t.slotId}') !== __s) ${writeOf("__s")}`);
+    lines.push(`${ind}} else if (${dedupGuard(t.ordinal)}) ${writeOf("textOrNode(__x)")}`);
+  } else if (mode2 === "item") {
+    lines.push(`${ind}if (${dedupGuard(t.ordinal)}) ${writeOf("textOrNode(__x)")}`);
+  } else {
+    lines.push(`${ind}${writeOf("textOrNode(__x)")}`);
+  }
+  lines.push(`${ind}__l[${t.ordinal}] = __x }`);
+}
+function seedDiffersExpr(target2, a) {
+  const html = toHTMLAttrName(a.attrName);
+  if (a.attrName === "dangerouslySetInnerHTML" || html === "dangerouslySetInnerHTML") return "true";
+  if (html === "style") return `${target2}.getAttribute('style') !== styleToCss(__x)`;
+  if (html === "class") return `${target2}.getAttribute('class') !== (__x != null ? String(__x) : null)`;
+  if (html === "value") return `${target2}.value !== String(__x)`;
+  if (isBooleanAttr(html)) return `${target2}.${html} !== !!(__x)`;
+  if (a.meta.presenceOrUndefined) {
+    const written = html.startsWith("aria-") ? "true" : "";
+    return `${target2}.getAttribute('${html}') !== (__x ? '${written}' : null)`;
+  }
+  return `${target2}.getAttribute('${html}') !== (__x != null ? String(__x) : null)`;
+}
+var init_lazy_row = __esm({
+  "../jsx/src/ir-to-client-js/control-flow/stringify/lazy-row.ts"() {
+    "use strict";
+    init_html_constants();
+    init_emit_reactive();
+    init_utils();
+    init_claim_plan();
+    init_skeleton_paths();
+    init_template_parse();
+  }
+});
+
 // ../jsx/src/ir-to-client-js/control-flow/stringify/loop.ts
 function emitLoopChildRefs(lines, refs, opts) {
   if (refs.length === 0) return;
@@ -19432,6 +20082,23 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     stringifyAnchoredLoop(lines, plan, topIndent, anchorKeyExpr);
     return;
   }
+  if (plan.lazyRow) {
+    stringifyLazyRowLoop(lines, {
+      indent: topIndent,
+      containerVar,
+      guardContainer: false,
+      markerId,
+      arrayExpr,
+      keyFn,
+      paramHead,
+      indexParam,
+      template,
+      skeletonTemplate,
+      skeletonPaths: plan.skeletonPaths,
+      lazyRow: plan.lazyRow
+    });
+    return;
+  }
   const hoistedTpl = !bodyIsMultiRoot && skeletonTemplate ? skeletonTemplate : null;
   const tplVar = `__tpl_${markerId.replace(/[^A-Za-z0-9_$]/g, "_")}`;
   if (hoistedTpl) {
@@ -19619,6 +20286,7 @@ var init_loop = __esm({
     init_component_loop();
     init_composite_loop();
     init_claim_plan();
+    init_lazy_row();
   }
 });
 
@@ -20052,6 +20720,23 @@ function emitPlain(lines, plan) {
     stringifyEventDelegation(lines, eventDelegation);
     return;
   }
+  if (plan.lazyRow) {
+    stringifyLazyRowLoop(lines, {
+      indent: "        ",
+      containerVar,
+      guardContainer: true,
+      markerId,
+      arrayExpr,
+      keyFn,
+      paramHead,
+      indexParam,
+      template,
+      lazyRow: plan.lazyRow
+    });
+    lines.push(`      }))`);
+    stringifyEventDelegation(lines, eventDelegation);
+    return;
+  }
   if (reactiveEffects === null && !bodyIsMultiRoot && childRefs.length === 0 && preambleRegions.length === 0) {
     const cloneExpr = emitTemplateCloneInline(template);
     if (mapPreambleWrapped) {
@@ -20097,6 +20782,7 @@ var init_branch_loop = __esm({
     init_reactive_effects();
     init_template_parse();
     init_loop();
+    init_lazy_row();
   }
 });
 
@@ -20283,7 +20969,7 @@ var init_build_component_loop = __esm({
 // ../jsx/src/ir-to-client-js/control-flow/plan/build-loop.ts
 function buildLoopPlan(elem, opts) {
   if (elem.bodyIsItemConditional) {
-    return buildPlainLoopPlan(elem, opts.profileComponentName);
+    return buildPlainLoopPlan(elem, opts.profileComponentName, opts.lazyScope);
   }
   if (elem.isStaticArray) {
     return buildStaticLoopPlan(elem, opts.unsafeLocalNames, opts.profileComponentName);
@@ -20295,9 +20981,9 @@ function buildLoopPlan(elem, opts) {
   if (elem.childComponent) {
     return buildComponentLoopPlan(elem, opts.profileComponentName);
   }
-  return buildPlainLoopPlan(elem, opts.profileComponentName);
+  return buildPlainLoopPlan(elem, opts.profileComponentName, opts.lazyScope);
 }
-function buildPlainLoopPlan(elem, profileComponentName) {
+function buildPlainLoopPlan(elem, profileComponentName, lazyScope) {
   const wrap = (expr) => wrapLoopParamAsAccessor(expr, elem.param, elem.paramBindings);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
   const hasReactive2 = elem.bindings.reactiveAttrs.length > 0 || elem.bindings.reactiveTexts.length > 0 || elem.bindings.conditionals.length > 0;
@@ -20326,30 +21012,48 @@ function buildPlainLoopPlan(elem, profileComponentName) {
       preambleRegions: []
     };
   }
+  const arrayExpr = buildChainedArrayExpr(elem);
+  const indexParam = elem.index || "__idx";
+  const mapPreambleWrapped = elem.preamble ? renderPreamble(elem.preamble, {
+    transformJs: wrap,
+    renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0, true)
+  }) : "";
+  const preambleRegions = buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings);
   return {
     kind: "plain",
     rowConstruction: "string-template",
     containerVar: `_${varSlotId(elem.slotId)}`,
     markerId: elem.markerId,
     profileLoopId: profileComponentName ? `${profileComponentName}#binding:${elem.slotId}` : void 0,
-    arrayExpr: buildChainedArrayExpr(elem),
+    arrayExpr,
     keyFn: loopKeyFn(elem),
     paramHead,
     paramUnwrap,
-    indexParam: elem.index || "__idx",
+    indexParam,
+    // Lazy row graph (§9, L3). `null` for every ineligible loop, which then
+    // keeps the eager emission below byte-for-byte.
+    lazyRow: buildLazyRowPlan({
+      loop: elem,
+      arrayExpr,
+      indexParam,
+      paramUnwrap,
+      mapPreambleWrapped,
+      preambleRegionCount: preambleRegions.length,
+      callSite: "plain",
+      flatMapLeafItem: false,
+      anchored: elem.bodyIsItemConditional ?? false,
+      scope: lazyScope
+    }) ?? void 0,
     // Stage 3 / D4 — js segments get the loop-param accessor wrap; jsx leaves
     // render as HTML-string templates under this loop's param context so a
     // leaf that reads the item (`r`) becomes `r()`.
-    mapPreambleWrapped: elem.preamble ? renderPreamble(elem.preamble, {
-      transformJs: wrap,
-      renderLeaf: (ir) => irToHtmlTemplate(ir, void 0, 1, [{ param: elem.param, bindings: elem.paramBindings }], void 0, true)
-    }) : "",
+    mapPreambleWrapped,
     template: elem.template,
     skeletonTemplate: elem.skeletonTemplate,
     skeletonPaths: elem.skeletonPaths,
     reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem, profileComponentName) : null,
     childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
-    preambleRegions: buildPreambleRegionPlans(elem.preambleRegions, elem.param, elem.paramBindings),
+    preambleRegions,
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
     anchored: elem.bodyIsItemConditional ?? false,
     // Fall back to the iteration index when the loop has no key. A whole-item
@@ -20411,6 +21115,7 @@ var init_build_loop = __esm({
     init_utils();
     init_shared();
     init_build_reactive_effects();
+    init_build_lazy_row();
     init_build_component_loop();
     init_build_composite_loop();
     init_html_template();
@@ -20421,7 +21126,7 @@ var init_build_loop = __esm({
 function emitConditionalUpdates(lines, ctx2) {
   const profileComponentName = ctx2.profile ? ctx2.componentName : void 0;
   for (const elem of ctx2.conditionalElements) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom", profileComponentName });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom", profileComponentName, lazyScope: buildLazyRowScopeInfo(ctx2) });
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
   }
@@ -20429,17 +21134,19 @@ function emitConditionalUpdates(lines, ctx2) {
 function emitClientOnlyConditionals(lines, ctx2) {
   const profileComponentName = ctx2.profile ? ctx2.componentName : void 0;
   for (const elem of ctx2.clientOnlyConditionals) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw", profileComponentName });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw", profileComponentName, lazyScope: buildLazyRowScopeInfo(ctx2) });
     lines.push(`  // @client conditional: ${elem.slotId}`);
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
   }
 }
 function emitLoopUpdates(lines, ctx2, unsafeLocalNames) {
+  const lazyScope = buildLazyRowScopeInfo(ctx2);
   for (const elem of ctx2.loopElements) {
     const plan = buildLoopPlan(elem, {
       unsafeLocalNames,
-      profileComponentName: ctx2.profile ? ctx2.componentName : void 0
+      profileComponentName: ctx2.profile ? ctx2.componentName : void 0,
+      lazyScope
     });
     internalInvariant(
       !(elem.preamble && elem.preamble.builderNames.length > 0 && plan.rowConstruction === "dom-ops"),
@@ -20467,6 +21174,7 @@ var init_control_flow = __esm({
     init_build_insert();
     init_insert();
     init_build_loop();
+    init_build_lazy_row();
     init_loop();
     init_build_event_delegation();
     init_event_delegation();
@@ -20692,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;
@@ -20724,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({
@@ -21413,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 = [];
@@ -21433,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 };
@@ -21464,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;
@@ -21512,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 };
   }
@@ -21531,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();
@@ -21566,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);
     });
   }
 }
@@ -21597,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;
@@ -21681,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);
@@ -21720,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();
@@ -21780,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);
 }
@@ -21801,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;
@@ -21827,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;
@@ -21895,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;
@@ -21915,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 = ",";
@@ -21939,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;
@@ -21966,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) {
@@ -21997,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;
@@ -22010,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();
@@ -22037,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) {
@@ -22086,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);
   };
@@ -22196,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;
@@ -22257,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;
@@ -22286,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;
@@ -22315,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);
@@ -22338,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;
@@ -23001,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;
@@ -23008,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}'`);
         }
@@ -23039,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;
@@ -23168,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();
@@ -23186,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,
@@ -23199,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"() {
@@ -24268,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();
@@ -24325,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]);
@@ -24343,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());
       }
@@ -24538,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) {
@@ -25750,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;
@@ -25838,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;
@@ -26093,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);
@@ -26386,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);
@@ -27091,6 +27801,7 @@ __export(src_exports, {
   collectContextConsumers: () => collectContextConsumers,
   collectLoopBoundNames: () => collectLoopBoundNames,
   collectModuleStringConsts: () => collectModuleStringConsts,
+  collectValueReferencedNames: () => collectValueReferencedNames,
   combineParentChildClientJs: () => combineParentChildClientJs,
   compileJSX: () => compileJSX,
   computeSsrSeedPlan: () => computeSsrSeedPlan,
@@ -27165,6 +27876,7 @@ __export(src_exports, {
   isStringTypedOperand: () => isStringTypedOperand,
   isSupported: () => isSupported,
   isValidHelperId: () => isValidHelperId,
+  isValueReferenceIdentifier: () => isValueReferenceIdentifier,
   joinProfilerEvents: () => joinProfilerEvents,
   jsxToIR: () => jsxToIR,
   listComponentFunctions: () => listComponentFunctions,
@@ -27241,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();
@@ -27315,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;
@@ -27325,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) {
@@ -27337,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;
@@ -27399,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) {
@@ -27455,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++;
@@ -27504,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 {
@@ -27520,7 +28286,8 @@ function buildTopLevelIIFE(topLevelId, body2, shapesNeeded, originalSource) {
 ${stripped}
 return {};
 })();`,
-      hoistedImports
+      hoistedImports,
+      errors
     };
   }
   const ret = `{ ${[...namesNeeded].join(", ")} }`;
@@ -27529,7 +28296,8 @@ return {};
 ${stripped}
 return ${ret};
 })();`,
-    hoistedImports
+    hoistedImports,
+    errors
   };
 }
 async function resolveSourceFile(importPath, searchDirs) {
@@ -27578,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 = [];
@@ -27652,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);
@@ -27812,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);
@@ -28115,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) {
@@ -28132,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;
@@ -28146,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;
@@ -28162,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) {
@@ -28170,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;
@@ -28250,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";
@@ -28898,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("://")) {
@@ -28965,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);
     }
@@ -28983,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;
@@ -110268,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) {
@@ -110338,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$/, "")));
@@ -110354,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}`);
         }
@@ -110869,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);