@bun-native/react 0.0.0-bootstrap.0 → 0.33.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bunly contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @bun-native/react
+
+React renderer for Bun Native desktop windows.
+
+Part of [Bun Native](https://github.com/0xPlayerOne/bun-native), an experimental developer preview. Version 0.33.0 was built from [fa8bef754122](https://github.com/0xPlayerOne/bun-native/tree/fa8bef754122621d4235eb06e30bb1085b4f7b1e) and published from GitHub Actions with npm provenance. Use the Bun revision pinned in that commit's toolchain.json. Start with the [getting-started guide](https://github.com/0xPlayerOne/bun-native/blob/fa8bef754122621d4235eb06e30bb1085b4f7b1e/docs/getting-started.md); `bun-native host install` fetches the matching release host. The license notice is in LICENSE.

package/bun-native-source.json

@@ -0,0 +1,59 @@
+{
+  "schemaVersion": 1,
+  "commit": "fa8bef754122621d4235eb06e30bb1085b4f7b1e",
+  "tree": "f805e2eb19a4e10fc29d1dc827cf5bc617b5773b",
+  "files": {
+    "package.json": {
+      "bytes": 2164,
+      "sha256": "db50b6f81f25c113a46f8c9b038bc548a92effaeb4ad9562e5e95044baa7b66f"
+    },
+    "packages/react/package.json": {
+      "bytes": 402,
+      "sha256": "18ac27eaf168a16c333e2b79e9aa7fa9ff9caf272fbf27523d865848946503ec"
+    },
+    "packages/react/src/commit-barrier.ts": {
+      "bytes": 987,
+      "sha256": "139f9f2827d3363642fee801e128dd1abf2a754d04550aca7d878493ef19bfd0"
+    },
+    "packages/react/src/index.ts": {
+      "bytes": 338,
+      "sha256": "211d06eb159c3afa4ceac566538e7cbc7ad4d106a4c58d05d7bb0cd842e2acda"
+    },
+    "packages/react/src/jsx-dev-runtime.ts": {
+      "bytes": 93,
+      "sha256": "bc127e1290abc7a6ba83fac0647b9f8ecca35c7aaa025a9ad25e35289a93bd85"
+    },
+    "packages/react/src/jsx-runtime.ts": {
+      "bytes": 92,
+      "sha256": "df1c78b5c254c4ccfa226d9b3d0c2b2a9dbf0733d40deac4f45cb47692a3763d"
+    },
+    "packages/react/src/jsx.ts": {
+      "bytes": 3189,
+      "sha256": "4458ba8196591d768d0c7d1a333e47fb2902f44b3e848b9fd7289f68092b8502"
+    },
+    "packages/react/src/mount.ts": {
+      "bytes": 7530,
+      "sha256": "73b271cb21be8774674a428550cd3cab42c065b6b8286f7c1c914e86fe65addd"
+    },
+    "packages/react/src/reconciler.ts": {
+      "bytes": 9500,
+      "sha256": "f29e9099e177009760406e4164bf8b740715d89bf6bc12b450cb4d575880615a"
+    },
+    "packages/react/src/root-errors.ts": {
+      "bytes": 963,
+      "sha256": "2380b9bcc709010f9f09bef444fda47fdda9f64f1fd22d0a4b351069ce09826a"
+    },
+    "LICENSE": {
+      "bytes": 1075,
+      "sha256": "86673fb485f12fa9aaa3941dfccc9f69a7f8322f8141d0d5c73db4323de10ac5"
+    }
+  },
+  "toolchain": {
+    "bytes": 3012,
+    "sha256": "00c3f707aae8abe9ca75cd2e162f5e1c7c34362a03675da39afead60d856066a"
+  },
+  "dependencyLock": {
+    "bytes": 28357,
+    "sha256": "65e3dbd01be4a1889367690faf1a9c3f08fb31d22dbd273d9bb9f39dd6baa6fb"
+  }
+}

package/package.json

@@ -1 +1,40 @@
-{"name":"@bun-native/react","version":"0.0.0-bootstrap.0","description":"Placeholder. Releases publish from GitHub Actions.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/0xPlayerOne/bun-native.git"}}
+{
+  "name": "@bun-native/react",
+  "version": "0.33.0",
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md",
+    "bun-native-source.json"
+  ],
+  "engines": {
+    "bun": "1.4.4-canary.1"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./jsx-runtime": "./src/jsx-runtime.ts",
+    "./jsx-dev-runtime": "./src/jsx-dev-runtime.ts"
+  },
+  "description": "React renderer for Bun Native desktop windows.",
+  "dependencies": {
+    "@bun-native/core": "0.33.0",
+    "@bun-native/renderer": "0.33.0",
+    "react": "19.3.1",
+    "react-reconciler": "0.34.0",
+    "@types/react": "19.3.0",
+    "@types/react-reconciler": "0.34.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xPlayerOne/bun-native.git",
+    "directory": "packages/react"
+  },
+  "homepage": "https://github.com/0xPlayerOne/bun-native#readme",
+  "bugs": "https://github.com/0xPlayerOne/bun-native/issues",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/src/commit-barrier.ts

