@xmachines/play-dom 1.0.0-beta.26 → 1.0.0-beta.28

package/LICENSE

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

package/README.md

@@ -0,0 +1,51 @@
+# @xmachines/play-dom
+
+**Vanilla DOM renderer for XMachines**
+
+`connectRenderer` — a framework-free `PlayRenderer` equivalent that wires an XState v5 actor's `currentView` TC39 Signal to pure DOM rendering via a catalog-typed `DomRegistry`.
+
+## Installation
+
+```bash
+npm install @xmachines/play-dom
+```
+
+## Key Exports
+
+- `connectRenderer({ actor, registry, container })` — connect actor view signal to DOM
+- `defineRegistry(catalog, { components, actions })` — build a catalog-typed `DomRegistry`
+- `PlayRenderer` — class-based renderer (connect/disconnect lifecycle)
+- `ComponentFn<C, K>` — catalog-typed DOM component function type
+- `ComponentContext<C, K>` — context passed to each `ComponentFn` (props, emit, on, children, bindings)
+- `renderSpec(spec, store, registry, send, actorActions)` — pure Spec → DOM renderer
+
+## Usage
+
+```ts
+import { definePlayer } from "@xmachines/play-xstate";
+import { connectRenderer, defineRegistry } from "@xmachines/play-dom";
+import { authMachine, authCatalog, type AuthCatalog } from "@xmachines/play-actor-shared";
+import type { ComponentFn } from "@xmachines/play-dom";
+
+const Home: ComponentFn<AuthCatalog, "Home"> = ({ props }) => {
+	const el = document.createElement("section");
+	el.textContent = props.title;
+	return el;
+};
+
+const { registry } = defineRegistry(authCatalog, {
+	components: { Home /* ... */ },
+	actions: { login: "auth.login", logout: "auth.logout" },
+});
+
+const createPlayer = definePlayer({ machine: authMachine });
+const actor = createPlayer();
+actor.start();
+
+const container = document.getElementById("app")!;
+const disconnect = connectRenderer({ actor, registry, container });
+```
+
+## Learn More
+
+- [DOM Router adapter `@xmachines/play-dom-router`](../play-dom-router/README.md)

package/dist/PlayRenderer.d.ts

@@ -1,5 +1,5 @@
 /**
- * PlayRenderer.ts — XMachines wrapper around the pure dom-renderer layer.
+ * PlayRenderer.ts — XMachines wrapper around the pure json-render/dom renderer layer.
  *
  * Bridges actor.currentView (TC39 Signal) to the inner DOM renderer using watchSignal.
  * Exposes connect() / disconnect() methods following the same pattern as
@@ -10,7 +10,8 @@
  */
 import type { AbstractActor, Viewable } from "@xmachines/play-actor";
 import type { AnyActorLogic } from "xstate";
-import type { DomRegistry, PlayDomOptions } from "./types.js";
+import type { DomRegistry } from "./json-render/types.js";
+import type { PlayDomOptions } from "./xm-types.js";
 /**
  * PlayRenderer connects an actor's currentView signal to the DOM renderer.
  *

package/dist/PlayRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlayRenderer.d.ts","sourceRoot":"","sources":["../src/PlayRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAgB,MAAM,uBAAuB,CAAC;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,YAAY;IAavB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAfzB,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,iBAAiB,CAA6B;IAEtD;;;;;;;OAOG;gBAEe,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,EAC9C,QAAQ,EAAE,WAAW,EACrB,OAAO,GAAE,cAAmB;IAG9C;;;OAGG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,UAAU,IAAI,IAAI;IAQlB,OAAO,CAAC,OAAO;CAkCf"}
+{"version":3,"file":"PlayRenderer.d.ts","sourceRoot":"","sources":["../src/PlayRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAgB,MAAM,uBAAuB,CAAC;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,YAAY;IAavB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAfzB,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,iBAAiB,CAA6B;IAEtD;;;;;;;OAOG;gBAEe,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,EAC9C,QAAQ,EAAE,WAAW,EACrB,OAAO,GAAE,cAAmB;IAG9C;;;OAGG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,UAAU,IAAI,IAAI;IAQlB,OAAO,CAAC,OAAO;CA2Bf"}

package/dist/PlayRenderer.js

@@ -1,5 +1,5 @@
 /**
- * PlayRenderer.ts — XMachines wrapper around the pure dom-renderer layer.
+ * PlayRenderer.ts — XMachines wrapper around the pure json-render/dom renderer layer.
  *
  * Bridges actor.currentView (TC39 Signal) to the inner DOM renderer using watchSignal.
  * Exposes connect() / disconnect() methods following the same pattern as
@@ -11,7 +11,7 @@
 import { watchSignal } from "@xmachines/play-signals";
 import { createAtom } from "@xstate/store";
 import { xstateStoreStateStore } from "@json-render/xstate";
-import { renderSpec } from "./dom-renderer.js";
+import { renderSpec } from "./json-render/renderer.js";
 /**
  * PlayRenderer connects an actor's currentView signal to the DOM renderer.
  *
@@ -86,7 +86,7 @@ export class PlayRenderer {
         const actorActions = this.options.actions ?? {};
         const rerender = () => {
             this.container.replaceChildren();
-            const node = renderSpec(view.spec, store, this.registry, send, this.actor, actorActions);
+            const node = renderSpec(view.spec, store, this.registry, send, actorActions);
             if (node)
                 this.container.appendChild(node);
         };

package/dist/PlayRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"PlayRenderer.js","sourceRoot":"","sources":["../src/PlayRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,YAAY;IAaN;IACA;IACA;IACA;IAfV,QAAQ,GAAwB,IAAI,CAAC;IACrC,iBAAiB,GAAwB,IAAI,CAAC;IAEtD;;;;;;;OAOG;IACH,YACkB,SAAsB,EACtB,KAA8C,EAC9C,QAAqB,EACrB,UAA0B,EAAE;QAH5B,cAAS,GAAT,SAAS,CAAa;QACtB,UAAK,GAAL,KAAK,CAAyC;QAC9C,aAAQ,GAAR,QAAQ,CAAa;QACrB,YAAO,GAAP,OAAO,CAAqB;IAC3C,CAAC;IAEJ;;;OAGG;IACH,OAAO;QACN,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACnF,CAAC;IAED;;OAEG;IACH,UAAU;QACT,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAEO,OAAO,CAAC,IAAyB;QACxC,2DAA2D;QAC3D,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAE9B,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI;YAAE,OAAO;QAElB,kEAAkE;QAClE,MAAM,KAAK,GAAe,IAAI,CAAC,OAAO,CAAC,KAAK;YAC3C,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK;YACpB,CAAC,CAAC,qBAAqB,CAAC;gBACtB,IAAI,EAAE,UAAU,CAAE,IAAI,CAAC,IAAI,CAAC,KAAiC,IAAI,EAAE,CAAC;aACpE,CAAC,CAAC;QAEL,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9C,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;QAEhD,MAAM,QAAQ,GAAG,GAAS,EAAE;YAC3B,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;YACjC,MAAM,IAAI,GAAG,UAAU,CACtB,IAAI,CAAC,IAAI,EACT,KAAK,EACL,IAAI,CAAC,QAAQ,EACb,IAAI,EACJ,IAAI,CAAC,KAAK,EACV,YAAY,CACZ,CAAC;YACF,IAAI,IAAI;gBAAE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC5C,CAAC,CAAC;QAEF,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACnD,QAAQ,EAAE,CAAC;IACZ,CAAC;CACD"}
+{"version":3,"file":"PlayRenderer.js","sourceRoot":"","sources":["../src/PlayRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAIvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,YAAY;IAaN;IACA;IACA;IACA;IAfV,QAAQ,GAAwB,IAAI,CAAC;IACrC,iBAAiB,GAAwB,IAAI,CAAC;IAEtD;;;;;;;OAOG;IACH,YACkB,SAAsB,EACtB,KAA8C,EAC9C,QAAqB,EACrB,UAA0B,EAAE;QAH5B,cAAS,GAAT,SAAS,CAAa;QACtB,UAAK,GAAL,KAAK,CAAyC;QAC9C,aAAQ,GAAR,QAAQ,CAAa;QACrB,YAAO,GAAP,OAAO,CAAqB;IAC3C,CAAC;IAEJ;;;OAGG;IACH,OAAO;QACN,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACnF,CAAC;IAED;;OAEG;IACH,UAAU;QACT,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAEO,OAAO,CAAC,IAAyB;QACxC,2DAA2D;QAC3D,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAE9B,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI;YAAE,OAAO;QAElB,kEAAkE;QAClE,MAAM,KAAK,GAAe,IAAI,CAAC,OAAO,CAAC,KAAK;YAC3C,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK;YACpB,CAAC,CAAC,qBAAqB,CAAC;gBACtB,IAAI,EAAE,UAAU,CAAE,IAAI,CAAC,IAAI,CAAC,KAAiC,IAAI,EAAE,CAAC;aACpE,CAAC,CAAC;QAEL,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9C,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;QAEhD,MAAM,QAAQ,GAAG,GAAS,EAAE;YAC3B,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;YACjC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;YAC7E,IAAI,IAAI;gBAAE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC5C,CAAC,CAAC;QAEF,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACnD,QAAQ,EAAE,CAAC;IACZ,CAAC;CACD"}

package/dist/connect-renderer.d.ts

@@ -6,7 +6,7 @@
  *
  * The implementation delegates entirely to PlayRenderer.
  */
