@pyreon/core 0.24.5 → 0.24.6

package/src/props.ts

@@ -1,269 +0,0 @@
-// Prop utilities for component authoring.
-
-/**
- * Split props into two groups: keys you want and the rest.
- * Unlike destructuring, this preserves reactivity (getters on the original object).
- *
- * @example
- * const [own, html] = splitProps(props, ["label", "icon"])
- * return <button {...html}><Icon name={own.icon} /> {own.label}</button>
- */
-export function splitProps<T extends object, K extends (keyof T)[]>(
-  props: T,
-  keys: K,
-): [Pick<T, K[number]>, Omit<T, K[number]>] {
-  const picked = {} as Pick<T, K[number]>
-  const rest = {} as Omit<T, K[number]>
-  const keySet = new Set<string | symbol>(keys as (string | symbol)[])
-
-  // Reflect.ownKeys includes symbol-keyed properties; Object.keys drops them
-  // silently. Without this, symbol-keyed props (e.g. branded reactive props
-  // under Symbol.for('pyreon.reactiveProp')) would vanish from both picked
-  // and rest.
-  for (const key of Reflect.ownKeys(props)) {
-    const desc = Object.getOwnPropertyDescriptor(props, key)
-    if (!desc) continue
-    // Force configurable: true when copying to a fresh object. Source descriptors
-    // may be non-configurable (default when created with `Object.defineProperty`
-    // and the caller omitted `configurable`). If we preserved that, any later
-    // `Object.defineProperty` on the same key — including subsequent splitProps
-    // post-processing or test mocks — would throw "Cannot redefine property".
-    const safe = { ...desc, configurable: true }
-    if (keySet.has(key)) {
-      Object.defineProperty(picked, key, safe)
-    } else {
-      Object.defineProperty(rest, key, safe)
-    }
-  }
-
-  return [picked, rest]
-}
-
-/** Merge a getter-backed source property with an existing getter or value. */
-function mergeGetterWithExisting(
-  result: Record<string, unknown>,
-  key: string,
-  desc: PropertyDescriptor,
-  existing: PropertyDescriptor,
-): void {
-  const prevGet = existing.get ?? (() => existing.value)
-  const nextGet = desc.get as () => unknown
-  Object.defineProperty(result, key, {
-    get: () => {
-      const v = nextGet()
-      return v !== undefined ? v : prevGet()
-    },
-    enumerable: true,
-    configurable: true,
-  })
-}
-
-/** Merge a static source property when the existing property has a getter. */
-function mergeStaticWithGetter(
-  result: Record<string, unknown>,
-  key: string,
-  desc: PropertyDescriptor,
-  existingGet: () => unknown,
-): void {
-  if (desc.value !== undefined) {
-    Object.defineProperty(result, key, { ...desc, configurable: true })
-  } else {
-    Object.defineProperty(result, key, {
-      get: existingGet,
-      enumerable: true,
-      configurable: true,
-    })
-  }
-}
-
-/** Apply a single source property onto the result object, handling getter/static combos. */
-function mergeProperty(
-  result: Record<string, unknown>,
-  key: string,
-  desc: PropertyDescriptor,
-): void {
-  const existing = Object.getOwnPropertyDescriptor(result, key)
-  if (desc.get && existing) {
-    mergeGetterWithExisting(result, key, desc, existing)
-  } else if (desc.get) {
-    // Force configurable: true — source getters may have been defined via
-    // `Object.defineProperty` without an explicit configurable flag (which
-    // defaults to false). Without this, a later source in the same mergeProps
-    // call that overrides the same key would crash with TypeError:
-    // "Cannot redefine property".
-    Object.defineProperty(result, key, { ...desc, configurable: true })
-  } else if (existing?.get) {
-    mergeStaticWithGetter(result, key, desc, existing.get)
-  } else if (desc.value !== undefined || !existing) {
-    // Both static — later value wins if defined
-    Object.defineProperty(result, key, { ...desc, configurable: true })
-  }
-}
-
-/**
- * Merge default values with component props. Defaults are used when
- * the prop is `undefined`. Preserves getter reactivity.
- *
- * @example
- * const merged = mergeProps({ size: "md", variant: "primary" }, props)
- * // merged.size is reactive — falls back to "md" when props.size is undefined
- */
-export function mergeProps<T extends Record<string, unknown>>(...sources: T[]): T {
-  const result = {} as T
-  for (const source of sources) {
-    // See splitProps for why this uses Reflect.ownKeys instead of Object.keys.
-    for (const key of Reflect.ownKeys(source)) {
-      const desc = Object.getOwnPropertyDescriptor(source, key)
-      if (!desc) continue
-      mergeProperty(result, key as string, desc)
-    }
-  }
-  return result
-}
-
-/**
- * Brand symbol for compiler-emitted reactive prop wrappers.
- * Distinguishes `() => expr` wrappers from user-written accessor props
- * (like Show's `when={() => condition()}`).
- */
-export const REACTIVE_PROP = Symbol.for('pyreon.reactiveProp')
-
-/** Symbol to access the underlying props signal for updates. */
-export const PROPS_SIGNAL = Symbol.for('pyreon.propsSignal')
-
-/**
- * Create a branded reactive prop wrapper.
- * Called by the compiler for component prop expressions containing signal reads.
- */
-export function _rp<T>(fn: () => T): () => T {
-  ;(fn as any)[REACTIVE_PROP] = true
-  return fn
-}
-
-/**
- * Wrap a JSX spread source so its getter-shaped reactive props survive
- * the JS-level object spread that esbuild's automatic JSX runtime emits
- * for `<Comp {...source}>`.
- *
- * Without this wrapper, esbuild compiles `<Comp {...source}>` to
- * `jsx(Comp, { ...source })` — and JS spread fires every getter on
- * `source`, storing the resolved values as plain data properties. Any
- * compiler-emitted reactive prop (`_rp(() => signal())` converted to a
- * getter by `makeReactiveProps`) on `source` is collapsed to its
- * initial value before the receiving component ever sees it.
- *
- * `_wrapSpread(source)` walks `source`'s own keys via `Reflect.ownKeys`
- * (no getter firing) and returns a new object whose values are
- * `_rp`-branded thunks `() => source[key]`. When `{ ..._wrapSpread(s) }`
- * is spread by esbuild, the thunks are stored as plain data property
- * values (no getters to fire), then `makeReactiveProps` in `mount.ts`
- * converts the brands back into getters that lazily read from the
- * original `source` — preserving the reactive subscription end-to-end.
- *
- * Fast path: when `source` has no getter descriptors, return the
- * source object unchanged. JS spread will work correctly in that case
- * because there's nothing reactive to preserve. Saves N thunk
- * allocations per component render in the 99% case.
- *
- * Emitted by the compiler — not generally meant for hand-written code.
- */
-export function _wrapSpread(
-  source: Record<string, unknown> | null | undefined,
-): Record<string, unknown> | null | undefined {
-  if (!source || typeof source !== 'object') return source
-  const descriptors = Object.getOwnPropertyDescriptors(source)
-  let hasGetter = false
-  for (const k in descriptors) {
-    if (descriptors[k]!.get) {
-      hasGetter = true
-      break
-    }
-  }
-  if (!hasGetter) return source
-
-  const result: Record<string, unknown> = {}
-  // Reflect.ownKeys covers symbol keys too — REACTIVE_PROP brands and
-  // other framework symbols must round-trip through the wrap.
-  for (const key of Reflect.ownKeys(source)) {
-    const desc = descriptors[key as string]
-    if (!desc) continue
-    if (desc.get) {
-      const fn: () => unknown = () => source[key as string]
-      ;(fn as unknown as Record<symbol, boolean>)[REACTIVE_PROP] = true
-      result[key as string] = fn
-    } else {
-      // Static data property — copy through as-is.
-      result[key as string] = desc.value
-    }
-  }
-  return result
-}
-
-/**
- * Convert compiler-emitted `_rp(() => expr)` prop values into getter properties.
- *
- * Only converts functions branded with REACTIVE_PROP — user-written accessor
- * props (like Show's when, For's each) are left as-is.
- *
- * Returns the same object if no reactive props found (fast path).
- */
-export function makeReactiveProps(
-  raw: Record<string, unknown>,
-): Record<string, unknown> {
-  // Fast path: scan for any REACTIVE_PROP-branded function first.
-  // If none found, return raw immediately — no object allocation, no property copying.
-  // This saves ~90 object allocations + ~450 property copies per page load
-  // for components with all-static props (buttons, icons, layout, etc.).
-  const keys = Object.keys(raw)
-  let hasAny = false
-  for (let i = 0; i < keys.length; i++) {
-    const val = raw[keys[i]!]
-    if (typeof val === 'function' && (val as any)[REACTIVE_PROP]) {
-      hasAny = true
-      break
-    }
-  }
-  if (!hasAny) return raw
-
-  // At least one reactive prop exists — build the getter-backed object.
-  const result: Record<string, unknown> = {}
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i]!
-    const val = raw[key]
-    if (typeof val === 'function' && (val as any)[REACTIVE_PROP]) {
-      Object.defineProperty(result, key, {
-        get: val as () => unknown,
-        enumerable: true,
-        configurable: true,
-      })
-    } else {
-      result[key] = val
-    }
-  }
-
-  return result
-}
-
-// ─── Unique ID ───────────────────────────────────────────────────────────────
-
-let _idCounter = 0
-
-/**
- * Generate a unique ID string for accessibility attributes (htmlFor, aria-describedby, etc.).
- * SSR-safe: uses a deterministic counter that resets per request context.
- *
- * @example
- * const id = createUniqueId()
- * return <>
- *   <label for={id}>Name</label>
- *   <input id={id} />
- * </>
- */
-export function createUniqueId(): string {
-  return `pyreon-${++_idCounter}`
-}
-
-/** Reset the ID counter (called by SSR per-request). */
-export function _resetIdCounter(): void {
-  _idCounter = 0
-}

