@feltdb/core 0.4.4 → 0.4.6

package/dist/migrate/types/index.d.ts

@@ -0,0 +1,228 @@
+export declare const CLASSIFICATIONS: readonly ["STATE", "HISTORY", "RELATIONSHIP", "MATERIALIZED", "BLOB_REFERENCE", "SECRET_REFERENCE", "EXTERNAL_STATE", "OPERATIONAL", "REMOVE"];
+export type Classification = typeof CLASSIFICATIONS[number];
+export type Readiness = 'NEW' | 'ANALYZED' | 'CLASSIFIED' | 'APPROVED' | 'CAPABILITY_READY' | 'PLAN_READY' | 'GENERATED' | 'MIGRATED' | 'STATE_CONTRACT_READY' | 'UI_WIRING_READY' | 'POSTGRES_RUNTIME_FREE' | 'PROVEN' | 'BENCHMARKED' | 'CUTOVER_READY' | 'CUTOVER_COMPLETE';
+export interface Column {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    default?: string | null;
+    primaryKey?: boolean;
+    unique?: boolean;
+    sizeBytes?: number;
+}
+export interface ForeignKey {
+    columns: string[];
+    referencedTable: string;
+    referencedColumns: string[];
+}
+export interface Entity {
+    name: string;
+    columns: Column[];
+    primaryKey?: string[];
+    foreignKeys?: ForeignKey[];
+    indexes?: Array<{
+        name: string;
+        columns: string[];
+        unique?: boolean;
+    }>;
+    kind?: 'table' | 'view';
+}
+export interface SourceFinding {
+    file: string;
+    line: number;
+    kind: string;
+    value: string;
+    entities: string[];
+}
+export interface Analysis {
+    version: 1;
+    generatedAt: string;
+    sourceRoot: string;
+    entities: Entity[];
+    findings: SourceFinding[];
+    dependencies: Array<{
+        from: string;
+        to: string;
+    }>;
+    schemaHash: string;
+}
+export interface ClassifiedEntity {
+    entity: string;
+    classification: Classification;
+    confidence: number;
+    reasons: string[];
+    requiresApproval: boolean;
+}
+export interface ClassificationResult {
+    version: 1;
+    threshold: number;
+    entities: ClassifiedEntity[];
+    classificationHash: string;
+    approved: boolean;
+}
+export interface DomainEntity extends ClassifiedEntity {
+    authoritative: boolean;
+    target: string;
+    secretColumns: string[];
+    blobColumns: string[];
+}
+export interface DomainModel {
+    version: 1;
+    entities: DomainEntity[];
+    hash: string;
+}
+export interface PlanStep {
+    id: string;
+    entity: string;
+    classification: Classification;
+    dependsOn: string[];
+    order: number;
+    tenantKey?: string;
+}
+export interface MigrationPlan {
+    version: 1;
+    planHash: string;
+    steps: PlanStep[];
+}
+export interface StateConsumer {
+    id: string;
+    file: string;
+    line: number;
+    surface: string;
+    semantic: string;
+    source: 'legacy' | 'canonical' | 'unknown';
+    endpoint?: string;
+}
+export interface StateDomain {
+    name: string;
+    authoritativeState: string;
+    history?: string;
+    fields: Record<string, {
+        source: string;
+        canonical: string;
+    }>;
+    uiSurfaces: string[];
+    lifecycleStates: string[];
+    emptyWhen: string;
+    refresh: 'subscription' | 'poll' | 'request';
+    tenantKey?: string;
+}
+export interface StateContract {
+    contractVersion: '1.0';
+    contractHash: string;
+    generatedAt: string;
+    domains: StateDomain[];
+    consumers: StateConsumer[];
+    legacyConsumers: number;
+    canonicalConsumers: number;
+    unresolved: string[];
+}
+export interface Capabilities {
+    [name: string]: boolean;
+}
+export interface Checkpoint {
+    stepId: string;
+    status: 'pending' | 'running' | 'complete' | 'failed';
+    cursor?: string;
+    records: number;
+    error?: string;
+}
+export interface MigrationTelemetry {
+    timestamp: string;
+    stepId: string;
+    operation: string;
+    records: number;
+    durationMs: number;
+    tenant?: string;
+}
+export interface MigrationAdapter {
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    put(collection: string, id: string, value: unknown, options: {
+        idempotencyKey: string;
+        tenant?: string;
+    }): Promise<void>;
+    append(collection: string, id: string, value: unknown, options: {
+        idempotencyKey: string;
+        tenant?: string;
+    }): Promise<void>;
+    relate(collection: string, from: string, to: string, options: {
+        idempotencyKey: string;
+        tenant?: string;
+    }): Promise<void>;
+}
+export interface SourceAdapter {
+    read(entity: string, cursor?: string, tenant?: string): AsyncIterable<{
+        id: string;
+        value: Record<string, unknown>;
+        cursor?: string;
+    }>;
+}
+export interface FeltDBRuntimeContract {
+    mode: 'browser' | 'node' | 'self-hosted' | 'managed';
+    requiredEnvironment: string[];
+    healthCheck?: string;
+    persistence?: string;
+}
+export type DependencyClassification = 'RUNTIME' | 'MIGRATION_SOURCE' | 'LEGACY_FALLBACK' | 'TEST_ONLY' | 'BUILD_ONLY' | 'DEVELOPMENT_ONLY' | 'ROLLBACK_ONLY';
+export type RuntimeFindingCode = 'POSTGRES_RUNTIME_CONNECTION' | 'POSTGRES_RUNTIME_ENV' | 'POSTGRES_RUNTIME_URL' | 'POSTGRES_RUNTIME_CLIENT' | 'POSTGRES_RUNTIME_SQL' | 'POSTGRES_RUNTIME_STARTUP_DEPENDENCY' | 'POSTGRES_RUNTIME_HEALTHCHECK' | 'POSTGRES_RUNTIME_CONTAINER' | 'POSTGRES_RUNTIME_DEPLOYMENT_DEPENDENCY';
+export interface RuntimeDependencyFinding {
+    id: string;
+    code: RuntimeFindingCode;
+    file: string;
+    line: number;
+    classification: DependencyClassification;
+    runtime: boolean;
+    kind: 'environment' | 'connection' | 'sql' | 'startup' | 'healthcheck' | 'container' | 'deployment' | 'dependency';
+    evidence: string;
+    action: string;
+}
+export interface PostgresDependencyManifest {
+    version: 1;
+    generatedAt: string;
+    sourceRoot: string;
+    findings: RuntimeDependencyFinding[];
+    runtime: RuntimeDependencyFinding[];
+    migrationSource: RuntimeDependencyFinding[];
+    legacyFallback: RuntimeDependencyFinding[];
+    testOnly: RuntimeDependencyFinding[];
+    developmentOnly: RuntimeDependencyFinding[];
+    buildOnly: RuntimeDependencyFinding[];
+    rollbackOnly: RuntimeDependencyFinding[];
+    runtimeDependencyHash: string;
+    feltDbRuntime: FeltDBRuntimeContract;
+}
+export interface RuntimeDependencyProof {
+    postgresRuntimeDependency: boolean;
+    postgresConnections: number;
+    postgresSqlExecutions: number;
+    postgresEnvironmentVariables: number;
+    postgresStartupDependencies: number;
+    postgresHealthChecks: number;
+    postgresRuntimeContainers: number;
+    postgresRuntimeDeploymentReferences: number;
+    feltDbRuntime: boolean;
+    verifiedWithoutPostgres: boolean;
+    startupVerified: boolean;
+    recoveryVerified: boolean;
+    networkIsolationVerified: boolean;
+    runtimeDependencyHash: string;
+}
+export interface SherpaConfig {
+    sourceRoot: string;
+    artifactDir?: string;
+    schemaFile: string;
+    confidenceThreshold?: number;
+    classificationOverrides?: Record<string, Classification>;
+    tenantKeys?: Record<string, string>;
+    capabilities?: Capabilities;
+    requiredCapabilities?: string[];
+    stateDomains?: Array<Partial<StateDomain> & {
+        name: string;
+        authoritativeState: string;
+    }>;
+    strictStateContract?: boolean;
+    blobThresholdBytes?: number;
+    feltDbRuntime?: FeltDBRuntimeContract;
+    runtimeDependencyOverrides?: Record<string, DependencyClassification>;
+    runtimeVerificationModule?: string;
+}

