@xmachines/play-actor 2.1.1 → 3.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 Abstract Actor base class for XMachines Play Architecture.
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-2.1.1-blue)](https://www.npmjs.com/package/@xmachines/play-actor)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-3.0.0-blue)](https://www.npmjs.com/package/@xmachines/play-actor)
 
 ## Installation
 

package/dist/failure-latch.d.ts

@@ -0,0 +1,157 @@
+/**
+ * The report rules of a provider, in one place.
+ *
+ * A provider resolves the store from three inputs — the actor, the view, and the store of
+ * the caller — and it reports a failure of that resolution to `onError`. This module holds
+ * the three rules that every renderer had written for itself, beside
+ * {@link createViewStoreLifecycle}, which already receives the same three inputs on every
+ * resolve:
+ *
+ * - {@link sameViewInputs} answers whether two attempts carry the SAME three inputs.
+ * - {@link createFailureLatch} reports ONE time for one set of those three. The render
+ *   path of a provider runs again for every tracked change, and a parent that renders
+ *   hands the props over again, so a report on each attempt gives the host one failure
+ *   many times.
+ * - {@link createReportGuard} keeps the host from defeating the containment: a reset that
+ *   the host starts from INSIDE the report does nothing, a reset after the provider is
+ *   gone does nothing, and a handler that THROWS is contained where the renderer needs it.
+ *
+ * The copies disagreed. play-vue held a boolean and cleared it at four sites, play-svelte
+ * held the three inputs and kept them across a null emission, and play-solid held nothing
+ * at all while the comment of play-vue said that it did.
+ *
+ * @packageDocumentation
+ */
+/**
+ * The three inputs that a provider resolves a store from.
+ *
+ * `ViewStoreLifecycle.resolve` takes exactly these, and every provider names all three in
+ * its reset rule. The type gives the rule one name, so the comparison below stands one
+ * time instead of once for each renderer that needs it.
+ */
+export interface ViewInputs {
+    actor: unknown;
+    view: unknown;
+    store: unknown;
+}
+/**
+ * Answers whether two sets of inputs are the SAME attempt.
+ *
+ * Identity, and not a deep compare: a provider holds the references that it rendered, and
+ * a new spec object is a new attempt even when it holds equal fields.
+ */
+export declare function sameViewInputs(a: ViewInputs, b: ViewInputs): boolean;
+/**
+ * A report guard of one provider.
+ *
+ * The rule it holds: a provider reports a contained failure to the host, and it must do
+ * that without letting the host defeat the containment. Two things follow — a reset that
+ * the host calls from INSIDE the report does nothing, because no input changed between
+ * the two attempts; and every callback that the provider handed out does nothing once the
+ * provider is gone, because a host can keep a reset (a "Retry" button of a toast outlives
+ * the route that opened it).
+ */
+export interface ReportGuard {
+    /** True when a reset that the host starts must do nothing. */
+    blocked(): boolean;
+    /**
+     * True once {@link ReportGuard.dispose} ran, and never for a report that runs.
+     *
+     * {@link ReportGuard.blocked} answers a different question: it is true for the
+     * re-entry of a report as well, and it goes back to false when that report ends. A
+     * caller that asks whether the guard is SPENT — play-react builds one again after the
+     * cleanup of `<StrictMode>` disposed it — must read this one: `blocked()` there would
+     * replace a live guard that is reporting, and the `finally` of that report would then
+     * clear the re-entry flag of a guard that nobody holds.
+     */
+    disposed(): boolean;
+    /** The provider is gone. */
+    dispose(): void;
+    /**
+     * Delivers one report, with the re-entry flag held for the call.
+     *
+     * @param error - The contained failure.
+     * @param deliver - The call of the handler of the host, or `undefined` when the host
+     *   gave none. Without a handler the guard writes {@link ReportGuardMessages.noHandler}
+     *   to `console.error`: a contained failure that reaches no handler and no caller is
+     *   the one result that nobody can debug. A handler that THROWS is contained where the
+     *   guard carries {@link ReportGuardMessages.handlerThrew}, and it reaches the caller
+     *   where it does not.
+     */
+    report(error: unknown, deliver: (() => void) | undefined): void;
+}
+/**
+ * What a {@link ReportGuard} writes to `console.error`, and what it therefore contains.
+ *
+ * Each message is optional, and each one is a DECISION of the renderer that builds the
+ * guard. The rule that both serve is one rule: a contained failure is never silent, and
+ * a handler of the host never defeats the containment.
+ */
+export interface ReportGuardMessages {
+    /**
+     * What `console.error` says when the host gave no handler.
+     *
+     * Omit it where the framework writes such a failure itself: React logs an error that
+     * a boundary caught, so play-react would report the same failure two times.
+     */
+    noHandler?: string;
+    /**
+     * What `console.error` says when the handler of the host THROWS.
+     *
+     * A guard that carries this message CONTAINS such a throw. All five renderers carry it,
+     * so a host learns one rule: a handler of the host never defeats the containment, and a
+     * host that must escalate raises the failure from a task of its own —
+     * `queueMicrotask(() => { throw error; })`. Omit it only where a throw must reach the
+     * caller, which no renderer of this workspace asks for today.
+     *
+     * A renderer needs the containment when a throw that leaves the report also stops the
+     * screen of the fallback: the flag of play-vue schedules a render, the fallback of
+     * play-solid is the RETURN of the callback that reports, `componentDidCatch` of
+     * play-react can take the complete React root down, and a throw that leaves the
+     * `onerror` of Svelte leaves its own `calling_on_error` flag raised, which makes every
+     * later reset of the host raise `svelte_boundary_reset_onerror`.
+     */
+    handlerThrew?: string;
+}
+/**
+ * Makes a {@link ReportGuard}.
+ *
+ * The flag SAVES and restores, and it is no plain `false` at the end: a handler of the
+ * host can start a second contained failure inside the first — a fallback that throws, a
+ * write of the store that drives another emission — and a bare reset in the inner
+ * `finally` would clear the guard while the outer report still runs.
+ *
+ * @param messages - See {@link ReportGuardMessages}. The two messages say what the guard
+ *   writes to `console.error`, and the absence of one says what it lets through.
+ */
+export declare function createReportGuard(messages: ReportGuardMessages): ReportGuard;
+/** The record of what a provider reported. See {@link createFailureLatch}. */
+export interface FailureLatch {
+    /**
+     * Answers whether a failure of these three inputs is new, and records it.
+     *
+     * @returns `true` the first time for one set of inputs, and `false` for every repeat
+     *   of the same set. A caller reports only when it returns `true`.
+     */
+    shouldReport(actor: unknown, view: unknown, store: unknown): boolean;
+    /**
+     * Forgets the record, so the next failure reports again.
+     *
+     * A caller clears it on EVERY emission of a view, the null emission included: a view,
+     * then null, then the same view is a real sequence of an actor, and the second failure
+     * of that view is a second attempt that the host must hear about. It also clears it on
+     * a resolution that works, and on a retry that the host starts — the host asked for
+     * that attempt, so it must hear the result.
+     */
+    clear(): void;
+}
+/**
+ * Makes a {@link FailureLatch}.
+ *
+ * The latch holds the three inputs BESIDE the flag. Clearing on each emission would be
+ * enough for a provider that can hook every emission, and the identity check covers the
+ * one that cannot: a render that runs again with nothing changed reports nothing, whether
+ * or not the provider noticed that it ran.
+ */
+export declare function createFailureLatch(): FailureLatch;
+//# sourceMappingURL=failure-latch.d.ts.map

package/dist/failure-latch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure-latch.d.ts","sourceRoot":"","sources":["../src/failure-latch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAEpE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC3B,8DAA8D;IAC9D,OAAO,IAAI,OAAO,CAAC;IACnB;;;;;;;;;OASG;IACH,QAAQ,IAAI,OAAO,CAAC;IACpB,4BAA4B;IAC5B,OAAO,IAAI,IAAI,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;CAChE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,WAAW,CAqC5E;AAED,8EAA8E;AAC9E,MAAM,WAAW,YAAY;IAC5B;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACrE;;;;;;;;OAQG;IACH,KAAK,IAAI,IAAI,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAgBjD"}

package/dist/failure-latch.js

@@ -0,0 +1,110 @@
+/**
+ * The report rules of a provider, in one place.
+ *
+ * A provider resolves the store from three inputs — the actor, the view, and the store of
+ * the caller — and it reports a failure of that resolution to `onError`. This module holds
+ * the three rules that every renderer had written for itself, beside
+ * {@link createViewStoreLifecycle}, which already receives the same three inputs on every
+ * resolve:
+ *
+ * - {@link sameViewInputs} answers whether two attempts carry the SAME three inputs.
+ * - {@link createFailureLatch} reports ONE time for one set of those three. The render
+ *   path of a provider runs again for every tracked change, and a parent that renders
+ *   hands the props over again, so a report on each attempt gives the host one failure
+ *   many times.
+ * - {@link createReportGuard} keeps the host from defeating the containment: a reset that
+ *   the host starts from INSIDE the report does nothing, a reset after the provider is
+ *   gone does nothing, and a handler that THROWS is contained where the renderer needs it.
+ *
+ * The copies disagreed. play-vue held a boolean and cleared it at four sites, play-svelte
+ * held the three inputs and kept them across a null emission, and play-solid held nothing
+ * at all while the comment of play-vue said that it did.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Answers whether two sets of inputs are the SAME attempt.
+ *
+ * Identity, and not a deep compare: a provider holds the references that it rendered, and
+ * a new spec object is a new attempt even when it holds equal fields.
+ */
+export function sameViewInputs(a, b) {
+    return a.actor === b.actor && a.view === b.view && a.store === b.store;
+}
+/**
+ * Makes a {@link ReportGuard}.
+ *
+ * The flag SAVES and restores, and it is no plain `false` at the end: a handler of the
+ * host can start a second contained failure inside the first — a fallback that throws, a
+ * write of the store that drives another emission — and a bare reset in the inner
+ * `finally` would clear the guard while the outer report still runs.
+ *
+ * @param messages - See {@link ReportGuardMessages}. The two messages say what the guard
+ *   writes to `console.error`, and the absence of one says what it lets through.
+ */
+export function createReportGuard(messages) {
+    const { noHandler, handlerThrew } = messages;
+    let disposed = false;
+    let reporting = false;
+    return {
+        blocked: () => disposed || reporting,
+        disposed: () => disposed,
+        dispose() {
+            disposed = true;
+        },
+        report(error, deliver) {
+            const wasReporting = reporting;
+            reporting = true;
+            try {
+                if (!deliver) {
+                    if (noHandler !== undefined)
+                        console.error(noHandler, error);
+                    return;
+                }
+                if (handlerThrew === undefined) {
+                    deliver();
+                    return;
+                }
+                // The containment of a handler that throws. The failure belongs to the host,
+                // and it stops here: a throw that leaves this call reaches the framework of
+                // the caller, which is the path that the boundary of the renderer closes.
+                // Write it where a caller can find it.
+                try {
+                    deliver();
+                }
+                catch (handlerFailure) {
+                    console.error(handlerThrew, handlerFailure);
+                }
+            }
+            finally {
+                reporting = wasReporting;
+            }
+        },
+    };
+}
+/**
+ * Makes a {@link FailureLatch}.
+ *
+ * The latch holds the three inputs BESIDE the flag. Clearing on each emission would be
+ * enough for a provider that can hook every emission, and the identity check covers the
+ * one that cannot: a render that runs again with nothing changed reports nothing, whether
+ * or not the provider noticed that it ran.
+ */
+export function createFailureLatch() {
+    // ONE record of the three inputs, and `null` for "nothing reported yet". A flag beside
+    // three loose fields says the same thing two times, and the two can disagree.
+    let last = null;
+    return {
+        shouldReport(actor, view, store) {
+            const next = { actor, view, store };
+            if (last !== null && sameViewInputs(last, next))
+                return false;
+            last = next;
+            return true;
+        },
+        clear() {
+            last = null;
+        },
+    };
+}
+//# sourceMappingURL=failure-latch.js.map

package/dist/failure-latch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure-latch.js","sourceRoot":"","sources":["../src/failure-latch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAeH;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,CAAa,EAAE,CAAa;IAC1D,OAAO,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,KAAK,CAAC;AACxE,CAAC;AA4ED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAA6B;IAC9D,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,QAAQ,CAAC;IAC7C,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,OAAO;QACN,OAAO,EAAE,GAAY,EAAE,CAAC,QAAQ,IAAI,SAAS;QAC7C,QAAQ,EAAE,GAAY,EAAE,CAAC,QAAQ;QACjC,OAAO;YACN,QAAQ,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,MAAM,CAAC,KAAc,EAAE,OAAiC;YACvD,MAAM,YAAY,GAAG,SAAS,CAAC;YAC/B,SAAS,GAAG,IAAI,CAAC;YACjB,IAAI,CAAC;gBACJ,IAAI,CAAC,OAAO,EAAE,CAAC;oBACd,IAAI,SAAS,KAAK,SAAS;wBAAE,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;oBAC7D,OAAO;gBACR,CAAC;gBACD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;oBAChC,OAAO,EAAE,CAAC;oBACV,OAAO;gBACR,CAAC;gBACD,6EAA6E;gBAC7E,4EAA4E;gBAC5E,0EAA0E;gBAC1E,uCAAuC;gBACvC,IAAI,CAAC;oBACJ,OAAO,EAAE,CAAC;gBACX,CAAC;gBAAC,OAAO,cAAc,EAAE,CAAC;oBACzB,OAAO,CAAC,KAAK,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;gBAC7C,CAAC;YACF,CAAC;oBAAS,CAAC;gBACV,SAAS,GAAG,YAAY,CAAC;YAC1B,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC;AAuBD;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB;IACjC,uFAAuF;IACvF,8EAA8E;IAC9E,IAAI,IAAI,GAAsB,IAAI,CAAC;IAEnC,OAAO;QACN,YAAY,CAAC,KAAc,EAAE,IAAa,EAAE,KAAc;YACzD,MAAM,IAAI,GAAe,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;YAChD,IAAI,IAAI,KAAK,IAAI,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC9D,IAAI,GAAG,IAAI,CAAC;YACZ,OAAO,IAAI,CAAC;QACb,CAAC;QACD,KAAK;YACJ,IAAI,GAAG,IAAI,CAAC;QACb,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -21,5 +21,7 @@ export { AbstractActor, typedSpec, type Routable, type Viewable, type PlaySpec,
 export { toAtomState, attachRenderErrorHandler } from "./provider-guards.js";
 export { CONTEXT_STATE_KEY, guardContextWrites, refreshContextSubtree, composePlayState, shallowEqualExcept, reuseComposedState, } from "./context-projection.js";
 export { createViewStoreLifecycle } from "./view-store-lifecycle.js";
+export { createFailureLatch, createReportGuard, sameViewInputs } from "./failure-latch.js";
+export type { FailureLatch, ReportGuard, ReportGuardMessages, ViewInputs, } from "./failure-latch.js";
 export type { ViewStoreLifecycle, ViewStoreResolution, ResolveViewStoreOptions, } from "./view-store-lifecycle.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;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACN,aAAa,EACb,SAAS,EACT,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,GACzB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EACN,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,YAAY,EACX,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,GACvB,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACN,aAAa,EACb,SAAS,EACT,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,GACzB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EACN,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC3F,YAAY,EACX,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,UAAU,GACV,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACX,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,GACvB,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -21,4 +21,5 @@ export { AbstractActor, typedSpec, } from "./abstract-actor.js";
 export { toAtomState, attachRenderErrorHandler } from "./provider-guards.js";
 export { CONTEXT_STATE_KEY, guardContextWrites, refreshContextSubtree, composePlayState, shallowEqualExcept, reuseComposedState, } from "./context-projection.js";
 export { createViewStoreLifecycle } from "./view-store-lifecycle.js";
+export { createFailureLatch, createReportGuard, sameViewInputs } from "./failure-latch.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACN,aAAa,EACb,SAAS,GAMT,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EACN,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACN,aAAa,EACb,SAAS,GAMT,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EACN,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-actor",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "private": false,
   "description": "Abstract Actor base class for XMachines Play Architecture",
   "keywords": [
@@ -49,7 +49,7 @@
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",
     "@types/node": "^26.2.0",
-    "@xmachines/json-render-core": "^0.20.0-xm.2",
+    "@xmachines/json-render-core": "^0.20.0-xm.4",
     "oxfmt": "^0.64.0",
     "oxlint": "^1.79.0",
     "vite": "^8.0.10",
@@ -57,9 +57,9 @@
     "xstate": "^5.31.0"
   },
   "peerDependencies": {
-    "@xmachines/json-render-core": "^0.20.0-xm.2",
-    "@xmachines/play": "2.1.1",
-    "@xmachines/play-signals": "2.1.1",
+    "@xmachines/json-render-core": "^0.20.0-xm.4",
+    "@xmachines/play": "3.0.0",
+    "@xmachines/play-signals": "3.0.0",
     "xstate": "^5.31.0"
   },
   "engines": {