package/src/ref.ts

@@ -1,32 +0,0 @@
-/**
- * createRef — mutable container for a DOM element or component value.
- *
- * Usage:
- *   const inputRef = createRef<HTMLInputElement>()
- *   onMount(() => { inputRef.current?.focus() })
- *   return <input ref={inputRef} />
- *
- * The runtime sets `ref.current` after the element is inserted into the DOM
- * and clears it to `null` when the element is removed.
- */
-
-export interface Ref<T = unknown> {
-  current: T | null
-}
-
-/** Callback ref — receives the element on mount and null on unmount. */
-export type RefCallback<T = unknown> = (el: T | null) => void
-
-/**
- * Union of object ref and callback ref — accepted by the JSX ref prop.
- * Callback refs are called with the element on mount and with `null` on
- * unmount (matches React/Solid/Vue). Callback refs MUST accept `T | null`
- * — the previous `(el: T) => void` mount-only arm was removed in the
- * post-#233 cleanup because the runtime always invokes with null on
- * unmount and the narrower type silently lied to consumers.
- */
-export type RefProp<T = unknown> = Ref<T> | RefCallback<T>
-
-export function createRef<T = unknown>(): Ref<T> {
-  return { current: null }
-}

package/src/show.ts

@@ -1,121 +0,0 @@
-import type { Props, VNode, VNodeChild, VNodeChildAtom } from './types'
-
-// ─── Show ─────────────────────────────────────────────────────────────────────
-
-export interface ShowProps extends Props {
-  /**
-   * Truthy condition. Accepts a value or an accessor.
-   *
-   * Use an accessor (`() => signal()`) for reactive conditions.
-   * Bare values are accepted for static cases and as a defensive normalization
-   * for cases where the compiler's signal auto-call has already invoked
-   * a signal at the prop site (e.g. `when={mySignal}` becomes `when={mySignal()}`).
-   */
-  when: unknown | (() => unknown)
-  fallback?: VNodeChild
-  children?: VNodeChild
-}
-
-// Normalize a value-or-accessor `when` into a single accessor.
-// Same shape used by Match — kept inline (one branch) to stay zero-cost.
-function callWhen(when: unknown): unknown {
-  return typeof when === 'function' ? (when as () => unknown)() : when
-}
-
-/**
- * Conditionally render children based on a reactive condition.
- *
- * @example
- * h(Show, { when: () => isLoggedIn() },
- *   h(Dashboard, null)
- * )
- *
- * // With fallback:
- * h(Show, { when: () => user(), fallback: h(Login, null) },
- *   h(Dashboard, null)
- * )
- */
-export function Show(props: ShowProps): VNode | null {
-  // Returns a reactive accessor; the renderer unwraps it at mount time.
-  return ((): VNodeChildAtom =>
-    (callWhen(props.when)
-      ? (props.children ?? null)
-      : (props.fallback ?? null)) as VNodeChildAtom) as unknown as VNode
-}
-
-// ─── Switch / Match ───────────────────────────────────────────────────────────
-
-export interface MatchProps extends Props {
-  /** Truthy condition. Accepts a value or an accessor — see {@link ShowProps.when}. */
-  when: unknown | (() => unknown)
-  children?: VNodeChild
-}
-
-/**
- * A branch inside `<Switch>`. Renders when `when()` is truthy.
- * Must be used as a direct child of `Switch`.
- *
- * `Match` acts as a pure type/identity marker — Switch identifies it by checking
- * `vnode.type === Match` rather than by the runtime return value.
- */
-export function Match(_props: MatchProps): VNode | null {
-  // Match is never mounted directly — Switch inspects Match VNodes by type identity.
-  return null
-}
-
-export interface SwitchProps extends Props {
-  /** Rendered when no Match branch is truthy. */
-  fallback?: VNodeChild
-  children?: VNodeChild | VNodeChild[]
-}
-
-/**
- * Multi-branch conditional rendering. Evaluates each `Match` child in order,
- * renders the first whose `when()` is truthy, or `fallback` if none match.
- *
- * @example
- * h(Switch, { fallback: h("p", null, "404") },
- *   h(Match, { when: () => route() === "/" }, h(Home, null)),
- *   h(Match, { when: () => route() === "/about" }, h(About, null)),
- * )
- */
-function isMatchVNode(branch: VNodeChild): branch is VNode {
-  return (
-    branch !== null &&
-    typeof branch === 'object' &&
-    !Array.isArray(branch) &&
-    (branch as VNode).type === Match
-  )
-}
-
-function resolveMatchChildren(matchVNode: VNode): VNodeChildAtom {
-  if (matchVNode.children.length === 0) {
-    return ((matchVNode.props as unknown as MatchProps).children ?? null) as VNodeChildAtom
-  }
-  if (matchVNode.children.length === 1) return matchVNode.children[0] as VNodeChildAtom
-  return matchVNode.children as unknown as VNodeChildAtom
-}
-
-function normalizeBranches(children: SwitchProps['children']): VNodeChild[] {
-  if (Array.isArray(children)) return children
-  if (children != null) return [children]
-  return []
-}
-
-export function Switch(props: SwitchProps): VNode | null {
-  // Returns a reactive accessor; the renderer unwraps it at mount time.
-  return ((): VNodeChildAtom => {
-    const branches = normalizeBranches(props.children)
-
-    for (const branch of branches) {
-      if (!isMatchVNode(branch)) continue
-      const matchProps = branch.props as unknown as MatchProps
-      if (callWhen(matchProps.when)) return resolveMatchChildren(branch)
-    }
-
-    return (props.fallback ?? null) as VNodeChildAtom
-  }) as unknown as VNode
-}
-
-// Keep MatchSymbol export for any code that was using it
-export const MatchSymbol: unique symbol = Symbol('pyreon.Match')

