@xmachines/play-xstate 1.0.0-beta.1

package/.oxfmtrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["@xmachines/shared/oxfmt"]
+}

package/.oxlintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["@xmachines/shared/oxlint"]
+}

package/README.md

@@ -0,0 +1,454 @@
+# @xmachines/play-xstate
+
+**XState v5 adapter for Play Architecture with signal-driven reactivity and routing**
+
+Transform declarative state machines into live actors with TC39 Signals and parameter-aware navigation.
+
+## Overview
+
+`@xmachines/play-xstate` provides `definePlayer()`, the primary API for binding XState v5 state machines to the Play Architecture actor base. It enables business logic to control routing and state through guard-enforced transitions with catalog binding, signal lifecycle management, and XState DevTools compatibility.
+
+Per [RFC Play v1](https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md), this package implements:
+
+- **Actor Authority (INV-01):** State machine guards decide navigation validity
+- **Strict Separation (INV-02):** Zero React/framework imports in business logic
+- **Signal-Only Reactivity (INV-05):** TC39 Signals expose all state changes
+
+**Routing:** Supports `meta.route` patterns, `play.route` events with parameters, and route extraction.
+
+## Installation
+
+```bash
+npm install xstate@^5.0.0 zod@^3.23.0
+npm install @xmachines/play-xstate
+```
+
+## Current Exports
+
+- `definePlayer`, `PlayerActor`
+- player types: `PlayerConfig`, `PlayerOptions`, `PlayerFactory`
+- guard utilities: `composeGuards`, `composeGuardsOr`, `negateGuard`, `hasContext`, `eventMatches`, `stateMatches`
+- routing utilities: `deriveRoute`, `isAbsoluteRoute`, `buildRouteUrl`, `formatPlayRouteTransitions`
+- catalog utilities: `validateComponentBinding`, `validateViewProps`, `mergeViewProps`
+
+**Peer dependencies:**
+
+- `xstate` ^5.0.0 - State machine runtime
+- `zod` ^3.23.0 - Schema validation for component props
+
+## Quick Start
+
+```typescript
+import { setup } from "xstate";
+import { z } from "zod";
+import { definePlayer } from "@xmachines/play-xstate";
+import { defineCatalog } from "@xmachines/play-catalog";
+
+// 1. Define XState machine with meta.route
+const machine = setup({
+	types: {
+		context: {} as { userId: string },
+		events: {} as { type: "play.route"; to: string } | { type: "auth.login"; userId: string },
+	},
+	guards: {
+		isLoggedIn: ({ context }) => !!context.userId,
+	},
+}).createMachine({
+	id: "app",
+	initial: "login",
+	context: { userId: "" },
+	states: {
+		login: {
+			id: "login",
+			meta: {
+				route: "/login",
+				view: { component: "LoginForm" },
+			},
+			on: {
+				"auth.login": {
+					guard: "isLoggedIn",
+					target: "dashboard",
+				},
+			},
+		},
+		dashboard: {
+			id: "dashboard",
+			meta: {
+				route: "/dashboard",
+				view: { component: "Dashboard", props: { userId: "" } },
+			},
+		},
+	},
+});
+
+// 2. Define catalog with Zod schemas
+const catalog = defineCatalog({
+	LoginForm: z.object({ error: z.string().optional() }),
+	Dashboard: z.object({ userId: z.string() }),
+});
+
+// 3. Create player factory
+const createPlayer = definePlayer({ machine, catalog });
+
+// 4. Create and start actor
+const actor = createPlayer({ userId: "" });
+actor.start();
+
+// 5. Send events (play.route with parameters)
+actor.send({ type: "play.route", to: "/login" });
+
+// 6. Observe signals
+console.log(actor.currentRoute.get()); // "/login"
+console.log(actor.currentView.get()); // { component: "LoginForm", props: {...} }
+
+// 7. Cleanup
+actor.dispose();
+```
+
+## API Reference
+
+### definePlayer()
+
+Create a player factory from XState machine and catalog:
+
+```typescript
+const createPlayer = definePlayer<TMachine, TCatalog>({
+	machine: AnyStateMachine,
+	catalog?: Catalog,
+	options?: PlayerOptions,
+}): PlayerFactory;
+```
+
+**Config:**
+
+- `machine` (required) - XState v5 state machine
+- `catalog` (optional) - UI component catalog with Zod schemas
+- `options` (optional) - Lifecycle hooks
+
+**Returns:** Factory function `(input?) => PlayerActor`
+
+**Example:**
+
+```typescript
+const createPlayer = definePlayer({
+	machine: authMachine,
+	catalog: authCatalog,
+	options: {
+		onStart: (actor) => console.log("Started:", actor.id),
+		onTransition: (actor, prev, next) => {
+			console.log("Transition:", prev.value, "→", next.value);
+		},
+	},
+});
+
+const actor1 = createPlayer({ userId: "user1" });
+const actor2 = createPlayer({ userId: "user2" });
+// Multiple independent actor instances
+```
+
+### PlayerActor
+
+Concrete actor implementing Play signal protocol:
+
+**Signal Properties:**
+
+- `state: Signal.State<Snapshot>` - Reactive snapshot of current state
+- `currentRoute: Signal.Computed<string | null>` - Derived navigation path
+- `currentView: Signal.Computed<ViewStructure | null>` - Derived UI structure
+
+**Actor Properties:**
+
+- `catalog: Catalog` - Component catalog
+
+**Methods:**
+
+- `start()` - Start the actor (must call after creation)
+- `stop()` - Stop the actor
+- `send(event: PlayEvent)` - Send event to actor
+- `dispose()` - Convenience cleanup (calls stop())
+
+**Example:**
+
+```typescript
+const actor = createPlayer();
+actor.start();
+
+// Observe signals with watcher
+const watcher = new Signal.subtle.Watcher(() => {
+	queueMicrotask(() => {
+		const route = actor.currentRoute.get();
+		console.log("Route changed:", route);
+	});
+});
+watcher.watch(actor.currentRoute);
+actor.currentRoute.get(); // Initial read
+```
+
+### Guard Composition
+
+```typescript
+import {
+	composeGuards,
+	composeGuardsOr,
+	negateGuard,
+	hasContext,
+	eventMatches,
+	stateMatches,
+} from "@xmachines/play-xstate";
+
+const machine = setup({
+	guards: {
+		isLoggedIn: hasContext("userId"),
+		isAdmin: ({ context }) => context.role === "admin",
+	},
+}).createMachine({
+	on: {
+		accessAdmin: {
+			// Array means AND - all guards must pass
+			guard: composeGuards(["isLoggedIn", "isAdmin"]),
+			target: "adminPanel",
+		},
+		accessPublic: {
+			// OR composition - any guard passes
+			guard: composeGuardsOr(["isLoggedIn", ({ event }) => event.type === "guest.access"]),
+			target: "publicArea",
+		},
+		logout: {
+			// NOT composition
+			guard: negateGuard("isLoggedIn"),
+			target: "login",
+		},
+	},
+});
+```
+
+**Helpers:**
+
+- `hasContext(path: string)` - Check if context property is truthy
+- `eventMatches(type: string)` - Check event type
+- `stateMatches(value: string)` - Check state value
+- `composeGuards(guards: Array)` - AND composition
+- `composeGuardsOr(guards: Array)` - OR composition
+- `negateGuard(guard)` - NOT composition
+
+**Complete API:** See [API Documentation](../../docs/api/@xmachines/play-xstate)
+
+## Examples
+
+### Guard Placement Philosophy
+
+**Guards check if you can BE in a state (state entry), not if you can TAKE an event (event handlers).**
+
+```typescript
+import { setup } from "xstate";
+import { definePlayer, formatPlayRouteTransitions } from "@xmachines/play-xstate";
+import { defineCatalog } from "@xmachines/play-catalog";
+
+// Pattern 1: RECOMMENDED - Use formatPlayRouteTransitions utility
+const machineConfig = {
+	id: "app",
+	initial: "home",
+	context: { isAuthenticated: false },
+	states: {
+		home: {
+			id: "home",
+			meta: { route: "/", view: { component: "Home" } },
+		},
+		dashboard: {
+			id: "dashboard",
+			meta: { route: "/dashboard", view: { component: "Dashboard" } },
+			// Always-guard validates state entry
+			always: [
+				{
+					target: "login",
+					guard: ({ context }) => !context.isAuthenticated,
+				},
+			],
+		},
+		login: {
+			id: "login",
+			meta: { route: "/login", view: { component: "Login" } },
+		},
+	},
+};
+
+// formatPlayRouteTransitions handles routing infrastructure
+const machine = setup({
+	types: {
+		events: {} as { type: "play.route"; to: string } | { type: "auth.login" },
+	},
+}).createMachine(formatPlayRouteTransitions(machineConfig));
+
+const catalog = defineCatalog({
+	Home,
+	Dashboard,
+	Login,
+});
+
+const createPlayer = definePlayer({ machine, catalog });
+const actor = createPlayer();
+actor.start();
+
+// Navigation via play.route event
+actor.send({ type: "play.route", to: "/dashboard" });
+// Guard validates: Can I BE in dashboard state?
+// If !isAuthenticated → redirects to login
+```
+
+**Why this works:**
+
+- `formatPlayRouteTransitions` adds routing infrastructure (event.to → state mapping)
+- Always-guards handle business logic (authentication checks)
+- Clear separation: routing is infrastructure, guards are business logic
+
+**Anti-pattern (DON'T DO THIS):**
+
+```typescript
+// ❌ WRONG - Guard on event checking event properties
+on: {
+  "play.route": {
+    guard: ({ event }) => event.to === "/dashboard",
+    target: "dashboard"
+  }
+}
+```
+
+**Reference:** See `docs/examples/routing-patterns.md` for canonical `formatPlayRouteTransitions` usage with always-guards for authentication.
+
+### Lifecycle Hooks
+
+```typescript
+const createPlayer = definePlayer({
+	machine,
+	catalog,
+	options: {
+		onStart: (actor) => {
+			console.log("Actor started:", actor.id);
+		},
+		onStop: (actor) => {
+			console.log("Actor stopped:", actor.id);
+		},
+		onTransition: (actor, prev, next) => {
+			console.log("State change:", {
+				from: prev.value,
+				to: next.value,
+				timestamp: Date.now(),
+			});
+		},
+		onStateChange: (actor, state) => {
+			// Called on every state update
+			console.log("Snapshot updated:", state.value);
+		},
+		onError: (actor, error) => {
+			console.error("Actor error:", error);
+			// Log to monitoring service, show error UI, etc.
+		},
+	},
+});
+```
+
+### XState DevTools Integration
+
+```typescript
+import { createBrowserInspector } from "@statelyai/inspect";
+import { definePlayer } from "@xmachines/play-xstate";
+
+const { inspect } = createBrowserInspector();
+
+const createPlayer = definePlayer({ machine, catalog });
+const actor = createPlayer();
+actor.start();
+
+// PlayerActor maintains XState Inspector compatibility
+// Inspector displays:
+// - State transitions and values
+// - Context data
+// - Events sent to actor
+// - Guard evaluation results
+
+// Signals accessible via actor properties, not snapshots
+console.log(actor.currentRoute.get()); // "/dashboard"
+```
+
+## Metadata Conventions
+
+### Route Metadata
+
+```typescript
+// meta.route marks states as routable
+states: {
+	dashboard: {
+		id: "dashboard",
+		meta: {
+			route: "/dashboard", // URL path - marks state as routable
+		},
+	},
+}
+
+// Parameters
+meta: {
+	route: "/profile/:userId", // Required parameter
+	route: "/settings/:section?", // Optional parameter
+}
+
+// Inheritance
+meta: {
+	route: "/absolute", // Starts with / → doesn't inherit parent route
+	route: "relative", // Doesn't start with / → inherits parent route
+}
+```
+
+### View Metadata
+
+```typescript
+meta: {
+	view: {
+		component: "Dashboard", // Must exist in catalog
+		props: { userId: "user123" }, // Validated against Zod schema
+		title: "Dashboard", // Additional metadata
+	},
+}
+
+// Dynamic props from context
+meta: {
+	view: {
+		component: "Dashboard",
+		props: (context) => ({
+			userId: context.userId,
+			notifications: context.unreadCount,
+		}),
+	},
+}
+```
+
+## Architecture
+
+This package implements RFC Play v1 requirements:
+
+**Architectural Invariants:**
+
+- **Actor Authority (INV-01):** Guards decide navigation validity
+- **Strict Separation (INV-02):** Zero framework imports
+- **Signal-Only Reactivity (INV-05):** All state via TC39 Signals
+
+**XState DevTools:** Maintains Inspector compatibility — snapshots remain pure XState format, signals accessible via actor properties.
+
+**Routing:**
+
+- `meta.route` property marks states as routable
+- `play.route` events support parameters (enhancement)
+- Route extraction for URL patterns
+
+**Note:** Route parameter extraction uses URLPattern API. See [@xmachines/play-tanstack-react-router browser support](../play-tanstack-react-router/README.md#browser-support) for polyfill requirements.
+
+## Related Packages
+
+- **[@xmachines/play-actor](../play-actor)** - AbstractActor base class
+- **[@xmachines/play-signals](../play-signals)** - TC39 Signals polyfill
+- **[@xmachines/play-catalog](../play-catalog)** - UI schema validation
+- **[@xmachines/play-router](../play-router)** - Route extraction
+- **[@xmachines/play](../play)** - Protocol types (PlayEvent)
+
+## License
+
+MIT

package/dist/catalog/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Catalog binding and validation utilities
+ *
+ * Provides functions for validating component references and props
+ * using Zod schemas from the catalog.
+ *
+ * @packageDocumentation
+ */
+export { validateComponentBinding } from "./validate-binding.js";
+export { validateViewProps, mergeViewProps } from "./validate-props.js";
+export type { Catalog, CatalogEntry, ViewMetadata } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/catalog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/catalog/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACxE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/catalog/index.js

@@ -0,0 +1,11 @@
+/**
+ * Catalog binding and validation utilities
+ *
+ * Provides functions for validating component references and props
+ * using Zod schemas from the catalog.
+ *
+ * @packageDocumentation
+ */
+export { validateComponentBinding } from "./validate-binding.js";
+export { validateViewProps, mergeViewProps } from "./validate-props.js";
+//# sourceMappingURL=index.js.map

package/dist/catalog/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/catalog/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/catalog/types.d.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod";
+import type { Catalog as BaseCatalog } from "@xmachines/play-catalog";
+/**
+ * UI component catalog entry with schema and component reference
+ *
+ * Per CONTEXT.md: String keys reference components, Zod schemas validate props
+ */
+export interface CatalogEntry {
+    /** Zod schema for component props */
+    schema: z.ZodType<any>;
+    /** React component (or other framework component) */
+    component: any;
+}
+/**
+ * Component catalog mapping
+ *
+ * Re-export from @xmachines/play-catalog for consistent API.
+ *
+ * Supports two formats:
+ * - Direct Zod schemas: `Record<string, z.ZodType>` via defineCatalog()
+ * - CatalogEntry objects: `Record<string, CatalogEntry>` with { schema, component }
+ *
+ * PlayerActor accepts either format - if entry has 'schema' property, uses CatalogEntry pattern,
+ * otherwise treats as direct Zod schema.
+ */
+export type Catalog = BaseCatalog | Record<string, CatalogEntry>;
+/**
+ * View metadata from state machine
+ */
+export interface ViewMetadata {
+    /** Component name from catalog */
+    component: string;
+    /** Additional view props/data */
+    [key: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/catalog/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/catalog/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,qCAAqC;IACrC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACvB,qDAAqD;IACrD,SAAS,EAAE,GAAG,CAAC;CACf;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACnB"}

package/dist/catalog/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/catalog/types.js.map

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

package/dist/catalog/validate-binding.d.ts

@@ -0,0 +1,21 @@
+import type { Catalog, ViewMetadata } from "./types.js";
+/**
+ * Validate component binding against catalog
+ *
+ * Per CONTEXT.md:
+ * - "Component references: String keys"
+ * - "Mismatch detection: Both compile-time (TypeScript) and runtime validation"
+ *
+ * @example
+ * ```typescript
+ * const view = { component: 'Dashboard', userId: '123' };
+ * validateComponentBinding(view, catalog);
+ * // Throws if 'Dashboard' not in catalog
+ * ```
+ *
+ * @param view - View metadata from meta.view
+ * @param catalog - Component catalog
+ * @throws Error if component not found in catalog
+ */
+export declare const validateComponentBinding: (view: ViewMetadata, catalog: Catalog) => void;
+//# sourceMappingURL=validate-binding.d.ts.map

package/dist/catalog/validate-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-binding.d.ts","sourceRoot":"","sources":["../../src/catalog/validate-binding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,wBAAwB,GAAI,MAAM,YAAY,EAAE,SAAS,OAAO,KAAG,IAc/E,CAAC"}

package/dist/catalog/validate-binding.js

@@ -0,0 +1,30 @@
+/**
+ * Validate component binding against catalog
+ *
+ * Per CONTEXT.md:
+ * - "Component references: String keys"
+ * - "Mismatch detection: Both compile-time (TypeScript) and runtime validation"
+ *
+ * @example
+ * ```typescript
+ * const view = { component: 'Dashboard', userId: '123' };
+ * validateComponentBinding(view, catalog);
+ * // Throws if 'Dashboard' not in catalog
+ * ```
+ *
+ * @param view - View metadata from meta.view
+ * @param catalog - Component catalog
+ * @throws Error if component not found in catalog
+ */
+export const validateComponentBinding = (view, catalog) => {
+    if (!view || !view.component) {
+        throw new Error("Invalid view metadata: missing 'component' property");
+    }
+    const { component } = view;
+    // Runtime validation
+    if (!(component in catalog)) {
+        const available = Object.keys(catalog).join(", ");
+        throw new Error(`Component "${component}" not found in catalog. Available components: ${available || "(none)"}`);
+    }
+};
+//# sourceMappingURL=validate-binding.js.map

package/dist/catalog/validate-binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-binding.js","sourceRoot":"","sources":["../../src/catalog/validate-binding.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,IAAkB,EAAE,OAAgB,EAAQ,EAAE;IACtF,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACxE,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAE3B,qBAAqB;IACrB,IAAI,CAAC,CAAC,SAAS,IAAI,OAAO,CAAC,EAAE,CAAC;QAC7B,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClD,MAAM,IAAI,KAAK,CACd,cAAc,SAAS,iDAAiD,SAAS,IAAI,QAAQ,EAAE,CAC/F,CAAC;IACH,CAAC;AACF,CAAC,CAAC"}

package/dist/catalog/validate-props.d.ts

@@ -0,0 +1,41 @@
+import type { z } from "zod";
+import type { Catalog, ViewMetadata } from "./types.js";
+/**
+ * Validate view props against Zod schema
+ *
+ * Per CONTEXT.md:
+ * - "Prop validation: At state entry"
+ * - "currentView derivation: Merge meta.view with relevant context data"
+ *
+ * Per RESEARCH.md Pattern 4: Use safeParse() for validation
+ *
+ * @example
+ * ```typescript
+ * const props = { userId: '123', stats: { logins: 5 } };
+ * const result = validateViewProps('Dashboard', props, catalog);
+ * if (!result.success) {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * @param componentName - Component name from catalog
+ * @param props - Props to validate
+ * @param catalog - Component catalog with schemas
+ * @returns Zod parse result
+ */
+export declare const validateViewProps: (componentName: string, props: any, catalog: Catalog) => {
+    success: boolean;
+    data?: any;
+    error?: z.ZodError | Error;
+};
+/**
+ * Merge view metadata with context for props
+ *
+ * Per CONTEXT.md: "Merge meta.view with relevant context data for component props"
+ *
+ * @param view - View metadata from meta.view
+ * @param context - Machine context
+ * @returns Merged props object
+ */
+export declare const mergeViewProps: (view: ViewMetadata, context: any) => Record<string, any>;
+//# sourceMappingURL=validate-props.d.ts.map

package/dist/catalog/validate-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-props.d.ts","sourceRoot":"","sources":["../../src/catalog/validate-props.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,GAC7B,eAAe,MAAM,EACrB,OAAO,GAAG,EACV,SAAS,OAAO,KACd;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAA;CA2B5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,YAAY,EAAE,SAAS,GAAG,KAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAwCnF,CAAC"}