-import type { ConnectRendererOptions } from "./types.js";
+import type { ConnectRendererOptions } from "./xm-types.js";
 /**
  * Connect a signal-driven DOM renderer to an actor's currentView signal.
  *

package/dist/connect-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect-renderer.d.ts","sourceRoot":"","sources":["../src/connect-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,IAAI,CAiB3E"}
+{"version":3,"file":"connect-renderer.d.ts","sourceRoot":"","sources":["../src/connect-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,IAAI,CAiB3E"}

package/dist/index.d.ts

@@ -1,20 +1,29 @@
 /**
- * @xmachines/play-dom - Vanilla DOM renderer for XMachines Play architecture
+ * @xmachines/play-dom — Vanilla DOM renderer for XMachines Play architecture.
  *
- * Provides a two-layer architecture:
- * - Inner layer (dom-renderer): Pure json-render-core compatible DOM renderer.
- *   Zero XMachines dependencies. Upstreamable to @json-render/dom.
- * - Outer layer (PlayRenderer): XMachines wrapper. Bridges actor.currentView
- *   (TC39 Signal) to the inner DOM renderer using watchSignal.
+ * Public API split into two layers:
  *
- * Also provides connectRenderer() as a backward-compat convenience function.
+ * **XMachines layer** (this package):
+ * - `PlayRenderer`      — connects actor.currentView signal → DOM renderer
+ * - `connectRenderer()` — backward-compat functional API
+ * - `ConnectRendererOptions`, `PlayDomOptions`
  *
- * No framework required. Pure DOM APIs only.
+ * **json-render layer** (upstreamable to @json-render/dom):
+ * - `defineRegistry`    — build a catalog-typed DomRegistry
+ * - `renderSpec`        — pure Spec → DOM renderer (uses resolveElementProps from core)
+ * - `ComponentFn`       — catalog-typed component function type
+ * - `ComponentContext`  — catalog-typed render context (props, emit, on, children, bindings)
+ * - `ComponentRegistry` — catalog-typed registry input type
+ * - `DomComponentRenderer` — raw element-level renderer type
+ * - `DomRegistry`       — raw registry type
+ * - `DomRenderContext`  — raw render context
+ * - `EventHandle`       — event handle returned by on()
  *
  * @packageDocumentation
  */
 export { connectRenderer } from "./connect-renderer.js";
 export { PlayRenderer } from "./PlayRenderer.js";
-export { renderSpec } from "./dom-renderer.js";
-export type { DomComponentRenderer, DomRegistry, DomRenderContext, ConnectRendererOptions, PlayDomOptions, } from "./types.js";
+export type { ConnectRendererOptions, PlayDomOptions } from "./xm-types.js";
+export { defineRegistry, renderSpec } from "./json-render/index.js";
+export type { EventHandle, DomRenderContext, DomComponentRenderer, ComponentContext, ComponentFn, ComponentRegistry, DefineRegistryOptions, DefineRegistryResult, DomRegistry, } from "./json-render/index.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;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,YAAY,EACX,oBAAoB,EACpB,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,GACd,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,YAAY,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG5E,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpE,YAAY,EACX,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,WAAW,GACX,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,19 +1,29 @@
 /**
- * @xmachines/play-dom - Vanilla DOM renderer for XMachines Play architecture
+ * @xmachines/play-dom — Vanilla DOM renderer for XMachines Play architecture.
  *
- * Provides a two-layer architecture:
- * - Inner layer (dom-renderer): Pure json-render-core compatible DOM renderer.
- *   Zero XMachines dependencies. Upstreamable to @json-render/dom.
- * - Outer layer (PlayRenderer): XMachines wrapper. Bridges actor.currentView
- *   (TC39 Signal) to the inner DOM renderer using watchSignal.
+ * Public API split into two layers:
  *
- * Also provides connectRenderer() as a backward-compat convenience function.
+ * **XMachines layer** (this package):
+ * - `PlayRenderer`      — connects actor.currentView signal → DOM renderer
+ * - `connectRenderer()` — backward-compat functional API
+ * - `ConnectRendererOptions`, `PlayDomOptions`
  *
- * No framework required. Pure DOM APIs only.
+ * **json-render layer** (upstreamable to @json-render/dom):
+ * - `defineRegistry`    — build a catalog-typed DomRegistry
+ * - `renderSpec`        — pure Spec → DOM renderer (uses resolveElementProps from core)
+ * - `ComponentFn`       — catalog-typed component function type
+ * - `ComponentContext`  — catalog-typed render context (props, emit, on, children, bindings)
+ * - `ComponentRegistry` — catalog-typed registry input type
+ * - `DomComponentRenderer` — raw element-level renderer type
+ * - `DomRegistry`       — raw registry type
+ * - `DomRenderContext`  — raw render context
+ * - `EventHandle`       — event handle returned by on()
  *
  * @packageDocumentation
  */
