@xmachines/play-react 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/PlayUIProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlayUIProvider.d.ts","sourceRoot":"","sources":["../src/PlayUIProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAA8B,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGzF,KAAK,oBAAoB,GAAG,IAAI,CAC/B,mBAAmB,EACnB,qBAAqB,GAAG,UAAU,GAAG,WAAW,CAChD,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB,EAAE,OAAO,CAAC,oBAAoB,CAAC;CAAG;AAgCjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAiBxD,CAAC"}

package/dist/PlayUIProvider.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * PlayUIProvider — batteries-included composite provider for actor-driven UI rendering.
+ *
+ * Wraps ActorProvider + JSONUIProvider (from @json-render/react) to provide a single
+ * entry point for all actor lifecycle and UI rendering concerns.
+ *
+ * Standard usage:
+ * ```tsx
+ * <PlayUIProvider actor={actor} registryResult={registryResult}>
+ *   <PlayRenderer />
+ * </PlayUIProvider>
+ * ```
+ *
+ * For custom provider composition (escape hatch), use <ActorProvider> directly.
+ *
+ * @packageDocumentation
+ */
+import React from "react";
+import { JSONUIProvider } from "@json-render/react";
+import { ActorProvider, usePlayView } from "./ActorProvider.js";
+/**
+ * Inner bridge component — reads ViewContext (usePlayView) to get the resolved handlers,
+ * registry, and store, then passes them to JSONUIProvider. The store is passed explicitly
+ * so JSONUIProvider's internal StateProvider uses the same store ActorProvider set up —
+ * without this, JSONUIProvider would create a fresh empty store, shadowing the seeded one.
+ *
+ * Must be inside ActorProvider's tree so usePlayView() has access to ViewContextValue.
+ */
+function JSONUIBridge({ validationFunctions, navigate, functions, children, }) {
+    const view = usePlayView();
+    return (_jsx(JSONUIProvider, { registry: view.registry, handlers: view.handlers, store: view.store, ...(validationFunctions && { validationFunctions }), ...(navigate && { navigate }), ...(functions && { functions }), children: children }));
+}
+/**
+ * PlayUIProvider — batteries-included entry point for actor-driven UI rendering.
+ *
+ * Combines actor lifecycle management (ActorProvider) with full UI provider setup
+ * (JSONUIProvider including ActionProvider, ValidationProvider, VisibilityProvider,
+ * StateProvider, and ConfirmDialogManager).
+ *
+ * @example
+ * ```tsx
+ * import { PlayUIProvider, PlayRenderer } from "@xmachines/play-react";
+ *
+ * const registryResult = defineRegistry(catalog, {
+ *   components: { Login, Dashboard },
+ *   actions: {
+ *     login: async ({ username }) => actor.send({ type: 'auth.login', username }),
+ *     logout: async () => actor.send({ type: 'auth.logout' }),
+ *   },
+ * });
+ *
+ * <PlayUIProvider actor={actor} registryResult={registryResult}>
+ *   <PlayRenderer />
+ * </PlayUIProvider>
+ *
+ * // With JSONUIProvider options:
+ * <PlayUIProvider
+ *   actor={actor}
+ *   registryResult={registryResult}
+ *   navigate={(path) => router.push(path)}
+ *   validationFunctions={{ isEmail: (v) => /^.+@.+$/.test(String(v)) }}
+ * >
+ *   <PlayRenderer />
+ * </PlayUIProvider>
+ * ```
+ *
+ * @public
+ */
+export const PlayUIProvider = ({ validationFunctions, navigate, functions, ...actorProps }) => {
+    return (_jsx(ActorProvider, { ...actorProps, children: _jsx(JSONUIBridge, { ...(validationFunctions && { validationFunctions }), ...(navigate && { navigate }), ...(functions && { functions }), children: actorProps.children }) }));
+};
+//# sourceMappingURL=PlayUIProvider.js.map