package/dist/migrate/types/index.js

@@ -0,0 +1 @@
+export const CLASSIFICATIONS = ['STATE', 'HISTORY', 'RELATIONSHIP', 'MATERIALIZED', 'BLOB_REFERENCE', 'SECRET_REFERENCE', 'EXTERNAL_STATE', 'OPERATIONAL', 'REMOVE'];

package/dist/migrate/ui-wiring/index.d.ts

@@ -0,0 +1,18 @@
+import type { StateContract } from '../types/index.js';
+export interface CanonicalStateReader {
+    state(domain: string, id: string): Promise<Record<string, unknown> | undefined>;
+    history(domain: string, id: string): Promise<unknown[]>;
+    relationships?(domain: string, id: string): Promise<unknown[]>;
+}
+export declare function createCanonicalAdapter(contract: StateContract, reader: CanonicalStateReader): {
+    read(domainName: string, id: string): Promise<{
+        status: unknown;
+        currentAction: unknown;
+        plan: unknown;
+        activity: unknown[];
+        history: unknown[];
+        result: unknown;
+        relationships: unknown[];
+        empty: boolean;
+    }>;
+};

package/dist/migrate/ui-wiring/index.js

@@ -0,0 +1,2 @@
+export function createCanonicalAdapter(contract, reader) { return { async read(domainName, id) { const domain = contract.domains.find(d => d.name === domainName); if (!domain)
+        throw new Error(`Unknown canonical domain: ${domainName}`); const [state, history, relationships] = await Promise.all([reader.state(domain.authoritativeState, id), domain.history ? reader.history(domain.history, id) : Promise.resolve([]), reader.relationships?.(domainName, id) ?? Promise.resolve([])]); return { status: state?.status, currentAction: state?.currentAction, plan: state?.plan, activity: history, history, result: state?.result, relationships, empty: !state && history.length === 0 }; } }; }

