@xmachines/play-vue 2.2.0 → 4.0.0

package/dist/PlayUIProvider.vue_vue_type_script_lang.js.map

@@ -1 +1 @@
-{"version":3,"file":"PlayUIProvider.vue_vue_type_script_lang.js","names":[],"sources":["../src/PlayUIProvider.vue"],"sourcesContent":["<script lang=\"ts\">\n/**\n * PlayUIProvider — the composite provider of an actor-driven UI.\n *\n * It wraps ActorProvider and JSONUIProvider, from @xmachines/json-render-vue. One\n * component therefore serves the complete actor lifecycle and the complete UI\n * rendering.\n *\n * The standard use:\n * ```ts\n * <PlayUIProvider :actor=\"actor\" :registryResult=\"registryResult\">\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n *\n * For a custom provider composition, use <ActorProvider> directly.\n *\n * @packageDocumentation\n */\n\nimport { defineComponent, h } from \"vue\";\nimport type { PropType } from \"vue\";\nimport { JSONUIProvider } from \"@xmachines/json-render-vue\";\nimport type { DefineRegistryResult, RenderErrorHandler } from \"@xmachines/json-render-vue\";\n\nimport type { StateStore } from \"@xmachines/json-render-core\";\nimport type { AbstractActor, Viewable } from \"@xmachines/play-actor\";\nimport type { AnyActorLogic } from \"xstate\";\nimport ActorProvider from \"./ActorProvider.vue\";\nimport { usePlayView } from \"./actor-provider-context.js\";\nimport type { PlayUIProviderProps } from \"./types.js\";\n\n// Re-export the props type, for a consumer that imports from this file\nexport type { PlayUIProviderProps } from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// JSONUIBridge — the inner component inside the tree of ActorProvider\n// It reads the ViewContextValue with usePlayView(), and it gives the handlers\n// and the registry to JSONUIProvider. Therefore ActorProvider and JSONUIProvider\n// share one state.\n// ---------------------------------------------------------------------------\n\nconst JSONUIBridge = defineComponent({\n\tname: \"JSONUIBridge\",\n\tprops: {\n\t\tnavigate: {\n\t\t\ttype: Function as PropType<(path: string) => void>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tvalidationFunctions: {\n\t\t\ttype: Object as PropType<\n\t\t\t\tRecord<string, (value: unknown, args?: Record<string, unknown>) => boolean>\n\t\t\t>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tfunctions: {\n\t\t\ttype: Object as PropType<\n\t\t\t\tRecord<\n\t\t\t\t\tstring,\n\t\t\t\t\t(args?: Record<string, unknown>, state?: Record<string, unknown>) => unknown\n\t\t\t\t>\n\t\t\t>,\n\t\t\tdefault: undefined,\n\t\t},\n\t},\n\tsetup(props, { slots }) {\n\t\treturn () => {\n\t\t\tconst view = usePlayView();\n\t\t\treturn h(\n\t\t\t\tJSONUIProvider,\n\t\t\t\t{\n\t\t\t\t\tregistry: view.registry,\n\t\t\t\t\thandlers: view.handlers,\n\t\t\t\t\tstore: view.store,\n\t\t\t\t\t...(props.navigate ? { navigate: props.navigate } : {}),\n\t\t\t\t\t...(props.validationFunctions\n\t\t\t\t\t\t? { validationFunctions: props.validationFunctions }\n\t\t\t\t\t\t: {}),\n\t\t\t\t\t...(props.functions ? { functions: props.functions } : {}),\n\t\t\t\t},\n\t\t\t\tslots,\n\t\t\t);\n\t\t};\n\t},\n});\n\n// ---------------------------------------------------------------------------\n// PlayUIProvider — the main export\n// ---------------------------------------------------------------------------\n\nexport default defineComponent({\n\tname: \"PlayUIProvider\",\n\tprops: {\n\t\tactor: {\n\t\t\ttype: Object as PropType<AbstractActor<AnyActorLogic> & Viewable>,\n\t\t\trequired: true,\n\t\t},\n\t\tregistryResult: {\n\t\t\ttype: Object as PropType<DefineRegistryResult>,\n\t\t\trequired: true,\n\t\t},\n\t\tstore: {\n\t\t\ttype: Object as PropType<StateStore>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tonRenderError: {\n\t\t\ttype: Function as PropType<RenderErrorHandler>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tnavigate: {\n\t\t\ttype: Function as PropType<PlayUIProviderProps[\"navigate\"]>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tvalidationFunctions: {\n\t\t\ttype: Object as PropType<PlayUIProviderProps[\"validationFunctions\"]>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tfunctions: {\n\t\t\ttype: Object as PropType<PlayUIProviderProps[\"functions\"]>,\n\t\t\tdefault: undefined,\n\t\t},\n\t},\n\tsetup(props, { slots }) {\n\t\treturn () =>\n\t\t\th(\n\t\t\t\tActorProvider,\n\t\t\t\t{\n\t\t\t\t\tactor: props.actor,\n\t\t\t\t\tregistryResult: props.registryResult,\n\t\t\t\t\t...(props.store ? { store: props.store } : {}),\n\t\t\t\t\t...(props.onRenderError ? { onRenderError: props.onRenderError } : {}),\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tdefault: () =>\n\t\t\t\t\t\th(\n\t\t\t\t\t\t\tJSONUIBridge,\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t...(props.navigate ? { navigate: props.navigate } : {}),\n\t\t\t\t\t\t\t\t...(props.validationFunctions\n\t\t\t\t\t\t\t\t\t? { validationFunctions: props.validationFunctions }\n\t\t\t\t\t\t\t\t\t: {}),\n\t\t\t\t\t\t\t\t...(props.functions ? { functions: props.functions } : {}),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tslots,\n\t\t\t\t\t\t),\n\t\t\t\t\tfallback: slots.fallback,\n\t\t\t\t},\n\t\t\t);\n\t},\n});\n</script>\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAM,eAAe,gBAAgB;CACpC,MAAM;CACN,OAAO;EACN,UAAU;GACT,MAAM;GACN,SAAS,KAAA;EACV;EACA,qBAAqB;GACpB,MAAM;GAGN,SAAS,KAAA;EACV;EACA,WAAW;GACV,MAAM;GAMN,SAAS,KAAA;EACV;CACD;CACA,MAAM,OAAO,EAAE,SAAS;EACvB,aAAa;GACZ,MAAM,OAAO,YAAY;GACzB,OAAO,EACN,gBACA;IACC,UAAU,KAAK;IACf,UAAU,KAAK;IACf,OAAO,KAAK;IACZ,GAAI,MAAM,WAAW,EAAE,UAAU,MAAM,SAAS,IAAI,CAAC;IACrD,GAAI,MAAM,sBACP,EAAE,qBAAqB,MAAM,oBAAoB,IACjD,CAAC;IACJ,GAAI,MAAM,YAAY,EAAE,WAAW,MAAM,UAAU,IAAI,CAAC;GACzD,GACA,KACD;EACD;CACD;AACD,CAAC;AAMD,IAAA,kDAAe,gBAAgB;CAC9B,MAAM;CACN,OAAO;EACN,OAAO;GACN,MAAM;GACN,UAAU;EACX;EACA,gBAAgB;GACf,MAAM;GACN,UAAU;EACX;EACA,OAAO;GACN,MAAM;GACN,SAAS,KAAA;EACV;EACA,eAAe;GACd,MAAM;GACN,SAAS,KAAA;EACV;EACA,UAAU;GACT,MAAM;GACN,SAAS,KAAA;EACV;EACA,qBAAqB;GACpB,MAAM;GACN,SAAS,KAAA;EACV;EACA,WAAW;GACV,MAAM;GACN,SAAS,KAAA;EACV;CACD;CACA,MAAM,OAAO,EAAE,SAAS;EACvB,aACC,EACC,uBACA;GACC,OAAO,MAAM;GACb,gBAAgB,MAAM;GACtB,GAAI,MAAM,QAAQ,EAAE,OAAO,MAAM,MAAM,IAAI,CAAC;GAC5C,GAAI,MAAM,gBAAgB,EAAE,eAAe,MAAM,cAAc,IAAI,CAAC;EACrE,GACA;GACC,eACC,EACC,cACA;IACC,GAAI,MAAM,WAAW,EAAE,UAAU,MAAM,SAAS,IAAI,CAAC;IACrD,GAAI,MAAM,sBACP,EAAE,qBAAqB,MAAM,oBAAoB,IACjD,CAAC;IACJ,GAAI,MAAM,YAAY,EAAE,WAAW,MAAM,UAAU,IAAI,CAAC;GACzD,GACA,KACD;GACD,UAAU,MAAM;EACjB,CACD;CACF;AACD,CAAC"}
+{"version":3,"file":"PlayUIProvider.vue_vue_type_script_lang.js","names":[],"sources":["../src/PlayUIProvider.vue"],"sourcesContent":["<script lang=\"ts\">\n/**\n * PlayUIProvider — the composite provider of an actor-driven UI.\n *\n * It wraps ActorProvider and JSONUIProvider, from @xmachines/json-render-vue. One\n * component therefore serves the complete actor lifecycle and the complete UI\n * rendering.\n *\n * The standard use:\n * ```ts\n * <PlayUIProvider :actor=\"actor\" :registryResult=\"registryResult\">\n *   <PlayRenderer />\n * </PlayUIProvider>\n * ```\n *\n * For a custom provider composition, use <ActorProvider> directly.\n *\n * @packageDocumentation\n */\n\nimport { defineComponent, h } from \"vue\";\nimport type { PropType } from \"vue\";\nimport { JSONUIProvider } from \"@xmachines/json-render-vue\";\nimport type { DefineRegistryResult, RenderErrorHandler } from \"@xmachines/json-render-vue\";\n\nimport type { StateStore } from \"@xmachines/json-render-core\";\nimport type { Viewable, ViewActor } from \"@xmachines/play-view\";\nimport ActorProvider from \"./ActorProvider.vue\";\nimport { usePlayView } from \"./actor-provider-context.js\";\nimport type { PlayUIProviderProps } from \"./types.js\";\n\n// Re-export the props type, for a consumer that imports from this file\nexport type { PlayUIProviderProps } from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// JSONUIBridge — the inner component inside the tree of ActorProvider\n// It reads the ViewContextValue with usePlayView(), and it gives the handlers\n// and the registry to JSONUIProvider. Therefore ActorProvider and JSONUIProvider\n// share one state.\n// ---------------------------------------------------------------------------\n\nconst JSONUIBridge = defineComponent({\n\tname: \"JSONUIBridge\",\n\tprops: {\n\t\tnavigate: {\n\t\t\ttype: Function as PropType<(path: string) => void>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tvalidationFunctions: {\n\t\t\ttype: Object as PropType<\n\t\t\t\tRecord<string, (value: unknown, args?: Record<string, unknown>) => boolean>\n\t\t\t>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tfunctions: {\n\t\t\ttype: Object as PropType<\n\t\t\t\tRecord<\n\t\t\t\t\tstring,\n\t\t\t\t\t(args?: Record<string, unknown>, state?: Record<string, unknown>) => unknown\n\t\t\t\t>\n\t\t\t>,\n\t\t\tdefault: undefined,\n\t\t},\n\t},\n\tsetup(props, { slots }) {\n\t\treturn () => {\n\t\t\tconst view = usePlayView();\n\t\t\treturn h(\n\t\t\t\tJSONUIProvider,\n\t\t\t\t{\n\t\t\t\t\tregistry: view.registry,\n\t\t\t\t\thandlers: view.handlers,\n\t\t\t\t\tstore: view.store,\n\t\t\t\t\t...(props.navigate ? { navigate: props.navigate } : {}),\n\t\t\t\t\t...(props.validationFunctions\n\t\t\t\t\t\t? { validationFunctions: props.validationFunctions }\n\t\t\t\t\t\t: {}),\n\t\t\t\t\t...(props.functions ? { functions: props.functions } : {}),\n\t\t\t\t},\n\t\t\t\tslots,\n\t\t\t);\n\t\t};\n\t},\n});\n\n// ---------------------------------------------------------------------------\n// PlayUIProvider — the main export\n// ---------------------------------------------------------------------------\n\nexport default defineComponent({\n\tname: \"PlayUIProvider\",\n\tprops: {\n\t\tactor: {\n\t\t\ttype: Object as PropType<ViewActor>,\n\t\t\trequired: true,\n\t\t},\n\t\tregistryResult: {\n\t\t\ttype: Object as PropType<DefineRegistryResult>,\n\t\t\trequired: true,\n\t\t},\n\t\tstore: {\n\t\t\ttype: Object as PropType<StateStore>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tonRenderError: {\n\t\t\ttype: Function as PropType<RenderErrorHandler>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tonError: {\n\t\t\ttype: Function as PropType<(error: unknown, reset: () => void) => void>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tnavigate: {\n\t\t\ttype: Function as PropType<PlayUIProviderProps[\"navigate\"]>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tvalidationFunctions: {\n\t\t\ttype: Object as PropType<PlayUIProviderProps[\"validationFunctions\"]>,\n\t\t\tdefault: undefined,\n\t\t},\n\t\tfunctions: {\n\t\t\ttype: Object as PropType<PlayUIProviderProps[\"functions\"]>,\n\t\t\tdefault: undefined,\n\t\t},\n\t},\n\tsetup(props, { slots }) {\n\t\treturn () =>\n\t\t\th(\n\t\t\t\tActorProvider,\n\t\t\t\t{\n\t\t\t\t\tactor: props.actor,\n\t\t\t\t\tregistryResult: props.registryResult,\n\t\t\t\t\t...(props.store ? { store: props.store } : {}),\n\t\t\t\t\t...(props.onRenderError ? { onRenderError: props.onRenderError } : {}),\n\t\t\t\t\t...(props.onError ? { onError: props.onError } : {}),\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tdefault: () =>\n\t\t\t\t\t\th(\n\t\t\t\t\t\t\tJSONUIBridge,\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t...(props.navigate ? { navigate: props.navigate } : {}),\n\t\t\t\t\t\t\t\t...(props.validationFunctions\n\t\t\t\t\t\t\t\t\t? { validationFunctions: props.validationFunctions }\n\t\t\t\t\t\t\t\t\t: {}),\n\t\t\t\t\t\t\t\t...(props.functions ? { functions: props.functions } : {}),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tslots,\n\t\t\t\t\t\t),\n\t\t\t\t\tfallback: slots.fallback,\n\t\t\t\t},\n\t\t\t);\n\t},\n});\n</script>\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAM,eAAe,gBAAgB;CACpC,MAAM;CACN,OAAO;EACN,UAAU;GACT,MAAM;GACN,SAAS,KAAA;EACV;EACA,qBAAqB;GACpB,MAAM;GAGN,SAAS,KAAA;EACV;EACA,WAAW;GACV,MAAM;GAMN,SAAS,KAAA;EACV;CACD;CACA,MAAM,OAAO,EAAE,SAAS;EACvB,aAAa;GACZ,MAAM,OAAO,YAAY;GACzB,OAAO,EACN,gBACA;IACC,UAAU,KAAK;IACf,UAAU,KAAK;IACf,OAAO,KAAK;IACZ,GAAI,MAAM,WAAW,EAAE,UAAU,MAAM,SAAS,IAAI,CAAC;IACrD,GAAI,MAAM,sBACP,EAAE,qBAAqB,MAAM,oBAAoB,IACjD,CAAC;IACJ,GAAI,MAAM,YAAY,EAAE,WAAW,MAAM,UAAU,IAAI,CAAC;GACzD,GACA,KACD;EACD;CACD;AACD,CAAC;AAMD,IAAA,kDAAe,gBAAgB;CAC9B,MAAM;CACN,OAAO;EACN,OAAO;GACN,MAAM;GACN,UAAU;EACX;EACA,gBAAgB;GACf,MAAM;GACN,UAAU;EACX;EACA,OAAO;GACN,MAAM;GACN,SAAS,KAAA;EACV;EACA,eAAe;GACd,MAAM;GACN,SAAS,KAAA;EACV;EACA,SAAS;GACR,MAAM;GACN,SAAS,KAAA;EACV;EACA,UAAU;GACT,MAAM;GACN,SAAS,KAAA;EACV;EACA,qBAAqB;GACpB,MAAM;GACN,SAAS,KAAA;EACV;EACA,WAAW;GACV,MAAM;GACN,SAAS,KAAA;EACV;CACD;CACA,MAAM,OAAO,EAAE,SAAS;EACvB,aACC,EACC,uBACA;GACC,OAAO,MAAM;GACb,gBAAgB,MAAM;GACtB,GAAI,MAAM,QAAQ,EAAE,OAAO,MAAM,MAAM,IAAI,CAAC;GAC5C,GAAI,MAAM,gBAAgB,EAAE,eAAe,MAAM,cAAc,IAAI,CAAC;GACpE,GAAI,MAAM,UAAU,EAAE,SAAS,MAAM,QAAQ,IAAI,CAAC;EACnD,GACA;GACC,eACC,EACC,cACA;IACC,GAAI,MAAM,WAAW,EAAE,UAAU,MAAM,SAAS,IAAI,CAAC;IACrD,GAAI,MAAM,sBACP,EAAE,qBAAqB,MAAM,oBAAoB,IACjD,CAAC;IACJ,GAAI,MAAM,YAAY,EAAE,WAAW,MAAM,UAAU,IAAI,CAAC;GACzD,GACA,KACD;GACD,UAAU,MAAM;EACjB,CACD;CACF;AACD,CAAC"}

package/dist/actor-provider-context.d.ts

@@ -10,7 +10,7 @@
  */
 import type { InjectionKey } from "vue";
 import type { ComponentRegistry } from "@xmachines/json-render-vue";
-import type { BaseViewContextValue } from "@xmachines/play-actor";
+import type { BaseViewContextValue } from "@xmachines/play-view";
 /**
  * The context value that ActorProvider provides and PlayRenderer, the leaf without
  * props, reads. usePlayView() gives it inside every ActorProvider tree and
@@ -37,12 +37,11 @@ export declare const ViewKey: InjectionKey<ViewContextValue>;
  * const view = usePlayView();
  * // view.spec, view.handlers, view.registry
  * ```
- */
-export declare function usePlayView(): ViewContextValue;
-/**
- * Access the current ViewContextValue from inside an ActorProvider tree.
  *
- * @deprecated Renamed to {@link usePlayView}; will be removed in the next major.
+ * **Read a field where you use it, and destructure it not.** The return value is a Proxy
+ * over the live context of the provider, so `const { spec } = usePlayView()` freezes at
+ * the first read and the screen stops following the actor — with no error and no
+ * warning. play-svelte and play-solid hold the same rule, for the same reason.
  */
-export declare const getPlayViewContext: typeof usePlayView;
+export declare function usePlayView(): ViewContextValue;
 //# sourceMappingURL=actor-provider-context.d.ts.map

package/dist/actor-provider-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actor-provider-context.d.ts","sourceRoot":"","sources":["../src/actor-provider-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAExC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB,CAAC,iBAAiB,CAAC;CAAG;AAEpF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,YAAY,CAAC,gBAAgB,CAA4B,CAAC;AAEhF;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,oBAAc,CAAC"}
+{"version":3,"file":"actor-provider-context.d.ts","sourceRoot":"","sources":["../src/actor-provider-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAExC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB,CAAC,iBAAiB,CAAC;CAAG;AAEpF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,YAAY,CAAC,gBAAgB,CAA4B,CAAC;AAEhF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C"}

package/dist/actor-provider-context.js

@@ -30,17 +30,16 @@ var ViewKey = Symbol("xmachines.view");
 * const view = usePlayView();
 * // view.spec, view.handlers, view.registry
 * ```
+*
+* **Read a field where you use it, and destructure it not.** The return value is a Proxy
+* over the live context of the provider, so `const { spec } = usePlayView()` freezes at
+* the first read and the screen stops following the actor — with no error and no
+* warning. play-svelte and play-solid hold the same rule, for the same reason.
 */
 function usePlayView() {
 	return assertNonNullable(inject(ViewKey), "ViewKey");
 }
-/**
-* Access the current ViewContextValue from inside an ActorProvider tree.
-*
-* @deprecated Renamed to {@link usePlayView}; will be removed in the next major.
-*/
-var getPlayViewContext = usePlayView;
 //#endregion
-export { ViewKey, getPlayViewContext, usePlayView };
+export { ViewKey, usePlayView };
 
 //# sourceMappingURL=actor-provider-context.js.map

package/dist/actor-provider-context.js.map

@@ -1 +1 @@
-{"version":3,"file":"actor-provider-context.js","names":[],"sources":["../src/actor-provider-context.ts"],"sourcesContent":["/**\n * ViewContextValue and usePlayView — the shared context types of the Vue provider architecture.\n *\n * This file holds them, and not ActorProvider.vue, so that TypeScript can\n * re-export the types from index.ts. (The file vue-shim.d.ts declares a default\n * export of each *.vue file only. Therefore TypeScript does not see a named export\n * of a .vue SFC when it resolves a re-export.)\n *\n * @packageDocumentation\n */\n\nimport { inject } from \"vue\";\nimport type { InjectionKey } from \"vue\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport type { ComponentRegistry } from \"@xmachines/json-render-vue\";\nimport type { BaseViewContextValue } from \"@xmachines/play-actor\";\n\n/**\n * The context value that ActorProvider provides and PlayRenderer, the leaf without\n * props, reads. usePlayView() gives it inside every ActorProvider tree and\n * PlayUIProvider tree.\n */\nexport interface ViewContextValue extends BaseViewContextValue<ComponentRegistry> {}\n\n/**\n * The injection key of the ViewContextValue. This file exports it, so that\n * ActorProvider.vue uses it as the canonical key and declares no second key.\n *\n * @internal Use usePlayView() as the public API. Never inject ViewKey directly.\n */\nexport const ViewKey: InjectionKey<ViewContextValue> = Symbol(\"xmachines.view\");\n\n/**\n * Returns the current ViewContextValue inside an ActorProvider tree.\n *\n * @throws {Error} When the caller is outside an <ActorProvider> tree or a <PlayUIProvider> tree\n *\n * @example\n * ```typescript\n * import { usePlayView } from \"@xmachines/play-vue\";\n *\n * const view = usePlayView();\n * // view.spec, view.handlers, view.registry\n * ```\n */\nexport function usePlayView(): ViewContextValue {\n\treturn assertNonNullable(inject(ViewKey), \"ViewKey\");\n}\n\n/**\n * Access the current ViewContextValue from inside an ActorProvider tree.\n *\n * @deprecated Renamed to {@link usePlayView}; will be removed in the next major.\n */\nexport const getPlayViewContext = usePlayView;\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8BA,IAAa,UAA0C,OAAO,gBAAgB;;;;;;;;;;;;;;AAe9E,SAAgB,cAAgC;CAC/C,OAAO,kBAAkB,OAAO,OAAO,GAAG,SAAS;AACpD;;;;;;AAOA,IAAa,qBAAqB"}
+{"version":3,"file":"actor-provider-context.js","names":[],"sources":["../src/actor-provider-context.ts"],"sourcesContent":["/**\n * ViewContextValue and usePlayView — the shared context types of the Vue provider architecture.\n *\n * This file holds them, and not ActorProvider.vue, so that TypeScript can\n * re-export the types from index.ts. (The file vue-shim.d.ts declares a default\n * export of each *.vue file only. Therefore TypeScript does not see a named export\n * of a .vue SFC when it resolves a re-export.)\n *\n * @packageDocumentation\n */\n\nimport { inject } from \"vue\";\nimport type { InjectionKey } from \"vue\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport type { ComponentRegistry } from \"@xmachines/json-render-vue\";\nimport type { BaseViewContextValue } from \"@xmachines/play-view\";\n\n/**\n * The context value that ActorProvider provides and PlayRenderer, the leaf without\n * props, reads. usePlayView() gives it inside every ActorProvider tree and\n * PlayUIProvider tree.\n */\nexport interface ViewContextValue extends BaseViewContextValue<ComponentRegistry> {}\n\n/**\n * The injection key of the ViewContextValue. This file exports it, so that\n * ActorProvider.vue uses it as the canonical key and declares no second key.\n *\n * @internal Use usePlayView() as the public API. Never inject ViewKey directly.\n */\nexport const ViewKey: InjectionKey<ViewContextValue> = Symbol(\"xmachines.view\");\n\n/**\n * Returns the current ViewContextValue inside an ActorProvider tree.\n *\n * @throws {Error} When the caller is outside an <ActorProvider> tree or a <PlayUIProvider> tree\n *\n * @example\n * ```typescript\n * import { usePlayView } from \"@xmachines/play-vue\";\n *\n * const view = usePlayView();\n * // view.spec, view.handlers, view.registry\n * ```\n *\n * **Read a field where you use it, and destructure it not.** The return value is a Proxy\n * over the live context of the provider, so `const { spec } = usePlayView()` freezes at\n * the first read and the screen stops following the actor — with no error and no\n * warning. play-svelte and play-solid hold the same rule, for the same reason.\n */\nexport function usePlayView(): ViewContextValue {\n\treturn assertNonNullable(inject(ViewKey), \"ViewKey\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8BA,IAAa,UAA0C,OAAO,gBAAgB;;;;;;;;;;;;;;;;;;;AAoB9E,SAAgB,cAAgC;CAC/C,OAAO,kBAAkB,OAAO,OAAO,GAAG,SAAS;AACpD"}

package/dist/error-source.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The classification of the source that `onErrorCaptured` of Vue reports.
+ *
+ * This module holds four functions, and a test covers each one directly. The rule
+ * that they carry cannot be tested through a mounted component: Vue reports the source in TWO
+ * spellings, and a test runner loads the DEVELOPMENT bundle, which reports only one of
+ * them.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Answers whether `info` carries the spelling of the PRODUCTION bundle.
+ *
+ * The production bundle re-throws an error that no handler took only where the
+ * application asks for `throwUnhandledErrorInProduction`. A boundary that waits for a
+ * repeat asks this before it arms a record for one.
+ *
+ * @param info - The third argument of an `onErrorCaptured` hook.
+ */
+export declare function isProductionSpelling(info: string): boolean;
+/**
+ * Answers whether the error failed the RENDER of a descendant.
+ *
+ * The boundary of ActorProvider replaces the view with the fallback content for a
+ * failure of the render only. `onErrorCaptured` of Vue also fires for an error of an
+ * event handler and of a watcher callback, which the boundary of React, the
+ * ErrorBoundary of Solid, and `<svelte:boundary>` each see never.
+ *
+ * The function accepts BOTH spellings of the source, so the rule holds in a development
+ * build and in a production build. An unknown value counts as a failure of the render,
+ * which is the safe answer: the boundary then contains the error instead of letting a
+ * broken subtree stay on the screen.
+ *
+ * @param info - The third argument of an `onErrorCaptured` hook.
+ */
+export declare function failsTheRender(info: string): boolean;
+/**
+ * The source that `flushJobs` of Vue reports, in both spellings.
+ *
+ * `flushJobs` runs every queued job through
+ * `callWithErrorHandling(job, job.i, job.i ? 15 : 14)`, and code 15 is "component
+ * update". That is the ONE source under which Vue can report an error a SECOND time: a
+ * job loses the re-throw of `logError` of the development bundle to that call, and the
+ * error arrives at `onErrorCaptured` again with a source that {@link failsTheRender}
+ * answers TRUE for. Code 14 belongs to a job with no instance, which reaches no
+ * `errorCaptured` hook, and it counts as a non-render source already.
+ *
+ * A boundary that ignores a repeat asks for this spelling as well. Without it a record
+ * of the turn could also disarm the boundary for a failure of a SETUP function or of a
+ * RENDER function that carries the same error value.
+ *
+ * @param info - The third argument of an `onErrorCaptured` hook.
+ */
+export declare function isComponentUpdate(info: string): boolean;
+/**
+ * The configuration of the application that {@link canRaiseAgain} reads.
+ *
+ * It names the two fields of `app.config` alone, so a caller passes the config of Vue
+ * itself, and a test passes an object literal.
+ */
+export interface RaiseConfig {
+    errorHandler?: unknown;
+    throwUnhandledErrorInProduction?: boolean;
+}
+/**
+ * Answers whether Vue can raise this error a SECOND time.
+ *
+ * `handleError` of Vue reaches `logError` only where the application wires no
+ * `app.config.errorHandler`, and it asks that field for TRUTH and not for a type: a host
+ * in JavaScript can set `errorHandler = null`, and Vue then re-throws. The development
+ * bundle re-throws every time. The production bundle writes the error and throws it only
+ * where the application asks for `throwUnhandledErrorInProduction`.
+ *
+ * The provider arms the record of a repeat only where this answers `true`. A record that
+ * waits for a repeat which never comes disarms the boundary for the next raise of that
+ * same error value.
+ *
+ * The production half lives HERE, and not in the component, for the reason that the
+ * header of this module states: a mounted test reaches it never.
+ *
+ * @param info - The source that `onErrorCaptured` reports, in either spelling.
+ * @param config - `app.config` of the application, or `undefined` outside an instance.
+ */
+export declare function canRaiseAgain(info: string, config: RaiseConfig | undefined): boolean;
+//# sourceMappingURL=error-source.d.ts.map

package/dist/error-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-source.d.ts","sourceRoot":"","sources":["../src/error-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAgDH;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKpD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,+BAA+B,CAAC,EAAE,OAAO,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAIpF"}

package/dist/error-source.js

@@ -0,0 +1,132 @@
+//#region packages/play-vue/src/error-source.ts
+/**
+* The classification of the source that `onErrorCaptured` of Vue reports.
+*
+* This module holds four functions, and a test covers each one directly. The rule
+* that they carry cannot be tested through a mounted component: Vue reports the source in TWO
+* spellings, and a test runner loads the DEVELOPMENT bundle, which reports only one of
+* them.
+*
+* @packageDocumentation
+*/
+/**
+* The sources of an error that leaves the rendered view alone, in the TWO spellings that
+* Vue uses: the key of its `ErrorTypeStrings` map, which the production bundle reports,
+* and the value of that entry, which the development bundle reports.
+*
+* ONE table, and not two sets: the two spellings name the same seven sources, and a
+* second list is a second chance for one half to fall behind the other.
+*/
+var NON_RENDER_SOURCES = /* @__PURE__ */ new Map([
+	["2", "watcher getter"],
+	["3", "watcher callback"],
+	["4", "watcher cleanup function"],
+	["5", "native event handler"],
+	["6", "component event handler"],
+	["13", "async component loader"],
+	["14", "scheduler flush"]
+]);
+/**
+* The sources above, in the spelling of the DEVELOPMENT bundle.
+*
+* The production spelling needs no set of its own: the code IS the key of the table, so
+* `NON_RENDER_SOURCES.has(code)` answers that half directly.
+*/
+var NON_RENDER_SOURCE_NAMES = new Set(NON_RENDER_SOURCES.values());
+/**
+* The prefix that the production bundle puts before the code.
+*
+* `runtime-core.cjs.prod.js` builds the value as
+* `` `https://vuejs.org/error-reference/#runtime-${type}` ``, and the development
+* bundle passes `ErrorTypeStrings[type]` instead. A rule that reads only the names of
+* the development bundle therefore matches nothing in a production application, and it
+* classifies EVERY error as a failure of the render.
+*/
+var PRODUCTION_PREFIX = "https://vuejs.org/error-reference/#runtime-";
+/**
+* `ErrorCodes.COMPONENT_UPDATE` of Vue, the source that `flushJobs` reports a job under,
+* in the TWO spellings — the development name, and the production URL that
+* {@link PRODUCTION_PREFIX} builds. The pair stands beside the table above, and not in
+* it: that table holds the sources that leave the render alone, and this one fails it.
+*/
+var COMPONENT_UPDATE_NAME = "component update";
+var COMPONENT_UPDATE_INFO = `${PRODUCTION_PREFIX}15`;
+/**
+* Answers whether `info` carries the spelling of the PRODUCTION bundle.
+*
+* The production bundle re-throws an error that no handler took only where the
+* application asks for `throwUnhandledErrorInProduction`. A boundary that waits for a
+* repeat asks this before it arms a record for one.
+*
+* @param info - The third argument of an `onErrorCaptured` hook.
+*/
+function isProductionSpelling(info) {
+	return info.startsWith(PRODUCTION_PREFIX);
+}
+/**
+* Answers whether the error failed the RENDER of a descendant.
+*
+* The boundary of ActorProvider replaces the view with the fallback content for a
+* failure of the render only. `onErrorCaptured` of Vue also fires for an error of an
+* event handler and of a watcher callback, which the boundary of React, the
+* ErrorBoundary of Solid, and `<svelte:boundary>` each see never.
+*
+* The function accepts BOTH spellings of the source, so the rule holds in a development
+* build and in a production build. An unknown value counts as a failure of the render,
+* which is the safe answer: the boundary then contains the error instead of letting a
+* broken subtree stay on the screen.
+*
+* @param info - The third argument of an `onErrorCaptured` hook.
+*/
+function failsTheRender(info) {
+	if (isProductionSpelling(info)) return !NON_RENDER_SOURCES.has(info.slice(43));
+	return !NON_RENDER_SOURCE_NAMES.has(info);
+}
+/**
+* The source that `flushJobs` of Vue reports, in both spellings.
+*
+* `flushJobs` runs every queued job through
+* `callWithErrorHandling(job, job.i, job.i ? 15 : 14)`, and code 15 is "component
+* update". That is the ONE source under which Vue can report an error a SECOND time: a
+* job loses the re-throw of `logError` of the development bundle to that call, and the
+* error arrives at `onErrorCaptured` again with a source that {@link failsTheRender}
+* answers TRUE for. Code 14 belongs to a job with no instance, which reaches no
+* `errorCaptured` hook, and it counts as a non-render source already.
+*
+* A boundary that ignores a repeat asks for this spelling as well. Without it a record
+* of the turn could also disarm the boundary for a failure of a SETUP function or of a
+* RENDER function that carries the same error value.
+*
+* @param info - The third argument of an `onErrorCaptured` hook.
+*/
+function isComponentUpdate(info) {
+	return info === COMPONENT_UPDATE_NAME || info === COMPONENT_UPDATE_INFO;
+}
+/**
+* Answers whether Vue can raise this error a SECOND time.
+*
+* `handleError` of Vue reaches `logError` only where the application wires no
+* `app.config.errorHandler`, and it asks that field for TRUTH and not for a type: a host
+* in JavaScript can set `errorHandler = null`, and Vue then re-throws. The development
+* bundle re-throws every time. The production bundle writes the error and throws it only
+* where the application asks for `throwUnhandledErrorInProduction`.
+*
+* The provider arms the record of a repeat only where this answers `true`. A record that
+* waits for a repeat which never comes disarms the boundary for the next raise of that
+* same error value.
+*
+* The production half lives HERE, and not in the component, for the reason that the
+* header of this module states: a mounted test reaches it never.
+*
+* @param info - The source that `onErrorCaptured` reports, in either spelling.
+* @param config - `app.config` of the application, or `undefined` outside an instance.
+*/
+function canRaiseAgain(info, config) {
+	if (config?.errorHandler) return false;
+	if (!isProductionSpelling(info)) return true;
+	return Boolean(config?.throwUnhandledErrorInProduction);
+}
+//#endregion
+export { canRaiseAgain, failsTheRender, isComponentUpdate, isProductionSpelling };
+
+//# sourceMappingURL=error-source.js.map

package/dist/error-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-source.js","names":[],"sources":["../src/error-source.ts"],"sourcesContent":["/**\n * The classification of the source that `onErrorCaptured` of Vue reports.\n *\n * This module holds four functions, and a test covers each one directly. The rule\n * that they carry cannot be tested through a mounted component: Vue reports the source in TWO\n * spellings, and a test runner loads the DEVELOPMENT bundle, which reports only one of\n * them.\n *\n * @packageDocumentation\n */\n\n/**\n * The sources of an error that leaves the rendered view alone, in the TWO spellings that\n * Vue uses: the key of its `ErrorTypeStrings` map, which the production bundle reports,\n * and the value of that entry, which the development bundle reports.\n *\n * ONE table, and not two sets: the two spellings name the same seven sources, and a\n * second list is a second chance for one half to fall behind the other.\n */\nconst NON_RENDER_SOURCES: ReadonlyMap<string, string> = new Map([\n\t[\"2\", \"watcher getter\"],\n\t[\"3\", \"watcher callback\"],\n\t[\"4\", \"watcher cleanup function\"],\n\t[\"5\", \"native event handler\"],\n\t[\"6\", \"component event handler\"],\n\t[\"13\", \"async component loader\"],\n\t[\"14\", \"scheduler flush\"],\n]);\n\n/**\n * The sources above, in the spelling of the DEVELOPMENT bundle.\n *\n * The production spelling needs no set of its own: the code IS the key of the table, so\n * `NON_RENDER_SOURCES.has(code)` answers that half directly.\n */\nconst NON_RENDER_SOURCE_NAMES: ReadonlySet<string> = new Set(NON_RENDER_SOURCES.values());\n\n/**\n * The prefix that the production bundle puts before the code.\n *\n * `runtime-core.cjs.prod.js` builds the value as\n * `` `https://vuejs.org/error-reference/#runtime-${type}` ``, and the development\n * bundle passes `ErrorTypeStrings[type]` instead. A rule that reads only the names of\n * the development bundle therefore matches nothing in a production application, and it\n * classifies EVERY error as a failure of the render.\n */\nconst PRODUCTION_PREFIX = \"https://vuejs.org/error-reference/#runtime-\";\n\n/**\n * `ErrorCodes.COMPONENT_UPDATE` of Vue, the source that `flushJobs` reports a job under,\n * in the TWO spellings — the development name, and the production URL that\n * {@link PRODUCTION_PREFIX} builds. The pair stands beside the table above, and not in\n * it: that table holds the sources that leave the render alone, and this one fails it.\n */\nconst COMPONENT_UPDATE_NAME = \"component update\";\nconst COMPONENT_UPDATE_INFO = `${PRODUCTION_PREFIX}15`;\n\n/**\n * Answers whether `info` carries the spelling of the PRODUCTION bundle.\n *\n * The production bundle re-throws an error that no handler took only where the\n * application asks for `throwUnhandledErrorInProduction`. A boundary that waits for a\n * repeat asks this before it arms a record for one.\n *\n * @param info - The third argument of an `onErrorCaptured` hook.\n */\nexport function isProductionSpelling(info: string): boolean {\n\treturn info.startsWith(PRODUCTION_PREFIX);\n}\n\n/**\n * Answers whether the error failed the RENDER of a descendant.\n *\n * The boundary of ActorProvider replaces the view with the fallback content for a\n * failure of the render only. `onErrorCaptured` of Vue also fires for an error of an\n * event handler and of a watcher callback, which the boundary of React, the\n * ErrorBoundary of Solid, and `<svelte:boundary>` each see never.\n *\n * The function accepts BOTH spellings of the source, so the rule holds in a development\n * build and in a production build. An unknown value counts as a failure of the render,\n * which is the safe answer: the boundary then contains the error instead of letting a\n * broken subtree stay on the screen.\n *\n * @param info - The third argument of an `onErrorCaptured` hook.\n */\nexport function failsTheRender(info: string): boolean {\n\tif (isProductionSpelling(info)) {\n\t\treturn !NON_RENDER_SOURCES.has(info.slice(PRODUCTION_PREFIX.length));\n\t}\n\treturn !NON_RENDER_SOURCE_NAMES.has(info);\n}\n\n/**\n * The source that `flushJobs` of Vue reports, in both spellings.\n *\n * `flushJobs` runs every queued job through\n * `callWithErrorHandling(job, job.i, job.i ? 15 : 14)`, and code 15 is \"component\n * update\". That is the ONE source under which Vue can report an error a SECOND time: a\n * job loses the re-throw of `logError` of the development bundle to that call, and the\n * error arrives at `onErrorCaptured` again with a source that {@link failsTheRender}\n * answers TRUE for. Code 14 belongs to a job with no instance, which reaches no\n * `errorCaptured` hook, and it counts as a non-render source already.\n *\n * A boundary that ignores a repeat asks for this spelling as well. Without it a record\n * of the turn could also disarm the boundary for a failure of a SETUP function or of a\n * RENDER function that carries the same error value.\n *\n * @param info - The third argument of an `onErrorCaptured` hook.\n */\nexport function isComponentUpdate(info: string): boolean {\n\treturn info === COMPONENT_UPDATE_NAME || info === COMPONENT_UPDATE_INFO;\n}\n\n/**\n * The configuration of the application that {@link canRaiseAgain} reads.\n *\n * It names the two fields of `app.config` alone, so a caller passes the config of Vue\n * itself, and a test passes an object literal.\n */\nexport interface RaiseConfig {\n\terrorHandler?: unknown;\n\tthrowUnhandledErrorInProduction?: boolean;\n}\n\n/**\n * Answers whether Vue can raise this error a SECOND time.\n *\n * `handleError` of Vue reaches `logError` only where the application wires no\n * `app.config.errorHandler`, and it asks that field for TRUTH and not for a type: a host\n * in JavaScript can set `errorHandler = null`, and Vue then re-throws. The development\n * bundle re-throws every time. The production bundle writes the error and throws it only\n * where the application asks for `throwUnhandledErrorInProduction`.\n *\n * The provider arms the record of a repeat only where this answers `true`. A record that\n * waits for a repeat which never comes disarms the boundary for the next raise of that\n * same error value.\n *\n * The production half lives HERE, and not in the component, for the reason that the\n * header of this module states: a mounted test reaches it never.\n *\n * @param info - The source that `onErrorCaptured` reports, in either spelling.\n * @param config - `app.config` of the application, or `undefined` outside an instance.\n */\nexport function canRaiseAgain(info: string, config: RaiseConfig | undefined): boolean {\n\tif (config?.errorHandler) return false;\n\tif (!isProductionSpelling(info)) return true;\n\treturn Boolean(config?.throwUnhandledErrorInProduction);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,IAAM,qCAAkD,IAAI,IAAI;CAC/D,CAAC,KAAK,gBAAgB;CACtB,CAAC,KAAK,kBAAkB;CACxB,CAAC,KAAK,0BAA0B;CAChC,CAAC,KAAK,sBAAsB;CAC5B,CAAC,KAAK,yBAAyB;CAC/B,CAAC,MAAM,wBAAwB;CAC/B,CAAC,MAAM,iBAAiB;AACzB,CAAC;;;;;;;AAQD,IAAM,0BAA+C,IAAI,IAAI,mBAAmB,OAAO,CAAC;;;;;;;;;;AAWxF,IAAM,oBAAoB;;;;;;;AAQ1B,IAAM,wBAAwB;AAC9B,IAAM,wBAAwB,GAAG,kBAAkB;;;;;;;;;;AAWnD,SAAgB,qBAAqB,MAAuB;CAC3D,OAAO,KAAK,WAAW,iBAAiB;AACzC;;;;;;;;;;;;;;;;AAiBA,SAAgB,eAAe,MAAuB;CACrD,IAAI,qBAAqB,IAAI,GAC5B,OAAO,CAAC,mBAAmB,IAAI,KAAK,MAAM,EAAwB,CAAC;CAEpE,OAAO,CAAC,wBAAwB,IAAI,IAAI;AACzC;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,kBAAkB,MAAuB;CACxD,OAAO,SAAS,yBAAyB,SAAS;AACnD;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,cAAc,MAAc,QAA0C;CACrF,IAAI,QAAQ,cAAc,OAAO;CACjC,IAAI,CAAC,qBAAqB,IAAI,GAAG,OAAO;CACxC,OAAO,QAAQ,QAAQ,+BAA+B;AACvD"}

package/dist/index.d.ts

@@ -15,8 +15,8 @@
 export { default as PlayRenderer } from "./PlayRenderer.vue";
 export { default as ActorProvider } from "./ActorProvider.vue";
 export { default as PlayUIProvider } from "./PlayUIProvider.vue";
-export type { ActorProviderProps, PlayUIProviderProps, RenderErrorHandler, VisibilityProviderProps, } from "./types.js";
-export { usePlayView, getPlayViewContext } from "./actor-provider-context.js";
+export type { ActorProviderProps, PlayUIProviderProps, RenderErrorHandler } from "./types.js";
+export { usePlayView } from "./actor-provider-context.js";
 export type { ViewContextValue } from "./actor-provider-context.js";
 export { useActor } from "./useActor.js";
 export type { AnyPlayActor } from "./useActor.js";
@@ -24,4 +24,5 @@ export { defineRegistry } from "./define-registry.js";
 export type { DefineRegistryOptions, ComponentsMap, ComponentEntry } from "./define-registry.js";
 export { JSONUIProvider, StateProvider, ActionProvider, VisibilityProvider, ValidationProvider, Renderer, useBoundProp, useFieldValidation, } from "@xmachines/json-render-vue";
 export type { JSONUIProviderProps, StateProviderProps, ActionProviderProps, ValidationProviderProps, RendererProps, ComponentFn, ComponentContext, DefineRegistryResult, } from "@xmachines/json-render-vue";
+export { schema } from "@xmachines/json-render-vue";
 //# 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,OAAO,IAAI,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGjE,YAAY,EACX,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,uBAAuB,GACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAC9E,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAGpE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGjG,OAAO,EACN,cAAc,EACd,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,kBAAkB,GAClB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACX,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,oBAAoB,GACpB,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGjE,YAAY,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC9F,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAGpE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGjG,OAAO,EACN,cAAc,EACd,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,kBAAkB,GAClB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACX,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,oBAAoB,GACpB,MAAM,4BAA4B,CAAC;AAQpC,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -1,8 +1,8 @@
-import { getPlayViewContext, usePlayView } from "./actor-provider-context.js";
+import { usePlayView } from "./actor-provider-context.js";
 import PlayRenderer_default from "./PlayRenderer.js";
 import { useActor } from "./useActor.js";
 import ActorProvider_default from "./ActorProvider.js";
 import PlayUIProvider_default from "./PlayUIProvider.js";
 import { defineRegistry } from "./define-registry.js";
-import { ActionProvider, JSONUIProvider, Renderer, StateProvider, ValidationProvider, VisibilityProvider, useBoundProp, useFieldValidation } from "@xmachines/json-render-vue";
-export { ActionProvider, ActorProvider_default as ActorProvider, JSONUIProvider, PlayRenderer_default as PlayRenderer, PlayUIProvider_default as PlayUIProvider, Renderer, StateProvider, ValidationProvider, VisibilityProvider, defineRegistry, getPlayViewContext, useActor, useBoundProp, useFieldValidation, usePlayView };
+import { ActionProvider, JSONUIProvider, Renderer, StateProvider, ValidationProvider, VisibilityProvider, schema, useBoundProp, useFieldValidation } from "@xmachines/json-render-vue";
+export { ActionProvider, ActorProvider_default as ActorProvider, JSONUIProvider, PlayRenderer_default as PlayRenderer, PlayUIProvider_default as PlayUIProvider, Renderer, StateProvider, ValidationProvider, VisibilityProvider, defineRegistry, schema, useActor, useBoundProp, useFieldValidation, usePlayView };

package/dist/types.d.ts

@@ -4,23 +4,79 @@
  * @packageDocumentation
  */
 import type { DefineRegistryResult } from "@xmachines/json-render-vue";
-import type { BaseActorProviderProps } from "@xmachines/play-actor";
+import type { BaseActorProviderProps } from "@xmachines/play-view";
 /**
  * The props of the ActorProvider component.
  * This file holds them, so that TypeScript can re-export them. The vue-shim has a
  * limit that stops a re-export from the .vue file.
+ *
+ * The null-view content is a **slot** named `fallback`, and not a prop. The provider
+ * shows that slot when `currentView` is null, and also while a contained error of a
+ * descendant is active (see `onError`).
  */
 export interface ActorProviderProps extends BaseActorProviderProps<DefineRegistryResult> {
+    /**
+     * The optional callback. The provider calls it when a descendant fails the RENDER —
+     * the render function, the setup function, or a lifecycle hook — and the error
+     * boundary of ActorProvider contains the error (`onErrorCaptured`).
+     *
+     * `onErrorCaptured` of Vue fires for an error of an event handler and of a watcher
+     * callback as well, and this prop reports NEITHER: the boundary of React, the
+     * ErrorBoundary of Solid and `<svelte:boundary>` see such an error never, so a report
+     * here would give play-vue a wider contract than the other four renderers. Those
+     * errors continue to `app.config.errorHandler` exactly as they do without this
+     * provider. `onError` reports a failure of the render, in every renderer.
+     *
+     * Vue reports such an error a SECOND time where the application wires no
+     * `app.config.errorHandler`: it re-throws the error, and a queued job carries it back
+     * as a failure of a render. The provider recognises that repeat and holds the view.
+     * It writes the error value to `console.error` with the name of this package, because
+     * Vue writes that value nowhere on this path, and `onError` stays silent. A
+     * development build re-throws every time, and a production build only where the
+     * application sets `app.config.throwUnhandledErrorInProduction`.
+     *
+     * ONE case escapes that rule. An ancestor `errorCaptured` hook that returns `false`
+     * stops Vue before the re-throw, so the record of the provider waits for a repeat that
+     * never comes. A second failure in the same flush can take that record. It must carry
+     * the same error value, and it must unwind out of the update job of a parent. Vue
+     * reports such a failure as a component update. The provider then holds the stale
+     * subtree on the screen, and `onError` stays silent.
+     *
+     * While the error is active, the provider renders the `fallback` slot instead of its
+     * children. The provider clears the error on the next view emission (when
+     * `currentView` changes), so a view transition retries the render.
+     *
+     * The boundary stops the error. Without this prop the provider therefore writes the
+     * error to `console.error`, because `app.config.errorHandler` sees it no longer.
+     *
+     * Element-level catalog component throws are caught upstream by the per-element
+     * boundary of @json-render, and reported through `onRenderError`. This boundary is
+     * the outer net for everything else.
+     *
+     * The second parameter is the RESET, for a retry that the host starts — a "Retry"
+     * button of its own. It clears the contained error and renders again, and it resolves
+     * the view that the actor holds at the MOMENT OF THE CALL, so a host that keeps the
+     * callback cannot rewind the screen to the view that failed. A reset that the host
+     * calls from inside this handler starts no second retry, because no input changed
+     * between the two attempts, and a reset after the provider is unmounted does nothing.
+     * The five renderers hold the same three rules.
+     *
+     * **A handler that THROWS reaches no caller.** The provider contains that throw, and
+     * it writes the throw to `console.error`. The errored flag schedules a RENDER, so a
+     * throw that left this handler would stop that render and skip the `return false` of
+     * `onErrorCaptured`: the subtree that threw stays on the screen AND the error reaches
+     * `app.config.errorHandler`.
+     *
+     * Report a failure from this handler. To ESCALATE one, raise it from a task of your
+     * own — `queueMicrotask(() => { throw error; })` — which reaches the global handler of
+     * the page and leaves the containment whole. The five renderers hold this one rule.
+     */
+    onError?: (error: unknown, reset: () => void) => void;
 }
 /**
  * The props of PlayUIProvider — every ActorProvider prop, and also the props of JSONUIProvider.
  */
 export type { RenderErrorHandler } from "@xmachines/json-render-vue";
-/**
- * @deprecated Unused; will be removed in the next major.
- */
-export interface VisibilityProviderProps {
-}
 export interface PlayUIProviderProps extends ActorProviderProps {
     /** The navigate function. The provider gives it to JSONUIProvider, which resolves each link with it */
     navigate?: (path: string) => void;

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,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE;;;;GAIG;AACH,MAAM,WAAW,kBAAmB,SAAQ,sBAAsB,CAAC,oBAAoB,CAAC;CAAG;AAE3F;;GAEG;AACH,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAIrE;;GAEG;AACH,MAAM,WAAW,uBAAuB;CAAG;AAE3C,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAC9D,uGAAuG;IACvG,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,0EAA0E;IAC1E,mBAAmB,CAAC,EAAE,MAAM,CAC3B,MAAM,EACN,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAC3D,CAAC;IACF,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CACjB,MAAM,EACN,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAC5E,CAAC;CACF"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAmB,SAAQ,sBAAsB,CAAC,oBAAoB,CAAC;IACvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;CACtD;AAED;;GAEG;AACH,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAC9D,uGAAuG;IACvG,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,0EAA0E;IAC1E,mBAAmB,CAAC,EAAE,MAAM,CAC3B,MAAM,EACN,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAC3D,CAAC;IACF,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CACjB,MAAM,EACN,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAC5E,CAAC;CACF"}

package/dist/useActor.d.ts

@@ -34,12 +34,19 @@
  * @packageDocumentation
  */
 import type { InjectionKey } from "vue";
-import type { AbstractActor } from "@xmachines/play-actor";
-import type { AnyActorLogic } from "xstate";
+import type { PlayActor } from "@xmachines/play-actor";
 /**
- * The bare actor type that the Vue context providers accept. For the complete routing and view shape, use `PlayActor` from `@xmachines/play-router`.
+ * The actor type of the context of this renderer.
+ *
+ * It is the `PlayActor` contract, which is `state` and `send`, and it names no engine, no
+ * routing and no view. A component inside the render tree reads the context to SEND an
+ * event, for example a retry from a fallback, and nothing reads `currentView` through it:
+ * a renderer receives the view from its provider, and not from this context.
+ *
+ * It was `AbstractActor<AnyActorLogic>`, which demanded the whole `Actor` surface of
+ * XState from a context that reads two members.
  */
-export type AnyPlayActor = AbstractActor<AnyActorLogic>;
+export type AnyPlayActor = PlayActor;
 export declare const ActorKey: InjectionKey<AnyPlayActor>;
 /**
  * Provides the actor to every descendant component, through the inject and provide

package/dist/useActor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useActor.d.ts","sourceRoot":"","sources":["../src/useActor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAExC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAExD,eAAO,MAAM,QAAQ,EAAE,YAAY,CAAC,YAAY,CAA6B,CAAC;AAE9E;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAEtD;AAED,wBAAgB,QAAQ,IAAI,YAAY,CAEvC"}
+{"version":3,"file":"useActor.d.ts","sourceRoot":"","sources":["../src/useActor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAExC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AAErC,eAAO,MAAM,QAAQ,EAAE,YAAY,CAAC,YAAY,CAA6B,CAAC;AAE9E;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAEtD;AAED,wBAAgB,QAAQ,IAAI,YAAY,CAEvC"}

package/dist/useActor.js.map

@@ -1 +1 @@
-{"version":3,"file":"useActor.js","names":[],"sources":["../src/useActor.ts"],"sourcesContent":["/**\n * useActor — the Vue composable that gives the actor inside a PlayRenderer tree.\n *\n * A component inside PlayRenderer calls useActor() to reach the actor instance. The\n * actor is then not necessary as a prop.\n *\n * The composable returns a **proxy that follows a swap**, and not the raw actor\n * object:\n * - The proxy is a stable reference for the life of the injection. It forwards\n *   every operation (a property read, a property write, `in`, `Object.keys`, a\n *   spread, and `instanceof`) to the actor that the tree provides at that moment.\n *   Therefore it follows a swap of `props.actor` on `<ActorProvider>`, and a\n *   consumer does not inject the actor again.\n * - The identity of each method is stable: `actor.send === actor.send` across\n *   repeated reads, with no allocation. The proxy binds the method again only when\n *   the method below it changes, or when the tree provides a different actor.\n * - The proxy is NOT `===` the `actor` prop of `<ActorProvider>`, because it is a\n *   separate Proxy object. Therefore give the actor prop itself, and not the value\n *   of `useActor()`, to each consumer that uses the identity of the actor as a key.\n *   The most important such consumer is a router bridge that extends\n *   `RouterBridgeBase`: its guard of one bridge for each actor uses the actor\n *   instance as the key of a WeakMap.\n *\n * @throws {Error} When the caller is outside a PlayRenderer tree\n *\n * @example\n * ```typescript\n * import { useActor } from \"@xmachines/play-vue\";\n *\n * const actor = useActor();\n * actor.send({ type: \"SUBMIT\" });\n * ```\n *\n * @packageDocumentation\n */\n\nimport { inject, provide } from \"vue\";\nimport type { InjectionKey } from \"vue\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport type { AbstractActor } from \"@xmachines/play-actor\";\nimport type { AnyActorLogic } from \"xstate\";\n\n/**\n * The bare actor type that the Vue context providers accept. For the complete routing and view shape, use `PlayActor` from `@xmachines/play-router`.\n */\nexport type AnyPlayActor = AbstractActor<AnyActorLogic>;\n\nexport const ActorKey: InjectionKey<AnyPlayActor> = Symbol(\"xmachines.actor\");\n\n/**\n * Provides the actor to every descendant component, through the inject and provide\n * mechanism of Vue.\n *\n * The `setup()` function of `PlayRenderer.vue` calls it. The actor is then\n * available to each child component that calls `useActor()`. You need this function\n * outside the framework internals only when you build your own renderer wrapper.\n *\n * @param actor - The actor instance to inject into the component tree.\n */\nexport function provideActor(actor: AnyPlayActor): void {\n\tprovide(ActorKey, actor);\n}\n\nexport function useActor(): AnyPlayActor {\n\treturn assertNonNullable(inject(ActorKey), \"ActorKey\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,WAAuC,OAAO,iBAAiB;;;;;;;;;;;AAY5E,SAAgB,aAAa,OAA2B;CACvD,QAAQ,UAAU,KAAK;AACxB;AAEA,SAAgB,WAAyB;CACxC,OAAO,kBAAkB,OAAO,QAAQ,GAAG,UAAU;AACtD"}
+{"version":3,"file":"useActor.js","names":[],"sources":["../src/useActor.ts"],"sourcesContent":["/**\n * useActor — the Vue composable that gives the actor inside a PlayRenderer tree.\n *\n * A component inside PlayRenderer calls useActor() to reach the actor instance. The\n * actor is then not necessary as a prop.\n *\n * The composable returns a **proxy that follows a swap**, and not the raw actor\n * object:\n * - The proxy is a stable reference for the life of the injection. It forwards\n *   every operation (a property read, a property write, `in`, `Object.keys`, a\n *   spread, and `instanceof`) to the actor that the tree provides at that moment.\n *   Therefore it follows a swap of `props.actor` on `<ActorProvider>`, and a\n *   consumer does not inject the actor again.\n * - The identity of each method is stable: `actor.send === actor.send` across\n *   repeated reads, with no allocation. The proxy binds the method again only when\n *   the method below it changes, or when the tree provides a different actor.\n * - The proxy is NOT `===` the `actor` prop of `<ActorProvider>`, because it is a\n *   separate Proxy object. Therefore give the actor prop itself, and not the value\n *   of `useActor()`, to each consumer that uses the identity of the actor as a key.\n *   The most important such consumer is a router bridge that extends\n *   `RouterBridgeBase`: its guard of one bridge for each actor uses the actor\n *   instance as the key of a WeakMap.\n *\n * @throws {Error} When the caller is outside a PlayRenderer tree\n *\n * @example\n * ```typescript\n * import { useActor } from \"@xmachines/play-vue\";\n *\n * const actor = useActor();\n * actor.send({ type: \"SUBMIT\" });\n * ```\n *\n * @packageDocumentation\n */\n\nimport { inject, provide } from \"vue\";\nimport type { InjectionKey } from \"vue\";\nimport { assertNonNullable } from \"@xmachines/play\";\nimport type { PlayActor } from \"@xmachines/play-actor\";\n\n/**\n * The actor type of the context of this renderer.\n *\n * It is the `PlayActor` contract, which is `state` and `send`, and it names no engine, no\n * routing and no view. A component inside the render tree reads the context to SEND an\n * event, for example a retry from a fallback, and nothing reads `currentView` through it:\n * a renderer receives the view from its provider, and not from this context.\n *\n * It was `AbstractActor<AnyActorLogic>`, which demanded the whole `Actor` surface of\n * XState from a context that reads two members.\n */\nexport type AnyPlayActor = PlayActor;\n\nexport const ActorKey: InjectionKey<AnyPlayActor> = Symbol(\"xmachines.actor\");\n\n/**\n * Provides the actor to every descendant component, through the inject and provide\n * mechanism of Vue.\n *\n * The `setup()` function of `PlayRenderer.vue` calls it. The actor is then\n * available to each child component that calls `useActor()`. You need this function\n * outside the framework internals only when you build your own renderer wrapper.\n *\n * @param actor - The actor instance to inject into the component tree.\n */\nexport function provideActor(actor: AnyPlayActor): void {\n\tprovide(ActorKey, actor);\n}\n\nexport function useActor(): AnyPlayActor {\n\treturn assertNonNullable(inject(ActorKey), \"ActorKey\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,IAAa,WAAuC,OAAO,iBAAiB;;;;;;;;;;;AAY5E,SAAgB,aAAa,OAA2B;CACvD,QAAQ,UAAU,KAAK;AACxB;AAEA,SAAgB,WAAyB;CACxC,OAAO,kBAAkB,OAAO,QAAQ,GAAG,UAAU;AACtD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-vue",
-  "version": "2.2.0",
+  "version": "4.0.0",
   "description": "Vue renderer for XMachines Play architecture",
   "keywords": [
     "reactive",
@@ -39,45 +39,48 @@
     "build": "vite build && tsc --build",
     "clean": "rm -rf dist *.tsbuildinfo coverage .vitest-attachments test/browser/__screenshots__ node_modules/.svelte2tsx-* node_modules/.vite*",
     "lint": "oxlint .",
+    "lint:security": "node ../../scripts/semgrep-scan.mjs",
     "format": "oxfmt .",
     "test": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@xmachines/play": "2.2.0",
-    "@xmachines/play-actor": "2.2.0",
-    "@xmachines/play-signals": "2.2.0"
+    "@xmachines/play-actor": "4.0.0",
+    "@xmachines/play-view": "4.0.0"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^6.9.1",
-    "@types/node": "^26.2.0",
-    "@vitejs/plugin-vue": "^6.0.5",
-    "@vitest/browser-playwright": "^4.1.11",
-    "@vue/test-utils": "^2.4.9",
-    "@xmachines/json-render-core": "^0.20.0-xm.3",
-    "@xmachines/json-render-vue": "^0.20.0-xm.3",
-    "@xmachines/json-render-xstate": "^0.20.0-xm.3",
-    "@xstate/store": "^3.17.0",
-    "oxfmt": "^0.64.0",
-    "oxlint": "^1.79.0",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@types/node": "^26.6.2",
+    "@vitejs/plugin-vue": "^6.0.9",
+    "@vitest/browser-playwright": "^5.0.1",
+    "@vue/test-utils": "^2.5.0",
+    "@xmachines/json-render-core": "^0.20.0-xm.4",
+    "@xmachines/json-render-vue": "^0.20.0-xm.4",
+    "@xmachines/json-render-xstate": "^0.20.0-xm.4",
+    "@xmachines/play": "4.0.0",
+    "@xmachines/play-signals": "4.0.0",
+    "@xstate/store": "^3.17.5",
+    "oxfmt": "^0.68.0",
+    "oxlint": "^1.83.0",
     "typescript": "^5.9.3 || ^6.0.3",
-    "vite": "^8.0.10",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.1.11",
-    "vue": "^3.5.33",
-    "xstate": "^5.31.0",
-    "zod": "^4.4.1"
+    "vite": "^8.3.0",
+    "vite-plugin-dts": "^5.1.0",
+    "vitest": "^5.0.1",
+    "vue": "^3.5.42",
+    "xstate": "^5.33.0",
+    "zod": "^4.6.5"
   },
   "peerDependencies": {
-    "@xmachines/json-render-core": "^0.20.0-xm.2",
-    "@xmachines/json-render-vue": "^0.20.0-xm.2",
-    "@xmachines/json-render-xstate": "^0.20.0-xm.2",
+    "@xmachines/json-render-core": "^0.20.0-xm.4",
+    "@xmachines/json-render-vue": "^0.20.0-xm.4",
+    "@xmachines/json-render-xstate": "^0.20.0-xm.4",
+    "@xmachines/play": "4.0.0",
+    "@xmachines/play-signals": "4.0.0",
     "@xstate/store": "^3.17.0",
-    "vue": "^3.5.0",
-    "xstate": "^5.31.0"
+    "vue": "^3.5.0"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   }
 }