package/dist/PlayUIProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlayUIProvider.js","sourceRoot":"","sources":["../src/PlayUIProvider.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,cAAc,EAA4B,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,WAAW,EAA2B,MAAM,oBAAoB,CAAC;AAezF;;;;;;;GAOG;AACH,SAAS,YAAY,CAAC,EACrB,mBAAmB,EACnB,QAAQ,EACR,SAAS,EACT,QAAQ,GACuD;IAC/D,MAAM,IAAI,GAAG,WAAW,EAAE,CAAC;IAE3B,OAAO,CACN,KAAC,cAAc,IACd,QAAQ,EAAE,IAAI,CAAC,QAAQ,EACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ,EACvB,KAAK,EAAE,IAAI,CAAC,KAAK,KACb,CAAC,mBAAmB,IAAI,EAAE,mBAAmB,EAAE,CAAC,KAChD,CAAC,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC,KAC1B,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC,YAE/B,QAAQ,GACO,CACjB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,cAAc,GAAkC,CAAC,EAC7D,mBAAmB,EACnB,QAAQ,EACR,SAAS,EACT,GAAG,UAAU,EACb,EAAE,EAAE;IACJ,OAAO,CACN,KAAC,aAAa,OAAK,UAAU,YAC5B,KAAC,YAAY,OACR,CAAC,mBAAmB,IAAI,EAAE,mBAAmB,EAAE,CAAC,KAChD,CAAC,QAAQ,IAAI,EAAE,QAAQ,EAAE,CAAC,KAC1B,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC,YAE/B,UAAU,CAAC,QAAQ,GACN,GACA,CAChB,CAAC;AACH,CAAC,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,23 @@
+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_RENDERER_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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+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_RENDERER_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_RENDERER_RENDER_ERROR", message, options);
+        this.name = "RendererError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"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,4BAA4B,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC7B,CAAC;CACD"}

package/dist/index.d.ts

@@ -1,18 +1,46 @@
 /**
  * @xmachines/play-react - React renderer for XMachines Play architecture
  *
- * Provides a thin React rendering layer that passively observes actor signals
- * and renders UI components from catalog definitions. This package enables
+ * Provides a provider-based React rendering layer that passively observes actor signals
+ * and renders UI components via @json-render/react. This package enables
  * framework-swappable architecture where React is just a rendering target
  * that subscribes to signal changes.
  *
  * **Key principle:** React state is NEVER used for business logic—only for
  * triggering React's render cycle. Signals are the source of truth.
  *
+ * **Standard usage:**
+ * ```tsx
+ * <PlayUIProvider actor={actor} registryResult={registryResult}>
+ *   <PlayRenderer />
+ * </PlayUIProvider>
+ * ```
+ *
+ * **Escape hatch (custom composition):**
+ * ```tsx
+ * <ActorProvider actor={actor} registryResult={registryResult}>
+ *   <JSONUIProvider registry={registryResult.registry}>
+ *     <PlayRenderer />
+ *   </JSONUIProvider>
+ * </ActorProvider>
+ * ```
+ *
  * @packageDocumentation
  * @module @xmachines/play-react
  */
 export { PlayRenderer } from "./PlayRenderer.js";
+export { ActorProvider } from "./ActorProvider.js";
+export type { ActorProviderProps, ViewContextValue } from "./ActorProvider.js";
+export { usePlayView } from "./ActorProvider.js";
+export { PlayUIProvider } from "./PlayUIProvider.js";
+export type { PlayUIProviderProps } from "./PlayUIProvider.js";
 export { useSignalEffect } from "./useSignalEffect.js";
-export type { PlayRendererProps } from "./types.js";
+export { PlayErrorBoundary } from "./PlayErrorBoundary.js";
+export { useActor } from "./useActor.js";
+export type { PlayActor } from "./useActor.js";
+export { defineRegistry, useBoundProp, JSONUIProvider, StateProvider, ActionProvider, VisibilityProvider, ValidationProvider, Renderer, } from "@json-render/react";
+export type { ComponentFn, ComponentContext, JSONUIProviderProps, StateProviderProps, ActionProviderProps, VisibilityProviderProps, ValidationProviderProps, RendererProps, } from "@json-render/react";
+export type { ActorProviderProps as PlayRendererProps } from "./ActorProvider.js";
+export type { RenderErrorHandler } from "./types.js";
+export type { PlayErrorBoundaryProps, PlayErrorBoundaryState } from "./PlayErrorBoundary.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EACN,cAAc,EACd,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,GACR,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACX,WAAW,EACX,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACvB,aAAa,GACb,MAAM,oBAAoB,CAAC;AAG5B,YAAY,EAAE,kBAAkB,IAAI,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAClF,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,YAAY,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,18 +1,41 @@
 /**
  * @xmachines/play-react - React renderer for XMachines Play architecture
  *
- * Provides a thin React rendering layer that passively observes actor signals
- * and renders UI components from catalog definitions. This package enables
+ * Provides a provider-based React rendering layer that passively observes actor signals
+ * and renders UI components via @json-render/react. This package enables
  * framework-swappable architecture where React is just a rendering target
  * that subscribes to signal changes.
  *
  * **Key principle:** React state is NEVER used for business logic—only for
  * triggering React's render cycle. Signals are the source of truth.
  *
+ * **Standard usage:**
+ * ```tsx
+ * <PlayUIProvider actor={actor} registryResult={registryResult}>
+ *   <PlayRenderer />
+ * </PlayUIProvider>
+ * ```
+ *
+ * **Escape hatch (custom composition):**
+ * ```tsx
+ * <ActorProvider actor={actor} registryResult={registryResult}>
+ *   <JSONUIProvider registry={registryResult.registry}>
+ *     <PlayRenderer />
+ *   </JSONUIProvider>
+ * </ActorProvider>
+ * ```
+ *
  * @packageDocumentation
  * @module @xmachines/play-react
  */
 // Main exports
 export { PlayRenderer } from "./PlayRenderer.js";