package/src/style.ts

@@ -1,102 +0,0 @@
-// Shared style utilities used by both runtime-dom and runtime-server.
-
-// CSS properties where numeric values are unitless (e.g. `opacity: 0.5`, `zIndex: 10`).
-// All other numeric values get "px" appended automatically (e.g. `height: 100` → `"100px"`).
-export const CSS_UNITLESS = new Set([
-  'animationIterationCount',
-  'aspectRatio',
-  'borderImageOutset',
-  'borderImageSlice',
-  'borderImageWidth',
-  'boxFlex',
-  'boxFlexGroup',
-  'boxOrdinalGroup',
-  'columnCount',
-  'columns',
-  'flex',
-  'flexGrow',
-  'flexPositive',
-  'flexShrink',
-  'flexNegative',
-  'flexOrder',
-  'gridArea',
-  'gridRow',
-  'gridRowEnd',
-  'gridRowSpan',
-  'gridRowStart',
-  'gridColumn',
-  'gridColumnEnd',
-  'gridColumnSpan',
-  'gridColumnStart',
-  'fontWeight',
-  'lineClamp',
-  'lineHeight',
-  'opacity',
-  'order',
-  'orphans',
-  'scale',
-  'tabSize',
-  'widows',
-  'zIndex',
-  'zoom',
-  'fillOpacity',
-  'floodOpacity',
-  'stopOpacity',
-  'strokeDasharray',
-  'strokeDashoffset',
-  'strokeMiterlimit',
-  'strokeOpacity',
-  'strokeWidth',
-])
-
-// ─── Class utilities ─────────────────────────────────────────────────────────
-
-/** Value accepted by the `class` prop — string, array, object, or nested mix. */
-export type ClassValue =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | ClassValue[]
-  | Record<string, boolean | null | undefined | (() => boolean)>
-
-function cxObject(obj: Record<string, boolean | null | undefined | (() => boolean)>): string {
-  let result = ''
-  for (const key in obj) {
-    const v = obj[key]
-    const truthy = typeof v === 'function' ? v() : v
-    if (truthy) result = result ? `${result} ${key}` : key
-  }
-  return result
-}
-
-function cxArray(arr: ClassValue[]): string {
-  let result = ''
-  for (const item of arr) {
-    const resolved = cx(item)
-    if (resolved) result = result ? `${result} ${resolved}` : resolved
-  }
-  return result
-}
-
-/** Resolve a ClassValue into a flat class string (like clsx/cx). */
-export function cx(value: ClassValue): string {
-  if (value == null || value === false || value === true) return ''
-  if (typeof value === 'string') return value
-  if (typeof value === 'number') return String(value)
-  if (Array.isArray(value)) return cxArray(value)
-  return cxObject(value)
-}
-
-// ─── Style utilities ─────────────────────────────────────────────────────────
-
-/** Convert a camelCase CSS property name to kebab-case. */
-export function toKebabCase(str: string): string {
-  return str.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)
-}
-
-/** Normalize a style value — appends "px" to numbers for non-unitless properties. */
-export function normalizeStyleValue(key: string, value: unknown): string {
-  return typeof value === 'number' && !CSS_UNITLESS.has(key) ? `${value}px` : String(value)
-}

