@barefootjs/hono 0.6.1 → 0.8.0

package/dist/adapter/hono-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hono-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/hono-adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"hono-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/hono-adapter.ts"],"names":[],"mappings":"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"}

package/dist/adapter/index.js

@@ -100,8 +100,11 @@ export default ${this.componentName}` : "";
     if (utilImports.length > 0) {
       lines.push(`import { ${utilImports.join(", ")} } from '@barefootjs/hono/utils'`);
     }
-    if (componentCode.includes("<Suspense")) {
-      lines.push(`import { Suspense } from 'hono/jsx/streaming'`);
+    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) {
@@ -518,7 +521,7 @@ export default ${this.componentName}` : "";
   renderAsync(node) {
     const fallback = this.renderNode(node.fallback);
     const children = this.renderChildren(node.children);
-    return `<Suspense fallback={<>${fallback}</>}>${children}</Suspense>`;
+    return `<__BfErrorBoundary fallback={<>${fallback}</>}>` + `<__BfSuspense fallback={<>${fallback}</>}>${children}</__BfSuspense>` + `</__BfErrorBoundary>`;
   }
   renderComponent(comp, ctx) {
     const props = this.renderComponentProps(comp);

package/dist/async.d.ts

@@ -4,12 +4,21 @@ export interface BfAsyncProps {
     fallback: Child;
     /** Async children that will be streamed when resolved. */
     children: Child;
+    /**
+     * Optional observer invoked when the body throws synchronously or its
+     * async resolution rejects. The `fallback` is rendered either way; this
+     * hook only exists so the error isn't swallowed silently (logging,
+     * metrics). It does not change what is rendered.
+     */
+    onError?: (error: Error) => void;
 }
 /**
  * Async streaming boundary component.
  *
  * Renders fallback content immediately (sent in the initial HTTP response
- * for fast TTFB), then streams the resolved children when ready.
+ * for fast TTFB), then streams the resolved children when ready. If the
+ * body throws (sync) or rejects (async), the same fallback is rendered via
+ * the surrounding `ErrorBoundary`.
  */
 export declare function BfAsync(props: BfAsyncProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
 //# sourceMappingURL=async.d.ts.map

package/dist/async.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../src/async.tsx"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAErC,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,QAAQ,EAAE,KAAK,CAAA;IACf,0DAA0D;IAC1D,QAAQ,EAAE,KAAK,CAAA;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,kDAM1C"}
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../src/async.tsx"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAErC,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,QAAQ,EAAE,KAAK,CAAA;IACf,0DAA0D;IAC1D,QAAQ,EAAE,KAAK,CAAA;IACf;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACjC;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,kDAQ1C"}

package/dist/async.js

@@ -1,10 +1,15 @@
 // src/async.tsx
 import { Suspense } from "hono/jsx/streaming";