+export { ActorProvider } from "./ActorProvider.js";
+export { usePlayView } from "./ActorProvider.js";
+export { PlayUIProvider } from "./PlayUIProvider.js";
 export { useSignalEffect } from "./useSignalEffect.js";
+export { PlayErrorBoundary } from "./PlayErrorBoundary.js";
+export { useActor } from "./useActor.js";
+// Re-exports from @json-render/react (per D-14)
+export { defineRegistry, useBoundProp, JSONUIProvider, StateProvider, ActionProvider, VisibilityProvider, ValidationProvider, Renderer, } from "@json-render/react";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,eAAe;AACf,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,eAAe;AACf,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,gDAAgD;AAChD,OAAO,EACN,cAAc,EACd,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,GACR,MAAM,oBAAoB,CAAC"}

package/dist/types.d.ts

@@ -1,24 +1,12 @@
 /**
  * TypeScript type definitions for play-react
  *
- * @packageDocumentation
- */
-import type { AbstractActor, Viewable } from "@xmachines/play-actor";
-import type React from "react";
-import type { AnyActorLogic } from "xstate";
-/**
- * Props for PlayRenderer component
+ * PlayRendererProps has been removed — use ActorProviderProps or PlayUIProviderProps instead.
+ * See ActorProvider.tsx and PlayUIProvider.tsx.
  *
- * @property actor - Actor instance with currentView signal (requires Viewable capability)
- * @property components - Map of component names to React components
- * @property fallback - Optional component shown when currentView is null
+ * @packageDocumentation
  */
-export interface PlayRendererProps {
-    /** Actor instance with currentView signal (requires Viewable capability) */
-    actor: AbstractActor<AnyActorLogic> & Viewable;
-    /** Map of component names to React components */
-    components: Record<string, React.ElementType>;
-    /** Optional component shown when currentView is null */
-    fallback?: React.ReactNode;
-}
+export type { ActorProviderProps } from "./ActorProvider.js";
+export type { PlayUIProviderProps } from "./PlayUIProvider.js";
+export type { RenderErrorHandler } from "@json-render/react";
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IACjC,4EAA4E;IAC5E,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;IAE/C,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAE9C,wDAAwD;IACxD,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/types.js

