@barefootjs/hono 0.1.0

package/dist/jsx/jsx-runtime/index.js

@@ -0,0 +1,10 @@
+// src/jsx/jsx-runtime/index.ts
+import { jsx, jsxs, Fragment, jsxAttr, jsxEscape, jsxTemplate } from "hono/jsx/jsx-runtime";
+export {
+  jsxs,
+  jsxTemplate,
+  jsxEscape,
+  jsxAttr,
+  jsx,
+  Fragment
+};

package/dist/portal-ssr.d.ts

@@ -0,0 +1,22 @@
+import type { Child } from 'hono/jsx';
+/**
+ * Reset portal counter (for testing or explicit reset).
+ */
+export declare function resetPortalCounter(): void;
+export interface PortalProps {
+    children: Child;
+    scopeId?: string;
+}
+/**
+ * Portal component that moves children to document.body during SSR.
+ *
+ * During SSR:
+ * - Collects content for BfPortals output (before BfPortals renders)
+ * - Returns placeholder <template> for hydration matching
+ * - If BfPortals already rendered (Suspense), outputs inline
+ *
+ * On client:
+ * - Renders children normally (createPortal moves them later)
+ */
+export declare function Portal(props: PortalProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+//# sourceMappingURL=portal-ssr.d.ts.map

package/dist/portal-ssr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal-ssr.d.ts","sourceRoot":"","sources":["../src/portal-ssr.tsx"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAarC;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,KAAK,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,kDA4BxC"}

package/dist/portal-ssr.js

@@ -0,0 +1,73 @@
+// src/portals.tsx
+import { useRequestContext } from "hono/jsx-renderer";
+import { Fragment } from "hono/jsx";
+import { jsxDEV } from "hono/jsx/jsx-dev-runtime";
+function collectPortal(id, scopeId, content) {
+  try {
+    const c = useRequestContext();
+    const portals = c.get("bfCollectedPortals") || [];
+    portals.push({ id, scopeId, content });
+    c.set("bfCollectedPortals", portals);
+  } catch {}
+}
+function isPortalsRendered() {
+  try {
+    const c = useRequestContext();
+    return c.get("bfPortalsRendered") ?? false;
+  } catch {
+    return true;
+  }
+}
+function BfPortals() {
+  try {
+    const c = useRequestContext();
+    c.set("bfPortalsRendered", true);
+    const portals = c.get("bfCollectedPortals") || [];
+    return /* @__PURE__ */ jsxDEV(Fragment, {
+      children: portals.map(({ id, scopeId, content }) => /* @__PURE__ */ jsxDEV("div", {
+        "bf-pi": id,
+        "bf-po": scopeId,
+        children: content
+      }, id, false, undefined, this))
+    }, undefined, false, undefined, this);
+  } catch {
+    return null;
+  }
+}
+
+// src/portal-ssr.tsx
+import { useRequestContext as useRequestContext2 } from "hono/jsx-renderer";
+import { Fragment as Fragment2 } from "hono/jsx";
+import { jsxDEV as jsxDEV2 } from "hono/jsx/jsx-dev-runtime";
+var portalCounter = 0;
+function generatePortalId() {
+  return `bf-portal-${++portalCounter}`;
+}
+function resetPortalCounter() {
+  portalCounter = 0;
+}
+function Portal(props) {
+  const portalId = generatePortalId();
+  try {
+    useRequestContext2();
+    if (isPortalsRendered()) {
+      return /* @__PURE__ */ jsxDEV2("div", {
+        "bf-pi": portalId,
+        "bf-po": props.scopeId || "",
+        children: props.children
+      }, undefined, false, undefined, this);
+    }
+    collectPortal(portalId, props.scopeId || "", props.children);
+    return /* @__PURE__ */ jsxDEV2("template", {
+      "bf-pp": portalId
+    }, undefined, false, undefined, this);
+  } catch {
+    return /* @__PURE__ */ jsxDEV2(Fragment2, {
+      children: props.children
+    }, undefined, false, undefined, this);
+  }
+}
+export {
+  resetPortalCounter,
+  Portal
+};

package/dist/portals.d.ts

