@happyvertical/smrt-svelte 0.37.8 → 0.37.10

package/dist/internal/logger.js

@@ -1,12 +1,37 @@
 /**
  * Shared package logger for `@happyvertical/smrt-svelte`.
  *
- * Browser-safe: the `@happyvertical/logger` console adapter pulls no Node
- * built-ins and its `@sentry/node` integration is an optional peer that is
- * never imported here. Centralising the instance keeps voice/AI error reporting
- * consistent across the form components (mic permission denials, STT init
- * failures) instead of swallowing them in empty `catch` blocks or scattering
- * raw `console.*` calls.
+ * This module is browser-reachable (Provider + the form components import it),
+ * so it must never touch Node globals at module scope. `createLogger()` reads
+ * `HAVE_LOGGER_LEVEL` from `process.env`, and `process` does not exist in
+ * browsers — calling it during module init threw
+ * `ReferenceError: process is not defined` under `vite dev` and killed
+ * client-side hydration for every consuming app. The logger is therefore
+ * created lazily on first use, and the env-config path is only consulted when
+ * a usable `process.env` actually exists; browsers get the plain console
+ * logger at the same level.
+ *
+ * Centralising the instance keeps voice/AI error reporting consistent across
+ * the form components (mic permission denials, STT init failures) instead of
+ * swallowing them in empty `catch` blocks or scattering raw `console.*` calls.
  */
-import { createLogger } from '@happyvertical/logger';
-export const logger = createLogger({ level: 'warn' });
+import { ConsoleLogger, createLogger, } from '@happyvertical/logger';
+const LEVEL = 'warn';
+let instance;
+function resolveLogger() {
+    if (!instance) {
+        const hasProcessEnv = typeof process !== 'undefined' &&
+            typeof process.env === 'object' &&
+            process.env !== null;
+        instance = hasProcessEnv
+            ? createLogger({ level: LEVEL })
+            : new ConsoleLogger(LEVEL);
+    }
+    return instance;
+}
+export const logger = {
+    debug: (message, context) => resolveLogger().debug(message, context),
+    info: (message, context) => resolveLogger().info(message, context),
+    warn: (message, context) => resolveLogger().warn(message, context),
+    error: (message, context) => resolveLogger().error(message, context),
+};

package/dist/internal/logger.test.js

@@ -0,0 +1,54 @@
+/**
+ * Regression coverage for the "process is not defined" hydration killer.
+ *
+ * `internal/logger` is browser-reachable through Provider and the form
+ * components, and `@happyvertical/logger`'s `createLogger()` eagerly reads
+ * `process.env` (HAVE_LOGGER_LEVEL). Constructing the logger at module scope
+ * therefore threw during Vite dev pre-bundle evaluation in browsers and killed
+ * client-side hydration for every consuming app.
+ *
+ * vite-node's module runner itself needs `process.platform` to load inline
+ * modules, so the test cannot delete `process` outright the way a real browser
+ * lacks it. Stubbing it to an object without a usable `env` reproduces the
+ * same failure mode: the pre-fix module init still blows up at import time
+ * (`Object.keys(process.env)`), and the fixed guard must route to the plain
+ * console logger.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+describe('internal/logger', () => {
+    beforeEach(() => {
+        vi.resetModules();
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+    it('imports and logs without a usable process.env (browser)', async () => {
+        vi.stubGlobal('process', {});
+        const { logger } = await import('./logger.js');
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        logger.warn('mic permission denied');
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn.mock.calls[0][0]).toContain('mic permission denied');
+    });
+    it('filters below the warn level in the browser fallback', async () => {
+        vi.stubGlobal('process', {});
+        const { logger } = await import('./logger.js');
+        const debug = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const info = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const error = vi.spyOn(console, 'error').mockImplementation(() => { });
+        logger.debug('below threshold');
+        logger.info('below threshold');
+        logger.error('stt init failed');
+        expect(debug).not.toHaveBeenCalled();
+        expect(info).not.toHaveBeenCalled();
+        expect(error).toHaveBeenCalledTimes(1);
+    });
+    it('logs through the env-aware logger when process exists (node/SSR)', async () => {
+        const { logger } = await import('./logger.js');
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        logger.warn('stt init failed', { adapter: 'whisper-cpp' });
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn.mock.calls[0][0]).toContain('stt init failed');
+    });
+});

package/dist/web/__tests__/harness.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+/**
+ * Test harness — invokes liveCollection() inside a component init scope so the
+ * `$effect` that `useLiveQuery` installs wires up correctly, then hands the
+ * returned reactive view back to the test via the `onReady` callback prop.
+ */
+import type { SmrtWebCollection } from '@happyvertical/smrt-web';
+import {
+  type LiveCollection,
+  liveCollection,
+} from '../live-collection.svelte.js';
+
+interface Props {
+  handle: SmrtWebCollection<Record<string, unknown>>;
+  onReady: (view: LiveCollection<Record<string, unknown>>) => void;
+}
+
+const props: Props = $props();
+// This harness intentionally snapshots the handle during setup.
+// svelte-ignore state_referenced_locally
+const view = liveCollection(props.handle);
+// This harness intentionally snapshots the callback during setup.
+// svelte-ignore state_referenced_locally
+props.onReady(view);
+</script>