+import { ErrorBoundary } from "hono/jsx";
 import { jsxDEV } from "hono/jsx/jsx-dev-runtime";
 function BfAsync(props) {
-  return /* @__PURE__ */ jsxDEV(Suspense, {
+  return /* @__PURE__ */ jsxDEV(ErrorBoundary, {
     fallback: props.fallback,
-    children: props.children
+    onError: props.onError,
+    children: /* @__PURE__ */ jsxDEV(Suspense, {
+      fallback: props.fallback,
+      children: props.children
+    }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
 export {

package/dist/build.js

@@ -100,8 +100,11 @@ export default ${this.componentName}` : "";
     if (utilImports.length > 0) {
       lines.push(`import { ${utilImports.join(", ")} } from '@barefootjs/hono/utils'`);
     }
-    if (componentCode.includes("<Suspense")) {
-      lines.push(`import { Suspense } from 'hono/jsx/streaming'`);
+    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) {
@@ -518,7 +521,7 @@ export default ${this.componentName}` : "";
   renderAsync(node) {
     const fallback = this.renderNode(node.fallback);
     const children = this.renderChildren(node.children);
-    return `<Suspense fallback={<>${fallback}</>}>${children}</Suspense>`;
+    return `<__BfErrorBoundary fallback={<>${fallback}</>}>` + `<__BfSuspense fallback={<>${fallback}</>}>${children}</__BfSuspense>` + `</__BfErrorBoundary>`;
   }
   renderComponent(comp, ctx) {
     const props = this.renderComponentProps(comp);

package/dist/index.js

@@ -100,8 +100,11 @@ export default ${this.componentName}` : "";
     if (utilImports.length > 0) {
       lines.push(`import { ${utilImports.join(", ")} } from '@barefootjs/hono/utils'`);
     }
-    if (componentCode.includes("<Suspense")) {
-      lines.push(`import { Suspense } from 'hono/jsx/streaming'`);
+    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) {
@@ -518,7 +521,7 @@ export default ${this.componentName}` : "";
   renderAsync(node) {
     const fallback = this.renderNode(node.fallback);
     const children = this.renderChildren(node.children);
-    return `<Suspense fallback={<>${fallback}</>}>${children}</Suspense>`;
+    return `<__BfErrorBoundary fallback={<>${fallback}</>}>` + `<__BfSuspense fallback={<>${fallback}</>}>${children}</__BfSuspense>` + `</__BfErrorBoundary>`;
   }
   renderComponent(comp, ctx) {
     const props = this.renderComponentProps(comp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/hono",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Hono integration for BarefootJS",
   "type": "module",
   "main": "./dist/index.js",

package/src/__tests__/async-error-boundary.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Hono adapter: compiled `<Async>` boundary wraps its body in ErrorBoundary
+ * for the body error path (#1375).
+ *
+ * The compiler lowers `<Async fallback={…}>…</Async>` to an `IRAsync` node;
+ * the Hono adapter's `renderAsync` emits it into the generated SSR template.
+ * A bare `<Suspense>` mishandles a body that fails at render time: a
+ * synchronous throw aborts the stream with empty output, and a Promise
+ * rejection during async resolution escapes as an unhandled rejection while
+ * the loading fallback is left stranded.
+ *
+ * The fix wraps the streaming body in Hono's `ErrorBoundary` with the same
+ * `fallback`, mirroring the hand-written `BfAsync` runtime component
+ * (`../async.tsx`). The runtime behaviour itself is asserted in
+ * `async.test.tsx`; this test pins the *emit shape* of the compiled path.
+ */
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '@barefootjs/jsx'
+import { HonoAdapter } from '../adapter'
+
+const adapter = new HonoAdapter()
+
+function templateOf(source: string): string {
+  const result = compileJSX(source, 'Page.tsx', { adapter })
+  expect(result.errors.filter((e) => e.severity === 'error')).toEqual([])
+  return result.files.find((f) => f.type === 'markedTemplate')?.content ?? ''
+}
+
+describe('compiled <Async> boundary — ErrorBoundary wrapping (#1375)', () => {
+  test('emits ErrorBoundary enclosing Suspense, sharing the fallback', () => {
+    const template = templateOf(`
+      export function Page() {
+        return (
+          <div>
+            <Async fallback={<p>Loading...</p>}>
+              <span>Resolved</span>
+            </Async>
+          </div>
+        )
+      }
+    `)
+
+    // Tags are emitted under `__Bf`-prefixed aliases so they can't collide
+    // with a user component named `ErrorBoundary` / `Suspense` (#1375).
+    expect(template).toContain('<__BfErrorBoundary fallback={<>')
+    expect(template).toContain('<__BfSuspense fallback={<>')
+    // ErrorBoundary must enclose Suspense (catch errors raised while the
+    // Suspense body resolves), not the reverse.
+    expect(template.indexOf('<__BfErrorBoundary')).toBeLessThan(template.indexOf('<__BfSuspense'))
+    expect(template).toContain('</__BfSuspense></__BfErrorBoundary>')
+  })
+
+  test('injects the aliased ErrorBoundary import alongside Suspense', () => {
+    const template = templateOf(`
+      export function Page() {
+        return (
+          <Async fallback={<p>Loading...</p>}>
+            <span>Resolved</span>
+          </Async>
+        )
+      }
+    `)
+
+    expect(template).toContain(`import { Suspense as __BfSuspense } from 'hono/jsx/streaming'`)
+    expect(template).toContain(`import { ErrorBoundary as __BfErrorBoundary } from 'hono/jsx'`)
+  })
+
+  test('aliasing avoids a duplicate import when the body uses a user component named ErrorBoundary', () => {
+    // Regression for the bare-name collision: a user component literally
+    // named `ErrorBoundary` used inside the boundary must not cause the
+    // injected Hono import to duplicate the user's own `ErrorBoundary`
+    // binding (which would be a "Duplicate identifier" build error).
+    const template = templateOf(`
+      import { ErrorBoundary } from './my-error-boundary'
+      export function Page() {
+        return (
+          <Async fallback={<ErrorBoundary><p>fail</p></ErrorBoundary>}>
+            <span>Resolved</span>
+          </Async>
+        )
+      }
+    `)
+
+    // Exactly one `ErrorBoundary` binding survives — the user's. The Hono
+    // wrapper imports under the `__BfErrorBoundary` alias, so no collision.
+    const bareImports = template.match(/import \{ ErrorBoundary \} from/g) ?? []
+    expect(bareImports.length).toBe(1)
+    expect(template).toContain(`import { ErrorBoundary } from './my-error-boundary'`)
+    expect(template).toContain(`import { ErrorBoundary as __BfErrorBoundary } from 'hono/jsx'`)
+  })
+
+  test('each of multiple boundaries gets its own ErrorBoundary wrapper', () => {
+    const template = templateOf(`
+      export function Dashboard() {
+        return (
+          <div>
+            <Async fallback={<p>A...</p>}>
+              <span>A</span>
+            </Async>
+            <Async fallback={<p>B...</p>}>
+              <span>B</span>
+            </Async>
+          </div>
+        )
+      }
+    `)
+
+    const wrappers = template.match(/<__BfErrorBoundary fallback=\{<>/g) ?? []
+    expect(wrappers.length).toBe(2)
+  })
+})

package/src/__tests__/async.test.tsx

@@ -33,13 +33,15 @@ describe('BfAsync', () => {
       </BfAsync>
     )
 
-    const chunks = await collectStream(stream)
+    const fullOutput = (await collectStream(stream)).join('')
 
-    // First chunk has fallback
-    expect(chunks[0]).toContain('Loading...')
-    // Later chunk has resolved content
-    const fullOutput = chunks.join('')
+    // Fallback streams first, resolved content swaps in afterwards. The
+    // body is wrapped in an ErrorBoundary (#1375) whose template/swap
+    // markers now lead the stream, so assert ordering across the full
+    // output rather than pinning the fallback to a literal `chunks[0]`.
+    expect(fullOutput).toContain('Loading...')
     expect(fullOutput).toContain('Loaded!')
+    expect(fullOutput.indexOf('Loading...')).toBeLessThan(fullOutput.indexOf('Loaded!'))
   })
 
   it('renders multiple async boundaries independently', async () => {
@@ -89,7 +91,7 @@ describe('BfAsync', () => {
     expect(fullOutput).toContain('bf-p=')
   })
 
-  it('renders synchronous children without streaming', async () => {
+  it('renders synchronous children without a fallback flash', async () => {
     const SyncContent = () => <div>Already here</div>
 
     const stream = renderToReadableStream(
@@ -98,9 +100,126 @@ describe('BfAsync', () => {
       </BfAsync>
     )
 
-    const chunks = await collectStream(stream)
+    const fullOutput = (await collectStream(stream)).join('')
+
+    // Synchronous content needs no fallback round-trip: it resolves in the
+    // initial flush and the loading fallback never appears. The
+    // ErrorBoundary wrapper (#1375) routes the content through a
+    // template/swap chunk, so it is no longer literally `chunks[0]`, but
+    // there is still no `Loading...` flash.
+    expect(fullOutput).toContain('Already here')
+    expect(fullOutput).not.toContain('Loading...')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error paths (#1375): a body that throws — synchronously or asynchronously.
+//
+// A bare `<Suspense>` mishandles both: a synchronous throw aborts the stream
+// with empty output (no fallback), and a rejection during async resolution
+// escapes as an unhandled rejection while the loading fallback is stranded.
+// `BfAsync` wraps the body in Hono's `ErrorBoundary` so the same `fallback`
+// is rendered on either failure and the error never leaks.
+//
+// These are the two cases the Layer 1 / streaming layer can observe directly
+// (a single SSR render). The remaining catalog cases — reset-signal re-mount
+// and throw-during-cleanup — are client-lifecycle behaviours covered by the
+// Layer 6 fixme stubs in `site/ui/e2e/stress-1244.spec.ts`.
+// ---------------------------------------------------------------------------
+
+describe('BfAsync — error paths (#1375)', () => {
+  // A render that errors must not surface a stray unhandled rejection on the
+  // process: install a guard for the duration of each test and assert it
+  // stayed quiet. `BfAsync`'s ErrorBoundary is what keeps it quiet.
+  function trackUnhandledRejections(): { count: () => number; restore: () => void } {
+    let n = 0
+    const onRejection = () => {
+      n++
+    }
+    process.on('unhandledRejection', onRejection)
+    return {
+      count: () => n,
+      restore: () => process.off('unhandledRejection', onRejection),
+    }
+  }
+
+  it('synchronous throw in the body renders the fallback (not empty output)', async () => {
+    const Boom = (): HtmlEscapedString => {
+      throw new Error('sync-boom')
+    }
+
+    const guard = trackUnhandledRejections()
+    let onErrorMessage: string | undefined
+    try {
+      const stream = renderToReadableStream(
+        <BfAsync
+          fallback={<p>Fallback shown</p>}
+          onError={(e) => {
+            onErrorMessage = e.message
+          }}
+        >
+          <Boom />
+        </BfAsync>
+      )
+      const fullOutput = (await collectStream(stream)).join('')
+
+      // The fallback is rendered (a bare <Suspense> would yield empty output).
+      expect(fullOutput).toContain('Fallback shown')
+      // onError observed the failure so it isn't swallowed silently.
+      expect(onErrorMessage).toBe('sync-boom')
+    } finally {
+      guard.restore()
+    }
+  })
+
+  it('async rejection during resolution renders the fallback and leaks no rejection', async () => {
+    const Rejects = (): Promise<HtmlEscapedString> =>
+      new Promise((_resolve, reject) =>
+        setTimeout(() => reject(new Error('async-boom')), 10)
+      )
+
+    const guard = trackUnhandledRejections()
+    let onErrorMessage: string | undefined
+    try {
+      const stream = renderToReadableStream(
+        <BfAsync
+          fallback={<p>Fallback shown</p>}
+          onError={(e) => {
+            onErrorMessage = e.message
+          }}
+        >
+          <Rejects />
+        </BfAsync>
+      )
+      const fullOutput = (await collectStream(stream)).join('')
+
+      // Fallback is the final rendered state; the rejected content never
+      // mutates into the DOM late.
+      expect(fullOutput).toContain('Fallback shown')
+      expect(onErrorMessage).toBe('async-boom')
+
+      // Give any stray rejection a tick to surface, then assert none did.
+      await new Promise((r) => setTimeout(r, 0))
+      expect(guard.count()).toBe(0)
+    } finally {
+      guard.restore()
+    }
+  })
+
+  it('the happy path still streams resolved content past the error boundary', async () => {
+    // Wrapping the body in ErrorBoundary must not regress normal streaming.
+    const AsyncContent = () =>
+      new Promise<HtmlEscapedString>((resolve) =>
+        setTimeout(() => resolve(<div>Loaded past boundary</div>), 10)
+      )
+
+    const stream = renderToReadableStream(
+      <BfAsync fallback={<p>Loading...</p>}>
+        <AsyncContent />
+      </BfAsync>
+    )
 
-    // Synchronous content should be in the first chunk (no fallback needed)
-    expect(chunks[0]).toContain('Already here')
+    const fullOutput = (await collectStream(stream)).join('')
+    expect(fullOutput).toContain('Loaded past boundary')
   })
 })

package/src/adapter/hono-adapter.ts

@@ -229,9 +229,16 @@ export class HonoAdapter extends JsxAdapter implements IRNodeEmitter<HonoRenderC
       lines.push(`import { ${utilImports.join(', ')} } from '@barefootjs/hono/utils'`)
     }
 
-    // Import Suspense when async boundaries are used
-    if (componentCode.includes('<Suspense')) {
-      lines.push(`import { Suspense } from 'hono/jsx/streaming'`)
+    // Import Suspense / ErrorBoundary when async boundaries are used. Both
+    // are imported under `__Bf`-prefixed aliases (and emitted as such by
+    // `renderAsync`) so the generated tags can never collide with a user
+    // component literally named `Suspense` or `ErrorBoundary` — a bare-name
+    // import would otherwise duplicate the user's own import binding (#1375).
+    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'`)
     }
 
     // Re-emit template imports, rewriting `@barefootjs/client` to this
@@ -962,7 +969,19 @@ export class HonoAdapter extends JsxAdapter implements IRNodeEmitter<HonoRenderC
   renderAsync(node: IRAsync): string {
     const fallback = this.renderNode(node.fallback)
     const children = this.renderChildren(node.children)
-    return `<Suspense fallback={<>${fallback}</>}>${children}</Suspense>`
+    // Wrap the streaming body in an ErrorBoundary so a synchronous throw or
+    // a rejected Promise during async resolution falls back to the same
+    // `fallback` instead of aborting the stream / leaking an unhandled
+    // rejection. Mirrors the runtime `BfAsync` component (#1375).
+    //
+    // Both tags use `__Bf`-prefixed aliases (see the import injection above)
+    // so they can't collide with a user component named `Suspense` /
+    // `ErrorBoundary` in the same module.
+    return (
+      `<__BfErrorBoundary fallback={<>${fallback}</>}>` +
+      `<__BfSuspense fallback={<>${fallback}</>}>${children}</__BfSuspense>` +
+      `</__BfErrorBoundary>`
+    )
   }
 
   renderComponent(comp: IRComponent, ctx?: { isRootOfClientComponent?: boolean; isInsideLoop?: boolean; isLoopItemRoot?: boolean }): string {

package/src/async.tsx

@@ -14,6 +14,16 @@
  * Suspense/streaming. The BarefootJS hydration runtime automatically picks
  * up components rendered inside async boundaries via requestAnimationFrame.
  *
+ * The body is additionally wrapped in Hono's `ErrorBoundary` so that a
+ * failure during render — a synchronous `throw` in a child, or a rejected
+ * Promise during async resolution — surfaces the same `fallback` instead
+ * of producing empty output (sync case) or leaking an unhandled rejection
+ * (async case). Without the boundary a bare `<Suspense>` does neither:
+ * a synchronous throw aborts the stream with no fallback, and a rejection
+ * during streaming escapes as an unhandled rejection while the loading
+ * fallback is left stranded. See `__tests__/async.test.tsx` error-path
+ * cases (#1375).
+ *
  * Usage:
  * ```tsx
  * import { BfAsync } from '@barefootjs/hono/async'
@@ -31,6 +41,7 @@
  */
 
 import { Suspense } from 'hono/jsx/streaming'
+import { ErrorBoundary } from 'hono/jsx'
 import type { Child } from 'hono/jsx'
 
 export interface BfAsyncProps {
@@ -38,18 +49,29 @@ export interface BfAsyncProps {
   fallback: Child
   /** Async children that will be streamed when resolved. */
   children: Child
+  /**
+   * Optional observer invoked when the body throws synchronously or its
+   * async resolution rejects. The `fallback` is rendered either way; this
+   * hook only exists so the error isn't swallowed silently (logging,
+   * metrics). It does not change what is rendered.
+   */
+  onError?: (error: Error) => void
 }
 
 /**
  * Async streaming boundary component.
  *
  * Renders fallback content immediately (sent in the initial HTTP response
- * for fast TTFB), then streams the resolved children when ready.
+ * for fast TTFB), then streams the resolved children when ready. If the
+ * body throws (sync) or rejects (async), the same fallback is rendered via
+ * the surrounding `ErrorBoundary`.
  */
 export function BfAsync(props: BfAsyncProps) {
   return (
-    <Suspense fallback={props.fallback}>
-      {props.children}
-    </Suspense>
+    <ErrorBoundary fallback={props.fallback} onError={props.onError}>
+      <Suspense fallback={props.fallback}>
+        {props.children}
+      </Suspense>
+    </ErrorBoundary>
   )
 }