package/src/suspense.ts

@@ -1,52 +0,0 @@
-import { Fragment, h } from './h'
-import type { Props, VNode, VNodeChild } from './types'
-
-// Dev-mode gate: see `pyreon/no-process-dev-gate` lint rule for why this
-// uses `import.meta.env.DEV` instead of `typeof process !== 'undefined'`.
-const __DEV__ = process.env.NODE_ENV !== 'production'
-
-/** Internal marker attached to lazy()-wrapped components */
-export type LazyComponent<P extends Props = Props> = ((props: P) => VNodeChild) & {
-  __loading: () => boolean
-}
-
-/**
- * Suspense — shows `fallback` while a lazy child component is still loading.
- *
- * Works in tandem with `lazy()` from `@pyreon/react-compat` (or `@pyreon/core/lazy`).
- * The child VNode's `.type.__loading()` signal drives the switch.
- *
- * Usage:
- *   const Page = lazy(() => import("./Page"))
- *
- *   h(Suspense, { fallback: h(Spinner, null) }, h(Page, null))
- *   // or with JSX:
- *   <Suspense fallback={<Spinner />}><Page /></Suspense>
- */
-export function Suspense(props: { fallback: VNodeChild; children?: VNodeChild }): VNode {
-  if (__DEV__ && props.fallback === undefined) {
-    // oxlint-disable-next-line no-console
-    console.warn(
-      '[Pyreon] <Suspense> is missing a `fallback` prop. Provide fallback UI to show while loading.',
-    )
-  }
-
-  return h(Fragment, null, () => {
-    const ch = props.children
-    const childNode = typeof ch === 'function' ? ch() : ch
-
-    // Check if the child is a VNode whose type is a lazy component still loading
-    const isLoading =
-      childNode != null &&
-      typeof childNode === 'object' &&
-      !Array.isArray(childNode) &&
-      typeof (childNode as VNode).type === 'function' &&
-      ((childNode as VNode).type as unknown as LazyComponent).__loading?.()
-
-    if (isLoading) {
-      const fb = props.fallback
-      return typeof fb === 'function' ? fb() : fb
-    }
-    return childNode
-  })
-}