+// XMachines integration layer
 export { connectRenderer } from "./connect-renderer.js";
 export { PlayRenderer } from "./PlayRenderer.js";
-export { renderSpec } from "./dom-renderer.js";
+// json-render/dom layer (re-exported for consumer convenience)
+export { defineRegistry, renderSpec } from "./json-render/index.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;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,8BAA8B;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAKjD,+DAA+D;AAC/D,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/json-render/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @json-render/dom barrel — re-exports all upstreamable DOM renderer code.
+ *
+ * This directory contains everything that belongs in a future @json-render/dom package:
+ * - types.ts     — DomRenderContext, DomComponentRenderer, ComponentFn, ComponentContext,
+ *                  ComponentRegistry, DomRegistry, EventHandle, DefineRegistryOptions,
+ *                  DefineRegistryResult, defineRegistry
+ * - renderer.ts  — renderSpec (pure Spec → DOM, uses resolveElementProps from @json-render/core)
+ *
+ * Zero XMachines dependencies. All XMachines integration lives in the parent src/ layer.
+ *
+ * @packageDocumentation
+ */
+export { renderSpec } from "./renderer.js";
+export { defineRegistry } from "./types.js";
+export type { EventHandle, DomRenderContext, DomComponentRenderer, ComponentContext, ComponentFn, ComponentRegistry, DefineRegistryOptions, DefineRegistryResult, DomRegistry, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/json-render/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/json-render/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,YAAY,EACX,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,WAAW,GACX,MAAM,YAAY,CAAC"}

package/dist/json-render/index.js

@@ -0,0 +1,16 @@
+/**
+ * @json-render/dom barrel — re-exports all upstreamable DOM renderer code.
+ *
+ * This directory contains everything that belongs in a future @json-render/dom package:
+ * - types.ts     — DomRenderContext, DomComponentRenderer, ComponentFn, ComponentContext,
+ *                  ComponentRegistry, DomRegistry, EventHandle, DefineRegistryOptions,
+ *                  DefineRegistryResult, defineRegistry
+ * - renderer.ts  — renderSpec (pure Spec → DOM, uses resolveElementProps from @json-render/core)
+ *
+ * Zero XMachines dependencies. All XMachines integration lives in the parent src/ layer.
+ *
+ * @packageDocumentation
+ */
+export { renderSpec } from "./renderer.js";
+export { defineRegistry } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/json-render/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/json-render/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/json-render/renderer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * renderer.ts — Pure json-render-core compatible DOM renderer.
+ *
+ * Zero XMachines dependencies. Upstreamable to @json-render/dom.
+ *
+ * Implements the same element-rendering contract as the framework renderers
+ * (@json-render/react, /solid, /svelte, /vue):
+ *
+ * - Props resolved via `resolveElementProps` from `@json-render/core` (handles
+ *   `$state`, `$item`, `$index`, `$bindState`, `$bindItem`, `$cond`, `$computed`,
+ *   `$template` — the full expression set, not just `$state`)
+ * - Visibility evaluated via `evaluateVisibility` from `@json-render/core`
+ * - Event handling is done **once**, inside the `defineRegistry` component
+ *   wrapper via the `emit`/`on` closures — `renderSpec` does NOT attach additional
+ *   DOM event listeners (eliminates the double-dispatch bug)
+ * - Children are rendered and passed to the component function as `ctx.children`
+ *   — `renderSpec` does NOT append them again after the component returns
+ *   (eliminates the double-append bug)
+ *
+ * @packageDocumentation
+ */
+import type { Spec, StateStore } from "@json-render/core";
+import type { DomRegistry, DomRenderContext } from "./types.js";
+/**
+ * Render a Spec tree into DOM nodes using the provided `DomRegistry`.
+ *
+ * Traverses the spec from `spec.root`, evaluates visibility, resolves all prop
+ * expressions (including `$state`, `$bindState`, `$computed`, `$template`, etc.),
+ * and calls the matching `DomComponentRenderer` for each visible element.
+ *
+ * Event wiring and child rendering are handled inside the component wrapper
+ * built by `defineRegistry` — this function only orchestrates the traversal.
+ *
+ * @param spec         - The json-render `Spec` describing the UI tree.
+ * @param store        - Live `StateStore` bound to `spec.state`.
+ * @param registry     - Map of element type names → `DomComponentRenderer`.
+ * @param send         - Dispatcher for interaction events (e.g. actor.send).
+ * @param actorActions - Map of catalog action names → event type strings.
+ * @returns            The root DOM `Node`, or `null` if the root is invisible
+ *                     or has no registered renderer.
+ *
+ * @example
+ * ```ts
+ * const node = renderSpec(spec, store, registry, actor.send.bind(actor), {
+ *   login: "auth.login",
+ *   logout: "auth.logout",
+ * });
+ * if (node) container.appendChild(node);
+ * ```
+ */
+export declare function renderSpec(spec: Spec, store: StateStore, registry: DomRegistry, send: DomRenderContext["send"], actorActions: Record<string, string>): Node | null;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/json-render/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/json-render/renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAa,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,WAAW,EACrB,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAC9B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,IAAI,GAAG,IAAI,CAyDb"}

package/dist/json-render/renderer.js

@@ -0,0 +1,101 @@
+/**
+ * renderer.ts — Pure json-render-core compatible DOM renderer.
+ *
+ * Zero XMachines dependencies. Upstreamable to @json-render/dom.
+ *
+ * Implements the same element-rendering contract as the framework renderers
+ * (@json-render/react, /solid, /svelte, /vue):
+ *
+ * - Props resolved via `resolveElementProps` from `@json-render/core` (handles
+ *   `$state`, `$item`, `$index`, `$bindState`, `$bindItem`, `$cond`, `$computed`,
+ *   `$template` — the full expression set, not just `$state`)
+ * - Visibility evaluated via `evaluateVisibility` from `@json-render/core`
+ * - Event handling is done **once**, inside the `defineRegistry` component
+ *   wrapper via the `emit`/`on` closures — `renderSpec` does NOT attach additional
+ *   DOM event listeners (eliminates the double-dispatch bug)
+ * - Children are rendered and passed to the component function as `ctx.children`
+ *   — `renderSpec` does NOT append them again after the component returns
+ *   (eliminates the double-append bug)
+ *
+ * @packageDocumentation
+ */
+import { evaluateVisibility, resolveBindings, resolveElementProps } from "@json-render/core";
+/**
+ * Render a Spec tree into DOM nodes using the provided `DomRegistry`.
+ *
+ * Traverses the spec from `spec.root`, evaluates visibility, resolves all prop
+ * expressions (including `$state`, `$bindState`, `$computed`, `$template`, etc.),
+ * and calls the matching `DomComponentRenderer` for each visible element.
+ *
+ * Event wiring and child rendering are handled inside the component wrapper
+ * built by `defineRegistry` — this function only orchestrates the traversal.
+ *
+ * @param spec         - The json-render `Spec` describing the UI tree.
+ * @param store        - Live `StateStore` bound to `spec.state`.
+ * @param registry     - Map of element type names → `DomComponentRenderer`.
+ * @param send         - Dispatcher for interaction events (e.g. actor.send).
+ * @param actorActions - Map of catalog action names → event type strings.
+ * @returns            The root DOM `Node`, or `null` if the root is invisible
+ *                     or has no registered renderer.
+ *
+ * @example
+ * ```ts
+ * const node = renderSpec(spec, store, registry, actor.send.bind(actor), {
+ *   login: "auth.login",
+ *   logout: "auth.logout",
+ * });
+ * if (node) container.appendChild(node);
+ * ```
+ */
+export function renderSpec(spec, store, registry, send, actorActions) {
+    function renderElement(key) {
+        const element = spec.elements[key];
+        if (!element)
+            return null;
+        const stateModel = store.getSnapshot();
+        // ── Visibility ────────────────────────────────────────────────────────
+        // Matches framework behavior: invisible elements are not rendered.
+        if (element.visible !== undefined) {
+            const visible = evaluateVisibility(element.visible, { stateModel });
+            if (!visible)
+                return null;
+        }
+        const rawProps = element.props ?? {};
+        // ── Bindings (before prop resolution) ────────────────────────────────
+        // resolveBindings must run on raw props — after resolveElementProps the
+        // $bindState/$bindItem expressions are replaced with resolved values.
+        const elementBindings = resolveBindings(rawProps, { stateModel }) ?? undefined;
+        // ── Prop resolution ───────────────────────────────────────────────────
+        // Use resolveElementProps from @json-render/core — handles the full
+        // DynamicValue expression set ($state, $item, $index, $bindState,
+        // $bindItem, $cond/$then/$else, $computed, $template).
+        // This replaces the former local resolveProps which only handled $state.
+        const resolvedProps = resolveElementProps(rawProps, { stateModel });
+        // ── DomRenderContext ──────────────────────────────────────────────────
+        // Build the context passed to DomComponentRenderer functions.
+        // renderChildren recurses into this same renderElement function.
+        const ctx = {
+            spec,
+            store,
+            send,
+            actorActions,
+            elementBindings,
+            renderChildren: (keys) => keys.flatMap((k) => {
+                const n = renderElement(k);
+                return n ? [n] : [];
+            }),
+        };
+        // ── Renderer lookup ───────────────────────────────────────────────────
+        const renderer = registry[element.type];
+        if (!renderer)
+            return null; // unknown type → null (matches framework behavior)
+        // ── Render ────────────────────────────────────────────────────────────
+        // Pass the resolved element. The component wrapper built by defineRegistry
+        // handles emit/on/children/bindings internally — do NOT wire events or
+        // append children here (doing so would double-fire and double-append).
+        const resolvedElement = { ...element, props: resolvedProps };
+        return renderer(resolvedElement, ctx);
+    }
+    return renderElement(spec.root);
+}
+//# sourceMappingURL=renderer.js.map

package/dist/json-render/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../src/json-render/renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAI7F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,UAAU,CACzB,IAAU,EACV,KAAiB,EACjB,QAAqB,EACrB,IAA8B,EAC9B,YAAoC;IAEpC,SAAS,aAAa,CAAC,GAAW;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAE1B,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QAEvC,yEAAyE;QACzE,mEAAmE;QACnE,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YACnC,MAAM,OAAO,GAAG,kBAAkB,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;YACpE,IAAI,CAAC,OAAO;gBAAE,OAAO,IAAI,CAAC;QAC3B,CAAC;QAED,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC;QAErC,wEAAwE;QACxE,wEAAwE;QACxE,sEAAsE;QACtE,MAAM,eAAe,GAAG,eAAe,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,CAAC,IAAI,SAAS,CAAC;QAE/E,yEAAyE;QACzE,oEAAoE;QACpE,kEAAkE;QAClE,uDAAuD;QACvD,yEAAyE;QACzE,MAAM,aAAa,GAAG,mBAAmB,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;QAEpE,yEAAyE;QACzE,8DAA8D;QAC9D,iEAAiE;QACjE,MAAM,GAAG,GAAqB;YAC7B,IAAI;YACJ,KAAK;YACL,IAAI;YACJ,YAAY;YACZ,eAAe;YACf,cAAc,EAAE,CAAC,IAAc,EAAE,EAAE,CAClC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;gBAClB,MAAM,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;gBAC3B,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrB,CAAC,CAAC;SACH,CAAC;QAEF,yEAAyE;QACzE,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC,CAAC,mDAAmD;QAE/E,yEAAyE;QACzE,2EAA2E;QAC3E,uEAAuE;QACvE,uEAAuE;QACvE,MAAM,eAAe,GAAc,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC;QACxE,OAAO,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;IACvC,CAAC;IAED,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC"}

package/dist/json-render/types.d.ts

@@ -0,0 +1,311 @@
+/**
+ * types.ts — Type definitions for @json-render/dom
+ *
+ * Zero XMachines dependencies. Upstreamable to @json-render/dom.
+ *
+ * Mirrors the component model from @json-render/react, /solid, /svelte, /vue:
+ * - `ComponentFn<C, K>`      — catalog-typed component function
+ * - `ComponentContext<C, K>` — context passed to each component (props, children, emit, on, bindings)
+ * - `defineRegistry(catalog, options)` — build a catalog-typed DomRegistry
+ *
+ * Key difference from framework renderers: `ComponentFn` returns
+ * `HTMLElement | Text | null` instead of a framework node, and
+ * `actions` is a `Record<string, string>` event-type map instead of
+ * async handler functions (because DOM dispatches directly via `send`).
+ *
+ * @packageDocumentation
+ */
+import type { Catalog, InferCatalogActions, InferCatalogComponents, InferComponentProps, Spec, StateStore, UIElement } from "@json-render/core";
+/**
+ * Handle returned by `ComponentContext.on(eventName)`.
+ *
+ * Matches the `EventHandle` interface from @json-render/react, /solid, /svelte, /vue.
+ *
+ * @example
+ * ```ts
+ * const handle = on("submit");
+ * if (handle.bound) {
+ *   btn.addEventListener("click", (e) => {
+ *     if (handle.shouldPreventDefault) e.preventDefault();
+ *     handle.emit();
+ *   });
+ * }
+ * ```
+ */
+export interface EventHandle {
+    /** Fire the bound action, resolving params from the current state store. */
+    emit: () => void;
+    /**
+     * Whether any binding for this event has `preventDefault: true`.
+     * Use to call `e.preventDefault()` on the triggering DOM event.
+     */
+    shouldPreventDefault: boolean;
+    /** `true` if an `on` binding exists for this event name; `false` otherwise. */
+    bound: boolean;
+}
+/**
+ * Low-level render context passed to each `DomComponentRenderer`.
+ *
+ * This is the raw renderer-level interface. Most component authors should use
+ * the higher-level `ComponentContext<C, K>` provided by `defineRegistry`.
+ */
+export interface DomRenderContext {
+    /** Full spec tree for this render pass. */
+    spec: Spec;
+    /** Live state store bound to `spec.state`. */
+    store: StateStore;
+    /** Dispatch an event (e.g. to an XState actor). */
+    send: (event: {
+        type: string;
+    } & Record<string, unknown>) => void;
+    /** Map of json-render catalog action names → dispatch event type strings. */
+    actorActions: Record<string, string>;
+    /** Render a list of child element keys into DOM nodes. */
+    renderChildren: (keys: string[]) => Node[];
+    /**
+     * Pre-computed two-way binding paths for this element's props.
+     * Resolved from raw props before `resolveElementProps` runs — the resolved
+     * props no longer contain `$bindState`/`$bindItem` expressions.
+     * `undefined` when no binding expressions were found.
+     */
+    elementBindings?: Record<string, string> | undefined;
+}
+/**
+ * Raw DOM component renderer function.
+ *
+ * Receives a resolved `UIElement` and a `DomRenderContext`, and returns a DOM
+ * node or `null`. Prefer using `ComponentFn<C, K>` via `defineRegistry` for
+ * catalog-typed, framework-consistent components.
+ *
+ * @example
+ * ```ts
+ * const myRenderer: DomComponentRenderer = (element, ctx) => {
+ *   const el = document.createElement("div");
+ *   el.textContent = String(element.props.title ?? "");
+ *   return el;
+ * };
+ * ```
+ */
+export type DomComponentRenderer = (element: UIElement, ctx: DomRenderContext) => HTMLElement | Text | null;
+/**
+ * Catalog-typed context passed to each DOM component function.
+ *
+ * Mirrors the `ComponentContext<C, K>` shape from @json-render/react, /solid,
+ * /svelte, /vue with three DOM-specific adaptations:
+ *
+ * - `children` is `Node[]` instead of a framework node/snippet/slot
+ * - `bindings` is `Record<string, string> | undefined` (path strings for DOM
+ *   consumers that implement their own two-way binding, e.g. input value ↔ store)
+ * - `ctx` (low-level `DomRenderContext`) is exposed for advanced use cases
+ *   (framework renderers do not expose this)
+ *
+ * @example
+ * ```ts
+ * const Login: ComponentFn<AuthCatalog, "Login"> = ({ props, emit, on, bindings }) => {
+ *   const section = document.createElement("section");
+ *
+ *   const input = document.createElement("input");
+ *   input.value = props.username ?? "";
+ *
+ *   // Two-way binding: write back to state store when input changes
+ *   if (bindings?.username) {
+ *     input.addEventListener("input", () => {
+ *       // bindings.username contains the store path e.g. "/username"
+ *     });
+ *   }
+ *
+ *   const btn = document.createElement("button");
+ *   const handle = on("submit");
+ *   btn.addEventListener("click", (e) => {
+ *     if (handle.shouldPreventDefault) e.preventDefault();
+ *     handle.emit();
+ *   });
+ *
+ *   section.append(input, btn);
+ *   return section;
+ * };
+ * ```
+ */
+export interface ComponentContext<C extends Catalog, K extends keyof InferCatalogComponents<C>> {
+    /** Catalog-typed, store-resolved props for this component. */
+    props: InferComponentProps<C, K>;
+    /**
+     * Rendered child nodes from the spec's `children` list.
+     * Append these into the returned element where children should appear.
+     */
+    children: Node[];
+    /**
+     * Two-way binding paths resolved from `$bindState` / `$bindItem` prop expressions.
+     *
+     * Keys match prop names that had `$bindState`/`$bindItem` expressions in the spec;
+     * values are the absolute state-store paths to write back to on user input.
+     *
+     * `undefined` when no bindings were found for this element.
+     */
+    bindings: Record<string, string> | undefined;
+    /**
+     * Dispatch a named event defined in the spec's `on` map.
+     *
+     * Resolves the catalog action binding, applies param expressions against the
+     * current state store, and calls `send()` with the mapped XState event type.
+     *
+     * @example
+     * ```ts
+     * btn.addEventListener("click", () => emit("submit"));
+     * ```
+     */
+    emit: (event: string) => void;
+    /**
+     * Get an `EventHandle` for a named event from the spec's `on` map.
+     *
+     * Use when you need `shouldPreventDefault` or want to check whether an `on`
+     * binding exists before attaching a listener.
+     *
+     * @example
+     * ```ts
+     * const handle = on("submit");
+     * if (handle.bound) {
+     *   form.addEventListener("submit", (e) => {
+     *     if (handle.shouldPreventDefault) e.preventDefault();
+     *     handle.emit();
+     *   });
+     * }
+     * ```
+     */
+    on: (event: string) => EventHandle;
+    /**
+     * Low-level render context.
+     *
+     * Exposes `send`, `store`, `actorActions`, and `renderChildren` for advanced
+     * use cases. Framework renderers do not expose this field — prefer `emit`/`on`
+     * for event dispatch and `children` for child rendering.
+     */
+    ctx: DomRenderContext;
+}
+/**
+ * Catalog-typed DOM component function.
+ *
+ * The DOM equivalent of `ComponentFn<C, K>` from @json-render/react, /solid,
+ * /svelte, /vue. The only structural difference is the return type:
+ * `HTMLElement | Text | null` instead of a framework node.
+ *
+ * Pass implementations to `defineRegistry` — do not call directly.
+ *
+ * @example
+ * ```ts
+ * import type { ComponentFn } from "@xmachines/play-dom";
+ * import type { AuthCatalog } from "@xmachines/play-actor-shared";
+ *
+ * export const Home: ComponentFn<AuthCatalog, "Home"> = ({ props, children }) => {
+ *   const section = document.createElement("section");
+ *   section.setAttribute("data-page", "home");
+ *
+ *   const h2 = document.createElement("h2");
+ *   h2.textContent = props.title;
+ *   section.appendChild(h2);
+ *
+ *   children.forEach((child) => section.appendChild(child));
+ *   return section;
+ * };
+ * ```
+ */
+export type ComponentFn<C extends Catalog, K extends keyof InferCatalogComponents<C>> = (ctx: ComponentContext<C, K>) => HTMLElement | Text | null;
+/**
+ * Catalog-keyed map of `ComponentFn` implementations.
+ *
+ * Used as the `components` field in `DefineRegistryOptions`.
+ * TypeScript enforces that every component key declared in the catalog has
+ * a matching implementation.
+ */
+export type ComponentRegistry<C extends Catalog> = {
+    [K in keyof InferCatalogComponents<C>]: ComponentFn<C, K>;
+};
+/**
+ * Raw registry of `DomComponentRenderer` functions keyed by element type.
+ *
+ * Passed to `connectRenderer` or `PlayRenderer`. Build with `defineRegistry`
+ * to get catalog-typed component functions automatically wrapped.
+ */
+export type DomRegistry = Record<string, DomComponentRenderer>;
+/**
+ * Options for `defineRegistry`.
+ *
+ * Mirrors `DefineRegistryOptions<C>` from @json-render/react, /solid, /svelte, /vue
+ * with one intentional difference: `actions` is a `Record<string, string>` event-type
+ * map rather than async handler functions, because the DOM renderer dispatches events
+ * directly via `send()` to an XState actor instead of calling framework action handlers.
+ */
+export interface DefineRegistryOptions<C extends Catalog> {
+    /**
+     * Catalog-typed component implementations.
+     * Each key must match a component declared in the catalog.
+     */
+    components?: ComponentRegistry<C>;
+    /**
+     * Map of catalog action name → XState event type string.
+     *
+     * When a spec element fires `emit("login")`, the DOM renderer looks up
+     * `actions.login` (e.g. `"auth.login"`) and calls `send({ type: "auth.login", ...params })`.
+     *
+     * In the framework renderers this field holds async handler functions. In the DOM
+     * renderer it is a simpler string map because routing to the actor is handled by
+     * the XMachines play-dom layer rather than inside the json-render action system.
+     */
+    actions?: InferCatalogActions<C> extends Record<string, never> ? Record<string, string> : Record<keyof InferCatalogActions<C>, string>;
+}
+/**
+ * Result returned by `defineRegistry`.
+ *
+ * Mirrors the `{ registry }` field from @json-render/react, /solid, /svelte, /vue.
+ * The DOM result also exposes `actorActions` — the resolved event-type map — so
+ * callers can pass it directly to `connectRenderer` or `PlayRenderer`.
+ */
+export interface DefineRegistryResult {
+    /**
+     * The built `DomRegistry`, ready to pass to `connectRenderer` or `PlayRenderer`.
+     */
+    registry: DomRegistry;
+    /**
+     * Resolved map of catalog action name → XState event type string.
+     *
+     * Pass to `connectRenderer({ ..., actions: actorActions })` or
+     * `new PlayRenderer(container, actor, registry, { actions: actorActions })`.
+     */
+    actorActions: Record<string, string>;
+}
+/**
+ * Build a `DomRegistry` from a catalog and component/action options.
+ *
+ * Mirrors the `defineRegistry(catalog, options)` API from @json-render/react,
+ * /solid, /svelte, /vue. The catalog parameter is used for TypeScript inference
+ * only (the same as in the framework renderers — it is not used at runtime).
+ *
+ * Each component in `options.components` is wrapped in a `DomComponentRenderer`
+ * adapter that:
+ * - Resolves props and two-way binding paths via `@json-render/core`
+ * - Builds `emit(event)` and `on(event)` closures over the element's `on` map
+ * - Renders child elements via `ctx.renderChildren`
+ * - Passes the assembled `ComponentContext` to your `ComponentFn`
+ *
+ * The `actions` map is passed through as `actorActions` so the caller does not
+ * need to manage it separately.
+ *
+ * @example
+ * ```ts
+ * import { defineRegistry } from "@xmachines/play-dom";
+ * import { authCatalog } from "@xmachines/play-actor-shared";
+ * import { Home, Login, Dashboard } from "./components/index.js";
+ *
+ * const { registry, actorActions } = defineRegistry(authCatalog, {
+ *   components: { Home, Login, Dashboard, ... },
+ *   actions: {
+ *     login: "auth.login",
+ *     logout: "auth.logout",
+ *   },
+ * });
+ *
+ * connectRenderer({ actor, registry, container, actions: actorActions });
+ * ```
+ */
+export declare function defineRegistry<C extends Catalog>(_catalog: C, options: DefineRegistryOptions<C>): DefineRegistryResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/json-render/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/json-render/types.ts"],"names":[],"mappings":"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"}

package/dist/json-render/types.js

@@ -0,0 +1,116 @@
+/**
+ * types.ts — Type definitions for @json-render/dom
+ *
+ * Zero XMachines dependencies. Upstreamable to @json-render/dom.
+ *
+ * Mirrors the component model from @json-render/react, /solid, /svelte, /vue:
+ * - `ComponentFn<C, K>`      — catalog-typed component function
+ * - `ComponentContext<C, K>` — context passed to each component (props, children, emit, on, bindings)
+ * - `defineRegistry(catalog, options)` — build a catalog-typed DomRegistry
+ *
+ * Key difference from framework renderers: `ComponentFn` returns
+ * `HTMLElement | Text | null` instead of a framework node, and
+ * `actions` is a `Record<string, string>` event-type map instead of
+ * async handler functions (because DOM dispatches directly via `send`).
+ *
+ * @packageDocumentation
+ */
+import { resolveActionParam } from "@json-render/core";
+/**
+ * Build a `DomRegistry` from a catalog and component/action options.
+ *
+ * Mirrors the `defineRegistry(catalog, options)` API from @json-render/react,
+ * /solid, /svelte, /vue. The catalog parameter is used for TypeScript inference
+ * only (the same as in the framework renderers — it is not used at runtime).
+ *
+ * Each component in `options.components` is wrapped in a `DomComponentRenderer`
+ * adapter that:
+ * - Resolves props and two-way binding paths via `@json-render/core`
+ * - Builds `emit(event)` and `on(event)` closures over the element's `on` map
+ * - Renders child elements via `ctx.renderChildren`
+ * - Passes the assembled `ComponentContext` to your `ComponentFn`
+ *
+ * The `actions` map is passed through as `actorActions` so the caller does not
+ * need to manage it separately.
+ *
+ * @example
+ * ```ts
+ * import { defineRegistry } from "@xmachines/play-dom";
+ * import { authCatalog } from "@xmachines/play-actor-shared";
+ * import { Home, Login, Dashboard } from "./components/index.js";
+ *
+ * const { registry, actorActions } = defineRegistry(authCatalog, {
+ *   components: { Home, Login, Dashboard, ... },
+ *   actions: {
+ *     login: "auth.login",
+ *     logout: "auth.logout",
+ *   },
+ * });
+ *
+ * connectRenderer({ actor, registry, container, actions: actorActions });
+ * ```
+ */
+export function defineRegistry(_catalog, options) {
+    const components = (options.components ?? {});
+    const actorActions = (options.actions ?? {});
+    const registry = {};
+    for (const key of Object.keys(components)) {
+        const fn = components[key];
+        registry[key] = (element, ctx) => {
+            const onBindings = element.on ?? {};
+            const stateModel = ctx.store.getSnapshot();
+            // ── emit ──────────────────────────────────────────────────────────
+            const emit = (eventName) => {
+                const binding = onBindings[eventName];
+                if (!binding)
+                    return;
+                const bindings = Array.isArray(binding) ? binding : [binding];
+                for (const b of bindings) {
+                    const xstateType = ctx.actorActions[b.action] ?? b.action;
+                    const params = {};
+                    if (b.params) {
+                        for (const [k, v] of Object.entries(b.params)) {
+                            params[k] = resolveActionParam(v, { stateModel });
+                        }
+                    }
+                    ctx.send({ type: xstateType, ...params });
+                }
+            };
+            // ── on ────────────────────────────────────────────────────────────
+            const on = (eventName) => {
+                const binding = onBindings[eventName];
+                if (!binding) {
+                    return { emit: () => { }, shouldPreventDefault: false, bound: false };
+                }
+                const bindings = Array.isArray(binding) ? binding : [binding];
+                return {
+                    emit: () => emit(eventName),
+                    // truthy check — matches @json-render/react and /solid
+                    shouldPreventDefault: bindings.some((b) => b.preventDefault),
+                    bound: true,
+                };
+            };
+            // ── bindings ──────────────────────────────────────────────────────
+            // Pre-computed by renderSpec on the raw (unresolved) props before
+            // resolveElementProps ran — $bindState/$bindItem expressions are
+            // no longer present in element.props at this point.
+            const bindings = ctx.elementBindings;
+            // ── children ──────────────────────────────────────────────────────
+            // Render children here (inside the wrapper) and pass them to the
+            // component. The outer renderSpec does NOT append children again —
+            // child rendering is solely the component's responsibility.
+            const children = ctx.renderChildren(element.children ?? []);
+            const componentCtx = {
+                props: element.props,
+                children,
+                bindings,
+                emit,
+                on,
+                ctx,
+            };
+            return fn(componentCtx);
+        };
+    }
+    return { registry, actorActions };
+}
+//# sourceMappingURL=types.js.map

package/dist/json-render/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/json-render/types.ts"],"names":[],"mappings":"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"}

package/dist/{types.d.ts → xm-types.d.ts}

@@ -1,39 +1,15 @@
 /**
- * TypeScript type definitions for play-dom
+ * xm-types.ts — XMachines-specific type definitions for play-dom.
+ *
+ * These types depend on @xmachines/play-actor and stay in play-dom.
+ * Pure json-render types live in ./json-render/types.ts.
  *
  * @packageDocumentation
  */
-import type { Spec, UIElement, StateStore } from "@json-render/core";
 import type { AbstractActor, Viewable } from "@xmachines/play-actor";
 import type { AnyActorLogic } from "xstate";
-/**
- * Context passed to each DomComponentRenderer when rendering an element.
- */
-export interface DomRenderContext {
-    /** Full spec tree */
-    spec: Spec;
-    /** State store bound to spec.state */
-    store: StateStore;
-    /** Send an event to the actor */
-    send: (event: {
-        type: string;
-    } & Record<string, unknown>) => void;
-    /** Raw actor — access from any DOM component for state reading, complex events, lifecycle */
-    actor: AbstractActor<AnyActorLogic> & Viewable;
-    /** Map of json-render action names → XState event types */
-    actorActions: Record<string, string>;
-    /** Recursively render child elements by key */
-    renderChildren: (keys: string[]) => Node[];
-}
-/**
- * Pure DOM component renderer — receives a UIElement + context and returns a DOM node.
- * No framework required. Return null for unknown/unsupported elements.
- */
-export type DomComponentRenderer = (element: UIElement, ctx: DomRenderContext) => HTMLElement | Text | null;
-/**
- * Registry of component renderers keyed by element type.
- */
-export type DomRegistry = Record<string, DomComponentRenderer>;
+import type { StateStore } from "@json-render/core";
+import type { DomRegistry } from "./json-render/types.js";
 /**
  * Options for PlayRenderer.
  */
@@ -70,4 +46,4 @@ export interface ConnectRendererOptions {
      */
     store?: StateStore;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=xm-types.d.ts.map

package/dist/xm-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xm-types.d.ts","sourceRoot":"","sources":["../src/xm-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,4EAA4E;IAC5E,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;IAE/C,sEAAsE;IACtE,QAAQ,EAAE,WAAW,CAAC;IAEtB,uCAAuC;IACvC,SAAS,EAAE,WAAW,CAAC;IAEvB,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAE9B,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;;OAIG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;CACnB"}

package/dist/xm-types.js

@@ -0,0 +1,10 @@
+/**
+ * xm-types.ts — XMachines-specific type definitions for play-dom.
+ *
+ * These types depend on @xmachines/play-actor and stay in play-dom.
+ * Pure json-render types live in ./json-render/types.ts.
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=xm-types.js.map

package/dist/xm-types.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-dom",
-  "version": "1.0.0-beta.26",
+  "version": "1.0.0-beta.28",
   "description": "Vanilla DOM renderer for XMachines Play architecture with signal-driven rendering",
   "keywords": [
     "actor",
@@ -43,15 +43,15 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@xmachines/play": "1.0.0-beta.26",
-    "@xmachines/play-actor": "1.0.0-beta.26",
-    "@xmachines/play-signals": "1.0.0-beta.26"
+    "@xmachines/play": "1.0.0-beta.28",
+    "@xmachines/play-actor": "1.0.0-beta.28",
+    "@xmachines/play-signals": "1.0.0-beta.28"
   },
   "devDependencies": {
     "@json-render/core": "^0.16.0",
     "@json-render/xstate": "^0.16.0",
     "@types/node": "^25.5.0",
-    "@xmachines/shared": "1.0.0-beta.26",
+    "@xmachines/shared": "1.0.0-beta.28",
     "@xstate/store": ">=3.17.0",
     "oxfmt": "^0.43.0",
     "oxlint": "^1.57.0",

package/dist/dom-renderer.d.ts

@@ -1,23 +0,0 @@
-/**
- * dom-renderer.ts — Pure json-render-core compatible DOM renderer.
- *
- * Zero XMachines dependencies. Takes a Spec + StateStore + DomRegistry
- * and produces DOM nodes.
- *
- * This layer is upstreamable to @json-render/dom as a PR to vercel-labs/json-render.
- */
-import type { Spec, StateStore } from "@json-render/core";
-import type { DomRegistry, DomRenderContext } from "./types.js";
-/**
- * Render a Spec tree into DOM nodes using the provided DomRegistry.
- *
- * @param spec - The json-render Spec describing the UI tree
- * @param store - StateStore holding the current state values
- * @param registry - Map of element type names to DomComponentRenderer functions
- * @param send - Function to dispatch XState events from UI interactions
- * @param actor - Raw actor — available to DOM components for state reading, complex events
- * @param actorActions - Map of json-render action names → XState event types
- * @returns The root DOM node, or null if root element is invisible or unknown
- */
-export declare function renderSpec(spec: Spec, store: StateStore, registry: DomRegistry, send: DomRenderContext["send"], actor: DomRenderContext["actor"], actorActions: Record<string, string>): Node | null;
-//# sourceMappingURL=dom-renderer.d.ts.map

package/dist/dom-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dom-renderer.d.ts","sourceRoot":"","sources":["../src/dom-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAa,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEhE;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,WAAW,EACrB,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAC9B,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAChC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,IAAI,GAAG,IAAI,CAsDb"}

package/dist/dom-renderer.js

@@ -1,103 +0,0 @@
-/**
- * dom-renderer.ts — Pure json-render-core compatible DOM renderer.
- *
- * Zero XMachines dependencies. Takes a Spec + StateStore + DomRegistry
- * and produces DOM nodes.
- *
- * This layer is upstreamable to @json-render/dom as a PR to vercel-labs/json-render.
- */
-import { evaluateVisibility, resolveDynamicValue } from "@json-render/core";
-import { resolveProps } from "./resolve-state.js";
-/**
- * Render a Spec tree into DOM nodes using the provided DomRegistry.
- *
- * @param spec - The json-render Spec describing the UI tree
- * @param store - StateStore holding the current state values
- * @param registry - Map of element type names to DomComponentRenderer functions
- * @param send - Function to dispatch XState events from UI interactions
- * @param actor - Raw actor — available to DOM components for state reading, complex events
- * @param actorActions - Map of json-render action names → XState event types
- * @returns The root DOM node, or null if root element is invisible or unknown
- */
-export function renderSpec(spec, store, registry, send, actor, actorActions) {
-    function renderElement(key) {
-        const element = spec.elements[key];
-        if (!element)
-            return null;
-        // Evaluate visibility condition
-        if (element.visible !== undefined) {
-            const stateModel = store.getSnapshot();
-            const visible = evaluateVisibility(element.visible, { stateModel });
-            if (!visible)
-                return null;
-        }
-        // Resolve $state expressions in props
-        const resolvedProps = resolveProps(element.props ?? {}, store);
-        // Build context for this element
-        const ctx = {
-            spec,
-            store,
-            send,
-            actor,
-            actorActions,
-            renderChildren: (keys) => keys.flatMap((k) => {
-                const n = renderElement(k);
-                return n ? [n] : [];
-            }),
-        };
-        // Look up renderer in registry
-        const renderer = registry[element.type];
-        if (!renderer)
-            return null; // unknown type → null (matches json-render behavior)
-        // Create resolved element to pass to renderer
-        const resolvedElement = { ...element, props: resolvedProps };
-        const node = renderer(resolvedElement, ctx);
-        if (!node)
-            return null;
-        // Wire event handlers from element.on
-        if (element.on && node instanceof HTMLElement) {
-            wireEventHandlers(node, element.on, ctx);
-        }
-        // Append children into the node if it has children and is an HTMLElement
-        const childKeys = element.children ?? [];
-        if (childKeys.length > 0 && node instanceof HTMLElement) {
-            const childNodes = ctx.renderChildren(childKeys);
-            childNodes.forEach((child) => node.appendChild(child));
-        }
-        return node;
-    }
-    return renderElement(spec.root);
-}
-/**
- * Wire event handlers from element.on bindings to DOM event listeners.
- *
- * Maps json-render event names to DOM events (e.g. "click" → "click").
- * For each binding, checks actorActions map to find the XState event type.
- * If found, calls send() with that event type on the DOM event.
- */
-function wireEventHandlers(node, on, ctx) {
-    if (!on)
-        return;
-    for (const [domEvent, binding] of Object.entries(on)) {
-        // binding can be ActionBinding | ActionBinding[]
-        const bindings = Array.isArray(binding) ? binding : [binding];
-        node.addEventListener(domEvent, () => {
-            for (const b of bindings) {
-                const eventType = ctx.actorActions[b.action];
-                if (eventType) {
-                    // Resolve DynamicValue params ($state:/ references) against current store
-                    const stateModel = ctx.store.getSnapshot();
-                    const resolvedParams = {};
-                    if (b.params) {
-                        for (const [key, val] of Object.entries(b.params)) {
-                            resolvedParams[key] = resolveDynamicValue(val, stateModel);
-                        }
-                    }
-                    ctx.send({ type: eventType, ...resolvedParams });
-                }
-                // Unknown action → no-op (matches json-render silent behavior)
-            }
-        });
-    }
-}
-//# sourceMappingURL=dom-renderer.js.map

package/dist/dom-renderer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dom-renderer.js","sourceRoot":"","sources":["../src/dom-renderer.ts"],"names":[],"mappings":"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"}

package/dist/resolve-state.d.ts

@@ -1,12 +0,0 @@
-/**
- * resolve-state.ts — Resolves json-render dynamic value expressions against a StateStore.
- *
- * Pure function — no XMachines dependencies. Upstreamable to @json-render/dom.
- */
-import type { StateStore } from "@json-render/core";
-/**
- * Resolve all props in an element's props object.
- * Returns a new props object with all $state expressions resolved against the store.
- */
-export declare function resolveProps(props: Record<string, unknown>, store: StateStore): Record<string, unknown>;
-//# sourceMappingURL=resolve-state.d.ts.map

package/dist/resolve-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-state.d.ts","sourceRoot":"","sources":["../src/resolve-state.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,UAAU,GACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMzB"}

package/dist/resolve-state.js

@@ -1,41 +0,0 @@
-/**
- * resolve-state.ts — Resolves json-render dynamic value expressions against a StateStore.
- *
- * Pure function — no XMachines dependencies. Upstreamable to @json-render/dom.
- */
-/**
- * Resolve all props in an element's props object.
- * Returns a new props object with all $state expressions resolved against the store.
- */
-export function resolveProps(props, store) {
-    const result = {};
-    for (const [key, value] of Object.entries(props)) {
-        result[key] = resolveValue(value, store);
-    }
-    return result;
-}
-/**
- * Resolve a single value that may contain json-render dynamic expressions.
- * - `{ "$state": "/path" }` → store.get("/path")
- * - Arrays → each element resolved recursively
- * - Nested objects → each value resolved recursively
- * - Plain values → returned as-is
- */
-function resolveValue(value, store) {
-    if (value === null || typeof value !== "object")
-        return value;
-    if (Array.isArray(value))
-        return value.map((v) => resolveValue(v, store));
-    const obj = value;
-    // $state binding: { "$state": "/path" }
-    if ("$state" in obj && typeof obj["$state"] === "string") {
-        return store.get(obj["$state"]);
-    }
-    // Nested plain object — recurse
-    const resolved = {};
-    for (const [k, v] of Object.entries(obj)) {
-        resolved[k] = resolveValue(v, store);
-    }
-    return resolved;
-}
-//# sourceMappingURL=resolve-state.js.map

package/dist/resolve-state.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-state.js","sourceRoot":"","sources":["../src/resolve-state.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;GAGG;AACH,MAAM,UAAU,YAAY,CAC3B,KAA8B,EAC9B,KAAiB;IAEjB,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAClD,MAAM,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,KAAc,EAAE,KAAiB;IACtD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IAE1E,MAAM,GAAG,GAAG,KAAgC,CAAC;IAE7C,wCAAwC;IACxC,IAAI,QAAQ,IAAI,GAAG,IAAI,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1D,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,gCAAgC;IAChC,MAAM,QAAQ,GAA4B,EAAE,CAAC;IAC7C,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1C,QAAQ,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,QAAQ,CAAC;AACjB,CAAC"}

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,qBAAqB;IACrB,IAAI,EAAE,IAAI,CAAC;IACX,sCAAsC;IACtC,KAAK,EAAE,UAAU,CAAC;IAClB,iCAAiC;IACjC,IAAI,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAClE,6FAA6F;IAC7F,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;IAC/C,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,+CAA+C;IAC/C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAClC,OAAO,EAAE,SAAS,EAClB,GAAG,EAAE,gBAAgB,KACjB,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;AAE/B;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,4EAA4E;IAC5E,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;IAE/C,sEAAsE;IACtE,QAAQ,EAAE,WAAW,CAAC;IAEtB,uCAAuC;IACvC,SAAS,EAAE,WAAW,CAAC;IAEvB,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAE9B,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;;OAIG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;CACnB"}

package/dist/types.js

@@ -1,7 +0,0 @@
-/**
- * TypeScript type definitions for play-dom
- *
- * @packageDocumentation
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/types.js.map

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