package/dist/migrate/util.d.ts

@@ -0,0 +1,5 @@
+export declare function stable(value: unknown): string;
+export declare function hash(value: unknown): string;
+export declare function json<T>(file: string): Promise<T>;
+export declare function writeJson(file: string, value: unknown): Promise<void>;
+export declare const artifact: (dir: string, name: string) => string;

package/dist/migrate/util.js

@@ -0,0 +1,10 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export function stable(value) { if (Array.isArray(value))
+    return `[${value.map(stable).join(',')}]`; if (value && typeof value === 'object')
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stable(v)}`).join(',')}}`; return JSON.stringify(value); }
+export function hash(value) { return createHash('sha256').update(stable(value)).digest('hex'); }
+export async function json(file) { return JSON.parse(await readFile(file, 'utf8')); }
+export async function writeJson(file, value) { await mkdir(dirname(file), { recursive: true }); await writeFile(file, JSON.stringify(value, null, 2) + '\n'); }
+export const artifact = (dir, name) => join(dir, name);

package/dist/react/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @feltdb/react - React Hooks for FeltDB
+ */
+export * from './useFeltDB.js';
+export * from './useCollection.js';
+export * from './useCapability.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/react/index.js

@@ -0,0 +1,6 @@
+/**
+ * @feltdb/react - React Hooks for FeltDB
+ */
+export * from './useFeltDB.js';
+export * from './useCollection.js';
+export * from './useCapability.js';

package/dist/react/useCapability.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hook for executing FeltDB capabilities
+ */
+import type { Capability } from '@feltdb/core';
+export declare function useCapability<TArgs extends any[] = any[], TResult = any>(capability: Capability | undefined): {
+    execute: (...args: TArgs) => Promise<any>;
+    loading: boolean;
+    error: Error | null;
+    result: TResult | null;
+};
+//# sourceMappingURL=useCapability.d.ts.map

