@barefootjs/hono 0.30.6 → 0.31.1

package/dist/vite.js

@@ -0,0 +1,2749 @@
+// src/vite.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { barefoot as coreBarefoot } from "@barefootjs/vite";
+import { devModuleUrl, loadManifest, resolveDevOrigin, resolveScriptAssets, toPosixRelative } from "@barefootjs/vite";
+
+// ../jsx/src/analyzer.ts
+import ts8 from "typescript";
+
+// ../jsx/src/expression-parser.ts
+import ts from "typescript";
+var UNSUPPORTED_METHODS = new Set([
+  "filter",
+  "map",
+  "reduce",
+  "reduceRight",
+  "every",
+  "some",
+  "forEach",
+  "flatMap",
+  "fill",
+  "charAt",
+  "charCodeAt",
+  "codePointAt",
+  "normalize",
+  "substring",
+  "substr",
+  "match",
+  "matchAll",
+  "search"
+]);
+var UNSUPPORTED_METHOD_REASONS = {
+  forEach: `'.forEach()' returns undefined and has no template-position meaning. ` + `Use it for side effects inside an event handler or createEffect callback ` + `(client JS), or use '.map(...)' if you meant to render each item.`
+};
+var LOWERED_ARRAY_METHODS = new Set([
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "concat"
+]);
+var CALLBACK_METHODS = new Set([
+  "filter",
+  "map",
+  "every",
+  "some",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "sort",
+  "toSorted",
+  "reduce",
+  "reduceRight",
+  "flatMap"
+]);
+var IMPERATIVE_BLOCK_REASON = "Block body cannot be normalized to a value expression. Only pure " + "`const` bindings, value-producing `if` / early `return`, and a final " + "`return` are supported. Imperative shapes (raw `for` / `while` loops, " + "`break`, local re-assignment, side-effecting or I/O calls) are not. " + "Rewrite an accumulation loop as `.reduce(...)`, or move the imperative " + "body to a `/* @client */` value so it runs natively on the client.";
+var CAPTURE_BLOCK_REASON = "Block body cannot be normalized: inlining a `const` binding would capture " + "one of its free variables under a nested callback parameter of the same " + "name (e.g. `const x = a; … list.map(a => a + x)`). Rename the inner " + "parameter, or move the body to a `/* @client */` value so it runs natively " + "on the client.";
+var IMPURE_INLINE_BLOCK_REASON = "Block body cannot be normalized: a `const` whose initializer may have side " + "effects (a function or method call) is not used exactly once on every path, " + "so inlining it would drop the effect on some path or duplicate it on " + "another. Bind a pure value, use the binding exactly once unconditionally, " + "or move the body to a `/* @client */` value so it runs natively on the client.";
+var EVAL_BINARY_OPS = new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "===",
+  "!=="
+]);
+var EVAL_UNARY_OPS = new Set(["!", "-", "+"]);
+var EVAL_BUILTIN_IDENTS = new Set(["String", "Number", "Boolean"]);
+var EVAL_MATH_METHODS = new Set([
+  "max",
+  "min",
+  "abs",
+  "floor",
+  "ceil",
+  "round"
+]);
+
+// ../jsx/src/prop-rewrite.ts
+import ts5 from "typescript";
+
+// ../jsx/src/ir-to-client-js/utils.ts
+import ts3 from "typescript";
+
+// ../jsx/src/loop-chain.ts
+function buildLoopChainExpr(opts) {
+  const sortExpr = opts.sortComparator ? `.toSorted((${opts.sortComparator.paramA}, ${opts.sortComparator.paramB}) => ${opts.sortComparator.raw})` : "";
+  const filterExpr = opts.filterPredicate ? `.filter(${opts.filterPredicate.param} => ${opts.filterPredicate.raw})` : "";
+  if (!sortExpr && !filterExpr)
+    return opts.base;
+  if (opts.chainOrder === "filter-sort") {
+    return `${opts.base}${filterExpr}${sortExpr}`;
+  }
+  return `${opts.base}${sortExpr}${filterExpr}`;
+}
+
+// ../jsx/src/scanner/js-scanner.ts
+import ts2 from "typescript";
+
+// ../shared/src/markers.ts
+var BF_SCOPE = "bf-s";
+var BF_SLOT = "bf";
+var BF_HOST = "bf-h";
+var BF_AT = "bf-m";
+var BF_ROOT = "bf-r";
+var BF_PROPS = "bf-p";
+var BF_COND = "bf-c";
+var BF_REGION = "bf-region";
+// ../shared/src/dom-prop.ts
+var BOOLEAN_ATTRS = new Set([
+  "checked",
+  "disabled",
+  "readonly",
+  "selected",
+  "required",
+  "hidden",
+  "autofocus",
+  "autoplay",
+  "controls",
+  "loop",
+  "muted",
+  "open",
+  "multiple",
+  "novalidate",
+  "formnovalidate"
+]);
+var SVG_XML_CAMEL_ATTRS = new Set([
+  "allowReorder",
+  "attributeName",
+  "attributeType",
+  "autoReverse",
+  "baseFrequency",
+  "baseProfile",
+  "calcMode",
+  "clipPathUnits",
+  "contentScriptType",
+  "contentStyleType",
+  "diffuseConstant",
+  "edgeMode",
+  "externalResourcesRequired",
+  "filterRes",
+  "filterUnits",
+  "glyphRef",
+  "gradientTransform",
+  "gradientUnits",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keyPoints",
+  "keySplines",
+  "keyTimes",
+  "lengthAdjust",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerUnits",
+  "markerWidth",
+  "maskContentUnits",
+  "maskUnits",
+  "numOctaves",
+  "pathLength",
+  "patternContentUnits",
+  "patternTransform",
+  "patternUnits",
+  "pointsAtX",
+  "pointsAtY",
+  "pointsAtZ",
+  "preserveAlpha",
+  "preserveAspectRatio",
+  "primitiveUnits",
+  "refX",
+  "refY",
+  "repeatCount",
+  "repeatDur",
+  "requiredExtensions",
+  "requiredFeatures",
+  "specularConstant",
+  "specularExponent",
+  "spreadMethod",
+  "startOffset",
+  "stdDeviation",
+  "stitchTiles",
+  "surfaceScale",
+  "systemLanguage",
+  "tableValues",
+  "targetX",
+  "targetY",
+  "textLength",
+  "viewBox",
+  "viewTarget",
+  "xChannelSelector",
+  "yChannelSelector",
+  "zoomAndPan"
+]);
+function isBooleanAttr(name) {
+  return BOOLEAN_ATTRS.has(name.toLowerCase());
+}
+// ../shared/src/html-entities.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+// ../jsx/src/ir-to-client-js/csr-substitute.ts
+import ts4 from "typescript";
+
+// ../jsx/src/ir-to-client-js/html-template.ts
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SKELETON_PATH_HAZARD_TAGS = new Set([
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "caption",
+  "colgroup",
+  "col",
+  "select",
+  "optgroup",
+  "p",
+  "pre",
+  "textarea",
+  "listing",
+  "template",
+  "math"
+]);
+var SKELETON_PATH_FORCE_CLOSE_GROUPS = [
+  new Set(["a"]),
+  new Set(["button"]),
+  new Set(["form"]),
+  new Set(["option"]),
+  new Set(["h1", "h2", "h3", "h4", "h5", "h6"]),
+  new Set(["dd", "dt"]),
+  new Set(["li"])
+];
+
+// ../jsx/src/instrumentation.ts
+var _counters = freshCounters();
+function freshCounters() {
+  return {
+    programCreations: 0,
+    typeCheckerQueries: 0,
+    reactivityChecks: 0,
+    filesAnalyzed: 0,
+    freeRefsTypeLookupFailures: 0
+  };
+}
+
+// ../jsx/src/analyzer-context.ts
+import ts7 from "typescript";
+
+// ../jsx/src/strip-types.ts
+import ts6 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);
+
+// ../jsx/src/errors.ts
+var ErrorCodes = {
+  MISSING_USE_CLIENT: "BF001",
+  CLIENT_IMPORTING_SERVER: "BF003",
+  SIGNAL_OUTSIDE_COMPONENT: "BF011",
+  UNSUPPORTED_JSX_PATTERN: "BF021",
+  MISSING_KEY_IN_LIST: "BF023",
+  MISSING_KEY_IN_NESTED_LIST: "BF024",
+  UNSUPPORTED_DESTRUCTURE_REST: "BF025",
+  PROPS_DESTRUCTURING: "BF043",
+  SIGNAL_GETTER_NOT_CALLED: "BF044",
+  JSX_IN_LOCAL_FUNCTION: "BF045",
+  COMPONENT_REQUIRED_PROP_MISSING: "BF046",
+  JSX_BRANCH_LOCAL_IN_CALLBACK: "BF047",
+  SHARED_PROGRAM_REQUIRED: "BF050",
+  WRONG_PACKAGE_IMPORT: "BF051",
+  BUILTIN_REQUIRES_IMPORT: "BF054",
+  INLINED_IMPORT_MISSING_EXPORT: "BF055",
+  UNDECLARED_INIT_STATEMENT_REFERENCE: "BF052",
+  STRIPPED_CLIENT_IMPORT_REFERENCED: "BF053",
+  STAGE_REACTIVE_IN_TEMPLATE: "BF060",
+  STAGE_INIT_LOCAL_IN_TEMPLATE: "BF061",
+  STAGE_AWAIT_IN_TEMPLATE: "BF062",
+  INLINE_JSX_CALLBACK_CAPTURE: "BF080",
+  UNRECOGNIZED_REACTIVE_FACTORY: "BF110",
+  REACTIVE_FACTORY_RENAME_UNSUPPORTED: "BF111",
+  REACTIVE_FACTORY_MODULE_CAPTURE: "BF112",
+  REACTIVE_FACTORY_IMPORT_COLLISION: "BF113",
+  REACTIVE_FACTORY_PARAM_SHADOWED: "BF114"
+};
+var errorMessages = {
+  [ErrorCodes.MISSING_USE_CLIENT]: "'use client' directive required for components with createSignal or event handlers",
+  [ErrorCodes.CLIENT_IMPORTING_SERVER]: "Client component cannot import server component",
+  [ErrorCodes.SIGNAL_OUTSIDE_COMPONENT]: "Module-level reactive declaration (createSignal / createMemo) is not allowed. " + "The downstream codegen drops the declaration silently and every reference becomes a ReferenceError at SSR and at hydrate. " + "Move the declaration inside a component function so each mount gets its own state.",
+  [ErrorCodes.UNSUPPORTED_JSX_PATTERN]: "Unsupported JSX pattern",
+  [ErrorCodes.MISSING_KEY_IN_LIST]: "Missing key attribute in list rendering. Add a key prop for efficient updates",
+  [ErrorCodes.MISSING_KEY_IN_NESTED_LIST]: "Nested .map() loop requires key attribute for event delegation. Add a key prop to elements in the inner loop",
+  [ErrorCodes.UNSUPPORTED_DESTRUCTURE_REST]: "Computed property key in .map() callback destructure is not supported. Rewrite the callback to destructure explicit bindings (e.g., `({ a, b }) => ...`) so the compiler can rewrite references to per-item signal accessors.",
+  [ErrorCodes.PROPS_DESTRUCTURING]: "Props destructuring in function parameters breaks reactivity. Use props object directly.",
+  [ErrorCodes.SIGNAL_GETTER_NOT_CALLED]: "Signal/memo getter passed without calling it. Use getter() to read the value.",
+  [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.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.",
+  [ErrorCodes.UNDECLARED_INIT_STATEMENT_REFERENCE]: "Init statement references an undeclared identifier. Declare it at module scope, inside the component, or import it — 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 — 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 — 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.",
+  [ErrorCodes.INLINE_JSX_CALLBACK_CAPTURE]: "Inline JSX-returning arrow function captures a non-module identifier. Extract the callback into a top-level 'use client' component (e.g. `function MyNode(n) { return <div/> }` then `renderNode={MyNode}`) or pass captured values via component props.",
+  [ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY]: "Tuple destructuring of a non-reactive factory call. The compiler only recognizes createSignal / createMemo calls and same-file helpers that wrap them with a single `return [a, b]` exit.",
+  [ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED]: "Reactive factory object return/destructure must use shorthand properties only. " + "Property renames (`{ lists: myLists }`), defaults, and rest elements are not " + "supported — destructure with the factory's own property names.",
+  [ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE]: "Imported reactive factory references bindings from its own module scope, so its " + "body cannot be inlined into the component file. Move those helpers into the " + "component file, pass them to the factory as parameters, or define the factory " + "in the component file.",
+  [ErrorCodes.REACTIVE_FACTORY_IMPORT_COLLISION]: "Inlining an imported reactive factory requires re-importing one of its helper " + "imports into this file, but that name is already bound here to something else. " + "Rename the conflicting binding in this file, or alias the import in the factory's own file.",
+  [ErrorCodes.REACTIVE_FACTORY_PARAM_SHADOWED]: "Reactive factory parameter is shadowed by a nested declaration inside the factory body, so argument substitution at the inline site would be ambiguous. Rename the inner binding so it does not collide with the parameter."
+};
+
+// ../jsx/src/rich-type-evidence.ts
+var HOST_RICH_TYPE_NAMES = new Set([
+  "Date",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "URL",
+  "URLSearchParams",
+  "RegExp",
+  "Promise",
+  "Error",
+  "Symbol",
+  "BigInt",
+  "Function"
+]);
+function baseTypeName(raw) {
+  const idx = raw.indexOf("<");
+  return (idx === -1 ? raw : raw.slice(0, idx)).trim();
+}
+function isNullishArm(t) {
+  return t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined");
+}
+function stripUnion(type) {
+  if (!type || type.kind !== "union" || !type.unionTypes)
+    return type;
+  const nonNullish = type.unionTypes.filter((t) => !isNullishArm(t));
+  return nonNullish.length === 1 ? stripUnion(nonNullish[0]) : type;
+}
+function derefNamedType(type, meta) {
+  if (type.kind !== "interface")
+    return type;
+  if (type.properties && type.properties.length > 0)
+    return type;
+  const name = baseTypeName(type.raw);
+  const def = meta.typeDefinitions.find((d) => d.name === name);
+  if (!def?.properties)
+    return type;
+  return { ...type, properties: def.properties };
+}
+function lookupProperty(objType, propName, meta) {
+  const stripped = stripUnion(objType);
+  if (!stripped)
+    return null;
+  const deref = derefNamedType(stripped, meta);
+  const prop = deref.properties?.find((p) => p.name === propName);
+  return prop ? stripUnion(prop.type) : null;
+}
+function resolveReceiverType(expr, meta, bindings) {
+  if (expr.kind === "identifier") {
+    if (bindings.has(expr.name))
+      return stripUnion(bindings.get(expr.name) ?? null);
+    if (meta.propsObjectName !== null) {
+      return expr.name === meta.propsObjectName ? stripUnion(meta.propsType) : null;
+    }
+    const param = meta.propsParams.find((p) => p.name === expr.name && !p.isRest);
+    if (!param)
+      return null;
+    return lookupProperty(meta.propsType, param.sourceName ?? param.name, meta);
+  }
+  if (expr.kind === "member" && !expr.computed) {
+    const objType = resolveReceiverType(expr.object, meta, bindings);
+    return lookupProperty(objType, expr.property, meta);
+  }
+  return null;
+}
+
+// ../jsx/src/date-lowering.ts
+var CATALOGUED_RICH_TYPE_NAMES = new Set(["Date"]);
+var DATE_METHODS = new Set([
+  "getUTCFullYear",
+  "getUTCMonth",
+  "getUTCDate",
+  "getUTCHours",
+  "getUTCMinutes",
+  "getUTCSeconds",
+  "getTime",
+  "toISOString"
+]);
+var EMPTY_BINDINGS = new Map;
+function typeReachesDate(type, meta, seen) {
+  const stripped = stripUnion(type);
+  if (!stripped)
+    return false;
+  if (stripped.kind === "interface") {
+    const name = baseTypeName(stripped.raw);
+    if (name === "Date")
+      return true;
+    if (seen.has(name))
+      return false;
+    seen.add(name);
+  } else if (stripped.kind !== "object") {
+    return false;
+  }
+  const deref = derefNamedType(stripped, meta);
+  if (!deref.properties)
+    return false;
+  return deref.properties.some((p) => typeReachesDate(p.type, meta, seen));
+}
+function matchDateCall(callee, args, metadata) {
+  if (callee.kind !== "member" || callee.computed)
+    return null;
+  if (args.length !== 0 || !DATE_METHODS.has(callee.property))
+    return null;
+  const receiverType = resolveReceiverType(callee.object, metadata, EMPTY_BINDINGS);
+  if (!receiverType || receiverType.kind !== "interface")
+    return null;
+  const typeName = baseTypeName(receiverType.raw);
+  if (typeName !== "Date")
+    return null;
+  if (metadata.typeDefinitions.some((d) => d.name === typeName))
+    return null;
+  return {
+    kind: "helper-call",
+    helper: "date",
+    args: [callee.object, { kind: "literal", value: callee.property, literalType: "string" }]
+  };
+}
+var datePlugin = {
+  name: "date",
+  prepare(metadata) {
+    if (!metadata.propsType || !typeReachesDate(metadata.propsType, metadata, new Set))
+      return null;
+    return (callee, args) => matchDateCall(callee, args, metadata);
+  }
+};
+
+// ../jsx/src/analyzer.ts
+var CLIENT_EXPORTS = new Set([
+  "createSignal",
+  "createEffect",
+  "createDisposableEffect",
+  "createMemo",
+  "createSelector",
+  "createRoot",
+  "onCleanup",
+  "onMount",
+  "untrack",
+  "batch",
+  "splitProps",
+  "forwardProps",
+  "unwrap",
+  "__slot",
+  "createContext",
+  "useContext",
+  "provideContext",
+  "createPortal",
+  "isSSRPortal",
+  "findSiblingSlot",
+  "cleanupPortalPlaceholder",
+  "createSearchParams",
+  "queryHref",
+  "formatDate",
+  "Async",
+  "Region"
+]);
+var BROWSER_ONLY_CLIENT_APIS = new Set([
+  "useContext",
+  "provideContext",
+  "createPortal",
+  "isSSRPortal",
+  "findSiblingSlot",
+  "cleanupPortalPlaceholder"
+]);
+var REACTIVE_PRIMITIVES = new Set([
+  "createSignal",
+  "createMemo",
+  "createEffect",
+  "createDisposableEffect",
+  "onMount",
+  "onCleanup"
+]);
+
+// ../jsx/src/jsx-to-ir.ts
+import ts11 from "typescript";
+
+// ../jsx/src/types.ts
+var SCOPE_FORBIDDEN = {
+  module: new Set([
+    "prop",
+    "signal-getter",
+    "signal-setter",
+    "memo-getter",
+    "reactive-brand",
+    "init-local",
+    "sub-init-local",
+    "render-item"
+  ]),
+  init: new Set([]),
+  template: new Set([
+    "prop",
+    "signal-getter",
+    "signal-setter",
+    "memo-getter",
+    "reactive-brand",
+    "init-local",
+    "sub-init-local",
+    "render-item"
+  ]),
+  "sub-init": new Set([]),
+  "render-item": new Set([])
+};
+var REACTIVE_BINDING_KINDS = new Set([
+  "prop",
+  "signal-getter",
+  "memo-getter",
+  "reactive-brand"
+]);
+
+// ../jsx/src/module-exports.ts
+function formatParamWithType(p) {
+  const rest = p.isRest ? "..." : "";
+  const optional = p.optional ? "?" : "";
+  const typeAnnotation = p.type?.raw && p.type.raw !== "unknown" ? `: ${p.type.raw}` : "";
+  const defaultPart = p.defaultValue !== undefined ? ` = ${p.defaultValue}` : "";
+  return `${rest}${p.name}${optional}${typeAnnotation}${defaultPart}`;
+}
+function findReachableNames(primaryRefs, declarations) {
+  const allNames = new Set(declarations.map((d) => d.name));
+  const bodyMap = new Map(declarations.map((d) => [d.name, d.body]));
+  const reachable = new Set;
+  const queue = [];
+  for (const name of allNames) {
+    if (new RegExp(`\\b${name}\\b`).test(primaryRefs)) {
+      reachable.add(name);
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const body = bodyMap.get(current) || "";
+    for (const name of allNames) {
+      if (!reachable.has(name) && new RegExp(`\\b${name}\\b`).test(body)) {
+        reachable.add(name);
+        queue.push(name);
+      }
+    }
+  }
+  return reachable;
+}
+
+// ../jsx/src/reactivity-checker.ts
+import ts9 from "typescript";
+
+// ../jsx/src/free-refs.ts
+import ts10 from "typescript";
+var _bindingMapCache = new WeakMap;
+
+// ../jsx/src/to-locale-date-lowering.ts
+var TO_LOCALE_TZ_RE = /^(?:UTC|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+var tzProbeCache = new Map;
+function isBuildResolvableTimeZone(value) {
+  const cached = tzProbeCache.get(value);
+  if (cached !== undefined)
+    return cached;
+  let verified;
+  try {
+    verified = new Intl.DateTimeFormat("en-US", { timeZone: value }).resolvedOptions().timeZone === value;
+  } catch {
+    verified = false;
+  }
+  tzProbeCache.set(value, verified);
+  return verified;
+}
+var PROBE_UTC = new Date(Date.UTC(2001, 1, 3));
+var formatCache = new Map;
+var namesCache = new Map;
+function deriveMonthNames(locale, ctx) {
+  return deriveNamesCached(`${locale}|m|${ctx}`, () => {
+    const months = (width) => Array.from({ length: 12 }, (_, m) => probePart(locale, ctx === "formatting" ? { month: width, day: "numeric" } : { month: width }, Date.UTC(2001, m, 15), "month"));
+    return [...months("long"), ...months("short")];
+  });
+}
+function deriveWeekdayNames(locale, ctx) {
+  return deriveNamesCached(`${locale}|w|${ctx}`, () => {
+    const weekdays = (width) => Array.from({ length: 7 }, (_, d) => probePart(locale, ctx === "formatting" ? { weekday: width, month: "numeric", day: "numeric" } : { weekday: width }, Date.UTC(2023, 0, 1 + d), "weekday"));
+    return [...weekdays("long"), ...weekdays("short")];
+  });
+}
+function probePart(locale, options, utc, type) {
+  const parts = new Intl.DateTimeFormat(locale, { ...options, timeZone: "UTC" }).formatToParts(new Date(utc));
+  const found = parts.find((p) => p.type === type);
+  if (!found || !found.value)
+    throw new Error("missing part");
+  return found.value;
+}
+function deriveNamesCached(key, derive) {
+  const cached = namesCache.get(key);
+  if (cached !== undefined)
+    return cached;
+  let derived;
+  try {
+    derived = derive();
+  } catch {
+    derived = null;
+  }
+  namesCache.set(key, derived);
+  return derived;
+}
+function resolveLocaleDateFormat(locale, probeOptions) {
+  const key = `${locale}|${JSON.stringify(probeOptions, Object.keys(probeOptions).sort())}`;
+  const cached = formatCache.get(key);
+  if (cached !== undefined)
+    return cached;
+  const derived = deriveFormat(locale, probeOptions);
+  formatCache.set(key, derived);
+  return derived;
+}
+var VERIFY_UTC = new Date(Date.UTC(2001, 4, 13));
+function renderPatternAt(pattern, names, y, m, d, wd) {
+  const pad2 = (n) => String(n).padStart(2, "0");
+  return pattern.replace(/YYYY|MMMM|MMM|MM|DD|dddd|ddd|M|D/g, (token) => {
+    switch (token) {
+      case "YYYY":
+        return String(y).padStart(4, "0");
+      case "MMMM":
+        return names[m - 1] ?? "";
+      case "MMM":
+        return names[12 + m - 1] ?? "";
+      case "MM":
+        return pad2(m);
+      case "M":
+        return String(m);
+      case "DD":
+        return pad2(d);
+      case "D":
+        return String(d);
+      case "dddd":
+        return names[24 + wd] ?? "";
+      default:
+        return names[31 + wd] ?? "";
+    }
+  });
+}
+function deriveFormat(locale, probeOptions) {
+  let dtf;
+  let parts;
+  try {
+    dtf = new Intl.DateTimeFormat(locale, {
+      ...probeOptions,
+      timeZone: "UTC"
+    });
+    const resolved = dtf.resolvedOptions();
+    if (resolved.calendar !== "gregory" || resolved.numberingSystem !== "latn")
+      return null;
+    parts = dtf.formatToParts(PROBE_UTC);
+  } catch {
+    return null;
+  }
+  const monthTables = [
+    deriveMonthNames(locale, "formatting"),
+    deriveMonthNames(locale, "standalone")
+  ];
+  const weekdayTables = [
+    deriveWeekdayNames(locale, "formatting"),
+    deriveWeekdayNames(locale, "standalone")
+  ];
+  let monthTable = null;
+  let weekdayTable = null;
+  let pattern = "";
+  let usesNames = false;
+  for (const part of parts) {
+    switch (part.type) {
+      case "year":
+        if (part.value !== "2001")
+          return null;
+        pattern += "YYYY";
+        break;
+      case "month": {
+        if (part.value === "2") {
+          pattern += "M";
+          break;
+        }
+        if (part.value === "02") {
+          pattern += "MM";
+          break;
+        }
+        const wide = monthTables.find((t) => t && part.value === t[1]) ?? null;
+        const abbr = wide ? null : monthTables.find((t) => t && part.value === t[12 + 1]) ?? null;
+        if (wide)
+          pattern += "MMMM";
+        else if (abbr)
+          pattern += "MMM";
+        else
+          return null;
+        monthTable = wide ?? abbr;
+        usesNames = true;
+        break;
+      }
+      case "day":
+        if (part.value === "3")
+          pattern += "D";
+        else if (part.value === "03")
+          pattern += "DD";
+        else
+          return null;
+        break;
+      case "weekday": {
+        const wide = weekdayTables.find((t) => t && part.value === t[6]) ?? null;
+        const abbr = wide ? null : weekdayTables.find((t) => t && part.value === t[7 + 6]) ?? null;
+        if (wide)
+          pattern += "dddd";
+        else if (abbr)
+          pattern += "ddd";
+        else
+          return null;
+        weekdayTable = wide ?? abbr;
+        usesNames = true;
+        break;
+      }
+      case "literal":
+        if (/[YMD]/.test(part.value) || /ddd/.test(part.value))
+          return null;
+        pattern += part.value;
+        break;
+      default:
+        return null;
+    }
+  }
+  if (!/YYYY|MMMM|MMM|MM|M/.test(pattern) && !/DD|D/.test(pattern))
+    return null;
+  if (!usesNames)
+    return { pattern, names: null };
+  const names = [
+    ...monthTable ?? monthTables[0] ?? monthTables[1] ?? Array(24).fill(""),
+    ...weekdayTable ?? weekdayTables[0] ?? weekdayTables[1] ?? Array(14).fill("")
+  ];
+  if (renderPatternAt(pattern, names, 2001, 5, 13, 0) !== dtf.format(VERIFY_UTC))
+    return null;
+  return { pattern, names };
+}
+function unionMemberLiteral(member) {
+  if (member.kind === "primitive" && member.primitive === "string" && member.literalValue !== undefined) {
+    return member.literalValue;
+  }
+  return null;
+}
+function resolveLocaleUnionMembers(locale, metadata) {
+  let sourcePropName = null;
+  if (metadata.propsObjectName) {
+    if (locale.kind === "member" && !locale.computed && locale.object.kind === "identifier" && locale.object.name === metadata.propsObjectName) {
+      sourcePropName = locale.property;
+    }
+  } else if (locale.kind === "identifier") {
+    const name = locale.name;
+    const param = metadata.propsParams?.find((pp) => pp.name === name);
+    if (param)
+      sourcePropName = param.sourceName ?? param.name;
+  }
+  if (!sourcePropName)
+    return null;
+  const target = sourcePropName;
+  const prop = metadata.propsType?.properties?.find((p) => p.name === target);
+  if (!prop || prop.optional)
+    return null;
+  const type = prop.type;
+  if (type.kind !== "union" || !type.unionTypes || type.unionTypes.length === 0)
+    return null;
+  const members = [];
+  for (const member of type.unionTypes) {
+    const value = unionMemberLiteral(member);
+    if (value === null)
+      return null;
+    members.push(value);
+  }
+  return members;
+}
+var strLit = (value) => ({ kind: "literal", value, literalType: "string" });
+function strArr(values) {
+  return {
+    kind: "array-literal",
+    elements: values.map((v) => strLit(v)),
+    raw: JSON.stringify(values)
+  };
+}
+function foldMembers(locale, members, leaves, allEqual) {
+  let expr = leaves[leaves.length - 1];
+  if (allEqual)
+    return expr;
+  for (let i = leaves.length - 2;i >= 0; i--) {
+    expr = {
+      kind: "conditional",
+      test: { kind: "binary", op: "===", left: locale, right: strLit(members[i]) },
+      consequent: leaves[i],
+      alternate: expr
+    };
+  }
+  return expr;
+}
+function matchToLocaleDateStringCall(callee, args, metadata) {
+  if (callee.kind !== "member" || callee.computed)
+    return null;
+  if (callee.property !== "toLocaleDateString" || args.length !== 2)
+    return null;
+  const [locale, options] = args;
+  if (options.kind !== "object-literal")
+    return null;
+  let tz = null;
+  const probeOptions = {};
+  for (const prop of options.properties) {
+    if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
+      return null;
+    const value = String(prop.value.value);
+    if (prop.key === "timeZone") {
+      if (!TO_LOCALE_TZ_RE.test(value) && !isBuildResolvableTimeZone(value))
+        return null;
+      tz = value;
+    } else {
+      probeOptions[prop.key] = value;
+    }
+  }
+  if (tz === null)
+    return null;
+  const receiverType = resolveReceiverType(callee.object, metadata, new Map);
+  if (!receiverType || receiverType.kind !== "interface")
+    return null;
+  const typeName = baseTypeName(receiverType.raw);
+  if (typeName !== "Date")
+    return null;
+  if (metadata.typeDefinitions.some((d) => d.name === typeName))
+    return null;
+  if (locale.kind === "literal" && locale.literalType === "string") {
+    const format = resolveLocaleDateFormat(String(locale.value), probeOptions);
+    if (format === null)
+      return null;
+    return {
+      kind: "helper-call",
+      helper: "format_date",
+      args: [callee.object, strLit(format.pattern), strLit(tz), strArr(format.names ?? [])]
+    };
+  }
+  const members = resolveLocaleUnionMembers(locale, metadata);
+  if (!members)
+    return null;
+  const formats = [];
+  for (const member of members) {
+    const format = resolveLocaleDateFormat(member, probeOptions);
+    if (format === null)
+      return null;
+    formats.push(format);
+  }
+  const patterns = formats.map((f) => f.pattern);
+  const nameTables = formats.map((f) => JSON.stringify(f.names ?? []));
+  return {
+    kind: "helper-call",
+    helper: "format_date",
+    args: [
+      callee.object,
+      foldMembers(locale, members, patterns.map(strLit), new Set(patterns).size === 1),
+      strLit(tz),
+      foldMembers(locale, members, formats.map((f) => strArr(f.names ?? [])), new Set(nameTables).size === 1)
+    ]
+  };
+}
+var toLocaleDatePlugin = {
+  name: "toLocaleDateString",
+  prepare(metadata) {
+    if (!metadata.propsType || !typeReachesDate(metadata.propsType, metadata, new Set))
+      return null;
+    return (callee, args) => matchToLocaleDateStringCall(callee, args, metadata);
+  }
+};
+
+// ../jsx/src/jsx-to-ir.ts
+var EMPTY_BOUND = new Set;
+var constInitializerCache = new WeakMap;
+var functionInfoExprCache = new WeakMap;
+
+// ../jsx/src/ir-to-client-js/control-flow/stringify/template-parse.ts
+var SVG_ROOT_TAGS = new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "text",
+  "tspan",
+  "textPath",
+  "g",
+  "defs",
+  "use",
+  "symbol",
+  "switch",
+  "clipPath",
+  "mask",
+  "marker",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "image",
+  "foreignObject",
+  "filter",
+  "feBlend",
+  "feColorMatrix",
+  "feComposite",
+  "feFlood",
+  "feGaussianBlur",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "feTurbulence",
+  "animate",
+  "animateTransform",
+  "animateMotion"
+]);
+
+// ../jsx/src/ir-to-client-js/collect-elements.ts
+var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
+
+// ../jsx/src/ir-to-client-js/identifiers.ts
+var KEYWORDS_AND_GLOBALS = new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "this",
+  "const",
+  "let",
+  "var",
+  "function",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "new",
+  "typeof",
+  "instanceof",
+  "void",
+  "delete",
+  "console",
+  "window",
+  "document",
+  "Math",
+  "String",
+  "Number",
+  "Array",
+  "Object",
+  "Boolean",
+  "Date",
+  "JSON",
+  "Promise",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval"
+]);
+
+// ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
+import ts12 from "typescript";
+
+// ../jsx/src/value-references.ts
+import ts13 from "typescript";
+
+// ../jsx/src/relocate.ts
+import ts14 from "typescript";
+
+// ../jsx/src/lowering-registry.ts
+var plugins = [];
+function registerLoweringPlugin(plugin) {
+  const existing = plugins.findIndex((p) => p.name === plugin.name);
+  if (existing >= 0)
+    plugins[existing] = plugin;
+  else
+    plugins.push(plugin);
+}
+
+// ../jsx/src/relocate.ts
+var REGISTRY_SAFE_BINDING_KINDS = new Set([
+  "global",
+  "module-import",
+  "module-local"
+]);
+var RESERVED_WORDS = new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "void",
+  "typeof",
+  "instanceof",
+  "new",
+  "delete",
+  "in",
+  "of",
+  "this",
+  "super",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "default",
+  "break",
+  "continue",
+  "function",
+  "class",
+  "const",
+  "let",
+  "var",
+  "async",
+  "await",
+  "try",
+  "catch",
+  "finally",
+  "throw"
+]);
+
+// ../jsx/src/ir-to-client-js/compute-inlinability.ts
+var JS_BUILTINS = new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity",
+  "typeof",
+  "instanceof",
+  "void",
+  "delete",
+  "new",
+  "in",
+  "of",
+  "this",
+  "super",
+  "return",
+  "throw",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "try",
+  "catch",
+  "finally",
+  "yield",
+  "await",
+  "async",
+  "let",
+  "const",
+  "var",
+  "function",
+  "class",
+  "Math",
+  "JSON",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Date",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "console",
+  "window",
+  "document",
+  "globalThis",
+  "navigator",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  "setTimeout",
+  "clearTimeout",
+  "setInterval",
+  "clearInterval",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "Symbol",
+  "Proxy",
+  "Reflect",
+  "BigInt"
+]);
+
+// ../jsx/src/adapters/env-signal.ts
+var ENV_SIGNAL_CLIENT_FACTORY = {
+  search: "createSearchParams"
+};
+var ENV_SIGNAL_READERS = new Map([
+  ["search", { key: "search", canonicalName: "searchParams", methods: new Set(["get"]) }]
+]);
+function queryHrefLocalNames(metadata) {
+  const names = new Set;
+  for (const imp of metadata.imports) {
+    if (!CLIENT_HELPER_SOURCES.has(imp.source) || imp.isTypeOnly)
+      continue;
+    for (const s of imp.specifiers) {
+      if (s.isTypeOnly || s.isNamespace || s.isDefault)
+        continue;
+      if (s.name === "queryHref")
+        names.add(s.alias ?? s.name);
+    }
+  }
+  return names;
+}
+var CLIENT_HELPER_SOURCES = new Set([
+  "@barefootjs/client",
+  "@barefootjs/client/runtime"
+]);
+function formatDateLocalNames(metadata) {
+  const names = new Set;
+  for (const imp of metadata.imports) {
+    if (!CLIENT_HELPER_SOURCES.has(imp.source) || imp.isTypeOnly)
+      continue;
+    for (const s of imp.specifiers) {
+      if (s.isTypeOnly || s.isNamespace || s.isDefault)
+        continue;
+      if (s.name === "formatDate")
+        names.add(s.alias ?? s.name);
+    }
+  }
+  return names;
+}
+
+// ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
+import ts15 from "typescript";
+
+// ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
+import ts16 from "typescript";
+var NO_PREAMBLE = {
+  lazySafe: true,
+  facts: { declaredNames: new Set, freeNames: new Set }
+};
+
+// ../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
+var PURE_SOURCE_GLOBALS = new Set([
+  "Object",
+  "Array",
+  "JSON",
+  "Number",
+  "String",
+  "Boolean"
+]);
+var INERT_BINDING_GLOBALS = 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"
+]);
+
+// ../jsx/src/ir-to-client-js/emit-reactive.ts
+import ts17 from "typescript";
+
+// ../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts
+var NON_BUBBLING_EVENTS = new Set([
+  "blur",
+  "focus",
+  "load",
+  "unload",
+  "mouseenter",
+  "mouseleave",
+  "pointerenter",
+  "pointerleave"
+]);
+
+// ../jsx/src/ir-to-client-js/rewrite-props-object.ts
+import ts18 from "typescript";
+
+// ../jsx/src/ir-to-client-js/source-map.ts
+var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeVLQ(value) {
+  let vlq = value < 0 ? (-value << 1) + 1 : value << 1;
+  let encoded = "";
+  do {
+    let digit = vlq & 31;
+    vlq >>>= 5;
+    if (vlq > 0)
+      digit |= 32;
+    encoded += BASE64_CHARS[digit];
+  } while (vlq > 0);
+  return encoded;
+}
+
+class SourceMapGenerator {
+  sources = [];
+  sourcesContent = [];
+  sourceIndexMap = new Map;
+  mappings = [];
+  file;
+  constructor(generatedFile) {
+    this.file = generatedFile;
+  }
+  addSource(sourcePath, content) {
+    const existing = this.sourceIndexMap.get(sourcePath);
+    if (existing !== undefined)
+      return existing;
+    const index = this.sources.length;
+    this.sources.push(sourcePath);
+    this.sourcesContent.push(content ?? null);
+    this.sourceIndexMap.set(sourcePath, index);
+    return index;
+  }
+  addMappingFromLoc(generatedLine, generatedColumn, loc) {
+    const sourceIndex = this.addSource(loc.file);
+    this.mappings.push({
+      generatedLine,
+      generatedColumn,
+      sourceIndex,
+      originalLine: loc.start.line - 1,
+      originalColumn: loc.start.column
+    });
+  }
+  toJSON() {
+    return {
+      version: 3,
+      file: this.file,
+      sourceRoot: "",
+      sources: this.sources,
+      sourcesContent: this.sourcesContent,
+      names: [],
+      mappings: this.encodeMappings()
+    };
+  }
+  toString() {
+    return JSON.stringify(this.toJSON());
+  }
+  encodeMappings() {
+    const sorted = [...this.mappings].sort((a, b) => a.generatedLine - b.generatedLine || a.generatedColumn - b.generatedColumn);
+    const lines = [];
+    let prevGeneratedColumn = 0;
+    let prevSourceIndex = 0;
+    let prevOriginalLine = 0;
+    let prevOriginalColumn = 0;
+    let prevGeneratedLine = 0;
+    for (const mapping of sorted) {
+      while (lines.length <= mapping.generatedLine) {
+        lines.push([]);
+        if (lines.length > 1) {
+          prevGeneratedColumn = 0;
+        }
+      }
+      if (mapping.generatedLine !== prevGeneratedLine) {
+        prevGeneratedColumn = 0;
+        prevGeneratedLine = mapping.generatedLine;
+      }
+      const segment = encodeVLQ(mapping.generatedColumn - prevGeneratedColumn) + encodeVLQ(mapping.sourceIndex - prevSourceIndex) + encodeVLQ(mapping.originalLine - prevOriginalLine) + encodeVLQ(mapping.originalColumn - prevOriginalColumn);
+      lines[mapping.generatedLine].push(segment);
+      prevGeneratedColumn = mapping.generatedColumn;
+      prevSourceIndex = mapping.sourceIndex;
+      prevOriginalLine = mapping.originalLine;
+      prevOriginalColumn = mapping.originalColumn;
+    }
+    return lines.map((segments) => segments.join(",")).join(";");
+  }
+}
+
+// ../jsx/src/preprocess-inline-jsx-callbacks.ts
+import ts19 from "typescript";
+
+// ../jsx/src/ssr-defaults.ts
+import ts20 from "typescript";
+var UNRESOLVED = Symbol("unresolved");
+var NO_RETURN = Symbol("no-return");
+
+// ../jsx/src/augment-inherited-props.ts
+import ts21 from "typescript";
+
+// ../jsx/src/rich-type-refusal.ts
+var EMPTY_BINDINGS2 = new Map;
+// ../jsx/src/shared-program.ts
+import ts22 from "typescript";
+// ../jsx/src/adapters/interface.ts
+class BaseAdapter {
+  renderChildren(children) {
+    return children.map((child) => this.renderNode(child)).join("");
+  }
+  renderAsync(node) {
+    return this.renderNode(node.fallback) + this.renderChildren(node.children);
+  }
+}
+// ../jsx/src/adapters/jsx-adapter.ts
+class JsxAdapter extends BaseAdapter {
+  componentName = "";
+  acceptsCallbackBody = () => true;
+  formatImportSpecifiers(specifiers) {
+    const defaultSpec = specifiers.find((s) => s.isDefault);
+    const namespaceSpec = specifiers.find((s) => s.isNamespace);
+    const namedSpecs = specifiers.filter((s) => !s.isDefault && !s.isNamespace);
+    const parts = [];
+    if (defaultSpec) {
+      parts.push(defaultSpec.alias || defaultSpec.name);
+    }
+    if (namespaceSpec) {
+      parts.push(`* as ${namespaceSpec.name}`);
+    }
+    if (namedSpecs.length > 0) {
+      const named = namedSpecs.map((s) => s.alias ? `${s.name} as ${s.alias}` : s.name).join(", ");
+      parts.push(`{ ${named} }`);
+    }
+    return parts.join(", ");
+  }
+  generateSignalInitializers(ir, jsxBody) {
+    const lines = [];
+    const { preserveTypes } = this.jsxConfig;
+    const primaryRefs = [jsxBody];
+    for (const signal of ir.metadata.signals) {
+      if (signal.isModule)
+        continue;
+      primaryRefs.push(signal.initialValue);
+    }
+    for (const memo of ir.metadata.memos) {
+      if (memo.isModule)
+        continue;
+      primaryRefs.push(memo.computation);
+    }
+    const primaryRefText = primaryRefs.join(`
+`);
+    const localFunctions = ir.metadata.localFunctions.filter((f) => !f.isExported);
+    const localConstants = ir.metadata.localConstants.filter((c) => !c.isExported && c.value);
+    const declarations = [
+      ...localFunctions.map((f) => ({ name: f.name, body: f.body })),
+      ...localConstants.map((c) => ({ name: c.name, body: c.value }))
+    ];
+    const reachable = findReachableNames(primaryRefText, declarations);
+    const reachableBodies = [...reachable].map((name) => {
+      const func = localFunctions.find((f) => f.name === name);
+      if (func)
+        return func.body;
+      const constant = localConstants.find((c) => c.name === name);
+      return constant?.value ?? "";
+    }).join(`
+`);
+    const setterRefText = primaryRefText + `
+` + reachableBodies;
+    for (const signal of ir.metadata.signals) {
+      if (signal.isModule)
+        continue;
+      if (signal.envReader) {
+        const factory = signal.envFactory ?? ENV_SIGNAL_CLIENT_FACTORY[signal.envReader];
+        if (factory) {
+          lines.push(signal.setter ? `  const [${signal.getter}, ${signal.setter}] = ${factory}()` : `  const [${signal.getter}] = ${factory}()`);
+        }
+        continue;
+      }
+      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";
+      if (needsTypeAssertion) {
+        lines.push(`  const ${signal.getter} = () => ${initialValue} as ${signal.type.raw}`);
+      } else {
+        lines.push(`  const ${signal.getter} = () => ${initialValue}`);
+      }
+      if (signal.setter) {
+        const setterUsed = new RegExp(`\\b${signal.setter}\\b`).test(setterRefText);
+        if (setterUsed) {
+          lines.push(`  const ${signal.setter} = (..._args: any[]) => {}`);
+        }
+      }
+    }
+    for (const memo of ir.metadata.memos) {
+      if (memo.isModule)
+        continue;
+      const computation = preserveTypes ? memo.typedComputation ?? memo.computation : memo.computation;
+      lines.push(`  const ${memo.name} = ${computation}`);
+    }
+    for (const constant of ir.metadata.localConstants) {
+      if (constant.isExported)
+        continue;
+      const keyword = constant.declarationKind ?? "const";
+      if (!constant.value) {
+        lines.push(`  ${keyword} ${constant.name}`);
+        continue;
+      }
+      const value = constant.value.trim();
+      if (/^createContext\b/.test(value) || /^new WeakMap\b/.test(value))
+        continue;
+      if (!reachable.has(constant.name))
+        continue;
+      const constValue = preserveTypes ? constant.typedValue ?? constant.value : constant.value;
+      lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
+    }
+    for (const func of localFunctions) {
+      if (!reachable.has(func.name))
+        continue;
+      const params = preserveTypes && func.typedParams !== undefined ? func.typedParams : func.params.map(formatParamWithType).join(", ");
+      const returnAnnotation = preserveTypes && func.typedReturnType ? `: ${func.typedReturnType}` : "";
+      const body = preserveTypes ? func.typedBody ?? func.body : func.body;
+      const asyncKw = func.isAsync ? "async " : "";
+      lines.push(`  ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body}`);
+    }
+    return lines.join(`
+`);
+  }
+  renderNodeRaw(node) {
+    if (node.type === "expression") {
+      if (node.expr === "null" || node.expr === "undefined") {
+        return "null";
+      }
+      return node.expr;
+    }
+    return this.renderNode(node);
+  }
+  renderScopeMarker(instanceIdExpr) {
+    return `${BF_SCOPE}={${instanceIdExpr}}`;
+  }
+  renderSlotMarker(slotId) {
+    return `${BF_SLOT}="${slotId}"`;
+  }
+  renderCondMarker(condId) {
+    return `${BF_COND}="${condId}"`;
+  }
+}
+
+// ../jsx/src/adapters/template-imports.ts
+var CLIENT_PACKAGE_SOURCES = new Set([
+  "@barefootjs/client",
+  "@barefootjs/client/runtime"
+]);
+function rewriteImportsForTemplate(imports, shimSource, rewriteRelative) {
+  const remap = (imp) => {
+    if (!rewriteRelative || !imp.source.startsWith("."))
+      return imp;
+    const next = rewriteRelative(imp.source);
+    return next === imp.source ? imp : { ...imp, source: next };
+  };
+  if (!shimSource) {
+    return imports.filter((imp) => !CLIENT_PACKAGE_SOURCES.has(imp.source)).map(remap);
+  }
+  const merged = new Map;
+  const result = [];
+  for (const imp of imports) {
+    if (!CLIENT_PACKAGE_SOURCES.has(imp.source)) {
+      result.push(remap(imp));
+      continue;
+    }
+    const existing = merged.get(shimSource);
+    if (existing) {
+      const seen = new Set(existing.specifiers.map(specKey));
+      for (const spec of imp.specifiers) {
+        if (!seen.has(specKey(spec))) {
+          existing.specifiers.push(spec);
+          seen.add(specKey(spec));
+        }
+      }
+      existing.isTypeOnly = existing.isTypeOnly && imp.isTypeOnly;
+    } else {
+      const rewritten = {
+        ...imp,
+        source: shimSource,
+        specifiers: imp.specifiers.map((s) => ({ ...s }))
+      };
+      merged.set(shimSource, rewritten);
+      result.push(rewritten);
+    }
+  }
+  return result;
+}
+function specKey(s) {
+  return `${s.isDefault ? "d" : ""}${s.isNamespace ? "n" : ""}:${s.name}:${s.alias ?? ""}`;
+}
+
+// ../jsx/src/adapters/test-adapter.ts
+class TestAdapter extends JsxAdapter {
+  name = "test";
+  extension = ".test.tsx";
+  jsxConfig = { preserveTypes: false };
+  generate(ir) {
+    this.componentName = ir.metadata.componentName;
+    const imports = this.generateImports(ir);
+    const types = this.generateTypes(ir);
+    const component = this.generateComponent(ir);
+    const defaultExport = ir.metadata.hasDefaultExport ? `
+export default ${this.componentName}` : "";
+    const sections = {
+      imports,
+      types: types || "",
+      component,
+      defaultExport
+    };
+    const template = [imports, types, component].filter(Boolean).join(`
+
+`) + defaultExport;
+    return {
+      template,
+      sections,
+      types: types || undefined,
+      extension: this.extension
+    };
+  }
+  generateImports(ir) {
+    const lines = [];
+    const templateImports = rewriteImportsForTemplate(ir.metadata.templateImports, undefined);
+    for (const imp of templateImports) {
+      if (imp.specifiers.length === 0) {
+        if (!imp.isTypeOnly) {
+          lines.push(`import '${imp.source}'`);
+        }
+        continue;
+      }
+      if (imp.isTypeOnly) {
+        lines.push(`import type ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      } else {
+        lines.push(`import ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  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("");
+      lines.push(`type ${this.componentName}PropsWithHydration = ${propsTypeName} & {`);
+      lines.push("  __instanceId?: string");
+      lines.push("  __bfScope?: string");
+      lines.push("}");
+    }
+    return lines.length > 0 ? lines.join(`
+`) : null;
+  }
+  generateComponent(ir) {
+    const name = ir.metadata.componentName;
+    const propsTypeName = ir.metadata.propsType?.raw;
+    const hasClientInteractivity = ir.metadata.signals.length > 0 || ir.metadata.memos.length > 0;
+    const typeAnnotation = propsTypeName ? `: ${name}PropsWithHydration` : ": { __instanceId?: string; __bfScope?: string }";
+    const jsxBody = this.renderNode(ir.root);
+    const signalInits = this.generateSignalInitializers(ir, jsxBody);
+    const scopeIdLine = hasClientInteractivity ? `(/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId` : `__bfScope || __instanceId`;
+    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 restPropsName = ir.metadata.restPropsName;
+    const hydrationProps = `__instanceId, ${bfScopeAlias}`;
+    const parts = [];
+    if (propsParams) {
+      parts.push(propsParams);
+    }
+    parts.push(hydrationProps);
+    if (restPropsName) {
+      parts.push(`...${restPropsName}`);
+    }
+    const fullPropsDestructure = `{ ${parts.join(", ")} }`;
+    const hasRequiredProps = ir.metadata.propsParams.some((p) => !p.optional && p.defaultValue === undefined && !p.isRest);
+    const propsTypeExpr = typeAnnotation.replace(/^:\s*/, "");
+    const noArgDefault = hasRequiredProps ? "" : ` = {} as ${propsTypeExpr}`;
+    const lines = [];
+    const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
+    lines.push(`${exportPrefix}function ${name}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+    if (hasClientInteractivity) {
+      lines.push(`  const __scopeId = (/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    } else {
+      lines.push(`  const __scopeId = __bfScope || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    }
+    if (signalInits) {
+      lines.push(signalInits);
+    }
+    lines.push("");
+    lines.push(`  return (`);
+    lines.push(`    ${jsxBody}`);
+    lines.push(`  )`);
+    lines.push(`}`);
+    return lines.join(`
+`);
+  }
+  renderNode(node) {
+    switch (node.type) {
+      case "element":
+        return this.renderElement(node);
+      case "text":
+        return node.value;
+      case "expression":
+        return this.renderExpression(node);
+      case "conditional":
+        return this.renderConditional(node);
+      case "loop":
+        return this.renderLoop(node);
+      case "component":
+        return this.renderComponent(node);
+      case "fragment":
+        return this.renderFragment(node);
+      case "slot":
+        return "{children}";
+      default:
+        return "";
+    }
+  }
+  renderElement(element) {
+    const tag = element.tag;
+    const attrs = this.renderAttributes(element);
+    const children = this.renderChildren(element.children);
+    let hydrationAttrs = "";
+    if (element.needsScope) {
+      hydrationAttrs += " bf-s={__scopeId}";
+    }
+    if (element.slotId) {
+      hydrationAttrs += ` bf="${element.slotId}"`;
+    }
+    if (children) {
+      return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
+    } else {
+      return `<${tag}${attrs}${hydrationAttrs} />`;
+    }
+  }
+  renderExpression(expr) {
+    if (expr.expr === "null" || expr.expr === "undefined") {
+      return "null";
+    }
+    if (expr.reactive && expr.slotId) {
+      return `{bfText("${expr.slotId}")}{${expr.expr}}{bfTextEnd()}`;
+    }
+    return `{${expr.expr}}`;
+  }
+  renderConditional(cond) {
+    const whenTrue = this.renderNodeRaw(cond.whenTrue);
+    let whenFalse = this.renderNodeRaw(cond.whenFalse);
+    if (!whenFalse || whenFalse === "" || whenFalse === "null") {
+      whenFalse = "null";
+    }
+    return `{${cond.condition} ? ${whenTrue} : ${whenFalse}}`;
+  }
+  renderLoop(loop) {
+    const indexParam = loop.index ? `, ${loop.index}` : "";
+    const children = this.renderChildren(loop.children);
+    const safeChildren = children.startsWith("{") ? `<>${children}</>` : children;
+    const preamble = loop.preamble?.ssrText;
+    if (preamble) {
+      return `{${loop.array}.map((${loop.param}${indexParam}) => { ${preamble} return ${safeChildren} })}`;
+    }
+    return `{${loop.array}.map((${loop.param}${indexParam}) => ${safeChildren})}`;
+  }
+  renderComponent(comp) {
+    const props = this.renderComponentProps(comp);
+    const children = this.renderChildren(comp.children);
+    const scopeAttr = " __bfScope={__scopeId}";
+    if (children) {
+      return `<${comp.name}${props}${scopeAttr}>${children}</${comp.name}>`;
+    } else {
+      return `<${comp.name}${props}${scopeAttr} />`;
+    }
+  }
+  renderFragment(fragment) {
+    const children = this.renderChildren(fragment.children);
+    return `<>${children}</>`;
+  }
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      const attrName = attr.name === "class" ? "className" : attr.name;
+      switch (attr.value.kind) {
+        case "spread":
+          parts.push(`{...${attr.value.expr}}`);
+          break;
+        case "boolean-attr":
+          parts.push(attrName);
+          break;
+        case "expression":
+          parts.push(`${attrName}={${attr.value.expr}}`);
+          break;
+        case "template":
+          parts.push(`${attrName}={${this.flattenTemplate(attr.value)}}`);
+          break;
+        case "literal":
+          parts.push(`${attrName}="${attr.value.value}"`);
+          break;
+        case "boolean-shorthand":
+        case "jsx-children":
+          break;
+      }
+    }
+    for (const event of element.events) {
+      const handlerName = event.originalAttr ?? `on${event.name.charAt(0).toUpperCase()}${event.name.slice(1)}`;
+      parts.push(`${handlerName}={() => {}}`);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+  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("") + "`";
+  }
+  renderComponentProps(comp) {
+    const parts = [];
+    for (const prop of comp.props) {
+      switch (prop.value.kind) {
+        case "jsx-children": {
+          const rendered = prop.value.children.map((c) => this.renderNode(c)).join("");
+          parts.push(`${prop.name}={<>${rendered}</>}`);
+          break;
+        }
+        case "spread":
+          parts.push(`{...${prop.value.expr}}`);
+          break;
+        case "expression":
+          parts.push(`${prop.name}={${prop.value.expr}}`);
+          break;
+        case "template":
+          parts.push(`${prop.name}={${this.flattenTemplate(prop.value)}}`);
+          break;
+        case "boolean-shorthand":
+          parts.push(prop.name);
+          break;
+        case "literal":
+          parts.push(`${prop.name}="${prop.value.value}"`);
+          break;
+        case "boolean-attr":
+          parts.push(prop.name);
+          break;
+      }
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+}
+var testAdapter = new TestAdapter;
+// ../jsx/src/query-href-lowering.ts
+function matchQueryHrefCall(callee, args, localNames) {
+  if (callee.kind !== "identifier" || !localNames.has(callee.name))
+    return null;
+  if (args.length !== 2)
+    return null;
+  const [base, obj] = args;
+  if (obj.kind !== "object-literal")
+    return null;
+  const triples = [];
+  for (const p of obj.properties) {
+    const v = p.value;
+    if (v.kind === "conditional" && isOmitBranch(v.alternate)) {
+      triples.push({ guard: v.test, key: p.key, value: v.consequent });
+    } else {
+      triples.push({ guard: null, key: p.key, value: v });
+    }
+  }
+  return { base, triples };
+}
+var GUARD_BOOL_OPS = new Set([
+  "==",
+  "===",
+  "!=",
+  "!==",
+  "<",
+  ">",
+  "<=",
+  ">="
+]);
+function isOmitBranch(node) {
+  if (node.kind === "identifier")
+    return node.name === "undefined";
+  if (node.kind === "literal") {
+    return node.literalType === "null" || node.literalType === "string" && node.value === "";
+  }
+  return false;
+}
+// ../jsx/src/format-date-lowering.ts
+var UTC_LITERAL = { kind: "literal", value: "UTC", literalType: "string" };
+var EMPTY_NAMES = { kind: "array-literal", elements: [], raw: "[]" };
+function matchFormatDateCall(callee, args, locals) {
+  if (callee.kind !== "identifier" || !locals.has(callee.name))
+    return null;
+  if (args.length < 2 || args.length > 4)
+    return null;
+  return {
+    kind: "helper-call",
+    helper: "format_date",
+    args: [args[0], args[1], args[2] ?? UTC_LITERAL, args[3] ?? EMPTY_NAMES]
+  };
+}
+var formatDatePlugin = {
+  name: "formatDate",
+  prepare(metadata) {
+    const locals = formatDateLocalNames(metadata);
+    if (locals.size === 0)
+      return null;
+    return (callee, args) => matchFormatDateCall(callee, args, locals);
+  }
+};
+
+// ../jsx/src/builtin-lowering-plugins.ts
+var queryHrefPlugin = {
+  name: "queryHref",
+  prepare(metadata) {
+    const locals = queryHrefLocalNames(metadata);
+    if (locals.size === 0)
+      return null;
+    return (callee, args) => {
+      const q = matchQueryHrefCall(callee, args, locals);
+      return q ? { kind: "guard-list", helper: "query", base: q.base, triples: q.triples } : null;
+    };
+  }
+};
+var BUILTIN_LOWERING_PLUGINS = [
+  queryHrefPlugin,
+  datePlugin,
+  formatDatePlugin,
+  toLocaleDatePlugin
+];
+function registerBuiltinLoweringPlugins() {
+  for (const plugin of BUILTIN_LOWERING_PLUGINS)
+    registerLoweringPlugin(plugin);
+}
+// ../jsx/src/adapters/ir-node-emitter.ts
+function emitIRNode(node, emitter, ctx) {
+  const emit = (child, childCtx) => emitIRNode(child, emitter, childCtx);
+  switch (node.type) {
+    case "element":
+      return emitter.emitElement(node, ctx, emit);
+    case "text":
+      return emitter.emitText(node);
+    case "expression":
+      return emitter.emitExpression(node);
+    case "conditional":
+      return emitter.emitConditional(node, ctx, emit);
+    case "loop":
+      return emitter.emitLoop(node, ctx, emit);
+    case "component":
+      return emitter.emitComponent(node, ctx, emit);
+    case "fragment":
+      return emitter.emitFragment(node, ctx, emit);
+    case "slot":
+      return emitter.emitSlot(node);
+    case "if-statement":
+      return emitter.emitIfStatement(node, ctx, emit);
+    case "provider":
+      return emitter.emitProvider(node, ctx, emit);
+    case "async":
+      return emitter.emitAsync(node, ctx, emit);
+    default: {
+      const _exhaustive = node;
+      throw new Error(`emitIRNode: unhandled IRNode kind ${_exhaustive.type}`);
+    }
+  }
+}
+// ../jsx/src/adapters/attr-value-emitter.ts
+function emitAttrValue(value, emitter, name) {
+  switch (value.kind) {
+    case "literal":
+      return emitter.emitLiteral(value, name);
+    case "expression":
+      return emitter.emitExpression(value, name);
+    case "boolean-attr":
+      return emitter.emitBooleanAttr(value, name);
+    case "boolean-shorthand":
+      return emitter.emitBooleanShorthand(value, name);
+    case "template":
+      return emitter.emitTemplate(value, name);
+    case "spread":
+      return emitter.emitSpread(value, name);
+    case "jsx-children":
+      return emitter.emitJsxChildren(value, name);
+    default: {
+      const _exhaustive = value;
+      throw new Error(`emitAttrValue: unhandled AttrValue kind ${_exhaustive.kind}`);
+    }
+  }
+}
+// ../jsx/src/combine-client-js.ts
+import ts23 from "typescript";
+// ../jsx/src/debug.ts
+import ts24 from "typescript";
+// ../jsx/src/profiler.ts
+import ts25 from "typescript";
+
+// ../jsx/src/index.ts
+registerBuiltinLoweringPlugins();
+
+// src/adapter/hono-adapter.ts
+import ts26 from "typescript";
+function applyHonoLoopChain(loop) {
+  return buildLoopChainExpr({
+    base: loop.array,
+    sortComparator: loop.sortComparator,
+    filterPredicate: loop.filterPredicate,
+    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";
+  extension = ".tsx";
+  clientShimSource = "@barefootjs/hono/client-shim";
+  acceptsTemplateCall = () => true;
+  jsxConfig = { preserveTypes: true };
+  options;
+  isClientComponent = false;
+  hasClientInteractivity = false;
+  currentComponentHasProps = false;
+  rewriteRelativeImport;
+  loopKeyStack = [];
+  scriptAssets;
+  preloadAssets;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      clientJsBasePath: options.clientJsBasePath ?? "/static/components/",
+      barefootJsPath: options.barefootJsPath ?? "/static/components/barefoot.js",
+      clientJsFilename: options.clientJsFilename
+    };
+    if (options.name)
+      this.name = options.name;
+  }
+  generate(ir, options) {
+    this.componentName = ir.metadata.componentName;
+    this.isClientComponent = ir.metadata.isClientComponent;
+    this.rewriteRelativeImport = options?.rewriteRelativeImport;
+    if (options?.skipScriptRegistration) {
+      this.scriptAssets = undefined;
+      this.preloadAssets = undefined;
+    } else {
+      this.scriptAssets = options?.scriptAssets;
+      this.preloadAssets = options?.preloadAssets;
+    }
+    const component = this.generateComponent(ir);
+    const types = this.generateTypes(ir, component);
+    const componentCode = [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 = {
+      imports,
+      types: types || "",
+      component,
+      defaultExport,
+      moduleConstants
+    };
+    const template = [imports, moduleConstants, types, component].filter(Boolean).join(`
+
+`) + defaultExport;
+    const result = {
+      template,
+      sections,
+      types: types || undefined,
+      extension: this.extension
+    };
+    this.rewriteRelativeImport = undefined;
+    this.scriptAssets = undefined;
+    this.preloadAssets = undefined;
+    return result;
+  }
+  hasScriptAssets() {
+    return !!this.scriptAssets && this.scriptAssets.length > 0;
+  }
+  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 = [];
+    for (const util of ["bfComment", "bfText", "bfTextEnd"]) {
+      if (new RegExp(`\\b${util}\\b`).test(componentCode)) {
+        utilImports.push(util);
+      }
+    }
+    if (utilImports.length > 0) {
+      lines.push(`import { ${utilImports.join(", ")} } from '@barefootjs/hono/utils'`);
+    }
+    if (this.hasScriptAssets()) {
+      const names = this.hasPreloadAssets() ? ["registerComponentScripts", "registerComponentPreloads", "wrapWithInlineScripts"] : ["registerComponentScripts", "wrapWithInlineScripts"];
+      lines.push(`import { ${names.join(", ")} } from '@barefootjs/hono/scripts'`);
+    }
+    if (componentCode.includes("<__BfSuspense")) {
+      lines.push(`import { Suspense as __BfSuspense } from 'hono/jsx/streaming'`);
+    }
+    if (componentCode.includes("<__BfErrorBoundary")) {
+      lines.push(`import { ErrorBoundary as __BfErrorBoundary } from 'hono/jsx'`);
+    }
+    const templateImports = rewriteImportsForTemplate(ir.metadata.templateImports, this.clientShimSource, this.rewriteRelativeImport);
+    for (const imp of templateImports) {
+      if (imp.specifiers.length === 0) {
+        if (!imp.isTypeOnly) {
+          lines.push(`import '${imp.source}'`);
+        }
+        continue;
+      }
+      if (imp.isTypeOnly) {
+        lines.push(`import type ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      } else {
+        lines.push(`import ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      }
+    }
+    if (/\bprovideContextSSR\(/.test(componentCode)) {
+      lines.push(`import { provideContextSSR } from '@barefootjs/hono/client-shim'`);
+    }
+    return lines.join(`
+`);
+  }
+  generateTypes(ir, componentBody) {
+    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");
+      lines.push("  __bfChild?: boolean");
+      lines.push("  __bfParentProps?: string");
+      lines.push("  __bfParent?: string");
+      lines.push("  __bfMount?: string");
+      lines.push('  "data-key"?: string | number');
+      lines.push("}");
+    }
+    return lines.length > 0 ? lines.join(`
+`) : null;
+  }
+  getPropsTypeName(ir) {
+    if (ir.metadata.propsType?.raw) {
+      return ir.metadata.propsType.raw;
+    }
+    return null;
+  }
+  generateComponent(ir) {
+    const name = ir.metadata.componentName;
+    const propsTypeName = this.getPropsTypeName(ir);
+    const hasReactivePrimitives = ir.metadata.signals.some((s) => !s.envReader) || ir.metadata.memos.length > 0 || ir.metadata.effects.length > 0 || ir.metadata.onMounts.length > 0;
+    if (hasReactivePrimitives && !ir.metadata.isClientComponent) {
+      throw new Error(`Component "${name}" has reactive primitives (signals, memos, effects, or onMounts) ` + `but is not marked as a client component. Add "use client" directive at the top of the file.`);
+    }
+    const needsClientInit = ir.metadata.clientAnalysis?.needsInit ?? false;
+    const hasClientInteractivity = ir.metadata.isClientComponent || needsClientInit;
+    this.hasClientInteractivity = hasClientInteractivity;
+    const propsObjectName = ir.metadata.propsObjectName;
+    let fullPropsDestructure;
+    let typeAnnotation;
+    let propsExtraction = null;
+    const HYDRATION_PROPS_TYPE = '{ __instanceId?: string; __bfScope?: string; __bfChild?: boolean; __bfParentProps?: string; __bfParent?: string; __bfMount?: string; "data-key"?: string | number }';
+    if (propsObjectName) {
+      fullPropsDestructure = `__allProps`;
+      typeAnnotation = propsTypeName ? `: ${propsTypeName} & ${HYDRATION_PROPS_TYPE}` : `: Record<string, unknown> & ${HYDRATION_PROPS_TYPE}`;
+    } else {
+      fullPropsDestructure = "";
+      typeAnnotation = propsTypeName ? `: ${name}PropsWithHydration` : `: ${HYDRATION_PROPS_TYPE}`;
+    }
+    const clientUsedProps = new Set(ir.metadata.clientAnalysis?.usedProps ?? []);
+    const needsInit = ir.metadata.clientAnalysis?.needsInit ?? false;
+    const propsToSerialize = ir.metadata.propsParams.filter((p) => {
+      return !p.name.startsWith("on") && !p.name.startsWith("__") && clientUsedProps.has(p.name);
+    });
+    const hasPropsToSerialize = propsToSerialize.length > 0 && hasClientInteractivity && needsInit;
+    const isIfStatement = ir.root.type === "if-statement";
+    const isRootComponent = ir.root.type === "component";
+    this.currentComponentHasProps = hasPropsToSerialize || hasClientInteractivity && isRootComponent;
+    let jsxBody = isIfStatement ? "" : this.renderNode(ir.root, {
+      isRootOfClientComponent: hasClientInteractivity && isRootComponent
+    });
+    if (!isIfStatement && hasClientInteractivity && isRootComponent) {
+      jsxBody = this.wrapWithScopeComment(jsxBody);
+    }
+    const ifCode = isIfStatement ? this.renderIfStatement(ir.root, { isRootOfClientComponent: true }) : "";
+    const fullBodyText = jsxBody + `
+` + ifCode;
+    const signalInits = this.generateSignalInitializers(ir, fullBodyText);
+    const scopeIdLine = hasClientInteractivity ? `__instanceId` : `__bfScope || __instanceId`;
+    const bodyRefText = [
+      fullBodyText,
+      signalInits,
+      scopeIdLine,
+      hasPropsToSerialize || hasClientInteractivity && isRootComponent ? "__bfParentProps" : ""
+    ].join(`
+`);
+    const bfScopeAlias = /\b__bfScope\b/.test(bodyRefText) ? "__bfScope" : "__bfScope: _bfScope";
+    const bfChildAlias = /\b__bfChild\b/.test(bodyRefText) ? "__bfChild" : "__bfChild: _bfChild";
+    const bfParentPropsAlias = /\b__bfParentProps\b/.test(bodyRefText) ? "__bfParentProps" : "__bfParentProps: _bfParentProps";
+    const bfParentAlias = /\b__bfParent\b/.test(bodyRefText) ? "__bfParent" : "__bfParent: _bfParent";
+    const bfMountAlias = /\b__bfMount\b/.test(bodyRefText) ? "__bfMount" : "__bfMount: _bfMount";
+    const dataKeyAlias = /\b__dataKey\b/.test(bodyRefText) ? '"data-key": __dataKey' : '"data-key": _dataKey';
+    if (propsObjectName) {
+      propsExtraction = `  const { __instanceId, ${bfScopeAlias}, ${bfChildAlias}, ${bfParentPropsAlias}, ${bfParentAlias}, ${bfMountAlias}, ${dataKeyAlias}, ...${propsObjectName} } = __allProps`;
+    } 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(", ");
+      if (propsParams) {
+        parts.push(propsParams);
+      }
+      parts.push(hydrationProps);
+      const restPropsName = ir.metadata.restPropsName;
+      if (restPropsName) {
+        parts.push(`...${restPropsName}`);
+      }
+      fullPropsDestructure = `{ ${parts.join(", ")} }`;
+    }
+    const hasRequiredProps = ir.metadata.propsParams.some((p) => !p.optional && p.defaultValue === undefined && !p.isRest);
+    const wantsNoArgDefault = propsObjectName ? !propsTypeName : !hasRequiredProps;
+    const propsTypeExpr = typeAnnotation.replace(/^:\s*/, "");
+    const noArgDefault = wantsNoArgDefault ? ` = {} as ${propsTypeExpr}` : "";
+    const lines = [];
+    const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
+    lines.push(`${exportPrefix}function ${name}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+    if (this.hasPreloadAssets()) {
+      lines.push(`  const __bfInlinePreloads = registerComponentPreloads(${JSON.stringify(this.preloadAssets)})`);
+    }
+    if (this.hasScriptAssets()) {
+      lines.push(`  const __bfInlineScripts = registerComponentScripts(${JSON.stringify(this.scriptAssets)})`);
+    }
+    if (propsExtraction) {
+      lines.push(propsExtraction);
+    }
+    if (hasClientInteractivity) {
+      lines.push(`  const __scopeId = __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    } else {
+      lines.push(`  const __scopeId = __bfScope || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    }
+    if (signalInits) {
+      lines.push(signalInits);
+    }
+    if (hasPropsToSerialize) {
+      lines.push("");
+      lines.push(`  // Serialize props for client hydration`);
+      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}`);
+      }
+      lines.push(`  const __bfPropsJson = __bfParentProps || (Object.keys(__hydrateProps).length > 0 ? JSON.stringify(__hydrateProps) : undefined)`);
+    } else if (hasClientInteractivity && isRootComponent) {
+      lines.push("");
+      lines.push(`  const __bfPropsJson = __bfParentProps`);
+    }
+    lines.push("");
+    if (isIfStatement) {
+      lines.push(ifCode);
+      lines.push(`}`);
+      return lines.join(`
+`);
+    }
+    if (this.hasScriptAssets()) {
+      lines.push(`  return wrapWithInlineScripts((`);
+      lines.push(`    ${jsxBody}`);
+      lines.push(this.hasPreloadAssets() ? `  ), __bfInlineScripts, __bfInlinePreloads)` : `  ), __bfInlineScripts)`);
+    } else {
+      lines.push(`  return (`);
+      lines.push(`    ${jsxBody}`);
+      lines.push(`  )`);
+    }
+    lines.push(`}`);
+    return lines.join(`
+`);
+  }
+  renderNode(node, ctx) {
+    return emitIRNode(node, this, ctx ?? {});
+  }
+  emitElement(node, ctx, _emit) {
+    return this.renderElement(node, ctx);
+  }
+  emitText(node) {
+    return this.renderText(node);
+  }
+  emitExpression(node) {
+    return this.renderExpression(node);
+  }
+  emitConditional(node, ctx, _emit) {
+    return this.renderConditional(node, ctx);
+  }
+  emitLoop(node, _ctx, _emit) {
+    return this.renderLoop(node);
+  }
+  emitComponent(node, ctx, _emit) {
+    return this.renderComponent(node, ctx);
+  }
+  emitFragment(node, _ctx, _emit) {
+    return this.renderFragment(node);
+  }
+  emitSlot(_node) {
+    return "{children}";
+  }
+  emitIfStatement(_node, _ctx, _emit) {
+    return "";
+  }
+  emitProvider(node, _ctx, _emit) {
+    const children = this.renderChildren(node.children);
+    const valueExpr = (() => {
+      const v = node.valueProp.value;
+      switch (v.kind) {
+        case "literal":
+          return JSON.stringify(v.value);
+        case "expression":
+        case "spread":
+          return v.expr;
+        case "template":
+          return this.renderTemplateLiteralParts(v.parts);
+        case "boolean-attr":
+        case "boolean-shorthand":
+          return "true";
+        case "jsx-children":
+          return "undefined";
+      }
+    })();
+    return `<>{provideContextSSR(${node.contextName}, ${valueExpr}, <>${children}</>)}</>`;
+  }
+  emitAsync(node, _ctx, _emit) {
+    return this.renderAsync(node);
+  }
+  renderElement(element, ctx) {
+    const tag = element.tag;
+    const attrs = this.renderAttributes(element);
+    const children = this.renderChildren(element.children);
+    let hydrationAttrs = "";
+    if (element.needsScope) {
+      hydrationAttrs += ` ${BF_SCOPE}={__scopeId}`;
+      hydrationAttrs += ` {...(__bfParent ? { "${BF_HOST}": __bfParent } : {})}`;
+      hydrationAttrs += ` {...(__bfMount ? { "${BF_AT}": __bfMount } : {})}`;
+      hydrationAttrs += ` {...(!__bfChild ? { "${BF_ROOT}": "" } : {})}`;
+      if (this.currentComponentHasProps) {
+        hydrationAttrs += ` {...(!__bfChild && __bfPropsJson ? { "${BF_PROPS}": __bfPropsJson } : {})}`;
+      }
+      hydrationAttrs += ' {...(__dataKey !== undefined ? { "data-key": __dataKey } : {})}';
+    }
+    if (ctx?.isLoopItemRoot && this.loopKeyStack.length > 0) {
+      const loop = this.loopKeyStack[this.loopKeyStack.length - 1];
+      if (loop.key) {
+        const keyAttrName2 = this.loopKeyStack.length === 1 ? "data-key" : `data-key-${this.loopKeyStack.length - 1}`;
+        hydrationAttrs += ` ${keyAttrName2}={String(${loop.key})}`;
+      }
+    }
+    if (element.slotId) {
+      hydrationAttrs += ` bf="${element.slotId}"`;
+    }
+    if (element.regionId) {
+      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`;
+    }
+    if (children) {
+      return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
+    } else {
+      return `<${tag}${attrs}${hydrationAttrs} />`;
+    }
+  }
+  renderText(text) {
+    return escapeHtml(text.value).replace(/\{/g, "&#123;").replace(/\}/g, "&#125;");
+  }
+  renderExpression(expr) {
+    if (expr.expr === "null" || expr.expr === "undefined") {
+      return "null";
+    }
+    if (expr.clientOnly && expr.slotId) {
+      if (expr.markerless)
+        return "";
+      return `{bfText("${expr.slotId}")}{bfTextEnd()}`;
+    }
+    if (expr.slotId) {
+      return `{bfText("${expr.slotId}")}{${expr.expr}}{bfTextEnd()}`;
+    }
+    return `{${expr.expr}}`;
+  }
+  renderConditional(cond, ctx) {
+    if (cond.clientOnly && cond.slotId) {
+      return `{bfComment("cond-start:${cond.slotId}")}{bfComment("cond-end:${cond.slotId}")}`;
+    }
+    const branchCtx = ctx?.isLoopItemRoot ? { isLoopItemRoot: true } : undefined;
+    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}}`;
+  }
+  renderNodeRawCtx(node, ctx) {
+    if (node.type === "expression") {
+      if (node.expr === "null" || node.expr === "undefined")
+        return "null";
+      return node.expr;
+    }
+    return this.renderNode(node, ctx);
+  }
+  wrapWithCondMarker(node, content, condId) {
+    if (node.type === "component") {
+      return `<>{bfComment("cond-start:${condId}")}${content}{bfComment("cond-end:${condId}")}</>`;
+    }
+    if (content.startsWith("<") && node.type !== "fragment") {
+      const match = content.match(/^<(\w+)/);
+      if (match) {
+        return content.replace(`<${match[1]}`, `<${match[1]} bf-c="${condId}"`);
+      }
+    }
+    if (node.type === "expression") {
+      const exprSlotId = node.slotId;
+      const inner = exprSlotId ? `{bfText("${exprSlotId}")}{${content}}{bfTextEnd()}` : `{${content}}`;
+      return `<>{bfComment("cond-start:${condId}")}${inner}{bfComment("cond-end:${condId}")}</>`;
+    }
+    return `<>{bfComment("cond-start:${condId}")}${content}{bfComment("cond-end:${condId}")}</>`;
+  }
+  renderLoop(loop) {
+    if (loop.clientOnly) {
+      return `{bfComment('loop:${loop.markerId}')}{bfComment('/loop:${loop.markerId}')}`;
+    }
+    const paramAnnotation = loop.paramType ? `: ${loop.paramType}` : "";
+    const indexAnnotation = loop.indexType ? `: ${loop.indexType}` : "";
+    const indexParam = loop.index ? `, ${loop.index}${indexAnnotation}` : "";
+    this.loopKeyStack.push({ key: loop.key, param: loop.param });
+    const children = this.renderChildrenInLoop(loop.children);
+    this.loopKeyStack.pop();
+    let mapExpr;
+    const preamble = loop.preamble?.ssrText;
+    let safeChildren = children.startsWith("{") ? `<>${children}</>` : children;
+    if (loop.bodyIsMultiRoot) {
+      safeChildren = `<>{bfComment('bf-loop-i')}${children}</>`;
+    } else if (loop.bodyIsItemConditional && loop.key) {
+      safeChildren = `<>{bfComment('loop-i:' + String(${loop.key}))}${children}</>`;
+    }
+    let chainedArray = applyHonoLoopChain(loop);
+    const iterMethod = loop.method ?? "map";
+    let callbackParam;
+    if (loop.iterationShape === "entries" && loop.index) {
+      chainedArray = `[...${chainedArray}.entries()]`;
+      callbackParam = `([${loop.index}${indexAnnotation}, ${loop.param}${paramAnnotation}])`;
+    } else if (loop.iterationShape === "keys") {
+      chainedArray = `[...${chainedArray}.keys()]`;
+      callbackParam = `(${loop.param}${paramAnnotation})`;
+    } else if (loop.objectIteration === "entries") {
+      chainedArray = `Object.entries(${chainedArray})`;
+      callbackParam = loop.index ? `([${loop.index}${indexAnnotation}, ${loop.param}${paramAnnotation}])` : `(${loop.param}${paramAnnotation}${indexParam})`;
+    } else if (loop.objectIteration === "keys") {
+      chainedArray = `Object.keys(${chainedArray})`;
+      callbackParam = `(${loop.param}${paramAnnotation})`;
+    } else if (loop.objectIteration === "values") {
+      chainedArray = `Object.values(${chainedArray})`;
+      callbackParam = `(${loop.param}${paramAnnotation})`;
+    } else {
+      callbackParam = `(${loop.param}${paramAnnotation}${indexParam})`;
+    }
+    if (loop.flatMapCallback) {
+      mapExpr = `{${chainedArray}.flatMap(${loop.flatMapCallback.params} => ${loop.flatMapCallback.rawBody})}`;
+    } else if (preamble) {
+      mapExpr = `{${chainedArray}.${iterMethod}(${callbackParam} => { ${preamble} return ${safeChildren} })}`;
+    } else {
+      mapExpr = `{${chainedArray}.${iterMethod}(${callbackParam} => ${safeChildren})}`;
+    }
+    return `{bfComment('loop:${loop.markerId}')}${mapExpr}{bfComment('/loop:${loop.markerId}')}`;
+  }
+  renderChildrenInLoop(children) {
+    return children.map((child) => this.renderNode(child, { isLoopItemRoot: true })).join("");
+  }
+  renderIfStatement(ifStmt, ctx) {
+    const lines = [];
+    for (const v of ifStmt.scopeVariables) {
+      const init = this.jsxConfig.preserveTypes && v.typedInitializer || v.initializer;
+      lines.push(`    const ${v.name} = ${init}`);
+    }
+    const consequent = this.renderNode(ifStmt.consequent, ctx);
+    const wrap = this.hasScriptAssets();
+    const wrapPreload = this.hasPreloadAssets();
+    const openReturn = wrap ? "    return wrapWithInlineScripts((" : "    return (";
+    const closeReturn = wrap ? wrapPreload ? "    ), __bfInlineScripts, __bfInlinePreloads)" : "    ), __bfInlineScripts)" : "    )";
+    lines.unshift(`  if (${ifStmt.condition}) {`);
+    lines.push(openReturn);
+    lines.push(`      ${consequent}`);
+    lines.push(closeReturn);
+    lines.push(`  }`);
+    if (ifStmt.alternate) {
+      if (ifStmt.alternate.type === "if-statement") {
+        const elseIfCode = this.renderIfStatement(ifStmt.alternate, ctx);
+        lines.push(elseIfCode.replace(/^\s*if/, "  else if"));
+      } else {
+        const alternate = this.renderNode(ifStmt.alternate, ctx);
+        lines.push(wrap ? "  return wrapWithInlineScripts((" : "  return (");
+        lines.push(`    ${alternate}`);
+        lines.push(wrap ? wrapPreload ? "  ), __bfInlineScripts, __bfInlinePreloads)" : "  ), __bfInlineScripts)" : "  )");
+      }
+    } else {
+      lines.push(`  return null`);
+    }
+    return lines.join(`
+`);
+  }
+  renderAsync(node) {
+    const fallback = this.renderNode(node.fallback);
+    const children = this.renderChildren(node.children);
+    return `<__BfErrorBoundary fallback={<>${fallback}</>}>` + `<__BfSuspense fallback={<>${fallback}</>}>${children}</__BfSuspense>` + `</__BfErrorBoundary>`;
+  }
+  renderComponent(comp, ctx) {
+    const props = this.renderComponentProps(comp);
+    const children = this.renderChildren(comp.children);
+    let scopeAttr;
+    const bfChildAttr = comp.slotId && this.hasClientInteractivity ? " __bfChild={true}" : "";
+    const bfMountAttr = comp.slotId ? ` __bfParent={__scopeId} __bfMount={'${comp.slotId}'}` : "";
+    if (ctx?.isRootOfClientComponent) {
+      const propsPassAttr = this.currentComponentHasProps ? " __bfParentProps={__bfPropsJson}" : "";
+      if (comp.slotId) {
+        scopeAttr = ` __instanceId={\`\${__scopeId}_${comp.slotId}\`}${propsPassAttr}${bfMountAttr}`;
+      } else {
+        scopeAttr = ` __instanceId={__scopeId}${propsPassAttr}`;
+      }
+      scopeAttr += ` ${BF_SCOPE}={__scopeId}`;
+    } else if (comp.loopItemRoot) {
+      if (comp.slotId) {
+        scopeAttr = ` __bfScope={\`\${__scopeId}_${comp.slotId}\`}${bfChildAttr}${bfMountAttr}`;
+      } else {
+        scopeAttr = " __bfScope={__scopeId}";
+      }
+    } else if (comp.slotId) {
+      scopeAttr = ` __instanceId={\`\${__scopeId}_${comp.slotId}\`}${bfChildAttr}${bfMountAttr}`;
+    } else {
+      scopeAttr = " __instanceId={__scopeId}";
+    }
+    if (children) {
+      return `<${comp.name}${props}${scopeAttr}>${children}</${comp.name}>`;
+    } else {
+      return `<${comp.name}${props}${scopeAttr} />`;
+    }
+  }
+  renderFragment(fragment) {
+    const children = this.renderChildren(fragment.children);
+    if (fragment.needsScopeComment) {
+      return this.wrapWithScopeComment(children);
+    }
+    return `<>${children}</>`;
+  }
+  wrapWithScopeComment(body) {
+    const hostExpr = '${__bfParent ? `|h=${__bfParent}|m=${__bfMount}` : ""}';
+    const propsExpr = this.currentComponentHasProps ? '${__bfPropsJson ? `|${__bfPropsJson}` : ""}' : "";
+    return `<>{bfComment(\`scope:\${__scopeId}${hostExpr}${propsExpr}\`)}${body}{bfComment(\`/scope:\${__scopeId}\`)}</>`;
+  }
+  elementAttrEmitter = {
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
+    emitExpression: (value, name) => {
+      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+        return `${name}={(${value.expr}) || undefined}`;
+      }
+      return `${name}={${value.expr}}`;
+    },
+    emitBooleanAttr: (_value, name) => name,
+    emitBooleanShorthand: () => "",
+    emitTemplate: (value, name) => `${name}={${this.renderTemplateLiteralParts(value.parts)}}`,
+    emitSpread: (value) => `{...${value.expr}}`,
+    emitJsxChildren: () => ""
+  };
+  componentPropEmitter = {
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
+    emitExpression: (value, name) => `${name}={${value.expr}}`,
+    emitBooleanAttr: (_value, name) => name,
+    emitBooleanShorthand: (_value, name) => name,
+    emitTemplate: (value, name) => `${name}={${this.renderTemplateLiteralParts(value.parts)}}`,
+    emitSpread: (value) => `{...${value.expr}}`,
+    emitJsxChildren: (value, name) => {
+      const rendered = value.children.map((c) => this.renderNode(c)).join("");
+      return `${name}={<>${rendered}</>}`;
+    }
+  };
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      if (attr.clientOnly)
+        continue;
+      const jsxName = attr.name === "class" ? "className" : attr.name;
+      const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, jsxName);
+      if (lowered)
+        parts.push(lowered);
+    }
+    for (const event of element.events) {
+      const handlerName = event.originalAttr ?? `on${event.name.charAt(0).toUpperCase()}${event.name.slice(1)}`;
+      parts.push(`${handlerName}={() => {}}`);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+  renderComponentProps(comp) {
+    const parts = [];
+    let keyValue = null;
+    for (const prop of comp.props) {
+      if (prop.name === "key") {
+        keyValue = this.attrValueToJsExpr(prop.value);
+        continue;
+      }
+      const lowered = emitAttrValue(prop.value, this.componentPropEmitter, prop.name);
+      if (lowered)
+        parts.push(lowered);
+    }
+    if (keyValue) {
+      parts.push(`data-key={${keyValue}}`);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+  attrValueToJsExpr(value) {
+    switch (value.kind) {
+      case "literal":
+        return JSON.stringify(value.value);
+      case "expression":
+      case "spread":
+        return value.expr;
+      case "template":
+        return this.renderTemplateLiteralParts(value.parts);
+      case "boolean-shorthand":
+      case "boolean-attr":
+        return "true";
+      case "jsx-children":
+        return "undefined";
+    }
+  }
+  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;
+  }
+}
+var honoAdapter = new HonoAdapter;
+// src/vite.ts
+async function writeIfChanged(absPath, content, label) {
+  const prev = await readFile(absPath, "utf-8").catch(() => null);
+  if (prev === content)
+    return;
+  await mkdir(dirname(absPath), { recursive: true });
+  await writeFile(absPath, content);
+  console.log(`Generated: ${label}`);
+}
+function resolveAssetUrl(ctx, config, devServer, entryRelPath, manifest) {
+  const absPath = resolve(ctx.projectDir, entryRelPath);
+  if (ctx.mode === "dev") {
+    if (!devServer)
+      throw new Error(`[hono/vite] asset "${entryRelPath}": dev server not ready`);
+    return devModuleUrl(config, resolveDevOrigin(devServer), absPath);
+  }
+  const manifestKey = toPosixRelative(config.root, absPath);
+  const [url] = resolveScriptAssets(manifest ?? {}, manifestKey, config.base);
+  if (!url) {
+    throw new Error(`[hono/vite] asset "${entryRelPath}" was not found in the build manifest. ` + `Did you also add it to build.rollupOptions.input?`);
+  }
+  return url;
+}
+async function writeAssetMap(ctx, config, devServer, assets, assetsOutputFile) {
+  const keys = Object.keys(assets);
+  if (keys.length === 0)
+    return;
+  const manifest = ctx.mode === "build" ? await loadManifest(ctx.outDir, config.build.manifest) : undefined;
+  const entries = keys.map((name) => `  ${JSON.stringify(name)}: ${JSON.stringify(resolveAssetUrl(ctx, config, devServer, assets[name], manifest))},`).join(`
+`);
+  const content = [
+    `// Code generated by BarefootJS. DO NOT EDIT.`,
+    "",
+    `/**`,
+    ` * Maps a logical asset name (this map's key) to its resolved URL for`,
+    ` * the current build: a Vite dev-server origin URL in dev, a`,
+    ` * content-hashed manifest path in production. Regenerated by`,
+    ` * @barefootjs/hono/vite's afterEmit hook every time templates are`,
+    ` * (re)emitted.`,
+    ` */`,
+    `export const Assets: Record<string, string> = {`,
+    entries,
+    `}`
+  ].join(`
+`) + `
+`;
+  await writeIfChanged(resolve(ctx.projectDir, assetsOutputFile), content, assetsOutputFile);
+}
+function barefoot(options) {
+  const assets = options.assets ?? {};
+  const assetsOutputFile = options.assetsOutputFile ?? "dist/bf-assets.ts";
+  let resolvedConfig;
+  let devServer;
+  const core = coreBarefoot({
+    adapter: new HonoAdapter(options.adapterOptions),
+    components: options.components,
+    templates: options.templates,
+    async afterEmit(ctx) {
+      if (Object.keys(assets).length > 0 && resolvedConfig) {
+        await writeAssetMap(ctx, resolvedConfig, devServer, assets, assetsOutputFile);
+      }
+    }
+  });
+  if (Object.keys(assets).length === 0)
+    return [core];
+  const honoAssetsConfigCapture = {
+    name: "barefoot-hono-assets-config-capture",
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    configureServer(server) {
+      devServer = server;
+    }
+  };
+  return [core, honoAssetsConfigCapture];
+}
+export {
+  barefoot as default,
+  barefoot
+};