@@ -1,6 +1,9 @@
 /**
  * TypeScript type definitions for play-react
  *
+ * PlayRendererProps has been removed — use ActorProviderProps or PlayUIProviderProps instead.
+ * See ActorProvider.tsx and PlayUIProvider.tsx.
+ *
  * @packageDocumentation
  */
 export {};

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/useActor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * useActor — React hook for accessing the raw actor inside a PlayRenderer tree.
+ *
+ * Components rendered inside PlayRenderer can call useActor() to get direct
+ * access to the actor instance without prop drilling.
+ *
+ * @throws {NonNullableError} If called outside an ActorProvider/PlayUIProvider tree
+ *
+ * @example
+ * ```typescript
+ * import { useActor } from "@xmachines/play-react";
+ *
+ * function MyComponent() {
+ *   const actor = useActor();
+ *   return <button onClick={() => actor.send({ type: "SUBMIT" })}>Submit</button>;
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import type { AbstractActor } from "@xmachines/play-actor";
+import type { AnyActorLogic } from "xstate";
+export type PlayActor = AbstractActor<AnyActorLogic>;
+export declare const ActorContext: import("react").Context<PlayActor | null>;
+export declare function useActor(): PlayActor;
+//# sourceMappingURL=useActor.d.ts.map

package/dist/useActor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActor.d.ts","sourceRoot":"","sources":["../src/useActor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,YAAY,2CAAwC,CAAC;AAElE,wBAAgB,QAAQ,IAAI,SAAS,CAEpC"}

package/dist/useActor.js

@@ -0,0 +1,27 @@
+/**
+ * useActor — React hook for accessing the raw actor inside a PlayRenderer tree.
+ *
+ * Components rendered inside PlayRenderer can call useActor() to get direct
+ * access to the actor instance without prop drilling.
+ *
+ * @throws {NonNullableError} If called outside an ActorProvider/PlayUIProvider tree
+ *
+ * @example
+ * ```typescript
+ * import { useActor } from "@xmachines/play-react";
+ *
+ * function MyComponent() {
+ *   const actor = useActor();
+ *   return <button onClick={() => actor.send({ type: "SUBMIT" })}>Submit</button>;
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { createContext, useContext } from "react";
+import { assertNonNullable } from "@xmachines/play";
+export const ActorContext = createContext(null);
+export function useActor() {
+    return assertNonNullable(useContext(ActorContext), "ActorContext");
+}
+//# sourceMappingURL=useActor.js.map

package/dist/useActor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActor.js","sourceRoot":"","sources":["../src/useActor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMpD,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,CAAmB,IAAI,CAAC,CAAC;AAElE,MAAM,UAAU,QAAQ;IACvB,OAAO,iBAAiB,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC,CAAC;AACpE,CAAC"}

package/dist/useSignalEffect.d.ts

@@ -51,6 +51,12 @@
  * **Implementation note:** We wrap the callback in Signal.Computed because
  * Signal.subtle.Watcher cannot automatically track arbitrary function calls.
  * The Computed handles dependency tracking, and the Watcher monitors it.
+ *
+ * **Memory safety (Phase 29):**
+ * - `disposed` flag prevents post-cleanup callback execution: if cleanup is
+ *   called before a pending microtask fires, the microtask returns early.
+ * - `needsEnqueue` guard dedups rapid synchronous signal changes: only one
+ *   microtask is ever queued per batch of synchronous mutations.
  */
 export declare const useSignalEffect: (callback: () => void | (() => void)) => 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;AAWH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,KAAG,IAuDrE,CAAC"}
+{"version":3,"file":"useSignalEffect.d.ts","sourceRoot":"","sources":["../src/useSignalEffect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,KAAG,IA+DrE,CAAC"}

package/dist/useSignalEffect.js

@@ -3,7 +3,7 @@
  *
  * @packageDocumentation
  */
-import { useEffect, useReducer } from "react";
+import { useEffect, useReducer, useRef } from "react";
 import { Signal } from "@xmachines/play-signals";
 /**
  * Marker symbol returned by effect Computed to satisfy type requirements
@@ -58,39 +58,54 @@ const EFFECT_RUN_MARKER = Symbol("effect-run");
  * **Implementation note:** We wrap the callback in Signal.Computed because
  * Signal.subtle.Watcher cannot automatically track arbitrary function calls.
  * The Computed handles dependency tracking, and the Watcher monitors it.
+ *
+ * **Memory safety (Phase 29):**
+ * - `disposed` flag prevents post-cleanup callback execution: if cleanup is
+ *   called before a pending microtask fires, the microtask returns early.
+ * - `needsEnqueue` guard dedups rapid synchronous signal changes: only one
+ *   microtask is ever queued per batch of synchronous mutations.
  */
 export const useSignalEffect = (callback) => {
+    // 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)
+    const callbackRef = useRef(callback);
+    // Assignment outside useEffect keeps ref current without triggering re-effect
+    callbackRef.current = callback;
     // Force re-render when signal changes (React needs state change to re-render)
     const [, forceUpdate] = useReducer((x) => x + 1, 0);
     useEffect(() => {
         let cleanup;
         let needsEnqueue = true;
+        let disposed = false;
         // Wrap callback in a Computed to automatically track dependencies
         // The Computed will re-evaluate when any accessed signal changes
         const effect = new Signal.Computed(() => {
             // Run cleanup from previous effect
-            cleanup?.();
-            // Run user callback (may access signals, return cleanup)
-            cleanup = callback();
+            if (typeof cleanup === "function")
+                cleanup();
+            // Run user callback via ref (always latest version, no dep churn)
+            cleanup = callbackRef.current();
             // Return marker value (Computed requires a return value)
             return EFFECT_RUN_MARKER;
         });
         // Create watcher to detect when Computed needs re-evaluation
         const watcher = new Signal.subtle.Watcher(() => {
             // Batching flag prevents multiple microtasks for rapid changes
-            if (needsEnqueue) {
-                needsEnqueue = false;
-                // Schedule microtask to batch updates (prevent React thrashing)
-                queueMicrotask(() => {
-                    needsEnqueue = true;
-                    // Re-evaluate the Computed (runs callback with new signal values)
-                    effect.get();
-                    // Force React re-render
-                    forceUpdate();
-                    // Re-watch for next change
-                    watcher.watch();
-                });
-            }
+            if (disposed || !needsEnqueue)
+                return;
+            needsEnqueue = false;
+            // Schedule microtask to batch updates (prevent React thrashing)
+            queueMicrotask(() => {
+                if (disposed)
+                    return;
+                needsEnqueue = true;
+                // Re-evaluate the Computed (runs callback with new signal values)
+                effect.get();
+                // Force React re-render
+                forceUpdate();
+                // Re-watch for next change
+                watcher.watch();
+            });
         });
         // Watch the Computed signal
         watcher.watch(effect);
@@ -98,10 +113,12 @@ export const useSignalEffect = (callback) => {
         effect.get();
         // Cleanup on unmount
         return () => {
-            cleanup?.();
+            disposed = true;
+            if (typeof cleanup === "function")
+                cleanup();
             // Unwatch to stop receiving signal updates
             watcher.unwatch(effect);
         };
-    }, [callback]);
+    }, []); // ← [] dep array: watcher created ONCE per mount, not once per render
 };
 //# sourceMappingURL=useSignalEffect.js.map

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,UAAU,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;GAGG;AACH,MAAM,iBAAiB,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,QAAmC,EAAQ,EAAE;IAC5E,8EAA8E;IAC9E,MAAM,CAAC,EAAE,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAEpD,SAAS,CAAC,GAAG,EAAE;QACd,IAAI,OAA4B,CAAC;QACjC,IAAI,YAAY,GAAG,IAAI,CAAC;QAExB,kEAAkE;QAClE,iEAAiE;QACjE,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE;YACvC,mCAAmC;YACnC,OAAO,EAAE,EAAE,CAAC;YAEZ,yDAAyD;YACzD,OAAO,GAAG,QAAQ,EAAE,CAAC;YAErB,yDAAyD;YACzD,OAAO,iBAAiB,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,6DAA6D;QAC7D,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;YAC9C,+DAA+D;YAC/D,IAAI,YAAY,EAAE,CAAC;gBAClB,YAAY,GAAG,KAAK,CAAC;gBACrB,gEAAgE;gBAChE,cAAc,CAAC,GAAG,EAAE;oBACnB,YAAY,GAAG,IAAI,CAAC;oBAEpB,kEAAkE;oBAClE,MAAM,CAAC,GAAG,EAAE,CAAC;oBAEb,wBAAwB;oBACxB,WAAW,EAAE,CAAC;oBAEd,2BAA2B;oBAC3B,OAAO,CAAC,KAAK,EAAE,CAAC;gBACjB,CAAC,CAAC,CAAC;YACJ,CAAC;QACF,CAAC,CAAC,CAAC;QAEH,4BAA4B;QAC5B,OAAO,CAAC,KAAK,CAAC,MAAa,CAAC,CAAC;QAE7B,yCAAyC;QACzC,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,qBAAqB;QACrB,OAAO,GAAG,EAAE;YACX,OAAO,EAAE,EAAE,CAAC;YACZ,2CAA2C;YAC3C,OAAO,CAAC,OAAO,CAAC,MAAa,CAAC,CAAC;QAChC,CAAC,CAAC;IACH,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;AAChB,CAAC,CAAC"}
+{"version":3,"file":"useSignalEffect.js","sourceRoot":"","sources":["../src/useSignalEffect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;GAGG;AACH,MAAM,iBAAiB,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,QAAmC,EAAQ,EAAE;IAC5E,gFAAgF;IAChF,2FAA2F;IAC3F,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IACrC,8EAA8E;IAC9E,WAAW,CAAC,OAAO,GAAG,QAAQ,CAAC;IAE/B,8EAA8E;IAC9E,MAAM,CAAC,EAAE,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAEpD,SAAS,CAAC,GAAG,EAAE;QACd,IAAI,OAA4B,CAAC;QACjC,IAAI,YAAY,GAAG,IAAI,CAAC;QACxB,IAAI,QAAQ,GAAG,KAAK,CAAC;QAErB,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,6DAA6D;QAC7D,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;YAC9C,+DAA+D;YAC/D,IAAI,QAAQ,IAAI,CAAC,YAAY;gBAAE,OAAO;YACtC,YAAY,GAAG,KAAK,CAAC;YACrB,gEAAgE;YAChE,cAAc,CAAC,GAAG,EAAE;gBACnB,IAAI,QAAQ;oBAAE,OAAO;gBACrB,YAAY,GAAG,IAAI,CAAC;gBAEpB,kEAAkE;gBAClE,MAAM,CAAC,GAAG,EAAE,CAAC;gBAEb,wBAAwB;gBACxB,WAAW,EAAE,CAAC;gBAEd,2BAA2B;gBAC3B,OAAO,CAAC,KAAK,EAAE,CAAC;YACjB,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,4BAA4B;QAC5B,OAAO,CAAC,KAAK,CAAC,MAAkC,CAAC,CAAC;QAElD,yCAAyC;QACzC,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,qBAAqB;QACrB,OAAO,GAAG,EAAE;YACX,QAAQ,GAAG,IAAI,CAAC;YAChB,IAAI,OAAO,OAAO,KAAK,UAAU;gBAAE,OAAO,EAAE,CAAC;YAC7C,2CAA2C;YAC3C,OAAO,CAAC,OAAO,CAAC,MAAkC,CAAC,CAAC;QACrD,CAAC,CAAC;IACH,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,sEAAsE;AAC/E,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-react",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.41",
   "description": "React renderer for XMachines Play architecture with signal-driven rendering",
   "keywords": [
     "actor",
@@ -26,6 +26,7 @@
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
@@ -35,31 +36,46 @@
   },
   "scripts": {
     "build": "tsc --build",
-    "clean": "rm -rf dist *.tsbuildinfo",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
+    "clean": "rm -rf dist *.tsbuildinfo coverage .vitest-attachments test/browser/__screenshots__ node_modules/.svelte2tsx-*",
+    "lint": "oxlint .",
+    "format": "oxfmt .",
+    "test": "vitest",
     "test:vitest": "vitest run",
-    "test:browser": "vitest run --browser.enabled --browser.name=chromium test/browser",
+    "test:browser": "vitest --browser.enabled --browser.name=chromium test/browser",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@xmachines/play-actor": "1.0.0-beta.4",
-    "@xmachines/play-catalog": "1.0.0-beta.4",
-    "@xmachines/play-signals": "1.0.0-beta.4"
+    "@xmachines/play": "1.0.0-beta.41",
+    "@xmachines/play-actor": "1.0.0-beta.41",
+    "@xmachines/play-signals": "1.0.0-beta.41"
   },
   "devDependencies": {
+    "@json-render/core": "^0.18.0",
+    "@json-render/react": "^0.18.0",
+    "@json-render/xstate": "^0.18.0",
+    "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
-    "@types/node": "^25.5.0",
+    "@types/node": "^25.6.0",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "@xmachines/shared": "1.0.0-beta.4",
-    "jsdom": "^29.0.0",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "typescript": "^5.9.3"
+    "@xmachines/shared": "1.0.0-beta.41",
+    "@xstate/store": "^3.17.0",
+    "jsdom": "^29.0.2",
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.60.0",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "typescript": "^5.9.3 || ^6.0.3",
+    "vitest": "^4.1.4",
+    "xstate": "^5.30.0"
   },
   "peerDependencies": {
-    "react": "^18.2.0 || ^19.0.0",
-    "react-dom": "^18.2.0 || ^19.0.0"
+    "@json-render/core": "^0.18.0",
+    "@json-render/react": "^0.18.0",
+    "@json-render/xstate": "^0.18.0",
+    "@xstate/store": "^3.17.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0",
+    "xstate": "^5.30.0"
   }
 }