@xmachines/play-react 2.0.0 → 2.1.0

package/dist/useSignalEffect.d.ts

@@ -1,71 +1,72 @@
 /**
- * useSignalEffect - React hook for signal subscriptions with automatic cleanup
+ * useSignalEffect - the React hook that subscribes to a signal and cleans up by itself
  *
  * @packageDocumentation
  */
 import type { DependencyList } from "react";
 /**
- * React hook that subscribes to signal changes and runs effect callback
+ * The React hook that subscribes to the signal changes and runs an effect callback
  *
- * Wraps the callback in a Signal.Computed to automatically track signal
- * dependencies accessed inside it, then delegates the watcher lifecycle
- * (microtask batching, re-arming, disposal) to `watchSignal` from
- * `@xmachines/play-signals` — the single canonical implementation shared
- * across framework renderers.
+ * The hook puts the callback in a Signal.Computed, which tracks each signal that
+ * the callback reads. It then gives the watcher lifecycle to `watchSignal` from
+ * `@xmachines/play-signals`. That function does the microtask batching, the new arm
+ * of the watcher, and the disposal. It is the one canonical implementation, and
+ * every framework renderer uses it.
  *
  * Architecture:
- * - Uses Signal.Computed to wrap callback for automatic dependency tracking
- * - watchSignal owns the Signal.subtle.Watcher lifecycle (Phase 29 memory safety)
- * - Microtask batching coalesces rapid signal updates
- * - Re-rendering is driven by the callback's own setState (see remarks)
- * - Handles cleanup on unmount to prevent memory leaks
+ * - The hook puts the callback in a Signal.Computed for the dependency tracking
+ * - watchSignal owns the Signal.subtle.Watcher lifecycle (Phase 29, memory safety)
+ * - The microtask batching groups rapid signal updates
+ * - The callback triggers each new render with its own setState (see the remarks)
+ * - The hook cleans up on unmount, so that nothing stays in memory
  *
- * Invariant: Signal-Only Reactivity - Signals accessed in callback are watched.
- * Invariant: Passive Infrastructure - React observes signals and does not control them.
+ * Invariant: Signal-Only Reactivity. The hook watches each signal that the callback reads.
+ * Invariant: Passive Infrastructure. React observes the signals, and it does not control them.
  *
- * @param callback - Effect function that accesses signals. Can return cleanup function.
- * @param deps - Optional dependency list (like useEffect). When any dependency
- * changes, the watcher and Computed are torn down and recreated, re-tracking
- * signals from scratch. Defaults to `[]` (subscribe once per mount). Pass this
- * when the identity of the object whose signals you read can change over the
- * component's lifetime (e.g. an `actor` prop) — otherwise the watcher keeps
- * tracking the OLD object's signals forever.
+ * @param callback - The effect function that reads the signals. It can return a cleanup function.
+ * @param deps - The optional dependency list, as in useEffect. On a change of one
+ * dependency, the hook removes the watcher and the Computed, then makes them again
+ * and tracks the signals from the start. The default is `[]`, which subscribes one
+ * time for each mount. Give this list when the identity of the object whose signals
+ * you read can change during the life of the component, for example an `actor`
+ * prop. Without the list, the watcher tracks the signals of the OLD object for
+ * ever.
  *
  * @example
  * ```typescript
  * const MyComponent = ({ actor }) => {
  *   const [view, setView] = useState(null);
  *
- *   // Subscribe to actor.currentView signal; re-subscribe if the actor swaps
+ *   // Subscribe to the actor.currentView signal, and subscribe again on a new actor
  *   useSignalEffect(() => {
  *     const currentView = actor.currentView.get();
  *     setView(currentView);
  *   }, [actor]);
  *
- *   return <div>{view?.component}</div>;
+ *   return <div>{view?.root}</div>;
  * };
  * ```
  *
  * @remarks
- * **CRITICAL:** Signals must be accessed unconditionally (no if statements).
- * Conditional signal access breaks automatic dependency tracking.
+ * **CRITICAL:** read each signal unconditionally, with no `if` statement. A
+ * conditional read breaks the dependency tracking.
  *
- * **Performance:** Microtask batching (queueMicrotask, inside watchSignal)
- * prevents React thrashing when multiple signals update rapidly.
+ * **Performance:** the microtask batching (queueMicrotask, inside watchSignal)
+ * stops a flood of React renders when several signals update in rapid sequence.
  *
- * **Re-rendering:** the hook itself does NOT force a React render on signal
- * change — the callback drives re-rendering by calling setState with the new
- * signal value (as in the example above). This lets React's setState bailout
- * skip renders when the derived value is unchanged; an unconditional
- * force-update here previously caused a wasted render per notification even
- * when the callback's setState bailed. If you need to re-render on every
- * notification while reading signals during render, mirror the signal value
- * into React state inside the callback.
+ * **Re-rendering:** the hook itself does NOT force a React render on a signal
+ * change. The callback triggers each new render, because it calls setState with the
+ * new signal value, as in the example above. The setState bailout of React can
+ * therefore skip a render when the derived value is the same. An unconditional
+ * force-update here caused one wasted render for each notification before, also
+ * when the setState of the callback made the bailout. If you must render again on
+ * every notification, and you read the signals during the render, copy the signal
+ * value into the React state inside the callback.
  *
- * **Implementation note:** We wrap the callback in Signal.Computed because
- * Signal.subtle.Watcher cannot automatically track arbitrary function calls.
- * The Computed handles dependency tracking; watchSignal evaluates it (which
- * runs the callback) whenever any tracked signal changes.
+ * **Implementation note:** the hook puts the callback in a Signal.Computed, because
+ * Signal.subtle.Watcher cannot track an arbitrary function call. The Computed does
+ * the dependency tracking. watchSignal evaluates the Computed, which runs the
+ * callback, on each change of a tracked signal.
  */
 export declare const useSignalEffect: (callback: () => void | (() => void), deps?: DependencyList) => void;
 //# sourceMappingURL=useSignalEffect.d.ts.map