@@ -0,0 +1,26 @@
+import type { Child } from 'hono/jsx';
+export type CollectedPortal = {
+    id: string;
+    scopeId: string;
+    content: Child;
+};
+/**
+ * Collect portal content for SSR output.
+ * Called by Portal component during SSR rendering.
+ */
+export declare function collectPortal(id: string, scopeId: string, content: Child): void;
+/**
+ * Check if BfPortals has already been rendered.
+ * Used by Portal component to determine if it should output inline.
+ */
+export declare function isPortalsRendered(): boolean;
+/**
+ * Renders all collected portal content.
+ * Place this component at the end of your <body> element, before BfScripts.
+ *
+ * After rendering, sets 'bfPortalsRendered' flag to true.
+ * Portal components rendered after BfPortals (e.g., inside Suspense boundaries)
+ * will check this flag and output their content inline instead.
+ */
+export declare function BfPortals(): import("hono/jsx/jsx-dev-runtime").JSX.Element | null;
+//# sourceMappingURL=portals.d.ts.map

package/dist/portals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portals.d.ts","sourceRoot":"","sources":["../src/portals.tsx"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAErC,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,KAAK,CAAA;CACf,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,GAAG,IAAI,CAS/E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAQ3C;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,0DAwBxB"}

package/dist/portals.js

@@ -0,0 +1,41 @@
+// src/portals.tsx
+import { useRequestContext } from "hono/jsx-renderer";
+import { Fragment } from "hono/jsx";
+import { jsxDEV } from "hono/jsx/jsx-dev-runtime";
+function collectPortal(id, scopeId, content) {
+  try {
+    const c = useRequestContext();
+    const portals = c.get("bfCollectedPortals") || [];
+    portals.push({ id, scopeId, content });
+    c.set("bfCollectedPortals", portals);
+  } catch {}
+}
+function isPortalsRendered() {
+  try {
+    const c = useRequestContext();
+    return c.get("bfPortalsRendered") ?? false;
+  } catch {
+    return true;
+  }
+}
+function BfPortals() {
+  try {
+    const c = useRequestContext();
+    c.set("bfPortalsRendered", true);
+    const portals = c.get("bfCollectedPortals") || [];
+    return /* @__PURE__ */ jsxDEV(Fragment, {
+      children: portals.map(({ id, scopeId, content }) => /* @__PURE__ */ jsxDEV("div", {
+        "bf-pi": id,
+        "bf-po": scopeId,
+        children: content
+      }, id, false, undefined, this))
+    }, undefined, false, undefined, this);
+  } catch {
+    return null;
+  }
+}
+export {
+  isPortalsRendered,
+  collectPortal,
+  BfPortals
+};

