@barefootjs/hono 0.31.1 → 0.31.3

package/dist/vite.js

@@ -4,8 +4,11 @@ import { dirname, resolve } from "node:path";
 import { barefoot as coreBarefoot } from "@barefootjs/vite";
 import { devModuleUrl, loadManifest, resolveDevOrigin, resolveScriptAssets, toPosixRelative } from "@barefootjs/vite";
 
+// ../jsx/src/compiler.ts
+import ts23 from "typescript";
+
 // ../jsx/src/analyzer.ts
-import ts8 from "typescript";
+import ts9 from "typescript";
 
 // ../jsx/src/expression-parser.ts
 import ts from "typescript";
@@ -98,6 +101,29 @@ function buildLoopChainExpr(opts) {
   return `${opts.base}${sortExpr}${filterExpr}`;
 }
 
+// ../jsx/src/template-parts.ts
+function lookupPartToJsExpr(part, opts) {
+  const key = opts?.useTemplate && part.templateKey ? part.templateKey : part.key;
+  const obj = "{" + Object.entries(part.cases).map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`).join(", ") + "}";
+  const typed = opts?.typed ? " as Record<string, string>" : "";
+  return `(${obj}${typed})[${key}]`;
+}
+function templatePartsToJsExpr(parts, opts) {
+  let result = "`";
+  for (const part of parts) {
+    if (part.type === "string") {
+      result += opts?.useTemplate && part.templateValue ? part.templateValue : part.value;
+    } else if (part.type === "ternary") {
+      const cond = opts?.useTemplate && part.templateCondition ? part.templateCondition : part.condition;
+      result += `\${${cond} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
+    } else if (part.type === "lookup") {
+      result += `\${${lookupPartToJsExpr(part, opts)}}`;
+    }
+  }
+  result += "`";
+  return result;
+}
+
 // ../jsx/src/scanner/js-scanner.ts
 import ts2 from "typescript";
 
@@ -203,6 +229,16 @@ function escapeHtml(text) {
 }
 // ../jsx/src/ir-to-client-js/csr-substitute.ts
 import ts4 from "typescript";
+function extractFreeIdentifiersFromText(text) {
+  if (!text || text.trim().length === 0)
+    return new Set;
+  const sf = ts4.createSourceFile("__free_ids__.ts", `(${text});`, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts4.isExpressionStatement(stmt))
+    return new Set;
+  const expr = ts4.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  return extractFreeIdentifiersFromNode(expr);
+}
 
 // ../jsx/src/ir-to-client-js/html-template.ts
 var VOID_ELEMENTS = new Set([
@@ -248,6 +284,27 @@ var SKELETON_PATH_FORCE_CLOSE_GROUPS = [
   new Set(["li"])
 ];
 
+// ../jsx/src/props-binding.ts
+import ts6 from "typescript";
+function isIdentifierName(key) {
+  if (key.length === 0)
+    return false;
+  for (let i = 0;i < key.length; ) {
+    const cp = key.codePointAt(i);
+    const ok = i === 0 ? ts6.isIdentifierStart(cp, ts6.ScriptTarget.Latest) : ts6.isIdentifierPart(cp, ts6.ScriptTarget.Latest);
+    if (!ok)
+      return false;
+    i += cp > 65535 ? 2 : 1;
+  }
+  return true;
+}
+function propsDestructureBinding(p) {
+  const callerKey = p.sourceName ?? p.name;
+  const localName = p.name;
+  const binding = callerKey === localName ? localName : `${isIdentifierName(callerKey) ? callerKey : JSON.stringify(callerKey)}: ${localName}`;
+  return p.defaultValue ? `${binding} = ${p.defaultValue}` : binding;
+}
+
 // ../jsx/src/instrumentation.ts
 var _counters = freshCounters();
 function freshCounters() {
@@ -261,14 +318,14 @@ function freshCounters() {
 }
 
 // ../jsx/src/analyzer-context.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 
 // ../jsx/src/strip-types.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 
 // ../jsx/src/analyzer-context.ts
-var _typePrinter = ts7.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-var _blankTypeSourceFile = ts7.createSourceFile("__bf_types__.ts", "", ts7.ScriptTarget.Latest);
+var _typePrinter = ts8.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+var _blankTypeSourceFile = ts8.createSourceFile("__bf_types__.ts", "", ts8.ScriptTarget.Latest);
 
 // ../jsx/src/errors.ts
 var ErrorCodes = {
@@ -284,6 +341,7 @@ var ErrorCodes = {
   JSX_IN_LOCAL_FUNCTION: "BF045",
   COMPONENT_REQUIRED_PROP_MISSING: "BF046",
   JSX_BRANCH_LOCAL_IN_CALLBACK: "BF047",
+  SIBLING_COMPONENT_NOT_COMPILED: "BF048",
   SHARED_PROGRAM_REQUIRED: "BF050",
   WRONG_PACKAGE_IMPORT: "BF051",
   BUILTIN_REQUIRES_IMPORT: "BF054",
@@ -313,6 +371,7 @@ var errorMessages = {
   [ErrorCodes.JSX_IN_LOCAL_FUNCTION]: "Local function returns JSX but cannot be inlined. Extract it as a top-level PascalCase component or use a single return statement.",
   [ErrorCodes.COMPONENT_REQUIRED_PROP_MISSING]: "Built-in component is missing a required prop.",
   [ErrorCodes.JSX_BRANCH_LOCAL_IN_CALLBACK]: "JSX-typed local declared inside an `if`-block cannot be referenced from a callback body (ref / event handler). " + "Render it as a child instead: `<div ref={...}>{local}</div>`.",
+  [ErrorCodes.SIBLING_COMPONENT_NOT_COMPILED]: "Referenced component did not compile to a template, so this reference would throw " + "`ReferenceError` at render time. Multi-return JSX dispatch (a `switch` or `if`/`else` " + "chain across multiple JSX-returning branches) cannot compile as a component in a " + `'use client' file. Extract it to a separate non-"use client" file (where it is preserved ` + "verbatim, see #932), or rewrite it as a single-return ternary/conditional chain so the " + "component pipeline can compile it.",
   [ErrorCodes.SHARED_PROGRAM_REQUIRED]: "Shared ts.Program required for type-based reactivity classification. This source imports a Reactive<T>-branded library (e.g. @barefootjs/form) whose getters cannot be classified by regex alone. Pass `options.program` (built via `createProgramForCorpus`) so the analyzer can resolve the brand through the TypeChecker.",
   [ErrorCodes.WRONG_PACKAGE_IMPORT]: "Import from wrong package.",
   [ErrorCodes.BUILTIN_REQUIRES_IMPORT]: "Built-in <Async> / <Region> must be imported from '@barefootjs/client'. " + "The compiler recognises these tags by their import (not by tag name), " + "so an unimported tag with this name is treated as an undeclared component.",
@@ -486,6 +545,54 @@ var CLIENT_EXPORTS = new Set([
   "Async",
   "Region"
 ]);
+function extractFreeIdentifiersFromNode(node) {
+  const ids = new Set;
+  const boundNames = new Set;
+  function addBindingNames(name, out) {
+    if (ts9.isIdentifier(name))
+      out.push(name.text);
+    else if (ts9.isObjectBindingPattern(name))
+      name.elements.forEach((e) => addBindingNames(e.name, out));
+    else if (ts9.isArrayBindingPattern(name))
+      name.elements.forEach((e) => {
+        if (!ts9.isOmittedExpression(e))
+          addBindingNames(e.name, out);
+      });
+  }
+  function visit(n) {
+    if (ts9.isTypeNode(n))
+      return;
+    if (ts9.isIdentifier(n)) {
+      const parent = n.parent;
+      if (parent && ts9.isPropertyAccessExpression(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isPropertyAssignment(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isParameter(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isVariableDeclaration(parent) && parent.name === n)
+        return;
+      if (boundNames.has(n.text))
+        return;
+      ids.add(n.text);
+      return;
+    }
+    if (ts9.isArrowFunction(n)) {
+      const params = [];
+      for (const p of n.parameters)
+        addBindingNames(p.name, params);
+      for (const name of params)
+        boundNames.add(name);
+      ts9.forEachChild(n, visit);
+      for (const name of params)
+        boundNames.delete(name);
+      return;
+    }
+    ts9.forEachChild(n, visit);
+  }
+  visit(node);
+  return ids;
+}
 var BROWSER_ONLY_CLIENT_APIS = new Set([
   "useContext",
   "provideContext",
@@ -504,7 +611,7 @@ var REACTIVE_PRIMITIVES = new Set([
 ]);
 
 // ../jsx/src/jsx-to-ir.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 
 // ../jsx/src/types.ts
 var SCOPE_FORBIDDEN = {
@@ -572,10 +679,10 @@ function findReachableNames(primaryRefs, declarations) {
 }
 
 // ../jsx/src/reactivity-checker.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // ../jsx/src/free-refs.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 var _bindingMapCache = new WeakMap;
 
 // ../jsx/src/to-locale-date-lowering.ts
@@ -893,6 +1000,83 @@ var toLocaleDatePlugin = {
   }
 };
 
+// ../jsx/src/scope/binding-scope.ts
+class BindingScope {
+  frames;
+  static EMPTY = new BindingScope([]);
+  constructor(frames) {
+    this.frames = frames;
+  }
+  enterLoopRow(loop) {
+    const bindings = new Map;
+    if (loop.paramBindings && loop.paramBindings.length > 0) {
+      for (const b of loop.paramBindings)
+        bindings.set(b.name, { source: "destructure" });
+    } else {
+      bindings.set(loop.param, { source: "item" });
+    }
+    if (loop.index != null)
+      bindings.set(loop.index, { source: "index" });
+    for (const name of loop.preamble?.declaredNames ?? [])
+      bindings.set(name, { source: "preamble" });
+    const frame = { kind: "loop-row", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  enterCallback(params) {
+    const bindings = new Map;
+    for (const name of params)
+      bindings.set(name, { source: "param" });
+    const frame = { kind: "callback", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  isBound(name) {
+    for (const frame of this.frames) {
+      if (frame.bindings.has(name))
+        return true;
+    }
+    return false;
+  }
+  lookup(name) {
+    for (let depth = 0;depth < this.frames.length; depth++) {
+      const frame = this.frames[depth];
+      const binding = frame.bindings.get(name);
+      if (binding)
+        return { depth, frame, binding };
+    }
+    return null;
+  }
+  boundNames() {
+    if (this.boundNamesCache)
+      return this.boundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const name of frame.bindings.keys())
+        names.add(name);
+    }
+    this.boundNamesCache = names;
+    return names;
+  }
+  boundNamesCache;
+  valueBoundNamesCache;
+  valueBoundNames() {
+    if (this.valueBoundNamesCache)
+      return this.valueBoundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const [name, binding] of frame.bindings) {
+        if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
+          names.add(name);
+        }
+      }
+    }
+    this.valueBoundNamesCache = names;
+    return names;
+  }
+  asShadowPredicate() {
+    return (name) => this.isBound(name);
+  }
+}
+
 // ../jsx/src/jsx-to-ir.ts
 var EMPTY_BOUND = new Set;
 var constInitializerCache = new WeakMap;
@@ -989,13 +1173,13 @@ var KEYWORDS_AND_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 // ../jsx/src/value-references.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 
 // ../jsx/src/relocate.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // ../jsx/src/lowering-registry.ts
 var plugins = [];
@@ -1174,10 +1358,10 @@ function formatDateLocalNames(metadata) {
 }
 
 // ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -1227,7 +1411,7 @@ var INERT_BINDING_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts
 var NON_BUBBLING_EVENTS = new Set([
@@ -1242,7 +1426,7 @@ var NON_BUBBLING_EVENTS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 
 // ../jsx/src/ir-to-client-js/source-map.ts
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -1333,20 +1517,20 @@ class SourceMapGenerator {
 }
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 
 // ../jsx/src/ssr-defaults.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 
 // ../jsx/src/augment-inherited-props.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 
 // ../jsx/src/rich-type-refusal.ts
 var EMPTY_BINDINGS2 = new Map;
 // ../jsx/src/shared-program.ts
-import ts22 from "typescript";
+import ts24 from "typescript";
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
   renderChildren(children) {
@@ -1422,7 +1606,7 @@ class JsxAdapter extends BaseAdapter {
       }
       const rawInitialValue = preserveTypes ? signal.typedInitialValue ?? signal.initialValue : signal.initialValue;
       const initialValue = rawInitialValue.trim().startsWith("{") ? `(${rawInitialValue})` : rawInitialValue;
-      const needsTypeAssertion = preserveTypes && !signal.typedInitialValue && signal.type.kind !== "unknown" && signal.type.kind !== "primitive";
+      const needsTypeAssertion = preserveTypes && !signal.typedInitialValue && signal.type.kind !== "unknown" && signal.type.kind !== "primitive" && signal.type.raw !== "object";
       if (needsTypeAssertion) {
         lines.push(`  const ${signal.getter} = () => ${initialValue} as ${signal.type.raw}`);
       } else {
@@ -1441,12 +1625,16 @@ class JsxAdapter extends BaseAdapter {
       const computation = preserveTypes ? memo.typedComputation ?? memo.computation : memo.computation;
       lines.push(`  const ${memo.name} = ${computation}`);
     }
+    const moduleScopeNames = this.moduleScopeDeclarationNames(ir);
     for (const constant of ir.metadata.localConstants) {
       if (constant.isExported)
         continue;
+      if (moduleScopeNames.has(constant.name))
+        continue;
       const keyword = constant.declarationKind ?? "const";
       if (!constant.value) {
-        lines.push(`  ${keyword} ${constant.name}`);
+        const typeAnnotation = preserveTypes && (constant.typeAnnotation ?? constant.type) ? `: ${constant.typeAnnotation ?? constant.type?.raw}` : "";
+        lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`);
         continue;
       }
       const value = constant.value.trim();
@@ -1455,9 +1643,12 @@ class JsxAdapter extends BaseAdapter {
       if (!reachable.has(constant.name))
         continue;
       const constValue = preserveTypes ? constant.typedValue ?? constant.value : constant.value;
-      lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
+      const letTypeAnnotation = preserveTypes && keyword === "let" && constant.typeAnnotation ? `: ${constant.typeAnnotation}` : "";
+      lines.push(`  ${keyword} ${constant.name}${letTypeAnnotation} = ${constValue}`);
     }
     for (const func of localFunctions) {
+      if (moduleScopeNames.has(func.name))
+        continue;
       if (!reachable.has(func.name))
         continue;
       const params = preserveTypes && func.typedParams !== undefined ? func.typedParams : func.params.map(formatParamWithType).join(", ");
@@ -1467,6 +1658,127 @@ class JsxAdapter extends BaseAdapter {
       lines.push(`  ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body}`);
     }
     return lines.join(`
+`);
+  }
+  moduleScopeNamesCache = new WeakMap;
+  moduleScopeDeclarationNames(ir) {
+    const cached = this.moduleScopeNamesCache.get(ir);
+    if (cached)
+      return cached;
+    const componentScope = new Set;
+    for (const sig of ir.metadata.signals) {
+      if (sig.isModule)
+        continue;
+      componentScope.add(sig.getter);
+      if (sig.setter)
+        componentScope.add(sig.setter);
+    }
+    for (const memo of ir.metadata.memos) {
+      if (!memo.isModule)
+        componentScope.add(memo.name);
+    }
+    for (const p of ir.metadata.propsParams)
+      componentScope.add(p.name);
+    if (ir.metadata.propsObjectName)
+      componentScope.add(ir.metadata.propsObjectName);
+    if (ir.metadata.restPropsName)
+      componentScope.add(ir.metadata.restPropsName);
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule)
+        componentScope.add(c.name);
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule)
+        componentScope.add(f.name);
+    }
+    const exported = new Set;
+    const candidates = new Map;
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule)
+        continue;
+      if (c.isJsx || c.isJsxFunction)
+        continue;
+      if (c.isExported) {
+        exported.add(c.name);
+        continue;
+      }
+      candidates.set(c.name, c.freeIdentifiers ?? extractFreeIdentifiersFromText(c.value ?? ""));
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule)
+        continue;
+      if (f.isJsxFunction || f.isMultiReturnJsxHelper)
+        continue;
+      if (f.isExported) {
+        exported.add(f.name);
+        continue;
+      }
+      const params = f.typedParams !== undefined ? f.typedParams : f.params.map(formatParamWithType).join(", ");
+      candidates.set(f.name, extractFreeIdentifiersFromText(`(${params}) => ${f.body}`));
+    }
+    const referencesAny = (refs, names) => {
+      for (const ref of refs) {
+        if (names.has(ref))
+          return true;
+      }
+      return false;
+    };
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const [name, refs] of candidates) {
+        if (referencesAny(refs, componentScope)) {
+          candidates.delete(name);
+          componentScope.add(name);
+          changed = true;
+        }
+      }
+    }
+    const result = new Set([...exported, ...candidates.keys()]);
+    this.moduleScopeNamesCache.set(ir, result);
+    return result;
+  }
+  generateModuleScopeDeclarations(ir) {
+    const { preserveTypes } = this.jsxConfig;
+    const moduleNames = this.moduleScopeDeclarationNames(ir);
+    const entries = [];
+    for (const t of ir.metadata.typeDefinitions) {
+      entries.push({ line: t.loc.start.line, text: t.definition });
+    }
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule || !moduleNames.has(c.name))
+        continue;
+      const keyword = c.declarationKind ?? "const";
+      const exportKw = c.isExported ? "export " : "";
+      if (!c.value) {
+        const typeAnnotation = preserveTypes && (c.typeAnnotation ?? c.type) ? `: ${c.typeAnnotation ?? c.type?.raw}` : "";
+        entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${typeAnnotation}` });
+        continue;
+      }
+      const trimmed = c.value.trim();
+      if (/^new WeakMap\b/.test(trimmed))
+        continue;
+      if (c.isExported && /^createContext\b/.test(trimmed))
+        continue;
+      const value = preserveTypes ? c.typedValue ?? c.value : c.value;
+      const letTypeAnnotation = preserveTypes && keyword === "let" && c.typeAnnotation ? `: ${c.typeAnnotation}` : "";
+      entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${letTypeAnnotation} = ${value}` });
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule || !moduleNames.has(f.name))
+        continue;
+      const params = preserveTypes && f.typedParams !== undefined ? f.typedParams : f.params.map(formatParamWithType).join(", ");
+      const returnAnnotation = preserveTypes && f.typedReturnType ? `: ${f.typedReturnType}` : "";
+      const body = preserveTypes ? f.typedBody ?? f.body : f.body;
+      const asyncKw = f.isAsync ? "async " : "";
+      const exportKw = f.isExported ? "export " : "";
+      entries.push({
+        line: f.loc.start.line,
+        text: `${exportKw}${asyncKw}function ${f.name}(${params})${returnAnnotation} ${body}`
+      });
+    }
+    entries.sort((a, b) => a.line - b.line);
+    return entries.map((e) => e.text).join(`
 `);
   }
   renderNodeRaw(node) {
@@ -1478,6 +1790,15 @@ class JsxAdapter extends BaseAdapter {
     }
     return this.renderNode(node);
   }
+  renderTemplatePartsAsJs(parts) {
+    return templatePartsToJsExpr(parts, { typed: this.jsxConfig.preserveTypes });
+  }
+  expressionValueToJs(value) {
+    if (this.jsxConfig.preserveTypes && value.parts && value.expr === templatePartsToJsExpr(value.parts)) {
+      return this.renderTemplatePartsAsJs(value.parts);
+    }
+    return value.expr;
+  }
   renderScopeMarker(instanceIdExpr) {
     return `${BF_SCOPE}={${instanceIdExpr}}`;
   }
@@ -1545,6 +1866,7 @@ class TestAdapter extends JsxAdapter {
   generate(ir) {
     this.componentName = ir.metadata.componentName;
     const imports = this.generateImports(ir);
+    const moduleConstants = this.generateModuleScopeDeclarations(ir);
     const types = this.generateTypes(ir);
     const component = this.generateComponent(ir);
     const defaultExport = ir.metadata.hasDefaultExport ? `
@@ -1553,9 +1875,11 @@ export default ${this.componentName}` : "";
       imports,
       types: types || "",
       component,
-      defaultExport
+      defaultExport,
+      moduleConstants,
+      moduleConstantsIncludeExports: true
     };
-    const template = [imports, types, component].filter(Boolean).join(`
+    const template = [imports, moduleConstants, types, component].filter(Boolean).join(`
 
 `) + defaultExport;
     return {
@@ -1586,9 +1910,6 @@ export default ${this.componentName}` : "";
   }
   generateTypes(ir) {
     const lines = [];
-    for (const typeDef of ir.metadata.typeDefinitions) {
-      lines.push(typeDef.definition);
-    }
     const propsTypeName = ir.metadata.propsType?.raw;
     if (propsTypeName && !ir.metadata.propsObjectName) {
       lines.push("");
@@ -1611,7 +1932,7 @@ export default ${this.componentName}` : "";
     const bodyRefText = [jsxBody, signalInits, scopeIdLine].join(`
 `);
     const bfScopeAlias = /\b__bfScope\b/.test(bodyRefText) ? "__bfScope" : "__bfScope: _bfScope";
-    const propsParams = ir.metadata.propsParams.map((p) => p.defaultValue ? `${p.name} = ${p.defaultValue}` : p.name).join(", ");
+    const propsParams = ir.metadata.propsParams.map((p) => propsDestructureBinding(p)).join(", ");
     const restPropsName = ir.metadata.restPropsName;
     const hydrationProps = `__instanceId, ${bfScopeAlias}`;
     const parts = [];
@@ -1758,13 +2079,7 @@ export default ${this.componentName}` : "";
   }
   flattenTemplate(value) {
     const v = value;
-    return "`" + v.parts.map((p) => {
-      if (p.type === "string")
-        return p.value;
-      if (p.type === "ternary")
-        return `\${${p.condition} ? '${p.whenTrue}' : '${p.whenFalse}'}`;
-      return `\${(${JSON.stringify(p.cases)})[${p.key}]}`;
-    }).join("") + "`";
+    return this.renderTemplatePartsAsJs(v.parts);
   }
   renderComponentProps(comp) {
     const parts = [];
@@ -1940,17 +2255,16 @@ function emitAttrValue(value, emitter, name) {
   }
 }
 // ../jsx/src/combine-client-js.ts
-import ts23 from "typescript";
+import ts25 from "typescript";
 // ../jsx/src/debug.ts
-import ts24 from "typescript";
+import ts26 from "typescript";
 // ../jsx/src/profiler.ts
-import ts25 from "typescript";
+import ts27 from "typescript";
 
 // ../jsx/src/index.ts
 registerBuiltinLoweringPlugins();
 
 // src/adapter/hono-adapter.ts
-import ts26 from "typescript";
 function applyHonoLoopChain(loop) {
   return buildLoopChainExpr({
     base: loop.array,
@@ -1959,18 +2273,6 @@ function applyHonoLoopChain(loop) {
     chainOrder: loop.chainOrder
   });
 }
-function isIdentifierName(key) {
-  if (key.length === 0)
-    return false;
-  for (let i = 0;i < key.length; ) {
-    const cp = key.codePointAt(i);
-    const ok = i === 0 ? ts26.isIdentifierStart(cp, ts26.ScriptTarget.Latest) : ts26.isIdentifierPart(cp, ts26.ScriptTarget.Latest);
-    if (!ok)
-      return false;
-    i += cp > 65535 ? 2 : 1;
-  }
-  return true;
-}
 
 class HonoAdapter extends JsxAdapter {
   name = "hono";
@@ -2008,11 +2310,11 @@ class HonoAdapter extends JsxAdapter {
       this.preloadAssets = options?.preloadAssets;
     }
     const component = this.generateComponent(ir);
-    const types = this.generateTypes(ir, component);
-    const componentCode = [types, component].filter(Boolean).join(`
+    const types = this.generateTypes(ir);
+    const moduleConstants = this.generateModuleScopeDeclarations(ir);
+    const componentCode = [moduleConstants, types, component].filter(Boolean).join(`
 `);
     const imports = this.generateImports(ir, componentCode);
-    const moduleConstants = this.generateModuleLevelContextBindings(ir);
     const defaultExport = ir.metadata.hasDefaultExport ? `
 export default ${this.componentName}` : "";
     const sections = {
@@ -2020,7 +2322,8 @@ export default ${this.componentName}` : "";
       types: types || "",
       component,
       defaultExport,
-      moduleConstants
+      moduleConstants,
+      moduleConstantsIncludeExports: true
     };
     const template = [imports, moduleConstants, types, component].filter(Boolean).join(`
 
@@ -2042,24 +2345,6 @@ export default ${this.componentName}` : "";
   hasPreloadAssets() {
     return this.hasScriptAssets() && !!this.preloadAssets && this.preloadAssets.length > 0;
   }
-  generateModuleLevelContextBindings(ir) {
-    const lines = [];
-    for (const c of ir.metadata.localConstants) {
-      if (!c.isModule)
-        continue;
-      if (c.isExported)
-        continue;
-      if (c.systemConstructKind !== "createContext")
-        continue;
-      if (!c.value)
-        continue;
-      const keyword = c.declarationKind ?? "const";
-      const value = this.jsxConfig.preserveTypes ? c.typedValue ?? c.value : c.value;
-      lines.push(`${keyword} ${c.name} = ${value}`);
-    }
-    return lines.join(`
-`);
-  }
   generateImports(ir, componentCode) {
     const lines = [];
     const utilImports = [];
@@ -2101,50 +2386,10 @@ export default ${this.componentName}` : "";
     return lines.join(`
 `);
   }
-  generateTypes(ir, componentBody) {
+  generateTypes(ir) {
     const lines = [];
-    if (componentBody && ir.metadata.typeDefinitions.length > 0) {
-      const propsTypeName2 = this.getPropsTypeName(ir);
-      const seedText = [
-        componentBody,
-        propsTypeName2 && !ir.metadata.propsObjectName ? propsTypeName2 : "",
-        ...ir.metadata.namedExports.filter((block) => block.source === null).flatMap((block) => block.specifiers.map((s) => s.name))
-      ].filter(Boolean).join(`
-`);
-      const included = new Set;
-      for (const typeDef of ir.metadata.typeDefinitions) {
-        if (new RegExp(`\\b${typeDef.name}\\b`).test(seedText)) {
-          included.add(typeDef.name);
-        }
-      }
-      let changed = true;
-      while (changed) {
-        changed = false;
-        for (const typeDef of ir.metadata.typeDefinitions) {
-          if (included.has(typeDef.name))
-            continue;
-          for (const name of included) {
-            const includedDef = ir.metadata.typeDefinitions.find((t) => t.name === name);
-            if (includedDef && new RegExp(`\\b${typeDef.name}\\b`).test(includedDef.definition)) {
-              included.add(typeDef.name);
-              changed = true;
-              break;
-            }
-          }
-        }
-      }
-      for (const typeDef of ir.metadata.typeDefinitions) {
-        if (included.has(typeDef.name))
-          lines.push(typeDef.definition);
-      }
-    } else {
-      for (const typeDef of ir.metadata.typeDefinitions) {
-        lines.push(typeDef.definition);
-      }
-    }
     const propsTypeName = this.getPropsTypeName(ir);
     if (propsTypeName && !ir.metadata.propsObjectName) {
-      lines.push("");
       lines.push(`type ${this.componentName}PropsWithHydration = ${propsTypeName} & {`);
       lines.push("  __instanceId?: string");
       lines.push("  __bfScope?: string");
@@ -2224,12 +2469,7 @@ export default ${this.componentName}` : "";
     } else {
       const hydrationProps = `__instanceId, ${bfScopeAlias}, ${bfChildAlias}, ${bfParentPropsAlias}, ${bfParentAlias}, ${bfMountAlias}, ${dataKeyAlias}`;
       const parts = [];
-      const propsParams = ir.metadata.propsParams.map((p) => {
-        const callerKey = p.sourceName ?? p.name;
-        const localName = p.name;
-        const binding = callerKey === localName ? localName : `${isIdentifierName(callerKey) ? callerKey : JSON.stringify(callerKey)}: ${localName}`;
-        return p.defaultValue ? `${binding} = ${p.defaultValue}` : binding;
-      }).join(", ");
+      const propsParams = ir.metadata.propsParams.map((p) => propsDestructureBinding(p)).join(", ");
       if (propsParams) {
         parts.push(propsParams);
       }
@@ -2270,7 +2510,8 @@ export default ${this.componentName}` : "";
       lines.push(`  const __hydrateProps: Record<string, unknown> = {}`);
       for (const p of propsToSerialize) {
         const propAccess = propsObjectName ? `${propsObjectName}.${p.name}` : p.name;
-        lines.push(`  if (typeof ${propAccess} !== 'function' && !(typeof ${propAccess} === 'object' && ${propAccess} !== null && 'isEscaped' in ${propAccess})) __hydrateProps['${p.name}'] = ${propAccess}`);
+        const callerKey = p.sourceName ?? p.name;
+        lines.push(`  if (typeof ${propAccess} !== 'function' && !(typeof ${propAccess} === 'object' && ${propAccess} !== null && 'isEscaped' in ${propAccess})) __hydrateProps['${callerKey}'] = ${propAccess}`);
       }
       lines.push(`  const __bfPropsJson = __bfParentProps || (Object.keys(__hydrateProps).length > 0 ? JSON.stringify(__hydrateProps) : undefined)`);
     } else if (hasClientInteractivity && isRootComponent) {
@@ -2335,6 +2576,7 @@ export default ${this.componentName}` : "";
         case "literal":
           return JSON.stringify(v.value);
         case "expression":
+          return this.expressionValueToJs(v);
         case "spread":
           return v.expr;
         case "template":
@@ -2406,18 +2648,26 @@ export default ${this.componentName}` : "";
     if (cond.clientOnly && cond.slotId) {
       return `{bfComment("cond-start:${cond.slotId}")}{bfComment("cond-end:${cond.slotId}")}`;
     }
+    return `{${this.renderConditionalBody(cond, ctx)}}`;
+  }
+  renderConditionalBody(cond, ctx) {
     const branchCtx = ctx?.isLoopItemRoot ? { isLoopItemRoot: true } : undefined;
+    if (!cond.slotId) {
+      const whenTrue2 = this.renderBareBranch(cond.whenTrue, branchCtx);
+      let whenFalse2 = this.renderBareBranch(cond.whenFalse, branchCtx);
+      if (!whenFalse2 || whenFalse2 === "" || whenFalse2 === "null") {
+        whenFalse2 = "null";
+      }
+      return `${cond.condition} ? ${whenTrue2} : ${whenFalse2}`;
+    }
     const whenTrue = this.renderNodeRawCtx(cond.whenTrue, branchCtx);
     let whenFalse = this.renderNodeRawCtx(cond.whenFalse, branchCtx);
     if (!whenFalse || whenFalse === "" || whenFalse === "null") {
       whenFalse = "null";
     }
-    if (cond.slotId) {
-      const trueWithMarker = this.wrapWithCondMarker(cond.whenTrue, whenTrue, cond.slotId);
-      const falseWithMarker = cond.whenFalse.type === "expression" && cond.whenFalse.expr === "null" ? `<>{bfComment("cond-start:${cond.slotId}")}{bfComment("cond-end:${cond.slotId}")}</>` : this.wrapWithCondMarker(cond.whenFalse, whenFalse, cond.slotId);
-      return `{${cond.condition} ? ${trueWithMarker} : ${falseWithMarker}}`;
-    }
-    return `{${cond.condition} ? ${whenTrue} : ${whenFalse}}`;
+    const trueWithMarker = this.wrapWithCondMarker(cond.whenTrue, whenTrue, cond.slotId);
+    const falseWithMarker = cond.whenFalse.type === "expression" && cond.whenFalse.expr === "null" ? `<>{bfComment("cond-start:${cond.slotId}")}{bfComment("cond-end:${cond.slotId}")}</>` : this.wrapWithCondMarker(cond.whenFalse, whenFalse, cond.slotId);
+    return `${cond.condition} ? ${trueWithMarker} : ${falseWithMarker}`;
   }
   renderNodeRawCtx(node, ctx) {
     if (node.type === "expression") {
@@ -2427,6 +2677,17 @@ export default ${this.componentName}` : "";
     }
     return this.renderNode(node, ctx);
   }
+  renderBareBranch(node, ctx) {
+    if (node.type === "expression") {
+      if (node.expr === "null" || node.expr === "undefined")
+        return "null";
+      return node.expr;
+    }
+    if (node.type === "conditional" && !(node.clientOnly && node.slotId)) {
+      return this.renderConditionalBody(node, ctx);
+    }
+    return this.renderNode(node, ctx);
+  }
   wrapWithCondMarker(node, content, condId) {
     if (node.type === "component") {
       return `<>{bfComment("cond-start:${condId}")}${content}{bfComment("cond-end:${condId}")}</>`;
@@ -2578,10 +2839,11 @@ export default ${this.componentName}` : "";
   elementAttrEmitter = {
     emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
+      const expr = this.expressionValueToJs(value);
       if (isBooleanAttr(name) || value.presenceOrUndefined) {
-        return `${name}={(${value.expr}) || undefined}`;
+        return `${name}={(${expr}) || undefined}`;
       }
-      return `${name}={${value.expr}}`;
+      return `${name}={${expr}}`;
     },
     emitBooleanAttr: (_value, name) => name,
     emitBooleanShorthand: () => "",
@@ -2591,7 +2853,7 @@ export default ${this.componentName}` : "";
   };
   componentPropEmitter = {
     emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
-    emitExpression: (value, name) => `${name}={${value.expr}}`,
+    emitExpression: (value, name) => `${name}={${this.expressionValueToJs(value)}}`,
     emitBooleanAttr: (_value, name) => name,
     emitBooleanShorthand: (_value, name) => name,
     emitTemplate: (value, name) => `${name}={${this.renderTemplateLiteralParts(value.parts)}}`,
@@ -2639,6 +2901,7 @@ export default ${this.componentName}` : "";
       case "literal":
         return JSON.stringify(value.value);
       case "expression":
+        return this.expressionValueToJs(value);
       case "spread":
         return value.expr;
       case "template":
@@ -2651,19 +2914,7 @@ export default ${this.componentName}` : "";
     }
   }
   renderTemplateLiteralParts(parts) {
-    let output = "`";
-    for (const part of parts) {
-      if (part.type === "string") {
-        output += part.value;
-      } else if (part.type === "ternary") {
-        output += `\${${part.condition} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
-      } else if (part.type === "lookup") {
-        const obj = "{" + Object.entries(part.cases).map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`).join(", ") + "}";
-        output += `\${(${obj})[${part.key}]}`;
-      }
-    }
-    output += "`";
-    return output;
+    return this.renderTemplatePartsAsJs(parts);
   }
 }
 var honoAdapter = new HonoAdapter;