package/dist/react/useCapability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCapability.d.ts","sourceRoot":"","sources":["../src/useCapability.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,wBAAgB,aAAa,CAAC,KAAK,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,OAAO,GAAG,GAAG,EACtE,UAAU,EAAE,UAAU,GAAG,SAAS;uBAOhB,KAAK;;;;EAsBxB"}

package/dist/react/useCapability.js

@@ -0,0 +1,30 @@
+/**
+ * Hook for executing FeltDB capabilities
+ */
+import { useCallback, useState } from 'react';
+export function useCapability(capability) {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const execute = useCallback(async (...args) => {
+        if (!capability) {
+            throw new Error('Capability not available');
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            const output = await capability.execute(...args);
+            setResult(output);
+            return output;
+        }
+        catch (err) {
+            const error = err;
+            setError(error);
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [capability]);
+    return { execute, loading, error, result };
+}

package/dist/react/useCollection.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hook for interacting with FeltDB collections
+ */
+import type { Collection } from '@feltdb/core';
+export interface UseCollectionOptions {
+    query?: any;
+    subscribe?: boolean;
+}
+export declare function useCollection<T = any>(collection: Collection<T>, options?: UseCollectionOptions): {
+    data: T[];
+    loading: boolean;
+    error: Error | null;
+    insert: (item: T) => Promise<void>;
+    update: (id: string, item: Partial<T>) => Promise<void>;
+    remove: (id: string) => Promise<void>;
+};
+//# sourceMappingURL=useCollection.d.ts.map

package/dist/react/useCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCollection.d.ts","sourceRoot":"","sources":["../src/useCollection.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,wBAAgB,aAAa,CAAC,CAAC,GAAG,GAAG,EACnC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,OAAO,CAAC,EAAE,oBAAoB;;;;mBA0Bf,CAAC;iBAaH,MAAM,QAAQ,OAAO,CAAC,CAAC,CAAC;iBAaxB,MAAM;EAapB"}

package/dist/react/useCollection.js

@@ -0,0 +1,69 @@
+/**
+ * Hook for interacting with FeltDB collections
+ */
+import { useCallback, useState, useEffect } from 'react';
+export function useCollection(collection, options) {
+    const [data, setData] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        let active = true;
+        setLoading(true);
+        collection
+            .find(options?.query || {})
+            .then((results) => {
+            if (active) {
+                setData(results);
+                setLoading(false);
+            }
+        })
+            .catch((err) => {
+            if (active) {
+                setError(err);
+                setLoading(false);
+            }
+        });
+        const unsubscribe = options?.subscribe === false ? undefined : collection.subscribe(() => {
+            void collection.find(options?.query || {}).then(results => {
+                if (active) {
+                    setData(results);
+                    setError(null);
+                    setLoading(false);
+                }
+            }).catch(err => { if (active)
+                setError(err); });
+        });
+        return () => { active = false; unsubscribe?.(); };
+    }, [collection, options?.query, options?.subscribe]);
+    const insert = useCallback(async (item) => {
+        try {
+            await collection.insert(item);
+            const updated = await collection.find(options?.query || {});
+            setData(updated);
+        }
+        catch (err) {
+            setError(err);
+        }
+    }, [collection, options?.query]);
+    const update = useCallback(async (id, item) => {
+        try {
+            await collection.update(id, item);
+            const updated = await collection.find(options?.query || {});
+            setData(updated);
+        }
+        catch (err) {
+            setError(err);
+        }
+    }, [collection, options?.query]);
+    const remove = useCallback(async (id) => {
+        try {
+            await collection.delete(id);
+            const updated = await collection.find(options?.query || {});
+            setData(updated);
+        }
+        catch (err) {
+            setError(err);
+        }
+    }, [collection, options?.query]);
+    return { data, loading, error, insert, update, remove };
+}

package/dist/react/useFeltDB.d.ts