package/dist/preload.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Manifest entry type for dependency tracking.
+ */
+export interface ManifestEntry {
+    markedTemplate: string;
+    clientJs?: string;
+    props?: Array<{
+        name: string;
+        type: string;
+        optional: boolean;
+    }>;
+    dependencies?: string[];
+}
+/**
+ * Manifest type mapping component names to their metadata.
+ */
+export type Manifest = Record<string, ManifestEntry>;
+export interface BfPreloadProps {
+    /**
+     * Path to static files directory.
+     * @default '/static'
+     */
+    staticPath?: string;
+    /**
+     * Additional script URLs to preload.
+     * These are added in addition to the barefoot runtime.
+     */
+    scripts?: string[];
+    /**
+     * Whether to preload the barefoot runtime.
+     * @default true
+     */
+    includeRuntime?: boolean;
+    /**
+     * Component manifest with dependency information.
+     * Used for automatic dependency chain preloading.
+     */
+    manifest?: Manifest;
+    /**
+     * Component names to preload with their dependencies.
+     * Requires manifest to be provided.
+     */
+    components?: string[];
+}
+/**
+ * Renders modulepreload link tags for BarefootJS scripts.
+ * Place this component in your <head> element.
+ *
+ * By default, preloads the barefoot.js runtime which is required
+ * by all BarefootJS components.
+ *
+ * When manifest and components props are provided, automatically
+ * preloads the full dependency chain for those components.
+ */
+export declare function BfPreload({ staticPath, scripts, includeRuntime, manifest, components }?: BfPreloadProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+//# sourceMappingURL=preload.d.ts.map

package/dist/preload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../src/preload.tsx"],"names":[],"mappings":"AAmCA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,cAAc,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;IAChE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAEpD,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAElB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IAExB;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAA;IAEnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAwCD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,EACxB,UAAsB,EACtB,OAAY,EACZ,cAAqB,EACrB,QAAQ,EACR,UAAe,EAChB,GAAE,cAAmB,kDA6BrB"}

package/dist/preload.js

@@ -0,0 +1,51 @@
+// src/preload.tsx
+import { Fragment } from "hono/jsx";
+import { jsxDEV } from "hono/jsx/jsx-dev-runtime";
+function resolveDependencyChain(components, manifest, visited = new Set) {
+  const result = [];
+  for (const compName of components) {
+    if (visited.has(compName))
+      continue;
+    visited.add(compName);
+    const entry = manifest[compName];
+    if (!entry)
+      continue;
+    if (entry.clientJs) {
+      result.push(entry.clientJs);
+    }
+    if (entry.dependencies && entry.dependencies.length > 0) {
+      const childScripts = resolveDependencyChain(entry.dependencies, manifest, visited);
+      result.push(...childScripts);
+    }
+  }
+  return result;
+}
+function BfPreload({
+  staticPath = "/static",
+  scripts = [],
+  includeRuntime = true,
+  manifest,
+  components = []
+} = {}) {
+  const urls = [];
+  if (includeRuntime) {
+    urls.push(`${staticPath}/components/barefoot.js`);
+  }
+  if (manifest && components.length > 0) {
+    const dependencyScripts = resolveDependencyChain(components, manifest);
+    for (const script of dependencyScripts) {
+      urls.push(`${staticPath}/${script}`);
+    }
+  }
+  urls.push(...scripts);
+  const uniqueUrls = [...new Set(urls)];
+  return /* @__PURE__ */ jsxDEV(Fragment, {
+    children: uniqueUrls.map((url) => /* @__PURE__ */ jsxDEV("link", {
+      rel: "modulepreload",
+      href: url
+    }, undefined, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+export {
+  BfPreload
+};

package/dist/scripts.d.ts

@@ -0,0 +1,80 @@
+import { type BarefootBuildManifest } from './app';
+export type CollectedScript = {
+    src: string;
+};
+export interface BfScriptsProps {
+    /**
+     * Build manifest from `dist/components/manifest.json`. When supplied
+     * alongside `base`, the component follows each rendered entry's
+     * `stubDeps` transitively and emits a `<script>` for every reachable
+     * `.client.js` — necessary for pages that only touch a child
+     * component through an imperative stub call (issue #1243).
+     *
+     * When omitted, behavior matches the pre-#1243 collector: only
+     * components whose SSR function executed get a script tag.
+     */
+    manifest?: BarefootBuildManifest;
+    /**
+     * URL base where the component bundles are served (e.g.
+     * `/static/components/`). Required when `manifest` is supplied —
+     * stubDep entries store dist-relative paths and the component
+     * needs the URL prefix to emit a working `<script src>`.
+     */
+    base?: string;
+    /**
+     * Extra manifest keys to treat as walk roots in addition to the
+     * SSR-rendered set. Use this for pages that mount a `'use client'`
+     * component via an inline `<script type="module">import "X.client.js"; render(root, "X", …)`
+     * instead of SSR'ing `<X />` directly. Without `entryRoots`, the
+     * walker has no anchor for `X`'s `stubDeps` and any sibling `'use
+     * client'` `.tsx` reached only through the imperative
+     * `createComponent` stub rewrite (#1240) never ships as a
+     * `<script>`, leaving the runtime registry empty and rendering
+     * `[ComponentName]` placeholders.
+     *
+     * The caller's inline `<script type="module">import …</script>`
+     * already loads the root bundle, so the root itself is *not*
+     * emitted as a separate `<script src>` — only the transitively
+     * reached `stubDeps` are. See #1431.
+     */
+    entryRoots?: string[];
+}
+/**
+ * Renders all collected BarefootJS script tags.
+ * Place this component at the end of your <body> element.
+ *
+ * After rendering, sets 'bfScriptsRendered' flag to true.
+ * Components rendered after BfScripts (e.g., inside Suspense boundaries)
+ * will check this flag and output their scripts inline instead of
+ * collecting them here.
+ */
+export declare function BfScripts(props?: BfScriptsProps): import("hono/jsx/jsx-dev-runtime").JSX.Element | null;
+/**
+ * Walk stub-rewrite edges from each manifest entry in `roots`,
+ * returning the script URLs for every transitively reachable
+ * `.client.js` in **DFS post-order** — every dep precedes its
+ * dependent in iteration order. Skips any name already present in
+ * `excluded` (these have a script tag elsewhere). Mutates `excluded`
+ * to record every dep that's been resolved so the caller can pass
+ * it to the next SSR pass without double-emitting. Exported for tests.
+ *
+ * Typical call shape: `roots` ⊆ `excluded`. The caller passes the
+ * set of components whose SSR function already pushed a `<script>`
+ * (`bfOutputScripts`) as BOTH arguments — "these are already
+ * emitted, now walk their stubDeps." A `roots` value already in
+ * `excluded` is still walked (we need its `stubDeps`); a `dep`
+ * already in `excluded` is recorded as visited but not re-emitted.
+ *
+ * Why post-order: `<script type="module">` tags evaluate in document
+ * order with microtask checkpoints between them, so the first
+ * script's `hydrate()`-scheduled walk fires before any later
+ * module loads. A chain A→B→C must ship C, B, then A's bundle —
+ * BFS order (B, C) would let B's hydration call
+ * `createComponent('C', ...)` against an empty registry. Post-order
+ * also handles DAG edges like A→B, A→C, C→B correctly
+ * (deepest-first, dependencies-first).
+ *
+ * Cycle-safe: a visited set short-circuits any A → B → A loop.
+ */
+export declare function collectStubDepScripts(manifest: BarefootBuildManifest, base: string, roots: Iterable<string>, excluded: Set<string>): Map<string, CollectedScript>;
+//# sourceMappingURL=scripts.d.ts.map

package/dist/scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../src/scripts.tsx"],"names":[],"mappings":"AA0CA,OAAO,EAA6B,KAAK,qBAAqB,EAAE,MAAM,OAAO,CAAA;AAE7E,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAA;IAChC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;;;;;;;;;;;OAeG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,GAAE,cAAmB,yDAgEnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,GACpB,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CA0B9B"}

package/dist/scripts.js

@@ -0,0 +1,198 @@
+// src/dev-worker.ts
+var HEARTBEAT_MS = 5000;
+var BOOT_ID = generateBootId();
+function generateBootId() {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+  }
+}
+function isDevDefault() {
+  return true;
+}
+function createDevReloader(options = {}) {
+  const { enabled = isDevDefault() } = options;
+  return (c) => {
+    if (!enabled)
+      return c.notFound();
+    const lastEventId = (c.req.header("Last-Event-ID") ?? "").trim();
+    const signal = c.req.raw.signal;
+    const stream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder;
+        const send = (chunk) => {
+          try {
+            controller.enqueue(encoder.encode(chunk));
+          } catch {}
+        };
+        send(`retry: 1000
+
+`);
+        const event = lastEventId && lastEventId !== BOOT_ID ? "reload" : "hello";
+        send(`event: ${event}
+id: ${BOOT_ID}
+data: ${BOOT_ID}
+
+`);
+        const heartbeat = setInterval(() => send(`: hb
+
+`), HEARTBEAT_MS);
+        const onAbort = () => {
+          clearInterval(heartbeat);
+          try {
+            controller.close();
+          } catch {}
+        };
+        if (signal.aborted)
+          onAbort();
+        else
+          signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no"
+      }
+    });
+  };
+}
+
+// src/app.ts
+import { html, raw } from "hono/html";
+import { useRequestContext } from "hono/jsx-renderer";
+var DEV_RELOAD_ENDPOINT_KEY = "bfDevReloadEndpoint";
+function manifestToScriptUrls(manifest, base) {
+  const out = [];
+  const prefix = `${base.replace(/\/$/, "")}/`;
+  if (manifest.__barefoot__?.clientJs) {
+    out.push(prefix + relPathFromComponentsBase(manifest.__barefoot__.clientJs));
+  }
+  for (const [name, entry] of Object.entries(manifest)) {
+    if (name === "__barefoot__")
+      continue;
+    if (entry?.clientJs)
+      out.push(prefix + relPathFromComponentsBase(entry.clientJs));
+  }
+  return out;
+}
+function relPathFromComponentsBase(p) {
+  return p.startsWith("components/") ? p.slice("components/".length) : p;
+}
+function BfImportMap(props) {
+  const base = props.base.replace(/\/$/, "");
+  const json = JSON.stringify({
+    imports: {
+      "@barefootjs/client": `${base}/barefoot.js`,
+      "@barefootjs/client/runtime": `${base}/barefoot.js`
+    }
+  });
+  return html`<script type="importmap">${raw(json)}</script>`;
+}
+var __bfEmptyManifestWarned = false;
+function BfScripts(props) {
+  const urls = manifestToScriptUrls(props.manifest, props.base);
+  if (urls.length === 0 && !__bfEmptyManifestWarned) {
+    __bfEmptyManifestWarned = true;
+    console.warn("[barefootjs] BfScripts: manifest is empty — no <script> tags emitted. " + "Run `bf build` to compile components and rebuild the manifest.");
+  }
+  const tags = urls.map((src) => `<script type="module" src="${src}"></script>`).join("");
+  return html`${raw(tags)}`;
+}
+function BfDevReload(props = {}) {
+  let endpoint = props.endpoint;
+  if (!endpoint) {
+    try {
+      endpoint = useRequestContext().get(DEV_RELOAD_ENDPOINT_KEY);
+    } catch {}
+  }
+  if (!endpoint)
+    return null;
+  const ep = JSON.stringify(endpoint);
+  const snippet = `(()=>{if(window.__bfDevReload)return;window.__bfDevReload=1;try{var s=sessionStorage.getItem('__bf_devreload_scroll');if(s){sessionStorage.removeItem('__bf_devreload_scroll');var y=parseInt(s,10);if(!isNaN(y)){var restore=function(){window.scrollTo(0,y)};if(document.readyState==='loading'){addEventListener('DOMContentLoaded',restore,{once:true})}else{restore()}}}}catch(e){}var es=new EventSource(${ep});es.addEventListener('reload',function(){try{sessionStorage.setItem('__bf_devreload_scroll',String(window.scrollY))}catch(e){}location.reload()});es.addEventListener('error',function(){})})();`;
+  return html`<script>${raw(snippet)}</script>`;
+}
+function barefootDevReload(opts) {
+  if (!opts.enabled) {
+    return async (_c, next) => next();
+  }
+  const reloader = createDevReloader();
+  const endpoint = opts.endpoint;
+  return async (c, next) => {
+    c.set(DEV_RELOAD_ENDPOINT_KEY, endpoint);
+    if (c.req.method === "GET" && c.req.path === endpoint) {
+      return reloader(c);
+    }
+    await next();
+  };
+}
+
+// src/scripts.tsx
+import { useRequestContext as useRequestContext2 } from "hono/jsx-renderer";
+import { Fragment } from "hono/jsx";
+import { jsxDEV } from "hono/jsx/jsx-dev-runtime";
+function BfScripts2(props = {}) {
+  try {
+    const c = useRequestContext2();
+    c.set("bfScriptsRendered", true);
+    const scripts = c.get("bfCollectedScripts") || [];
+    const outputSet = c.get("bfOutputScripts") || new Set;
+    const { manifest, base, entryRoots } = props;
+    const roots = entryRoots && entryRoots.length > 0 ? new Set([...outputSet, ...entryRoots]) : outputSet;
+    if (entryRoots)
+      for (const r of entryRoots)
+        outputSet.add(r);
+    const stubScripts = manifest && base ? collectStubDepScripts(manifest, base, roots, outputSet) : new Map;
+    if (stubScripts.size > 0)
+      c.set("bfOutputScripts", outputSet);
+    const barefootScript = scripts.find((s) => s.src.includes("barefoot.js"));
+    const componentScripts = scripts.filter((s) => !s.src.includes("barefoot.js"));
+    const finalScripts = [
+      ...barefootScript ? [barefootScript] : [],
+      ...stubScripts.values(),
+      ...componentScripts.reverse()
+    ];
+    return /* @__PURE__ */ jsxDEV(Fragment, {
+      children: finalScripts.map(({ src }) => /* @__PURE__ */ jsxDEV("script", {
+        type: "module",
+        src
+      }, undefined, false, undefined, this))
+    }, undefined, false, undefined, this);
+  } catch {
+    return null;
+  }
+}
+function collectStubDepScripts(manifest, base, roots, excluded) {
+  const result = new Map;
+  const prefix = base.endsWith("/") ? base : base + "/";
+  const visited = new Set;
+  function visit(name) {
+    if (name === "__barefoot__")
+      return;
+    if (visited.has(name))
+      return;
+    visited.add(name);
+    const entry = manifest[name];
+    if (entry?.stubDeps) {
+      for (const dep of entry.stubDeps)
+        visit(dep);
+    }
+    if (excluded.has(name))
+      return;
+    excluded.add(name);
+    if (entry?.clientJs) {
+      const src = prefix + relPathFromComponentsBase(entry.clientJs);
+      result.set(name, { src });
+    }
+  }
+  for (const name of roots)
+    visit(name);
+  return result;
+}
+export {
+  collectStubDepScripts,
+  BfScripts2 as BfScripts
+};

package/dist/test-render.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hono test renderer
+ *
+ * Compiles JSX source with HonoAdapter and renders to HTML via Hono's app.request().
+ * Used by adapter-tests conformance runner.
+ */
+import type { TemplateAdapter } from '@barefootjs/jsx';
+export interface RenderOptions {
+    /** JSX source code */
+    source: string;
+    /** Template adapter to use */
+    adapter: TemplateAdapter;
+    /** Props to inject (optional) */
+    props?: Record<string, unknown>;
+    /** Additional component files (filename → source) */
+    components?: Record<string, string>;
+    /**
+     * Explicit component to render when the source declares multiple
+     * exports. When omitted, the first function-valued export in
+     * `Object.keys(mod)` iteration order is picked — that order is
+     * alphabetical for dynamically imported ES modules in Bun/V8, so
+     * relying on declaration order can pick the wrong component
+     * (e.g. `PropsReactivityComparison` before `ReactiveProps`).
+     */
+    componentName?: string;
+}
+export declare function renderHonoComponent(options: RenderOptions): Promise<string>;
+//# sourceMappingURL=test-render.d.ts.map

package/dist/test-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAQtD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,eAAe,CAAA;IACxB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA0GjF"}

package/dist/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Output HTML comment marker for conditional reconciliation.
+ * Same signature as Go template bfComment function.
+ */
+export declare function bfComment(key: string): import("hono/utils/html").HtmlEscapedString;
+/**
+ * Output opening comment marker for reactive text expressions.
+ * Renders <!--bf:slotId-->
+ */
+export declare function bfText(slotId: string): import("hono/utils/html").HtmlEscapedString;
+/**
+ * Output closing comment marker for reactive text expressions.
+ * Renders <!--/-->
+ */
+export declare function bfTextEnd(): import("hono/utils/html").HtmlEscapedString;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,+CAEpC;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,+CAEpC;AAED;;;GAGG;AACH,wBAAgB,SAAS,gDAExB"}

package/dist/utils.js

@@ -0,0 +1,16 @@
+// src/utils.ts
+import { raw } from "hono/html";
+function bfComment(key) {
+  return raw(`<!--bf-${key}-->`);
+}
+function bfText(slotId) {
+  return raw(`<!--bf:${slotId}-->`);
+}
+function bfTextEnd() {
+  return raw("<!--/-->");
+}
+export {
+  bfTextEnd,
+  bfText,
+  bfComment
+};