package/dist/useSignalEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSignalEffect.d.ts","sourceRoot":"","sources":["../src/useSignalEffect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAS5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,eAAe,GAC3B,UAAU,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EACnC,OAAM,cAAmB,KACvB,IA0CF,CAAC"}
+{"version":3,"file":"useSignalEffect.d.ts","sourceRoot":"","sources":["../src/useSignalEffect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAS5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,eAAe,GAC3B,UAAU,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EACnC,OAAM,cAAmB,KACvB,IA4CF,CAAC"}

package/dist/useSignalEffect.js

@@ -1,109 +1,112 @@
 /**
- * useSignalEffect - React hook for signal subscriptions with automatic cleanup
+ * useSignalEffect - the React hook that subscribes to a signal and cleans up by itself
  *
  * @packageDocumentation
  */
 import { useEffect, useRef } from "react";
 import { Signal, watchSignal } from "@xmachines/play-signals";
 /**
- * Marker symbol returned by effect Computed to satisfy type requirements
- * The actual value doesn't matter - we only care about side effects
+ * The marker symbol that the effect Computed returns, to satisfy the type.
+ * The value has no meaning. Only the side effects are important.
  */
 const EFFECT_RUN_MARKER = Symbol("effect-run");
 /**
- * React hook that subscribes to signal changes and runs effect callback
+ * The React hook that subscribes to the signal changes and runs an effect callback
  *
- * Wraps the callback in a Signal.Computed to automatically track signal
- * dependencies accessed inside it, then delegates the watcher lifecycle
- * (microtask batching, re-arming, disposal) to `watchSignal` from
- * `@xmachines/play-signals` — the single canonical implementation shared
- * across framework renderers.
+ * The hook puts the callback in a Signal.Computed, which tracks each signal that
+ * the callback reads. It then gives the watcher lifecycle to `watchSignal` from
+ * `@xmachines/play-signals`. That function does the microtask batching, the new arm
+ * of the watcher, and the disposal. It is the one canonical implementation, and
+ * every framework renderer uses it.
  *
  * Architecture:
- * - Uses Signal.Computed to wrap callback for automatic dependency tracking
- * - watchSignal owns the Signal.subtle.Watcher lifecycle (Phase 29 memory safety)
- * - Microtask batching coalesces rapid signal updates
- * - Re-rendering is driven by the callback's own setState (see remarks)
- * - Handles cleanup on unmount to prevent memory leaks
+ * - The hook puts the callback in a Signal.Computed for the dependency tracking
+ * - watchSignal owns the Signal.subtle.Watcher lifecycle (Phase 29, memory safety)
+ * - The microtask batching groups rapid signal updates
+ * - The callback triggers each new render with its own setState (see the remarks)
+ * - The hook cleans up on unmount, so that nothing stays in memory
  *
- * Invariant: Signal-Only Reactivity - Signals accessed in callback are watched.
- * Invariant: Passive Infrastructure - React observes signals and does not control them.
+ * Invariant: Signal-Only Reactivity. The hook watches each signal that the callback reads.
+ * Invariant: Passive Infrastructure. React observes the signals, and it does not control them.
  *
- * @param callback - Effect function that accesses signals. Can return cleanup function.
- * @param deps - Optional dependency list (like useEffect). When any dependency
- * changes, the watcher and Computed are torn down and recreated, re-tracking
- * signals from scratch. Defaults to `[]` (subscribe once per mount). Pass this
- * when the identity of the object whose signals you read can change over the
- * component's lifetime (e.g. an `actor` prop) — otherwise the watcher keeps
- * tracking the OLD object's signals forever.
+ * @param callback - The effect function that reads the signals. It can return a cleanup function.
+ * @param deps - The optional dependency list, as in useEffect. On a change of one
+ * dependency, the hook removes the watcher and the Computed, then makes them again
+ * and tracks the signals from the start. The default is `[]`, which subscribes one
+ * time for each mount. Give this list when the identity of the object whose signals
+ * you read can change during the life of the component, for example an `actor`
+ * prop. Without the list, the watcher tracks the signals of the OLD object for
+ * ever.
  *
  * @example
  * ```typescript
  * const MyComponent = ({ actor }) => {
  *   const [view, setView] = useState(null);
  *
- *   // Subscribe to actor.currentView signal; re-subscribe if the actor swaps
+ *   // Subscribe to the actor.currentView signal, and subscribe again on a new actor
  *   useSignalEffect(() => {
  *     const currentView = actor.currentView.get();
  *     setView(currentView);
  *   }, [actor]);
  *
- *   return <div>{view?.component}</div>;
+ *   return <div>{view?.root}</div>;
  * };
  * ```
  *
  * @remarks
- * **CRITICAL:** Signals must be accessed unconditionally (no if statements).
- * Conditional signal access breaks automatic dependency tracking.
+ * **CRITICAL:** read each signal unconditionally, with no `if` statement. A
+ * conditional read breaks the dependency tracking.
  *
- * **Performance:** Microtask batching (queueMicrotask, inside watchSignal)
- * prevents React thrashing when multiple signals update rapidly.
+ * **Performance:** the microtask batching (queueMicrotask, inside watchSignal)
+ * stops a flood of React renders when several signals update in rapid sequence.
  *
- * **Re-rendering:** the hook itself does NOT force a React render on signal
- * change — the callback drives re-rendering by calling setState with the new
- * signal value (as in the example above). This lets React's setState bailout
- * skip renders when the derived value is unchanged; an unconditional
- * force-update here previously caused a wasted render per notification even
- * when the callback's setState bailed. If you need to re-render on every
- * notification while reading signals during render, mirror the signal value
- * into React state inside the callback.
+ * **Re-rendering:** the hook itself does NOT force a React render on a signal
+ * change. The callback triggers each new render, because it calls setState with the
+ * new signal value, as in the example above. The setState bailout of React can
+ * therefore skip a render when the derived value is the same. An unconditional
+ * force-update here caused one wasted render for each notification before, also
+ * when the setState of the callback made the bailout. If you must render again on
+ * every notification, and you read the signals during the render, copy the signal
+ * value into the React state inside the callback.
  *
- * **Implementation note:** We wrap the callback in Signal.Computed because
- * Signal.subtle.Watcher cannot automatically track arbitrary function calls.
- * The Computed handles dependency tracking; watchSignal evaluates it (which
- * runs the callback) whenever any tracked signal changes.
+ * **Implementation note:** the hook puts the callback in a Signal.Computed, because
+ * Signal.subtle.Watcher cannot track an arbitrary function call. The Computed does
+ * the dependency tracking. watchSignal evaluates the Computed, which runs the
+ * callback, on each change of a tracked signal.
  */
 export const useSignalEffect = (callback, deps = []) => {
-    // Store callback in a ref so the effect closure always calls the latest version
-    // WITHOUT triggering watcher teardown/re-setup on each render (standard React ref pattern)
+    // A ref holds the callback. The closure of the effect therefore always calls the
+    // newest callback, and the code removes the watcher on each render NOT and installs it
+    // again NOT. This is the standard ref pattern of React.
     const callbackRef = useRef(callback);
-    // Assignment outside useEffect keeps ref current without triggering re-effect
+    // The assignment is outside useEffect. The ref therefore holds the newest value, and no effect runs again
     callbackRef.current = callback;
     useEffect(() => {
         let cleanup;
-        // Wrap callback in a Computed to automatically track dependencies
-        // The Computed will re-evaluate when any accessed signal changes
+        // Put the callback in a Computed, which tracks each dependency.
+        // The Computed evaluates the callback again after a change of a signal that the
+        // callback reads.
         const effect = new Signal.Computed(() => {
-            // Run cleanup from previous effect
+            // Run the cleanup of the previous effect
             if (typeof cleanup === "function")
                 cleanup();
-            // Run user callback via ref (always latest version, no dep churn)
+            // Run the callback of the user through the ref. It is always the newest one, and the deps therefore change not
             cleanup = callbackRef.current();
-            // Return marker value (Computed requires a return value)
+            // Return the marker value, because a Computed requires a return value
             return EFFECT_RUN_MARKER;
         });
-        // watchSignal owns the watcher lifecycle: microtask batching, disposed
-        // guard, and re-arming after each notification (Phase 29 memory safety
-        // lives there — single source of truth, no copy-pasted watcher code).
-        // Reading the Computed inside watchSignal re-evaluates it, which runs the
-        // user callback; re-rendering is the callback's job (setState), so no
-        // extra work is needed in onValue.
+        // watchSignal owns the lifecycle of the watcher: the batching in a microtask, the
+        // guard of a disposal, and the new arm after each notification. The memory safety of
+        // Phase 29 is there, in one place, and no file holds a copy of the watcher code.
+        // The read of the Computed inside watchSignal evaluates it again, and that run calls
+        // the callback of the user. The callback starts each new render with its setState.
+        // Therefore onValue needs no more work.
         const unwatch = watchSignal(effect, () => { });
-        // Initial run of callback (via Computed)
+        // The first run of the callback, through the Computed
         effect.get();
-        // Cleanup on unmount or deps change
+        // The cleanup, on an unmount and on a change of the deps
         return () => {
-            // Stop receiving signal updates (idempotent, disposes pending microtasks)
+            // Stop the signal updates. The call is idempotent, and it disposes of each microtask that waits
             unwatch();
             if (typeof cleanup === "function")
                 cleanup();

package/dist/useSignalEffect.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSignalEffect.js","sourceRoot":"","sources":["../src/useSignalEffect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAE1C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE9D;;;GAGG;AACH,MAAM,iBAAiB,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC9B,QAAmC,EACnC,OAAuB,EAAE,EAClB,EAAE;IACT,gFAAgF;IAChF,2FAA2F;IAC3F,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IACrC,8EAA8E;IAC9E,WAAW,CAAC,OAAO,GAAG,QAAQ,CAAC;IAE/B,SAAS,CAAC,GAAG,EAAE;QACd,IAAI,OAA4B,CAAC;QAEjC,kEAAkE;QAClE,iEAAiE;QACjE,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE;YACvC,mCAAmC;YACnC,IAAI,OAAO,OAAO,KAAK,UAAU;gBAAE,OAAO,EAAE,CAAC;YAE7C,kEAAkE;YAClE,OAAO,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC;YAEhC,yDAAyD;YACzD,OAAO,iBAAiB,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,uEAAuE;QACvE,uEAAuE;QACvE,sEAAsE;QACtE,0EAA0E;QAC1E,sEAAsE;QACtE,mCAAmC;QACnC,MAAM,OAAO,GAAG,WAAW,CAAC,MAAkC,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAE1E,yCAAyC;QACzC,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,oCAAoC;QACpC,OAAO,GAAG,EAAE;YACX,0EAA0E;YAC1E,OAAO,EAAE,CAAC;YACV,IAAI,OAAO,OAAO,KAAK,UAAU;gBAAE,OAAO,EAAE,CAAC;QAC9C,CAAC,CAAC;QACF,wHAAwH;IACzH,CAAC,EAAE,IAAI,CAAC,CAAC;AACV,CAAC,CAAC"}
+{"version":3,"file":"useSignalEffect.js","sourceRoot":"","sources":["../src/useSignalEffect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAE1C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE9D;;;GAGG;AACH,MAAM,iBAAiB,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC9B,QAAmC,EACnC,OAAuB,EAAE,EAClB,EAAE;IACT,iFAAiF;IACjF,uFAAuF;IACvF,wDAAwD;IACxD,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IACrC,0GAA0G;IAC1G,WAAW,CAAC,OAAO,GAAG,QAAQ,CAAC;IAE/B,SAAS,CAAC,GAAG,EAAE;QACd,IAAI,OAA4B,CAAC;QAEjC,gEAAgE;QAChE,gFAAgF;QAChF,kBAAkB;QAClB,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE;YACvC,yCAAyC;YACzC,IAAI,OAAO,OAAO,KAAK,UAAU;gBAAE,OAAO,EAAE,CAAC;YAE7C,+GAA+G;YAC/G,OAAO,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC;YAEhC,sEAAsE;YACtE,OAAO,iBAAiB,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,kFAAkF;QAClF,qFAAqF;QACrF,iFAAiF;QACjF,qFAAqF;QACrF,mFAAmF;QACnF,wCAAwC;QACxC,MAAM,OAAO,GAAG,WAAW,CAAC,MAAkC,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAE1E,sDAAsD;QACtD,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,yDAAyD;QACzD,OAAO,GAAG,EAAE;YACX,gGAAgG;YAChG,OAAO,EAAE,CAAC;YACV,IAAI,OAAO,OAAO,KAAK,UAAU;gBAAE,OAAO,EAAE,CAAC;QAC9C,CAAC,CAAC;QACF,wHAAwH;IACzH,CAAC,EAAE,IAAI,CAAC,CAAC;AACV,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-react",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "React renderer for XMachines Play architecture with signal-driven rendering",
   "keywords": [
     "actor",
@@ -43,13 +43,14 @@
     "lint": "oxlint .",
     "format": "oxfmt .",
     "test": "vitest",
+    "test:coverage": "vitest run --coverage",
     "test:vitest": "vitest run",
     "test:browser": "vitest --browser.enabled --browser.name=chromium test/browser"
   },
   "dependencies": {
-    "@xmachines/play": "2.0.0",
-    "@xmachines/play-actor": "2.0.0",
-    "@xmachines/play-signals": "2.0.0"
+    "@xmachines/play": "2.1.0",
+    "@xmachines/play-actor": "2.1.0",
+    "@xmachines/play-signals": "2.1.0"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",

package/dist/errors.d.ts

@@ -1,23 +0,0 @@
-import { PlayError } from "@xmachines/play";
-/**
- * Error class for renderer-level errors in the Play architecture.
- *
- * **Note (Phase 29):** `PlayErrorBoundary.componentDidCatch()` no longer throws
- * this error. Re-throwing from `componentDidCatch` can unmount the entire React 19
- * root. `RendererError` is retained for programmatic use in custom error handlers
- * and parent boundaries — it is no longer emitted by the built-in boundary itself.
- *
- * **Error code:** `PLAY_REACT_RENDER_ERROR`
- *
- * @example
- * ```typescript
- * import { RendererError } from "@xmachines/play-react/errors";
- *
- * // Create a RendererError programmatically in a custom boundary:
- * throw new RendererError("Custom render failure", { cause: originalError });
- * ```
- */
-export declare class RendererError extends PlayError {
-    constructor(message: string, options?: ErrorOptions);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAc,SAAQ,SAAS;gBAC/B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAInD"}

package/dist/errors.js

@@ -1,26 +0,0 @@
-import { PlayError } from "@xmachines/play";
-/**
- * Error class for renderer-level errors in the Play architecture.
- *
- * **Note (Phase 29):** `PlayErrorBoundary.componentDidCatch()` no longer throws
- * this error. Re-throwing from `componentDidCatch` can unmount the entire React 19
- * root. `RendererError` is retained for programmatic use in custom error handlers
- * and parent boundaries — it is no longer emitted by the built-in boundary itself.
- *
- * **Error code:** `PLAY_REACT_RENDER_ERROR`
- *
- * @example
- * ```typescript
- * import { RendererError } from "@xmachines/play-react/errors";
- *
- * // Create a RendererError programmatically in a custom boundary:
- * throw new RendererError("Custom render failure", { cause: originalError });
- * ```
- */
-export class RendererError extends PlayError {
-    constructor(message, options) {
-        super("PlayRenderer", "PLAY_REACT_RENDER_ERROR", message, options);
-        this.name = "RendererError";
-    }
-}
-//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,aAAc,SAAQ,SAAS;IAC3C,YAAY,OAAe,EAAE,OAAsB;QAClD,KAAK,CAAC,cAAc,EAAE,yBAAyB,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACnE,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC7B,CAAC;CACD"}