@continuum-dev/runtime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CooperContinuum
+
+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,403 @@
+# ♾️ @continuum-dev/runtime
+
+**The State Reconciliation Engine for Generative UI.** Saving state is easy. Reconciling state across unpredictable AI mutations is hard.
+
+[![npm version](https://badge.fury.io/js/@continuum-dev%2Fruntime.svg)](https://badge.fury.io/js/@continuum-dev%2Fruntime)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## The Problem: AI Forces Reconciliation
+
+In a traditional application, state management is trivial: a field has a static ID, and you map a value to it.
+
+But in **Generative UI**, the AI doesn't just change data-it changes *structure*.
+
+Imagine an AI agent renders a UI for a user. The user starts filling out a text field (`id: "field_123"`). Halfway through, the AI decides to "improve" the layout. It streams an updated UI that moves the field into a new grid, changes the container type, and renames the ID to `id: "grid_item_456"`.
+
+Standard frameworks drop the old node, mount the new node, and the user's input is destroyed. The data wasn't lost because of a bad state store; it was orphaned because **the map between the state and the UI was mutated**.
+
+To fix this, you don't need a better state manager. You need a reconciliation engine.
+
+## The Solution
+
+**Continuum Runtime** is a pure, stateless reconciliation engine designed specifically to solve the continuity problem in AI-generated interfaces.
+
+Given a `priorView`, a `newView`, and the `priorData`, the engine performs deterministic semantic diffing. It matches nodes by stable keys (even when IDs change), executes data migrations, handles deep nesting restructures, and outputs a perfectly reconciled state ready for rendering.
+
+```bash
+npm install @continuum-dev/runtime
+
+```
+
+## Core Capabilities
+
+* 🧠 **Semantic Reconciliation:** AI changed the node IDs? Wrapped them in a new `Row` or `Grid`? Continuum reconciles data via stable semantic keys, ensuring state survives massive layout overhauls.
+* 🛡️ **Detached State Retention:** If the AI temporarily removes a field, Continuum doesn't throw the data away. It caches it as an "orphaned" value and automatically restores it if the AI brings the field back in a future turn.
+* 🔄 **Data Migrations:** Upgrading a simple text `field` to a complex `collection`? Provide migration strategies to transform data payloads seamlessly across view transitions.
+* ⚛️ **Pure & Framework Agnostic:** 100% pure TypeScript. Zero I/O side-effects. Use it to power the reconciliation layer of your React, Angular, Vue, or Vanilla JS agents.
+
+---
+
+## Quick Start
+
+Here is how Continuum reconciles state when an AI completely restructures a UI mid-session.
+
+```typescript
+import { reconcile } from '@continuum-dev/runtime';
+
+// 1. The old view and the user's current data
+const priorView = {
+  viewId: 'v1',
+  version: '1.0',
+  nodes: [{ id: 'random_id_1', key: 'user_email', type: 'field' }]
+};
+
+const priorData = {
+  values: {
+    'random_id_1': { value: 'alice@example.com' } // The user typed this!
+  },
+  lineage: { timestamp: Date.now(), sessionId: 'session_123', viewId: 'v1', viewVersion: '1.0' }
+};
+
+// 2. The AI generates a totally new layout, burying the field in a group and changing the ID.
+const newView = {
+  viewId: 'v2',
+  version: '2.0',
+  nodes: [{
+    id: 'layout_group',
+    type: 'group',
+    children: [{ id: 'new_id_99', key: 'user_email', type: 'field' }]
+  }]
+};
+
+// 3. Reconcile the AI's structural mutation! 🪄
+const { reconciledState, diffs, issues, resolutions } = reconcile(
+  newView,
+  priorView,
+  priorData
+);
+
+// Continuum reconciled the state using the stable 'user_email' key.
+// Your data survived the AI's restructure!
+console.log(reconciledState.values['layout_group/new_id_99'].value);
+// Output: 'alice@example.com'
+
+```
+
+## Deep Dive: The Reconciliation Pipeline
+
+When you call `reconcile()`, the runtime executes a strict, deterministic pipeline to figure out exactly what the AI did:
+
+1. **Context Indexing:** Recursively indexes both views into lookup maps by `id` and `key`, using scoped nested paths plus dot-suffix key matching to detect structural shifts.
+2. **Node Resolution:** Evaluates every node in the new view:
+* **Carry:** Type and Hash match; data moves forward effortlessly.
+* **Migrate:** Hash changed; trigger explicit or registry-based migration strategies to reshape the data payload.
+* **Detach:** Type mismatch (e.g., a text input became a button); old data is safely stored in `detachedValues` rather than discarded.
+* **Restore:** A newly generated node matches the key/type of a previously detached value, reconciling the old data back to life.
+
+
+3. **Collection Mapping:** Normalizes arrays, enforcing `minItems`/`maxItems` constraints and remapping nested template paths if the AI restructures list items.
+4. **Validation:** Runs lightweight constraints checks (`min`, `max`, `pattern`, `required`) to immediately surface data issues caused by the AI's new schema.
+
+## Advanced: Migration Strategies
+
+Sometimes an AI doesn't just move a node; it fundamentally changes its data structure. Continuum allows you to define explicit migration strategies during reconciliation.
+
+```typescript
+const result = reconcile(newView, priorView, priorData, {
+  migrationStrategies: {
+    // If the AI changes the 'status' node schema, run this transformation
+    'status': (nodeId, priorNode, newNode, priorValue) => {
+       const typedValue = priorValue as { value: string };
+       return { value: typedValue.value.toUpperCase() };
+    }
+  },
+  // Or pass a registry of chainable strategies defined by the view AST
+  strategyRegistry: {
+    'string-to-array': myStringToArrayFunction
+  }
+});
+
+```
+
+---
+
+## The Continuum Ecosystem
+
+This package is the core engine, but the Continuum SDK provides dedicated framework bindings so you don't have to wire this up manually:
+
+* `@continuum-dev/session` - Stateful manager for conversational UI streams.
+* `@continuum-dev/react` - React bindings and component renderer.
+* `@continuum-dev/angular` - Angular bindings and directives.
+
+---
+
+## Public API Reference
+
+The runtime barrel file exports:
+
+- `./lib/reconcile.js`
+- `./lib/types.js`
+- `./lib/context.js`
+- `./lib/reconciliation/validator.js`
+
+Most integrations only need `reconcile()`, but advanced applications can use the lower-level APIs for debugging, preflight checks, and custom matching workflows.
+
+### 1) Core Orchestration
+
+#### `reconcile()`
+
+Primary runtime entrypoint. Compares a new view against prior view/data and returns reconciled state plus reconciliation metadata.
+
+```typescript
+function reconcile(
+  newView: ViewDefinition,
+  priorView: ViewDefinition | null,
+  priorData: DataSnapshot | null,
+  options?: ReconciliationOptions
+): ReconciliationResult;
+```
+
+Use case:
+- Call this on every new AI-generated view push to preserve user state across structural mutations.
+- Use the returned `diffs`, `issues`, and `resolutions` to power devtools, telemetry, or UI diagnostics.
+
+### 2) Core Types and Interfaces
+
+Exported from `src/lib/types.ts`.
+
+#### `ReconciliationOptions`
+
+Controls runtime behavior and migration extension points.
+
+```typescript
+interface ReconciliationOptions {
+  allowPartialRestore?: boolean;
+  allowBlindCarry?: boolean;
+  migrationStrategies?: Record<string, MigrationStrategy>;
+  strategyRegistry?: Record<string, MigrationStrategy>;
+  clock?: () => number;
+}
+```
+
+Use case:
+- Enable `allowBlindCarry` when you have prior data but no prior view AST.
+- Provide `migrationStrategies` or `strategyRegistry` when node schemas evolve across view versions.
+- Provide `clock` in tests for deterministic lineage timestamps.
+
+#### `ReconciliationResult`
+
+Full output payload from `reconcile()`.
+
+```typescript
+interface ReconciliationResult {
+  reconciledState: DataSnapshot;
+  diffs: StateDiff[];
+  issues: ReconciliationIssue[];
+  resolutions: ReconciliationResolution[];
+}
+```
+
+Use case:
+- Persist `reconciledState` as your canonical session state.
+- Use `issues` as immediate feedback when AI-generated schemas introduce invalid data.
+
+#### `StateDiff`
+
+Represents a single change produced during reconciliation.
+
+```typescript
+interface StateDiff {
+  nodeId: string;
+  type: ViewDiff;
+  oldValue?: unknown;
+  newValue?: unknown;
+  reason?: string;
+}
+```
+
+Use case:
+- Render "what changed" timelines in developer tooling.
+- Trigger downstream automation only for specific diff types (for example, `migrated` or `removed`).
+
+#### `ReconciliationResolution`
+
+Per-node trace of how a value was resolved.
+
+```typescript
+interface ReconciliationResolution {
+  nodeId: string;
+  priorId: string | null;
+  matchedBy: 'id' | 'key' | null;
+  priorType: string | null;
+  newType: string;
+  resolution: DataResolution;
+  priorValue: unknown;
+  reconciledValue: unknown;
+}
+```
+
+Use case:
+- Explain why a node was carried, migrated, detached, added, or restored.
+- Audit matching reliability (`matchedBy: 'id' | 'key'`) over real AI traffic.
+
+#### `ReconciliationIssue`
+
+Structured issue emitted by reconciliation and validation.
+
+```typescript
+interface ReconciliationIssue {
+  severity: IssueSeverity;
+  nodeId?: string;
+  message: string;
+  code: IssueCode;
+}
+```
+
+Use case:
+- Surface warning/error banners in debugging UIs.
+- Build alerting and metrics keyed by `code` and `severity`.
+
+#### `MigrationStrategy`
+
+User-implemented function for transforming payloads when a node schema changes.
+
+```typescript
+type MigrationStrategy = (
+  nodeId: string,
+  priorNode: ViewNode,
+  newNode: ViewNode,
+  priorValue: unknown
+) => unknown;
+```
+
+Use case:
+- Convert old value shapes into new structures when AI changes a node contract.
+- Keep business-critical data continuity through deliberate, explicit transformations.
+
+Note:
+- `NodeResolutionAccumulator` is also exported but is primarily an internal accumulator used by the reconciliation loop.
+
+### 3) Context and Matching Utilities (Advanced)
+
+Exported from `src/lib/context.ts`.
+
+#### `buildReconciliationContext()`
+
+Indexes new and prior views into id/key lookup maps used by matching and resolution.
+
+```typescript
+function buildReconciliationContext(
+  newView: ViewDefinition,
+  priorView: ViewDefinition | null
+): ReconciliationContext;
+```
+
+Use case:
+- Build custom reconciliation inspectors or diagnostics outside the main pipeline.
+- Precompute matching context once when running specialized custom workflows.
+
+#### `findPriorNode()`
+
+Finds the best prior-view match for a new node using scoped id, key, and suffix fallback rules.
+
+```typescript
+function findPriorNode(
+  ctx: ReconciliationContext,
+  newNode: ViewNode
+): ViewNode | null;
+```
+
+Use case:
+- Debug matching behavior node-by-node.
+- Validate whether your semantic key strategy is stable across generated layouts.
+
+#### `buildPriorValueLookupByIdAndKey()`
+
+Creates a lookup map that carries prior values by id and semantic key remapping.
+
+```typescript
+function buildPriorValueLookupByIdAndKey(
+  priorData: DataSnapshot,
+  ctx: ReconciliationContext
+): Map<string, unknown>;
+```
+
+Use case:
+- Reuse runtime value remapping logic in custom reconciliation or simulation tooling.
+
+#### `determineNodeMatchStrategy()`
+
+Returns how a new node matched to prior state (`id`, `key`, or `null`).
+
+```typescript
+function determineNodeMatchStrategy(
+  ctx: ReconciliationContext,
+  newNode: ViewNode,
+  priorNode: ViewNode | null
+): 'id' | 'key' | null;
+```
+
+Use case:
+- Instrument matching quality and identify over-reliance on id-only carries.
+
+#### `resolvePriorSnapshotId()`
+
+Resolves a snapshot key to a unique scoped prior node id when possible.
+
+```typescript
+function resolvePriorSnapshotId(
+  ctx: ReconciliationContext,
+  priorId: string
+): string | null;
+```
+
+Use case:
+- Normalize snapshot keys before custom diffing, reconciliation, or migration passes.
+
+#### `findNewNodeByPriorNode()`
+
+Maps a prior node forward to its best new-view candidate by key.
+
+```typescript
+function findNewNodeByPriorNode(
+  ctx: ReconciliationContext,
+  priorNode: ViewNode
+): ViewNode | null;
+```
+
+Use case:
+- Build forward-mapping analyzers for node removals, moves, and restores.
+
+#### `collectDuplicateIssues()`
+
+Scans a view tree for duplicate ids/keys and returns structured issues.
+
+```typescript
+function collectDuplicateIssues(nodes: ViewNode[]): ReconciliationIssue[];
+```
+
+Use case:
+- Run preflight validation on AI-generated views before invoking `reconcile()`.
+
+### 4) Validation
+
+Exported from `src/lib/reconciliation/validator.ts`.
+
+#### `validateNodeValue()`
+
+Validates a node value against view constraints (`required`, numeric bounds, length bounds, pattern).
+
+```typescript
+function validateNodeValue(
+  node: ViewNode,
+  state: NodeValue | undefined
+): ReconciliationIssue[];
+```
+
+Use case:
+- Reuse runtime-consistent validation semantics in custom form flows and pre-submit checks.
+- Re-validate values independently when users edit data outside the default reconciliation loop.
+
+## License
+
+MIT © CooperContinuum

package/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/reconcile.js';
+export * from './lib/types.js';
+export * from './lib/context.js';
+export * from './lib/reconciliation/validator.js';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../packages/runtime/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mCAAmC,CAAC"}

package/index.js

@@ -0,0 +1,4 @@
+export * from './lib/reconcile.js';
+export * from './lib/types.js';
+export * from './lib/context.js';
+export * from './lib/reconciliation/validator.js';

package/lib/context.d.ts

@@ -0,0 +1,128 @@
+import { type DataSnapshot, type ViewDefinition, type ViewNode } from '@continuum/contract';
+import type { ReconciliationIssue } from './types.js';
+/**
+ * Scans a view tree for duplicate ids/keys and traversal-level issues.
+ *
+ * Useful for preflight checks when validating generated views before running
+ * full reconciliation.
+ *
+ * @param nodes Root nodes from a view definition.
+ * @returns Aggregated issues for duplicates and traversal anomalies.
+ */
+export declare function collectDuplicateIssues(nodes: ViewNode[]): ReconciliationIssue[];
+export interface ReconciliationContext {
+    /**
+     * New view currently being reconciled.
+     */
+    newView: ViewDefinition;
+    /**
+     * Prior view used for matching, if available.
+     */
+    priorView: ViewDefinition | null;
+    /**
+     * New-view node lookup keyed by scoped node id.
+     */
+    newById: Map<string, ViewNode>;
+    /**
+     * New-view node lookup keyed by semantic key (scoped when needed).
+     */
+    newByKey: Map<string, ViewNode>;
+    /**
+     * Prior-view node lookup keyed by scoped node id.
+     */
+    priorById: Map<string, ViewNode>;
+    /**
+     * Prior-view node lookup keyed by semantic key (scoped when needed).
+     */
+    priorByKey: Map<string, ViewNode>;
+    /**
+     * New-view indexed ids grouped by raw node id.
+     */
+    newIdsByRawId: Map<string, string[]>;
+    /**
+     * Prior-view indexed ids grouped by raw node id.
+     */
+    priorIdsByRawId: Map<string, string[]>;
+    /**
+     * Stable mapping from new node objects to scoped node ids.
+     */
+    newNodeIds: WeakMap<ViewNode, string>;
+    /**
+     * Stable mapping from prior node objects to scoped node ids.
+     */
+    priorNodeIds: WeakMap<ViewNode, string>;
+    /**
+     * Frequency table for keys in the new view.
+     */
+    newKeyCounts: Map<string, number>;
+    /**
+     * Frequency table for keys in the prior view.
+     */
+    priorKeyCounts: Map<string, number>;
+    /**
+     * Issues captured while indexing both view trees.
+     */
+    issues: ReconciliationIssue[];
+}
+/**
+ * Builds lookup maps used by the reconciliation matching pipeline.
+ *
+ * Context indexes scoped ids and semantic keys so downstream logic can resolve
+ * carry/migrate/restore decisions in O(1) lookups.
+ *
+ * @param newView Target view for this reconciliation cycle.
+ * @param priorView Previous view to compare against, if available.
+ * @returns Indexed reconciliation context consumed by resolver stages.
+ */
+export declare function buildReconciliationContext(newView: ViewDefinition, priorView: ViewDefinition | null): ReconciliationContext;
+/**
+ * Resolves the best prior-view match for a node in the new view.
+ *
+ * Matching is attempted in deterministic order: scoped id, semantic key,
+ * dot-suffix key fallback, and unique raw-id fallback.
+ *
+ * @param ctx Reconciliation context with prior/new indexes.
+ * @param newNode Node from the new view to resolve against prior view.
+ * @returns Matched prior node, or null when no candidate can be resolved.
+ */
+export declare function findPriorNode(ctx: ReconciliationContext, newNode: ViewNode): ViewNode | null;
+/**
+ * Builds a value lookup that supports id-based and key-based carry.
+ *
+ * The returned map contains direct prior ids plus remapped ids when semantic
+ * key matches indicate the value should move to a different node id.
+ *
+ * @param priorData Previous data snapshot.
+ * @param ctx Reconciliation context built from prior/new views.
+ * @returns Value lookup used by node resolution.
+ */
+export declare function buildPriorValueLookupByIdAndKey(priorData: DataSnapshot, ctx: ReconciliationContext): Map<string, unknown>;
+/**
+ * Reports whether a match was resolved by id or by semantic key.
+ *
+ * This metadata is attached to reconciliation resolution records so consumers
+ * can explain why a value was carried/migrated/restored.
+ *
+ * @param ctx Reconciliation context with id/key indexes.
+ * @param newNode Node from the new view.
+ * @param priorNode Prior match candidate for the new node.
+ * @returns `id`, `key`, or null when no prior node exists.
+ */
+export declare function determineNodeMatchStrategy(ctx: ReconciliationContext, newNode: ViewNode, priorNode: ViewNode | null): 'id' | 'key' | null;
+/**
+ * Resolves a snapshot value key to a unique scoped prior node id.
+ *
+ * @param ctx Reconciliation context with prior-view indexes.
+ * @param priorId Snapshot key from `priorData.values`.
+ * @returns Scoped prior id when uniquely resolvable; otherwise null.
+ */
+export declare function resolvePriorSnapshotId(ctx: ReconciliationContext, priorId: string): string | null;
+/**
+ * Finds the best new-view node candidate for a given prior node by key.
+ *
+ * @param ctx Reconciliation context with new-view key indexes.
+ * @param priorNode Prior-view node to map forward.
+ * @returns Matching new-view node, or null when no key-compatible node exists.
+ */
+export declare function findNewNodeByPriorNode(ctx: ReconciliationContext, priorNode: ViewNode): ViewNode | null;
+//# sourceMappingURL=context.d.ts.map

package/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../packages/runtime/src/lib/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAA+B,MAAM,qBAAqB,CAAC;AACzH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,mBAAmB,EAAE,CA+B/E;AAED,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,OAAO,EAAE,cAAc,CAAC;IACxB;;OAEG;IACH,SAAS,EAAE,cAAc,GAAG,IAAI,CAAC;IACjC;;OAEG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC/B;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAChC;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjC;;OAEG;IACH,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC;;OAEG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACrC;;OAEG;IACH,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACtC;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC;;OAEG;IACH,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC;;OAEG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC;;OAEG;IACH,MAAM,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,cAAc,GAAG,IAAI,GAC/B,qBAAqB,CAuDvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,qBAAqB,EAC1B,OAAO,EAAE,QAAQ,GAChB,QAAQ,GAAG,IAAI,CA4CjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,YAAY,EACvB,GAAG,EAAE,qBAAqB,GACzB,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAsBtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,qBAAqB,EAC1B,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,QAAQ,GAAG,IAAI,GACzB,IAAI,GAAG,KAAK,GAAG,IAAI,CAsBrB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,qBAAqB,EAC1B,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAEf;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,qBAAqB,EAC1B,SAAS,EAAE,QAAQ,GAClB,QAAQ,GAAG,IAAI,CAUjB"}