@fencyai/js 0.1.192 → 0.1.194

package/lib/parsing/AgentTaskEventDataSchemas.js

@@ -0,0 +1,415 @@
+import { z } from 'zod';
+const messageSchema = z
+    .object({
+    role: z.enum(['SYSTEM', 'USER', 'ASSISTANT']),
+    content: z.string(),
+})
+    .passthrough();
+const memorySearchResultItemSchema = z
+    .object({
+    memoryId: z.string(),
+    memoryTitle: z.string(),
+    memoryTypeId: z.string(),
+    memoryTypeName: z.string(),
+    matchingChunkScore: z.number(),
+    matchingChunk: z
+        .object({
+        chunkNumber: z.number(),
+        pageNumbers: z.array(z.number()),
+        content: z.string(),
+    })
+        .passthrough(),
+    chunks: z.array(z
+        .object({
+        chunkNumber: z.number(),
+        pageNumbers: z.array(z.number()),
+        content: z.string(),
+        relation: z.enum([
+            'MATCH',
+            'CONTEXT_BEFORE',
+            'CONTEXT_AFTER',
+        ]),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const memoryRefSchema = z
+    .object({
+    memoryId: z.string(),
+    memoryTitle: z.string(),
+})
+    .passthrough();
+const streamingChatCompletionTextSchema = z
+    .object({
+    taskType: z.literal('StreamingChatCompletion'),
+    eventType: z.literal('Text'),
+    text: z.string(),
+})
+    .passthrough();
+const streamingChatCompletionCompletedSchema = z
+    .object({
+    taskType: z.literal('StreamingChatCompletion'),
+    eventType: z.literal('Completed'),
+    response: z
+        .object({
+        textResponse: z.string(),
+        messages: z.array(messageSchema),
+    })
+        .passthrough(),
+})
+    .passthrough();
+const streamingChatCompletionErrorSchema = z
+    .object({
+    taskType: z.literal('StreamingChatCompletion'),
+    eventType: z.literal('Error'),
+    message: z.string(),
+})
+    .passthrough();
+const structuredChatCompletionCompletedSchema = z
+    .object({
+    taskType: z.literal('StructuredChatCompletion'),
+    eventType: z.literal('Completed'),
+    response: z
+        .object({
+        jsonResponse: z.string(),
+        messages: z.array(messageSchema),
+    })
+        .passthrough(),
+})
+    .passthrough();
+const structuredChatCompletionErrorSchema = z
+    .object({
+    taskType: z.literal('StructuredChatCompletion'),
+    eventType: z.literal('Error'),
+    message: z.string(),
+})
+    .passthrough();
+const memoryChatTextSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('Text'),
+    text: z.string(),
+})
+    .passthrough();
+const memoryChatThinkingSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('Thinking'),
+})
+    .passthrough();
+const memoryChatSearchSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('Search'),
+    queryDescription: z.string(),
+    memories: z.array(memoryRefSchema).optional(),
+})
+    .passthrough();
+const memoryChatFindMemoriesSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('FindMemories'),
+    titles: z.array(z.string()),
+})
+    .passthrough();
+const memoryChatFindMemoriesResultSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('FindMemoriesResult'),
+    memories: z.array(memoryRefSchema),
+})
+    .passthrough();
+const scrapeWebsitesResultStatusSchema = z.enum([
+    'downloading',
+    'downloaded',
+    'analyzing',
+    'summarizing',
+]);
+const memoryChatScrapeWebsitesSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('ScrapeWebsites'),
+    input: z
+        .object({
+        query: z.string(),
+        urls: z.array(z.string()),
+    })
+        .passthrough(),
+    results: z
+        .array(z
+        .object({
+        url: z.string(),
+        status: scrapeWebsitesResultStatusSchema.optional(),
+        summary: z.string().optional(),
+        error: z.string().optional(),
+    })
+        .passthrough())
+        .optional(),
+})
+    .passthrough();
+const memoryChatGoogleSearchSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('GoogleSearch'),
+    input: z
+        .object({
+        query: z.string(),
+        countryCode: z.string().optional(),
+    })
+        .passthrough(),
+    results: z
+        .array(z
+        .object({
+        rank: z.number(),
+        title: z.string(),
+        link: z.string(),
+        description: z.string(),
+    })
+        .passthrough())
+        .optional(),
+})
+    .passthrough();
+const memoryChatSearchMemoryChunksSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('SearchMemoryChunks'),
+    input: z
+        .object({
+        queryDescription: z.string(),
+        memories: z.array(memoryRefSchema).optional(),
+    })
+        .passthrough(),
+    items: z.array(memorySearchResultItemSchema).optional(),
+})
+    .passthrough();
+const memoryChatFindSourcesSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('FindSources'),
+})
+    .passthrough();
+const memoryChatExploreMemoriesSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('ExploreMemories'),
+    memories: z.array(z
+        .object({
+        memoryId: z.string(),
+        memoryTitle: z.string(),
+        result: z.string().optional(),
+        error: z.string().optional(),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const memoryChatChunkResultsSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('ChunkResults'),
+    items: z.array(memorySearchResultItemSchema),
+})
+    .passthrough();
+const memoryChatSourcesResultSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('SourcesResult'),
+    sources: z.array(z
+        .object({
+        memoryId: z.string(),
+        memoryTitle: z.string(),
+        memoryTypeId: z.string(),
+        memoryTypeName: z.string(),
+        pageNumbers: z.array(z.number()),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const memoryChatCompletedSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('Completed'),
+    response: z
+        .object({
+        textResponse: z.string(),
+        sources: z.array(z
+            .object({
+            memoryId: z.string(),
+            memoryTitle: z.string(),
+            memoryTypeId: z.string(),
+            memoryTypeName: z.string(),
+            pageNumbers: z.array(z.number()),
+        })
+            .passthrough()),
+    })
+        .passthrough(),
+})
+    .passthrough();
+const memoryChatGenerateReportSetupSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('GenerateReportSetup'),
+    userRequest: z.string(),
+})
+    .passthrough();
+const memoryChatGenerateReportExportingSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('GenerateReportExporting'),
+    fileCount: z.number(),
+})
+    .passthrough();
+const memoryChatGenerateReportRunCodeSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('GenerateReportRunCode'),
+    title: z.string(),
+})
+    .passthrough();
+const memoryChatGenerateReportRunCommandSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('GenerateReportRunCommand'),
+    title: z.string(),
+})
+    .passthrough();
+const memoryChatGenerateReportAssemblingSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('GenerateReportAssembling'),
+    reportTitle: z.string(),
+})
+    .passthrough();
+const memoryChatGenerateReportCompletedSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('GenerateReportCompleted'),
+    reportTitle: z.string(),
+})
+    .passthrough();
+const memoryChatErrorSchema = z
+    .object({
+    taskType: z.literal('MemoryChat'),
+    eventType: z.literal('Error'),
+    message: z.string(),
+})
+    .passthrough();
+const memorySearchGeneratingQueriesSchema = z
+    .object({
+    taskType: z.literal('MemorySearch'),
+    eventType: z.literal('GeneratingQueries'),
+    memoryTypes: z.array(z
+        .object({
+        memoryTypeId: z.string(),
+        memoryTypeName: z.string(),
+        reasoning: z.string().optional(),
+        reasoningCompleted: z.boolean().optional(),
+        queries: z
+            .array(z.object({ query: z.string() }).passthrough())
+            .optional(),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const memorySearchExploreQueriesSchema = z
+    .object({
+    taskType: z.literal('MemorySearch'),
+    eventType: z.literal('ExploreQueries'),
+    queries: z.array(z
+        .object({
+        query: z.string(),
+        memoryTypeId: z.string(),
+        memoryTypeName: z.string(),
+        result: z
+            .object({
+            numberOfChunks: z.number(),
+            highestChunkScore: z.number(),
+            items: z.array(memorySearchResultItemSchema),
+        })
+            .passthrough()
+            .optional(),
+        error: z.string().optional(),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const memorySearchSearchMemoryTypesSchema = z
+    .object({
+    taskType: z.literal('MemorySearch'),
+    eventType: z.literal('SearchMemoryTypes'),
+    memoryTypes: z.array(z
+        .object({
+        memoryTypeId: z.string(),
+        memoryTypeName: z.string(),
+        result: z
+            .object({
+            numberOfChunks: z.number(),
+            highestChunkScore: z.number(),
+        })
+            .passthrough()
+            .optional(),
+        error: z.string().optional(),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const memorySearchCompletedSchema = z
+    .object({
+    taskType: z.literal('MemorySearch'),
+    eventType: z.literal('Completed'),
+    response: z
+        .object({
+        query: z.string(),
+        items: z.array(memorySearchResultItemSchema),
+    })
+        .passthrough(),
+})
+    .passthrough();
+const memorySearchErrorSchema = z
+    .object({
+    taskType: z.literal('MemorySearch'),
+    eventType: z.literal('Error'),
+    message: z.string(),
+})
+    .passthrough();
+/** Zod schema matching {@link AgentTaskEventData}; objects use `.passthrough()` for forward-compatible extra fields. @public */
+export const AgentTaskEventDataSchema = z.union([
+    streamingChatCompletionTextSchema,
+    streamingChatCompletionCompletedSchema,
+    streamingChatCompletionErrorSchema,
+    structuredChatCompletionCompletedSchema,
+    structuredChatCompletionErrorSchema,
+    memoryChatTextSchema,
+    memoryChatThinkingSchema,
+    memoryChatSearchSchema,
+    memoryChatFindMemoriesSchema,
+    memoryChatFindMemoriesResultSchema,
+    memoryChatScrapeWebsitesSchema,
+    memoryChatGoogleSearchSchema,
+    memoryChatSearchMemoryChunksSchema,
+    memoryChatFindSourcesSchema,
+    memoryChatExploreMemoriesSchema,
+    memoryChatChunkResultsSchema,
+    memoryChatSourcesResultSchema,
+    memoryChatGenerateReportSetupSchema,
+    memoryChatGenerateReportExportingSchema,
+    memoryChatGenerateReportRunCodeSchema,
+    memoryChatGenerateReportRunCommandSchema,
+    memoryChatGenerateReportAssemblingSchema,
+    memoryChatGenerateReportCompletedSchema,
+    memoryChatCompletedSchema,
+    memoryChatErrorSchema,
+    memorySearchGeneratingQueriesSchema,
+    memorySearchExploreQueriesSchema,
+    memorySearchSearchMemoryTypesSchema,
+    memorySearchCompletedSchema,
+    memorySearchErrorSchema,
+]);
+/** @public */
+export function parseAgentTaskEventData(raw) {
+    const result = AgentTaskEventDataSchema.safeParse(raw);
+    if (!result.success) {
+        console.warn('[fency] Dropping unrecognized or malformed agent task event:', result.error.format(), raw);
+        return null;
+    }
+    return result.data;
+}

package/lib/stream/StreamCacheManager.d.ts

@@ -0,0 +1,41 @@
+import type { FencyInstance } from '../types/FencyInstance';
+import type { Stream } from '../types/Stream';
+import type { StreamCache } from '../types/StreamCache';
+/** Stream lifecycle: 8 minutes — below backend SSE timeout (~10m). @public */
+export declare const STREAM_MAX_LIFETIME = 480000;
+/** Default reuse window for new agent tasks: 5 minutes. @public */
+export declare const DEFAULT_STREAM_REUSE_MAX_AGE = 300000;
+/** @public */
+export interface StreamCacheManagerOptions {
+    maxLifetime?: number;
+    reuseMaxAge?: number;
+}
+/** @public */
+export type StreamCacheChangeListener = (streams: StreamCache[]) => void;
+/**
+ * Manages stream cache lifecycle: reuse, expiration, and creation with locking.
+ * @public
+ */
+export declare class StreamCacheManager {
+    private fency;
+    private fetchClientToken;
+    private activeStreams;
+    private streamLock;
+    private listeners;
+    private readonly maxLifetime;
+    private readonly reuseMaxAge;
+    private cleanupInterval;
+    constructor(fency: FencyInstance, fetchClientToken: () => Promise<{
+        clientToken: string;
+    }>, options?: StreamCacheManagerOptions);
+    onChange(listener: StreamCacheChangeListener): () => void;
+    getActiveStreams(): StreamCache[];
+    getLatestStream(): StreamCache | null;
+    cleanupExpired(): StreamCache[];
+    startPeriodicCleanup(intervalMs?: number): void;
+    stopPeriodicCleanup(): void;
+    getOrCreateStream(maxAge?: number): Promise<Stream>;
+    destroy(): void;
+    private setStreams;
+}
+//# sourceMappingURL=StreamCacheManager.d.ts.map

package/lib/stream/StreamCacheManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamCacheManager.d.ts","sourceRoot":"","sources":["../../src/stream/StreamCacheManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAEvD,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,SAAU,CAAA;AAE1C,mEAAmE;AACnE,eAAO,MAAM,4BAA4B,SAAU,CAAA;AAEnD,cAAc;AACd,MAAM,WAAW,yBAAyB;IACtC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,cAAc;AACd,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,IAAI,CAAA;AAUxE;;;GAGG;AACH,qBAAa,kBAAkB;IASvB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,gBAAgB;IAT5B,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,SAAS,CAAuC;IACxD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,eAAe,CAA8C;gBAGzD,KAAK,EAAE,aAAa,EACpB,gBAAgB,EAAE,MAAM,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,EAChE,OAAO,CAAC,EAAE,yBAAyB;IAMvC,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,GAAG,MAAM,IAAI;IAQzD,gBAAgB,IAAI,WAAW,EAAE;IAIjC,eAAe,IAAI,WAAW,GAAG,IAAI;IAKrC,cAAc,IAAI,WAAW,EAAE;IAS/B,oBAAoB,CAAC,UAAU,SAAS,GAAG,IAAI;IAO/C,mBAAmB,IAAI,IAAI;IAOrB,iBAAiB,CACnB,MAAM,GAAE,MAAyB,GAClC,OAAO,CAAC,MAAM,CAAC;IA8ClB,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,UAAU;CAIrB"}

package/lib/stream/StreamCacheManager.js

@@ -0,0 +1,101 @@
+import { createStream as createStreamApi } from '../api/createStream';
+/** Stream lifecycle: 8 minutes — below backend SSE timeout (~10m). @public */
+export const STREAM_MAX_LIFETIME = 480000;
+/** Default reuse window for new agent tasks: 5 minutes. @public */
+export const DEFAULT_STREAM_REUSE_MAX_AGE = 300000;
+function cleanupOldStreams(streams, maxLifetime) {
+    const now = Date.now();
+    return streams.filter((cache) => now - cache.createdAt < maxLifetime);
+}
+/**
+ * Manages stream cache lifecycle: reuse, expiration, and creation with locking.
+ * @public
+ */
+export class StreamCacheManager {
+    constructor(fency, fetchClientToken, options) {
+        this.fency = fency;
+        this.fetchClientToken = fetchClientToken;
+        this.activeStreams = [];
+        this.streamLock = null;
+        this.listeners = new Set();
+        this.cleanupInterval = null;
+        this.maxLifetime = options?.maxLifetime ?? STREAM_MAX_LIFETIME;
+        this.reuseMaxAge = options?.reuseMaxAge ?? DEFAULT_STREAM_REUSE_MAX_AGE;
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        listener(this.activeStreams);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    getActiveStreams() {
+        return [...this.activeStreams];
+    }
+    getLatestStream() {
+        if (this.activeStreams.length === 0)
+            return null;
+        return this.activeStreams[this.activeStreams.length - 1];
+    }
+    cleanupExpired() {
+        const before = this.activeStreams;
+        const cleaned = cleanupOldStreams(before, this.maxLifetime);
+        if (cleaned.length !== before.length) {
+            this.setStreams(cleaned);
+        }
+        return before.filter((s) => !cleaned.includes(s));
+    }
+    startPeriodicCleanup(intervalMs = 60000) {
+        this.stopPeriodicCleanup();
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupExpired();
+        }, intervalMs);
+    }
+    stopPeriodicCleanup() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+    async getOrCreateStream(maxAge = this.reuseMaxAge) {
+        if (this.streamLock) {
+            return this.streamLock;
+        }
+        const now = Date.now();
+        const latestStream = this.getLatestStream();
+        if (latestStream && now - latestStream.createdAt < maxAge) {
+            return latestStream.stream;
+        }
+        const streamPromise = (async () => {
+            const tokens = await this.fetchClientToken();
+            const response = await createStreamApi({
+                pk: this.fency.publishableKey,
+                baseUrl: this.fency.baseUrl,
+                clientToken: tokens?.clientToken ?? '',
+            });
+            if (response.type === 'success') {
+                const newStreamCache = {
+                    stream: response.stream,
+                    createdAt: Date.now(),
+                };
+                this.setStreams(cleanupOldStreams([...this.activeStreams, newStreamCache], this.maxLifetime));
+                this.streamLock = null;
+                return response.stream;
+            }
+            this.streamLock = null;
+            throw new Error('Failed to create stream');
+        })();
+        this.streamLock = streamPromise;
+        return streamPromise;
+    }
+    destroy() {
+        this.stopPeriodicCleanup();
+        this.listeners.clear();
+        this.activeStreams = [];
+        this.streamLock = null;
+    }
+    setStreams(streams) {
+        this.activeStreams = streams;
+        this.listeners.forEach((listener) => listener(streams));
+    }
+}

package/lib/stream/StreamEventManager.d.ts

@@ -0,0 +1,52 @@
+import type { FencyInstance } from '../types/FencyInstance';
+import { StreamCache } from '../types/StreamCache';
+type EventCallback = (data: string, streamId: string) => void;
+type ErrorCallback = (streamId: string, errorMessage?: string) => void;
+/** @public */
+export interface Subscription {
+    onMessage: EventCallback;
+    onError: ErrorCallback;
+}
+/**
+ * Centralized manager for EventSource connections to streams.
+ * Ensures only one connection per stream regardless of how many hooks subscribe.
+ *
+ * When a Web Worker is available, the main thread performs fetch (correct CORS origin)
+ * and transfers the response body to the worker for parsing, so the read loop is not
+ * stalled by background tab throttling. Otherwise falls back to fetchEventSource on
+ * the main thread with openWhenHidden so the connection is not aborted on tab switch.
+ * @public
+ */
+export declare class StreamEventManager {
+    private activeConnections;
+    private subscribers;
+    private fency;
+    private worker;
+    private workerBlobUrl;
+    private workerSupported;
+    constructor(fency: FencyInstance);
+    private tryInitWorker;
+    private handleWorkerMessage;
+    /**
+     * Called by FencyProvider when activeStreams changes.
+     * Creates new connections and removes old ones.
+     */
+    updateStreams(streams: StreamCache[]): void;
+    private connectStream;
+    private connectStreamInWorker;
+    private startWorkerStream;
+    private connectStreamOnMainThread;
+    /**
+     * Subscribe to events from all active streams.
+     * Returns an unsubscribe function.
+     */
+    subscribe(subscriberId: string, callbacks: Subscription): () => void;
+    private broadcast;
+    private broadcastError;
+    /**
+     * Cleanup all connections and subscriptions
+     */
+    cleanup(): void;
+}
+export {};
+//# sourceMappingURL=StreamEventManager.d.ts.map

package/lib/stream/StreamEventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamEventManager.d.ts","sourceRoot":"","sources":["../../src/stream/StreamEventManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAclD,KAAK,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;AAC7D,KAAK,aAAa,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;AAEtE,cAAc;AACd,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;CACzB;AAeD;;;;;;;;;GASG;AACH,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,iBAAiB,CAA2C;IACpE,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,eAAe,CAAQ;gBAEnB,KAAK,EAAE,aAAa;IAKhC,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,mBAAmB;IAuB3B;;;OAGG;IACH,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,IAAI;IAiB3C,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,qBAAqB;YAqBf,iBAAiB;IAoE/B,OAAO,CAAC,yBAAyB;IAgDjC;;;OAGG;IACH,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,GAAG,MAAM,IAAI;IAQpE,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,cAAc;IAMtB;;OAEG;IACH,OAAO,IAAI,IAAI;CAqBlB"}