@@ -0,0 +1,31 @@
+/** Revocable ownership for a callback retained by an opaque reconciler update. */
+export interface CommitBarrierBindings {
+  release: (() => void) | undefined
+  resolve: (() => void) | undefined
+  reject: ((cause: unknown) => void) | undefined
+}
+
+function settle(bindings: CommitBarrierBindings, failed: boolean, cause?: unknown): void {
+  const release = bindings.release
+  const resolve = bindings.resolve
+  const reject = bindings.reject
+  // Revoke the actual root/promise bindings before callbacks can reenter.
+  bindings.release = undefined
+  bindings.resolve = undefined
+  bindings.reject = undefined
+  release?.()
+  if (failed) reject?.(cause)
+  else resolve?.()
+}
+
+/** Keep this factory outside Root's scope; retained callbacks own only this cell. */
+export function createCommitBarrier(bindings: CommitBarrierBindings) {
+  return {
+    complete(): void {
+      settle(bindings, false)
+    },
+    reject(cause: unknown): void {
+      settle(bindings, true, cause)
+    },
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export {
+  focusNode,
+  inputState,
+  registerDropTarget,
+  scrollNodeIntoView,
+  scrollNodeTo,
+} from '@bun-native/renderer'
+export type { RendererNode as NativeRef } from '@bun-native/renderer'
+export { render } from './mount.ts'
+export type { ReactRenderOptions, ReactRenderRoot } from './mount.ts'
+export type { JSX } from './jsx.ts'

package/src/jsx-dev-runtime.ts

@@ -0,0 +1,2 @@
+export { Fragment, jsxDEV } from 'react/jsx-dev-runtime'
+export type { JSX } from './jsx.ts'

package/src/jsx-runtime.ts

@@ -0,0 +1,2 @@
+export { Fragment, jsx, jsxs } from 'react/jsx-runtime'
+export type { JSX } from './jsx.ts'

package/src/jsx.ts

@@ -0,0 +1,74 @@
+import type { Element as NativeElement, InputState } from '@bun-native/core'
+import type { EventHandlers, RendererNode } from '@bun-native/renderer'
+import type { JSX as ReactJSX, ReactNode, Ref } from 'react'
+
+export namespace JSX {
+  export type Element = ReactJSX.Element
+  export type ElementType = ReactJSX.ElementType
+  export type ElementClass = ReactJSX.ElementClass
+  export type ElementAttributesProperty = ReactJSX.ElementAttributesProperty
+  export type ElementChildrenAttribute = ReactJSX.ElementChildrenAttribute
+  export type LibraryManagedAttributes<C, P> = ReactJSX.LibraryManagedAttributes<C, P>
+  export type IntrinsicAttributes = ReactJSX.IntrinsicAttributes
+  export type IntrinsicClassAttributes<T> = ReactJSX.IntrinsicClassAttributes<T>
+
+  type Base<K extends NativeElement['kind']> = EventHandlers &
+    ReactJSX.IntrinsicAttributes & {
+      style?: NonNullable<Extract<NativeElement, { kind: K }>['style']>
+      ref?: Ref<RendererNode>
+    }
+  type TextContent = { text?: string; children?: ReactNode }
+  export interface IntrinsicElements {
+    /**
+     * Requires `accessibility_lists_v1` for the accessible members. A list's
+     * `accessibleSetSize` counts every item, mounted or not; an item's
+     * `accessiblePosition` is its 1-based place in that full set.
+     */
+    box: Base<'box'> & { children?: ReactNode } & {
+      accessibleRole?: 'list' | 'list_item'
+      /** Only with `accessibleRole`. */
+      accessibleLabel?: string
+      /** Only on a `list`. */
+      accessibleSetSize?: number
+      /** Only on a `list_item`; 1-based. */
+      accessiblePosition?: number
+      /** Only on a `list_item`. */
+      accessibleSelected?: boolean
+    }
+    text: Base<'text'> &
+      TextContent & {
+        /** Requires `accessibility_lists_v1`: announce the text when it appears and changes. */
+        accessibleLive?: 'polite' | 'assertive'
+      }
+    button: Base<'button'> & TextContent & { disabled?: boolean }
+    input: Base<'input'> & {
+      value?: string | InputState
+      placeholder?: string
+      /** Requires the host's `input_states_v1` capability. */
+      disabled?: boolean
+      /** Requires the host's `input_states_v1` capability. */
+      readOnly?: boolean
+    }
+    /** At most two pane children; the host owns the divider drag and keyboard steps. */
+    split: Base<'split'> & {
+      children?: ReactNode
+      ratio?: number
+      min_size?: number
+      /** Requires `accessibility_v1`: the divider's accessible name. */
+      accessibleLabel?: string
+    }
+    /** Painted above the ordinary tree; only window-anchored overlays may be modal. */
+    overlay: Base<'overlay'> & {
+      children?: ReactNode
+      /** Requires `overlay_keyboard_v1`: focus the first enabled control on open. */
+      autofocus?: boolean
+      /** Requires `overlay_keyboard_v1`: `menu` adds arrow-key roving focus and type-ahead. */
+      navigation?: 'tab' | 'menu'
+      /** Requires `accessibility_v1`: the dialog's accessible name. */
+      accessibleLabel?: string
+    } & (
+        | { anchor?: 'window'; modal?: boolean; surface?: 'layer' }
+        | { anchor: 'parent'; modal?: false; surface?: 'layer' | 'window' }
+      )
+  }
+}

package/src/mount.ts

@@ -0,0 +1,197 @@
+import { NativeStateError, type NativeWindow, type Style } from '@bun-native/core'
+import { createRenderRoot, type RenderOptions, type RenderRoot } from '@bun-native/renderer'
+import type { ErrorInfo, ReactNode } from 'react'
+import { ConcurrentRoot } from 'react-reconciler/constants'
+import { reconciler } from './reconciler.ts'
+import { createRootErrors } from './root-errors.ts'
+import { createCommitBarrier } from './commit-barrier.ts'
+
+type FiberRoot = ReturnType<typeof reconciler.createContainer>
+
+export interface ReactRenderRoot extends RenderRoot {
+  /** Submit a new React tree; resolves after its native acknowledgement. */
+  render(children: ReactNode): Promise<void>
+}
+
+export interface ReactRenderOptions extends RenderOptions {
+  /** Synchronously observe errors React recovered from; defaults to console.error. A thrown reporter error terminates this root. */
+  onRecoverableError?: (error: unknown, info: Readonly<ErrorInfo>) => void
+}
+
+class Root implements ReactRenderRoot {
+  readonly ready: Promise<void>
+  readonly closed: Promise<void>
+  private readonly native: RenderRoot
+  private fiber!: FiberRoot
+  private errors: ReturnType<typeof createRootErrors> | undefined
+  private element: ReactNode
+  private phase: 'active' | 'disposing' | 'closed' = 'active'
+  private failure: Error | undefined
+  private disposal: Promise<void> | undefined
+  private readonly barriers = new Set<ReturnType<typeof createCommitBarrier>>()
+
+  constructor(
+    children: ReactNode,
+    window: NativeWindow,
+    onRecoverableError: NonNullable<ReactRenderOptions['onRecoverableError']>,
+    style: Style | undefined
+  ) {
+    this.element = children
+    this.native = createRenderRoot(
+      window,
+      ({ container, onCleanup, fail }) => {
+        const terminate = (error: unknown) => {
+          this.failure ??= error instanceof Error ? error : new Error(String(error))
+          // React invokes this inside its commit. Teardown must start after that
+          // stack returns, rather than recursively entering Fiber's commit.
+          queueMicrotask(() => fail(this.failure))
+        }
+        this.errors = createRootErrors({ terminate, report: onRecoverableError })
+        this.fiber = reconciler.createContainer(
+          container,
+          ConcurrentRoot,
+          null,
+          false,
+          null,
+          '',
+          this.errors.uncaught,
+          this.errors.caught,
+          this.errors.recoverable,
+          this.errors.transition,
+          null
+        )
+        onCleanup(() => {
+          this.phase = 'disposing'
+          try {
+            reconciler.updateContainerSync(null, this.fiber, null)
+            reconciler.flushSyncWork()
+            reconciler.flushPassiveEffects()
+            // React reports unmount effect/ref errors through onUncaughtError.
+            // The shared root is already disposing, so forward the synchronous
+            // result here instead of relying on a later terminal-error request.
+            if (this.failure) throw this.failure
+          } finally {
+            // Framework teardown is terminal even while native removal awaits
+            // acknowledgement. Keep unmount errors active until this boundary.
+            this.errors?.release()
+            this.errors = undefined
+          }
+        })
+        reconciler.updateContainerSync(children, this.fiber, null)
+        reconciler.flushSyncWork()
+        if (this.failure !== undefined) throw this.failure
+        reconciler.flushPassiveEffects()
+      },
+      style === undefined ? {} : { style }
+    )
+    this.ready = this.native.ready.then(() => {
+      if (this.phase !== 'active')
+        throw new NativeStateError(
+          'invalid_handle',
+          'React root closed before initial native acknowledgement'
+        )
+    })
+    void this.ready.catch(() => {})
+    this.closed = this.native.closed
+    void this.closed.then(
+      () => this.finish(),
+      (error) => {
+        this.failure = error
+        this.finish()
+      }
+    )
+  }
+
+  get diagnostics() {
+    return this.native.diagnostics
+  }
+
+  private finish(): void {
+    this.phase = 'closed'
+    this.errors?.release()
+    this.errors = undefined
+    const error = this.failure ?? new NativeStateError('invalid_state', 'React root is closed')
+    for (const barrier of this.barriers) barrier.reject(error)
+    this.barriers.clear()
+    this.element = null
+    this.fiber = null
+  }
+
+  private assertActive(): void {
+    if (this.failure !== undefined) throw this.failure
+    if (this.phase !== 'active') throw new NativeStateError('invalid_state', 'React root is closed')
+  }
+
+  async render(children: ReactNode): Promise<void> {
+    this.assertActive()
+    this.element = children
+    reconciler.updateContainerSync(children, this.fiber, null)
+    reconciler.flushSyncWork()
+    await this.flush()
+  }
+
+  async flush(): Promise<void> {
+    this.assertActive()
+    // A normal-priority root update is a Fiber commit barrier for already
+    // scheduled ordinary hook updates. It does not wait for future async work,
+    // unresolved Suspense, or lower-priority transitions.
+    reconciler.flushPassiveEffects()
+    await new Promise<void>((resolve, reject) => {
+      if (this.barriers.size >= 128) {
+        reject(new NativeStateError('limit_exceeded', 'React commit barrier queue is full'))
+        return
+      }
+      const barrier = createCommitBarrier({
+        release: () => this.barriers.delete(barrier),
+        resolve,
+        reject,
+      })
+      this.barriers.add(barrier)
+      try {
+        reconciler.updateContainer(this.element, this.fiber, null, barrier.complete)
+      } catch (cause) {
+        // A rejected submission owns no future commit. Release its capacity and
+        // callback bindings now instead of poisoning all later flushes.
+        barrier.reject(cause)
+      }
+    })
+    // Native failure cleanup may already have entered disposal. Join it before
+    // checking local lifetime so the triggering operation preserves its cause.
+    await this.native.flush()
+    this.assertActive()
+    // Effect code may schedule future work; its mere execution is not evidence
+    // that another render is pending. Re-enqueuing barriers until this returns
+    // false would itself keep producing commits indefinitely.
+    reconciler.flushPassiveEffects()
+    await this.native.flush()
+  }
+
+  dispose(): Promise<void> {
+    if (!this.disposal) {
+      this.phase = 'disposing'
+      // A listener/layout effect may request disposal. Never reenter Fiber's
+      // render or commit from the current application callback stack.
+      this.disposal = reconciler.isAlreadyRendering()
+        ? Promise.resolve().then(() => this.native.dispose())
+        : this.native.dispose()
+    }
+    return this.disposal
+  }
+}
+
+/** Mount React into one independently disposable shared native subtree. */
+export function render(
+  children: ReactNode,
+  window: NativeWindow,
+  options: ReactRenderOptions = {}
+): ReactRenderRoot {
+  if (!options || typeof options !== 'object' || Array.isArray(options))
+    throw new TypeError('React render options must be an object')
+  for (const name of Object.keys(options))
+    if (name !== 'onRecoverableError' && name !== 'style')
+      throw new TypeError('Unknown React render option: ' + name)
+  const reporter = options.onRecoverableError
+  if (reporter !== undefined && typeof reporter !== 'function')
+    throw new TypeError('onRecoverableError must be a function')
+  return new Root(children, window, reporter ?? console.error, options.style)
+}

package/src/reconciler.ts

@@ -0,0 +1,258 @@
+import { UnsupportedFeatureError, type Listener, type NativeUIEvent } from '@bun-native/core'
+import {
+  createElement,
+  createTextNode,
+  insertNode,
+  isEventProperty,
+  removeNode,
+  replaceText,
+  setProperty,
+  type ElementTag,
+  type EventProperty,
+  type Node,
+  type PropertyName,
+  type RendererNode,
+} from '@bun-native/renderer'
+import { createContext } from 'react'
+import Reconciler from 'react-reconciler'
+import { DefaultEventPriority, NoEventPriority } from 'react-reconciler/constants'
+
+type Props = Readonly<Record<string, unknown>>
+type HostContext = Readonly<Record<string, never>>
+type Timer = ReturnType<typeof setTimeout>
+
+// Unsupported host surfaces use never; no React Fiber fields are inspected.
+type Config = Reconciler.HostConfig<
+  string,
+  Props,
+  Node,
+  Node,
+  Node,
+  never,
+  never,
+  never,
+  never,
+  RendererNode,
+  HostContext,
+  never,
+  Timer,
+  null,
+  null,
+  null,
+  never,
+  never,
+  never,
+  never
+>
+
+const context: HostContext = Object.freeze({})
+let updatePriority: Reconciler.EventPriority = NoEventPriority
+let activeEvent: { type: string; observedAt: number } | undefined
+type EventBinding = {
+  listener: Listener<NativeUIEvent> | undefined
+  dispatch: Listener<NativeUIEvent>
+}
+const bindings = new WeakMap<Node, Map<EventProperty, EventBinding>>()
+
+function unsupported(feature: string): never {
+  throw new UnsupportedFeatureError('react-' + feature)
+}
+
+// React requires these hooks even when a host has no corresponding resource.
+// Reuse their identical semantics instead of maintaining separate empty bodies.
+const noOp = (): void => {}
+const noInstance = () => null
+const returnFalse = () => false
+const hostContext = () => context
+
+function createBinding(listener: Listener<NativeUIEvent>): EventBinding {
+  const binding: EventBinding = { listener, dispatch }
+  function dispatch(event: NativeUIEvent): void | Promise<void> {
+    const current = binding.listener
+    if (!current) return
+    const previous = activeEvent
+    activeEvent = { type: event.type, observedAt: performance.now() }
+    try {
+      return reconciler.discreteUpdates(current, event, undefined, undefined, undefined)
+    } finally {
+      activeEvent = previous
+      reconciler.flushSyncWork()
+    }
+  }
+  return binding
+}
+
+function updateEvent(node: Node, name: EventProperty, value: unknown): void {
+  const registered = bindings.get(node)
+  const existing = registered?.get(name)
+  if (value === undefined) {
+    if (existing) existing.listener = undefined
+    registered?.delete(name)
+    setProperty(node, name, undefined)
+    return
+  }
+  if (typeof value !== 'function') throw new TypeError('Native event listeners must be functions')
+  // The callable boundary is checked here; core supplies the validated event.
+  const listener = value as Listener<NativeUIEvent>
+  if (existing) {
+    // React replaces inline closures on ordinary rerenders. Keep the node's
+    // native type/phase registration alive so queued events retain their ordering.
+    existing.listener = listener
+    return
+  }
+  const binding = createBinding(listener)
+  setProperty(node, name, binding.dispatch)
+  const next = registered ?? new Map<EventProperty, EventBinding>()
+  next.set(name, binding)
+  bindings.set(node, next)
+}
+
+function updateProperty(node: Node, name: string, value: unknown): void {
+  if (isEventProperty(name)) updateEvent(node, name, value)
+  // React props arrive as strings; the renderer rejects unknown names at runtime.
+  else setProperty(node, name as PropertyName, value)
+}
+
+const reserved = (name: string) => name === 'children' || name === 'ref' || name === 'key'
+
+type StyleObject = Readonly<Record<string, unknown>>
+const isStyleObject = (value: unknown): value is StyleObject =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+/**
+ * Inline `style={{ ... }}` is a new object on every render. The renderer keeps
+ * a shallow copy, so an object with the same own keys, in the same order, and
+ * the same values commits the identical element and sends no native set;
+ * setting it anyway would only recapture the node and its ancestors.
+ */
+function sameStyle(previous: unknown, next: unknown): boolean {
+  if (!isStyleObject(previous) || !isStyleObject(next)) return false
+  const names = Object.keys(previous)
+  const nextNames = Object.keys(next)
+  if (names.length !== nextNames.length) return false
+  for (let index = 0; index < names.length; index += 1) {
+    const name = names[index]!
+    if (name !== nextNames[index] || !Object.is(previous[name], next[name])) return false
+  }
+  return true
+}
+
+// React commits every rerendered host fiber, so this runs once per row of a
+// rerendered list: compare in place rather than allocating a merged key set.
+function updateProperties(node: Node, previous: Props, next: Props): void {
+  for (const name of Object.keys(previous))
+    if (!reserved(name) && !Object.hasOwn(next, name)) updateProperty(node, name, undefined)
+  for (const name of Object.keys(next)) {
+    if (reserved(name)) continue
+    const value = next[name]
+    if (Object.hasOwn(previous, name)) {
+      const old = previous[name]
+      if (Object.is(old, value) || (name === 'style' && sameStyle(old, value))) continue
+    }
+    updateProperty(node, name, value)
+  }
+}
+
+function createProperties(node: Node, props: Props): void {
+  for (const name of Object.keys(props))
+    if (!reserved(name)) updateProperty(node, name, props[name])
+}
+
+const host: Config = {
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: false,
+  supportsResources: false,
+  supportsSingletons: false,
+  supportsTestSelectors: false,
+  isPrimaryRenderer: true,
+  rendererVersion: '0.0.0',
+  rendererPackageName: '@bun-native/react',
+  extraDevToolsConfig: null,
+  bindToConsole(method, args) {
+    const log = method === 'warn' ? console.warn : method === 'error' ? console.error : console.log
+    return log.bind(console, ...args)
+  },
+  createInstance(type, props) {
+    // The host config types an element as any string; the renderer rejects unknown tags.
+    const node = createElement(type as ElementTag)
+    createProperties(node, props)
+    return node
+  },
+  createTextInstance: createTextNode,
+  appendInitialChild: insertNode,
+  finalizeInitialChildren: returnFalse,
+  shouldSetTextContent: returnFalse,
+  getRootHostContext: hostContext,
+  getChildHostContext: hostContext,
+  getPublicInstance: (node) => node,
+  prepareForCommit: noInstance,
+  resetAfterCommit: noOp,
+  preparePortalMount: unsupported.bind(null, 'portals'),
+  scheduleTimeout: setTimeout,
+  cancelTimeout: clearTimeout,
+  noTimeout: null,
+  supportsMicrotasks: true,
+  scheduleMicrotask: queueMicrotask,
+  getInstanceFromNode: noInstance,
+  beforeActiveInstanceBlur: noOp,
+  afterActiveInstanceBlur: noOp,
+  prepareScopeUpdate: unsupported.bind(null, 'scope'),
+  getInstanceFromScope: noInstance,
+  detachDeletedInstance(node) {
+    for (const binding of bindings.get(node)?.values() ?? []) binding.listener = undefined
+    bindings.delete(node)
+    node.children.length = 0
+    node.parent = undefined
+    for (const name of Object.keys(node.properties)) {
+      if (isEventProperty(name)) delete node.properties[name]
+    }
+  },
+  appendChild: insertNode,
+  appendChildToContainer: insertNode,
+  insertBefore: insertNode,
+  insertInContainerBefore: insertNode,
+  removeChild: removeNode,
+  removeChildFromContainer: removeNode,
+  commitTextUpdate: (node, _previous, next) => replaceText(node, next),
+  commitUpdate: (node, _type, previous, next) => updateProperties(node, previous, next),
+  hideInstance: unsupported.bind(null, 'hidden-subtrees'),
+  hideTextInstance: unsupported.bind(null, 'hidden-subtrees'),
+  unhideInstance: unsupported.bind(null, 'hidden-subtrees'),
+  unhideTextInstance: unsupported.bind(null, 'hidden-subtrees'),
+  clearContainer(container) {
+    // Removing the last child pops it; removing the first would leave a hole
+    // that the next `children` read compacts, making the loop quadratic.
+    const children = container.children
+    while (children.length) removeNode(container, children[children.length - 1]!)
+  },
+  NotPendingTransition: null,
+  HostTransitionContext: createContext(null),
+  setCurrentUpdatePriority(priority) {
+    updatePriority = priority
+  },
+  getCurrentUpdatePriority: () => updatePriority,
+  resolveUpdatePriority: () => updatePriority || DefaultEventPriority,
+  resetFormInstance: unsupported.bind(null, 'forms'),
+  requestPostPaintCallback: unsupported.bind(null, 'presentation-timing'),
+  shouldAttemptEagerTransition: returnFalse,
+  trackSchedulerEvent: noOp,
+  resolveEventType: () => activeEvent?.type ?? null,
+  resolveEventTimeStamp: () => activeEvent?.observedAt ?? -1,
+  maySuspendCommit: returnFalse,
+  maySuspendCommitOnUpdate: returnFalse,
+  maySuspendCommitInSyncRender: returnFalse,
+  preloadInstance: () => true,
+  startSuspendingCommit: noInstance,
+  suspendInstance: unsupported.bind(null, 'suspended-host-commit'),
+  // React 19.3 calls this for ordinary transition lanes too. This host has no
+  // active view-transition animation whose completion could delay a commit.
+  suspendOnActiveViewTransition: noOp,
+  createViewTransitionInstance: unsupported.bind(null, 'view-transitions'),
+  applyViewTransitionName: unsupported.bind(null, 'view-transitions'),
+  startViewTransition: unsupported.bind(null, 'view-transitions'),
+  waitForCommitToBeReady: noInstance,
+  getSuspendedCommitReason: noInstance,
+}
+
+export const reconciler = Reconciler(host)

package/src/root-errors.ts

@@ -0,0 +1,33 @@
+import type { ErrorInfo } from 'react'
+
+/** Owned callbacks must be revocable even while React retains an opaque root. */
+export interface RootErrorOwner {
+  terminate: ((error: unknown) => void) | undefined
+  report: ((error: unknown, info: Readonly<ErrorInfo>) => void) | undefined
+}
+
+function ignore(): void {}
+
+/** Created outside the Root constructor so callback scopes cannot capture its arguments. */
+export function createRootErrors(owner: RootErrorOwner) {
+  return {
+    uncaught(error: unknown): void {
+      owner.terminate?.(error)
+    },
+    caught: ignore,
+    transition: ignore,
+    recoverable(error: unknown, info: ErrorInfo): void {
+      const report = owner.report
+      if (!report) return
+      try {
+        report(error, Object.freeze({ ...info }))
+      } catch (reporterError) {
+        owner.terminate?.(reporterError)
+      }
+    },
+    release(): void {
+      owner.terminate = undefined
+      owner.report = undefined
+    },
+  }
+}