package/src/telemetry.ts

@@ -1,120 +0,0 @@
-/**
- * Error telemetry — hook into Pyreon's error reporting for Sentry, Datadog, etc.
- *
- * Captures errors from ALL lifecycle phases including reactive effects.
- * `effect()` errors thrown by `@pyreon/reactivity` are bridged through a
- * globalThis sink (no upward import — reactivity doesn't depend on core).
- *
- * @example
- * import { registerErrorHandler } from "@pyreon/core"
- * import * as Sentry from "@sentry/browser"
- *
- * registerErrorHandler(ctx => {
- *   Sentry.captureException(ctx.error, {
- *     extra: { component: ctx.component, phase: ctx.phase },
- *   })
- * })
- */
-
-import { getReactiveTrace, type ReactiveTraceEntry } from '@pyreon/reactivity'
-
-// Bundler-agnostic dev gate (see pyreon/no-process-dev-gate).
-const __DEV__ = process.env.NODE_ENV !== 'production'
-
-export type { ReactiveTraceEntry }
-
-export interface ErrorContext {
-  /** Component function name, "Anonymous", or "Effect" for reactive effects */
-  component: string
-  /** Lifecycle phase where the error occurred */
-  phase: 'setup' | 'render' | 'mount' | 'unmount' | 'effect'
-  /** The thrown value */
-  error: unknown
-  /** Unix timestamp (ms) */
-  timestamp: number
-  /** Component props at the time of the error */
-  props?: Record<string, unknown>
-  /**
-   * The last N signal writes (chronological, oldest → newest) leading
-   * up to the error — the causal sequence of reactive state changes,
-   * not a point-in-time snapshot. Each entry is `{ name, prev, next,
-   * timestamp }` with `prev` / `next` as bounded string previews.
-   *
-   * Populated automatically in development from `@pyreon/reactivity`'s
-   * dev-only ring buffer. **`undefined` in production** — the recorder
-   * feeding the buffer tree-shakes out of prod bundles, so the cost is
-   * zero and the field is simply absent.
-   *
-   * For a signal framework this answers the first question a crash
-   * raises — "what reactive state changed in the run-up?" — that the
-   * thrown value + stack alone can't.
-   */
-  reactiveTrace?: ReactiveTraceEntry[]
-}
-
-export type ErrorHandler = (ctx: ErrorContext) => void
-
-let _handlers: ErrorHandler[] = []
-
-/**
- * Register a global error handler. Called whenever a component throws in any
- * lifecycle phase, OR an effect throws in `@pyreon/reactivity`. Returns an
- * unregister function.
- *
- * Also installs a `globalThis.__pyreon_report_error__` bridge so the
- * reactivity package (which can't depend on core) can forward effect errors
- * into the same telemetry pipeline. Pre-fix the two surfaces were
- * disconnected — Sentry/Datadog wiring missed effect-thrown errors.
- */
-export function registerErrorHandler(handler: ErrorHandler): () => void {
-  _handlers.push(handler)
-  _installReactivityBridge()
-  return () => {
-    _handlers = _handlers.filter((h) => h !== handler)
-  }
-}
-
-/**
- * Internal — called by the runtime whenever a component error is caught.
- * Existing console.error calls are preserved; this is additive.
- */
-export function reportError(ctx: ErrorContext): void {
-  // Enrich with the recent-signal-write trace so every handler (Sentry,
-  // Datadog, console) gets the causal reactive sequence for free. Only
-  // when the caller didn't already supply one, and only in dev — the
-  // gate lets the `getReactiveTrace` call (and the buffer behind it)
-  // tree-shake out of production. A throwing/empty trace must never
-  // block error reporting, so it's best-effort.
-  if (__DEV__ && ctx.reactiveTrace === undefined) {
-    try {
-      const trace = getReactiveTrace()
-      if (trace.length > 0) ctx.reactiveTrace = trace
-    } catch {
-      // Trace capture is diagnostic — never let it swallow the real error.
-    }
-  }
-  for (const h of _handlers) {
-    try {
-      h(ctx)
-    } catch {
-      // handler errors must never propagate back into the framework
-    }
-  }
-}
-
-// ─── Reactivity bridge ──────────────────────────────────────────────────────
-// Installs `globalThis.__pyreon_report_error__` so `@pyreon/reactivity`
-// effect-error path can forward into reportError. Idempotent — multiple
-// `registerErrorHandler` calls install once.
-
-interface PyreonErrorBridge {
-  __pyreon_report_error__?: (err: unknown, phase: 'effect') => void
-}
-const _bridgeHost = globalThis as PyreonErrorBridge
-
-function _installReactivityBridge(): void {
-  if (_bridgeHost.__pyreon_report_error__) return
-  _bridgeHost.__pyreon_report_error__ = (err, phase) => {
-    reportError({ component: 'Effect', phase, error: err, timestamp: Date.now() })
-  }
-}