@@ -0,0 +1,136 @@
+/**
+ * useFeltDB - React hook for FeltDB integration
+ *
+ * This module provides React hooks for easily integrating FeltDB
+ * into React applications with automatic state management.
+ *
+ * Usage:
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList() {
+ *   const users = useFeltDB("users");
+ *
+ *   const addUser = (name, email) => {
+ *     users.insert(name, email);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {users.records.map(user => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import type { JsDb } from '@feltdb/core/wasm';
+import type { Collection } from '@feltdb/core';
+interface UseFeltDBOptions {
+    /** Auto-refresh interval in milliseconds (0 to disable) */
+    refreshInterval?: number;
+    /** Callback when data updates */
+    onUpdate?: (records: any[]) => void;
+    /** Callback when error occurs */
+    onError?: (error: string) => void;
+}
+interface UseFeltDBResult<T = any> {
+    /** Array of records from the database */
+    records: T[];
+    /** Whether data is loading */
+    loading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Insert a new record */
+    insert: (key: string, data: Record<string, any>) => boolean;
+    /** Get a single record by key */
+    get: (key: string) => any | null;
+    /** Refresh data manually */
+    refresh: () => void;
+    /** Update a record */
+    update: (id: string | number, changes: Partial<T>) => Promise<void>;
+    /** Delete a record */
+    delete: (id: string | number) => Promise<void>;
+}
+/**
+ * React hook for FeltDB state-first collections
+ *
+ * This is a thin adapter that bridges React state management with FeltDB's
+ * unified state model. All applications (React, Vue, Svelte) use the same
+ * underlying Collection semantics.
+ *
+ * @param collection A FeltDB Collection (live application state)
+ * @param options Configuration options
+ * @returns UseFeltDBResult with records and helper methods
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from 'feltdb/useFeltDB';
+ *
+ * function UserList({ collection }) {
+ *   const { records, loading, error, insert, update } = useFeltDB(collection);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user) => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useFeltDB<T = any>(collection: Collection<T> | null, options?: UseFeltDBOptions): UseFeltDBResult<T>;
+/**
+ * Legacy compatibility: React hook for FeltDB capability queries
+ * Uses the low-level JsDb API for backward compatibility.
+ *
+ * New code should use useFeltDB with Collections instead.
+ */
+export declare function useLegacyFeltDB(db: JsDb | null, capability: string, options?: UseFeltDBOptions): UseFeltDBResult;
+/**
+ * Higher-order component for wrapping components with FeltDB
+ *
+ * @param Component React component that receives db and useFeltDB hook
+ * @param dbPath Path to the database file
+ * @returns Wrapped component
+ *
+ * @example
+ * ```jsx
+ * const UserListWithDb = withFeltDB(UserList, "app.db");
+ * ```
+ */
+export declare function withFeltDB<P extends object>(Component: React.ComponentType<P & {
+    db: JsDb;
+}>, dbPath: string): React.FC<P>;
+/**
+ * Example component using useFeltDB
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList({ db }) {
+ *   const { records, loading, error, insert } = useFeltDB(db, "users", {
+ *     refreshInterval: 5000, // Refresh every 5 seconds
+ *   });
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user: any) => (
+ *         <div key={user.id}>{user.name} ({user.email})</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export default useFeltDB;
+//# sourceMappingURL=useFeltDB.d.ts.map

package/dist/react/useFeltDB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFeltDB.d.ts","sourceRoot":"","sources":["../src/useFeltDB.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,UAAU,gBAAgB;IACxB,2DAA2D;IAC3D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IACpC,iCAAiC;IACjC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,UAAU,eAAe,CAAC,CAAC,GAAG,GAAG;IAC/B,yCAAyC;IACzC,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,8BAA8B;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,0BAA0B;IAC1B,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC;IAC5D,iCAAiC;IACjC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,GAAG,IAAI,CAAC;IACjC,4BAA4B;IAC5B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,sBAAsB;IACtB,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,sBAAsB;IACtB,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAC/B,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,EAChC,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CAAC,CAAC,CAAC,CAiJpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,IAAI,GAAG,IAAI,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CA8GjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC,EAChD,MAAM,EAAE,MAAM,GACb,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CA4Bb;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAe,SAAS,CAAC"}