package/dist/web/__tests__/harness.svelte.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Test harness — invokes liveCollection() inside a component init scope so the
+ * `$effect` that `useLiveQuery` installs wires up correctly, then hands the
+ * returned reactive view back to the test via the `onReady` callback prop.
+ */
+import type { SmrtWebCollection } from '@happyvertical/smrt-web';
+import { type LiveCollection } from '../live-collection.svelte.js';
+interface Props {
+    handle: SmrtWebCollection<Record<string, unknown>>;
+    onReady: (view: LiveCollection<Record<string, unknown>>) => void;
+}
+declare const Harness: import("svelte").Component<Props, {}, "">;
+type Harness = ReturnType<typeof Harness>;
+export default Harness;
+//# sourceMappingURL=harness.svelte.d.ts.map

package/dist/web/__tests__/harness.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/harness.svelte.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,8BAA8B,CAAC;AAGtC,UAAU,KAAK;IACb,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,OAAO,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC;CAClE;AAkBD,QAAA,MAAM,OAAO,2CAAwC,CAAC;AACtD,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC;AAC1C,eAAe,OAAO,CAAC"}

package/dist/web/__tests__/live-collection.svelte.test.js

@@ -0,0 +1,184 @@
+/**
+ * Behavior tests for the Svelte 5 live-query binding over `@happyvertical/smrt-web`
+ * (#1761, slice A).
+ *
+ * Per repo policy only the network boundary is mocked: the generated REST
+ * client fetchers passed to `createSmrtCollection`. Everything else — the
+ * client-data engine collection, the real `useLiveQuery` live view, its
+ * transactions, and the runes reactivity — is real. The binding is exercised
+ * through a thin host component (`harness.svelte`) so `useLiveQuery`'s internal
+ * `$effect` has a genuine component-init scope, matching this package's other
+ * runes-composable tests.
+ */
+import { createSmrtCollection, } from '@happyvertical/smrt-web';
+import { flushSync, mount, unmount } from 'svelte';
+import { afterEach, describe, expect, it } from 'vitest';
+import Harness from './harness.svelte';
+function productDefinition(name) {
+    return {
+        name,
+        className: 'Product',
+        endpoint: `/${name}`,
+        idField: 'id',
+        actions: ['create', 'get', 'list', 'update'],
+        fields: {
+            name: { type: 'text', required: true },
+            price: { type: 'decimal' },
+        },
+    };
+}
+/**
+ * Scripted stand-in for `createClient('/api/v1').products`: resolves like the
+ * generated fetchers (JSON payloads, `{ error }` bodies on failure, never
+ * rejects on HTTP status) so the engine's optimistic/rollback path is real.
+ */
+function makeScriptedFetchers(initialRows) {
+    const serverRows = [...initialRows];
+    let failNextCreate = null;
+    const fetchers = {
+        list: async () => serverRows.map((row) => ({ ...row })),
+        create: async (data) => {
+            if (failNextCreate) {
+                const error = failNextCreate;
+                failNextCreate = null;
+                return { error };
+            }
+            const created = { ...data, id: `server-${serverRows.length + 1}` };
+            serverRows.push(created);
+            return { ...created };
+        },
+    };
+    return {
+        fetchers,
+        failCreateWith(message) {
+            failNextCreate = message;
+        },
+    };
+}
+function mountView(handle) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    let exposed = undefined;
+    const component = mount(Harness, {
+        target,
+        props: {
+            // The harness is typed against the base object shape; ProductData is a
+            // structural subtype, so this cross-cast is purely nominal.
+            handle: handle,
+            onReady: (view) => {
+                exposed = view;
+            },
+        },
+    });
+    return {
+        view: exposed,
+        teardown: () => {
+            unmount(component);
+            target.remove();
+        },
+    };
+}
+describe('liveCollection', () => {
+    const cleanup = [];
+    afterEach(async () => {
+        for (const fn of cleanup.splice(0))
+            fn();
+    });
+    function track(mounted) {
+        cleanup.push(mounted.teardown);
+        return mounted.view;
+    }
+    it('exposes live rows that reflect the collection as plain DTOs (no $-prefixed keys)', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'p1', name: 'Widget', price: 9.99 },
+        ]);
+        const collection = createSmrtCollection(productDefinition('live-dto'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const view = track(mountView(collection));
+        await collection.preload();
+        flushSync();
+        expect(view.isReady).toBe(true);
+        expect(view.status).toBe('ready');
+        expect(view.rows).toHaveLength(1);
+        const [row] = view.rows;
+        // Exact equality (not toMatchObject): must be a plain DTO — no
+        // $synced/$origin/$key/$collectionId leaking through the engine live view.
+        expect(row).toEqual({ id: 'p1', name: 'Widget', price: 9.99 });
+        expect(Object.keys(row).some((key) => key.startsWith('$'))).toBe(false);
+        expect(JSON.stringify(row)).not.toContain('$');
+    });
+    it('reports loading before the first read resolves', () => {
+        const scripted = makeScriptedFetchers([{ id: 'p1', name: 'Widget' }]);
+        const collection = createSmrtCollection(productDefinition('live-loading'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+            // Do not eagerly preload — observe the initial loading status.
+        });
+        const view = track(mountView(collection));
+        flushSync();
+        expect(view.isLoading).toBe(true);
+        expect(view.status).toBe('loading');
+        expect(view.error).toBeNull();
+    });
+    it('reflects an optimistic insert reactively and settles its pending state', async () => {
+        const scripted = makeScriptedFetchers([{ id: 'p1', name: 'Widget' }]);
+        const collection = createSmrtCollection(productDefinition('live-insert'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const view = track(mountView(collection));
+        await collection.preload();
+        flushSync();
+        expect(view.rows).toHaveLength(1);
+        const mutation = view.insert({
+            id: 'local-1',
+            name: 'Gadget',
+            price: 19.99,
+        });
+        flushSync();
+        // Optimistic row is visible in the live rows synchronously, and pending.
+        expect(view.rows.map((row) => row.name).sort()).toEqual([
+            'Gadget',
+            'Widget',
+        ]);
+        expect(mutation.pending).toBe(true);
+        expect(mutation.settled).toBe(false);
+        await mutation.done;
+        flushSync();
+        // Persisted: pending cleared, no error, and the server-assigned row is in.
+        expect(mutation.pending).toBe(false);
+        expect(mutation.settled).toBe(true);
+        expect(mutation.error).toBeNull();
+        const gadget = view.rows.find((row) => row.name === 'Gadget');
+        expect(gadget?.id).toBe('server-2');
+        // Still plain DTOs after the mutation reconciles.
+        expect(Object.keys(gadget ?? {}).some((key) => key.startsWith('$'))).toBe(false);
+    });
+    it('rolls the optimistic row back and surfaces the error when the create fails', async () => {
+        const scripted = makeScriptedFetchers([{ id: 'p1', name: 'Widget' }]);
+        const collection = createSmrtCollection(productDefinition('live-rollback'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const view = track(mountView(collection));
+        await collection.preload();
+        flushSync();
+        scripted.failCreateWith('Validation failed: name is reserved');
+        const mutation = view.insert({ id: 'local-2', name: 'FAIL Gadget' });
+        flushSync();
+        expect(view.rows.some((row) => row.name === 'FAIL Gadget')).toBe(true);
+        // `done` resolves (never rejects) on settle — the failure is surfaced only
+        // reactively via `error`, so a reactive-only consumer risks no unhandled
+        // rejection.
+        await expect(mutation.done).resolves.toBeUndefined();
+        flushSync();
+        // Optimistic state rolled back reactively; the mutation carries the error.
+        expect(view.rows.some((row) => row.name === 'FAIL Gadget')).toBe(false);
+        expect(view.rows).toHaveLength(1);
+        expect(mutation.pending).toBe(false);
+        expect(mutation.settled).toBe(true);
+        expect(String(mutation.error?.message)).toContain('Validation failed: name is reserved');
+    });
+});

package/dist/web/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@happyvertical/smrt-svelte/web` — Svelte 5 live-query bindings for the
+ * `@happyvertical/smrt-web` browser client data runtime (#1761, slice A).
+ *
+ * Consumers turn a `SmrtWebCollection<T>` into runes-reactive live-query state
+ * plus mutation helpers WITHOUT importing TanStack. The client-data engine
+ * stays an implementation detail of the runtime + this binding; nothing here
+ * re-exports an `@tanstack/*` type.
+ *
+ * @packageDocumentation
+ */
+export { type LiveCollection, type LiveCollectionMutation, type LiveCollectionOptions, type LiveCollectionStatus, liveCollection, } from './live-collection.svelte.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC"}

package/dist/web/index.js

@@ -0,0 +1,12 @@
+/**
+ * `@happyvertical/smrt-svelte/web` — Svelte 5 live-query bindings for the
+ * `@happyvertical/smrt-web` browser client data runtime (#1761, slice A).
+ *
+ * Consumers turn a `SmrtWebCollection<T>` into runes-reactive live-query state
+ * plus mutation helpers WITHOUT importing TanStack. The client-data engine
+ * stays an implementation detail of the runtime + this binding; nothing here
+ * re-exports an `@tanstack/*` type.
+ *
+ * @packageDocumentation
+ */
+export { liveCollection, } from './live-collection.svelte.js';

package/dist/web/live-collection.svelte.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Svelte 5 live-query bindings for `@happyvertical/smrt-web` (#1761, slice A).
+ *
+ * Turns a SMRT-owned {@link SmrtWebCollection} into runes-reactive live-query
+ * state plus mutation helpers, so a consumer writes reactive components WITHOUT
+ * importing TanStack. The client-data engine (`@tanstack/db` +
+ * `@tanstack/svelte-db`) is used only inside this module — its types never
+ * appear on the public surface, mirroring smrt-web's own engine-absorption
+ * boundary (ratified condition for #1761).
+ *
+ * Two engine facts drive the shape of this file:
+ *
+ * 1. `useLiveQuery` internally uses `$state`/`$derived`/`$effect`, so it (and
+ *    therefore {@link liveCollection}) MUST be called during Svelte component
+ *    initialization — exactly like this package's other `use*` composables.
+ *    Its internal `$effect` binds to the calling component's lifecycle, so the
+ *    live subscription is torn down automatically when the component unmounts.
+ *
+ * 2. `@tanstack/svelte-db` live-query rows carry ENUMERABLE engine virtual
+ *    props (`$key`/`$origin`/`$synced`/`$collectionId`) that would otherwise
+ *    escape through spread or JSON. Every exposed row is projected to a plain
+ *    DTO by stripping `$`-prefixed keys (the `$` prefix is reserved for the
+ *    engine; SMRT columns never begin with it), mirroring smrt-web's internal
+ *    `toPlainRow`.
+ */
+import { type SmrtWebCollection, type SmrtWebRow } from '@happyvertical/smrt-web';
+/**
+ * Lifecycle status of a {@link LiveCollection}'s underlying read.
+ *
+ * - `loading` — the first load has not completed yet (also covers the engine's
+ *   pre-start `idle` and post-teardown `cleaned-up` phases).
+ * - `ready` — data has arrived and the collection is live.
+ * - `error` — the read failed during sync initialization.
+ */
+export type LiveCollectionStatus = 'loading' | 'ready' | 'error';
+/**
+ * A live, runes-reactive view over a {@link SmrtWebCollection}. Read `rows`,
+ * `status`, and `error` directly in markup — they update as the collection
+ * changes. Do NOT destructure this object (Svelte 5 reactivity is lost on
+ * destructure); read through the object, e.g. `view.rows`, or wrap in
+ * `$derived`.
+ */
+export interface LiveCollection<TData extends object> {
+    /** Live rows as plain DTOs (no `$`-prefixed engine props), insertion order. */
+    readonly rows: ReadonlyArray<SmrtWebRow<TData>>;
+    /** Coarse lifecycle status of the underlying read. */
+    readonly status: LiveCollectionStatus;
+    /**
+     * The most recent error surfaced by the underlying read, or `null`. Mutation
+     * errors are surfaced on the {@link LiveCollectionMutation} returned by the
+     * mutation helpers, not here.
+     */
+    readonly error: unknown;
+    /** True while the first load has not completed (`status === 'loading'`). */
+    readonly isLoading: boolean;
+    /** True once data has arrived (`status === 'ready'`). */
+    readonly isReady: boolean;
+    /** True when the underlying read failed (`status === 'error'`). */
+    readonly isError: boolean;
+    /**
+     * Optimistically insert a row and persist it through the collection's create
+     * surface. The row is visible in `rows` synchronously; the returned handle's
+     * reactive `pending`/`error` track the server outcome and a failed create
+     * rolls the optimistic row back automatically.
+     */
+    insert(row: SmrtWebRow<TData>): LiveCollectionMutation;
+}
+/**
+ * Reactive handle to one in-flight mutation. Read `pending`/`error`/`settled`
+ * in markup to drive optimistic UI; await {@link done} to observe completion
+ * imperatively. All fields are SMRT-owned — no engine transaction leaks.
+ */
+export interface LiveCollectionMutation {
+    /** True while the write is persisting; flips to false on success or failure. */
+    readonly pending: boolean;
+    /** True once the write has settled (persisted or rolled back). */
+    readonly settled: boolean;
+    /** The rollback error if the write failed, else `null`. */
+    readonly error: unknown;
+    /**
+     * Resolves when the write settles (persisted or rolled back); read
+     * {@link error} (or {@link settled}) for the outcome. Never rejects, so
+     * reactive-only consumers never risk an unhandled rejection.
+     */
+    readonly done: Promise<void>;
+}
+/** Options for {@link liveCollection}. Reserved for forward-compatible growth. */
+export interface LiveCollectionOptions {
+    /**
+     * Trigger the collection's first load eagerly when the binding is created,
+     * rather than waiting for the engine's first read. Defaults to `true`.
+     */
+    preload?: boolean;
+}
+/**
+ * Create a runes-reactive live view over a {@link SmrtWebCollection}.
+ *
+ * MUST be called during Svelte component initialization (it delegates to
+ * `@tanstack/svelte-db`'s `useLiveQuery`, which sets up a `$effect`). The live
+ * subscription is torn down automatically when the calling component unmounts.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { createSmrtCollection } from '@happyvertical/smrt-web';
+ *   import { liveCollection } from '@happyvertical/smrt-svelte/web';
+ *   import { productsDefinition } from '@happyvertical/smrt-virt-web';
+ *
+ *   const products = createSmrtCollection(productsDefinition, {});
+ *   const view = liveCollection(products);
+ *
+ *   async function add() {
+ *     const m = view.insert({ id: crypto.randomUUID(), name: 'New' });
+ *     await m.done.catch(() => {}); // error also reflected on m.error
+ *   }
+ * </script>
+ *
+ * {#if view.isLoading}
+ *   <p>Loading…</p>
+ * {:else if view.isError}
+ *   <p>Failed: {String(view.error)}</p>
+ * {:else}
+ *   <ul>
+ *     {#each view.rows as row (row.id)}
+ *       <li>{row.name}</li>
+ *     {/each}
+ *   </ul>
+ * {/if}
+ * ```
+ */
+export declare function liveCollection<TData extends object>(handle: SmrtWebCollection<TData>, options?: LiveCollectionOptions): LiveCollection<TData>;
+//# sourceMappingURL=live-collection.svelte.d.ts.map

package/dist/web/live-collection.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-collection.svelte.d.ts","sourceRoot":"","sources":["../../src/web/live-collection.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,UAAU,EAChB,MAAM,yBAAyB,CAAC;AASjC;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,SAAS,MAAM;IAClD,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;IAChD,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,sBAAsB,CAAC;CACxD;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAkCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,MAAM,EACjD,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,EAChC,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAAC,KAAK,CAAC,CA6DvB"}