@ixo/oracle-runtime 0.0.1

package/dist/modules/messages/user-context-fetcher.d.ts

@@ -0,0 +1,41 @@
+import { MemoryEngineService } from '@ixo/common';
+import { Cache } from '@nestjs/cache-manager';
+import { ConfigService } from '@nestjs/config';
+import { UcanService } from '../ucan/ucan.service.js';
+/**
+ * Local widening: the graph state's `userContext` field is typed as
+ * `Record<string, unknown>`. `@ixo/common`'s `UserContextData` is a
+ * structural subtype (typed slots like `identity`, `work`, etc.) but
+ * TypeScript treats them as distinct types. We carry the looser shape
+ * through this module so the value flows cleanly into `buildTimeState`.
+ */
+type UserContextRecord = Record<string, unknown>;
+/**
+ * Per-room fetcher for Memory Engine `userContext`, cached for 5 minutes.
+ *
+ * Used by `AgentBuilder` to populate `state.userContext` BEFORE the agent is
+ * compiled so the system prompt sees the value on turn 1. The previous
+ * middleware-based approach wrote the value mid-run, by which point the
+ * prompt was already a frozen string — so turn-1 prompts were always empty.
+ *
+ * Returns `undefined` when:
+ *  - `MEMORY_ENGINE_URL` is not configured (`MemoryEngineService` is null)
+ *  - UCAN signing key is missing (Matrix listener path, no per-user UCAN)
+ *  - the Memory Engine call throws — userContext is best-effort, missing
+ *    enrichment must never break a chat.
+ */
+export declare class UserContextFetcher {
+    private readonly cache;
+    private readonly memoryEngine;
+    private readonly ucanService;
+    private readonly configService;
+    private readonly logger;
+    constructor(cache: Cache, memoryEngine: MemoryEngineService | null, ucanService: UcanService, configService: ConfigService);
+    fetch(params: {
+        roomId: string;
+        userDid: string;
+        sessionId: string;
+    }): Promise<UserContextRecord | undefined>;
+}
+export {};
+//# sourceMappingURL=user-context-fetcher.d.ts.map

package/dist/modules/messages/user-context-fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-context-fetcher.d.ts","sourceRoot":"","sources":["../../../src/modules/messages/user-context-fetcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,KAAK,EAAiB,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD;;;;;;GAMG;AACH,KAAK,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAQjD;;;;;;;;;;;;;GAaG;AACH,qBACa,kBAAkB;IAIJ,OAAO,CAAC,QAAQ,CAAC,KAAK;IAG7C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IARhC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;gBAGpB,KAAK,EAAE,KAAK,EAGnC,YAAY,EAAE,mBAAmB,GAAG,IAAI,EACxC,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa;IAOzC,KAAK,CAAC,MAAM,EAAE;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;CAyF3C"}

package/dist/modules/messages/user-context-fetcher.js

@@ -0,0 +1,117 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var UserContextFetcher_1;
+import { MemoryEngineService } from '@ixo/common';
+import { Cache, CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { minutes } from '@nestjs/throttler';
+import { UcanService } from '../ucan/ucan.service.js';
+const CACHE_TTL_MS = minutes(5);
+function cacheKey(sessionId) {
+    return `user-context:${sessionId}`;
+}
+/**
+ * Per-room fetcher for Memory Engine `userContext`, cached for 5 minutes.
+ *
+ * Used by `AgentBuilder` to populate `state.userContext` BEFORE the agent is
+ * compiled so the system prompt sees the value on turn 1. The previous
+ * middleware-based approach wrote the value mid-run, by which point the
+ * prompt was already a frozen string — so turn-1 prompts were always empty.
+ *
+ * Returns `undefined` when:
+ *  - `MEMORY_ENGINE_URL` is not configured (`MemoryEngineService` is null)
+ *  - UCAN signing key is missing (Matrix listener path, no per-user UCAN)
+ *  - the Memory Engine call throws — userContext is best-effort, missing
+ *    enrichment must never break a chat.
+ */
+let UserContextFetcher = UserContextFetcher_1 = class UserContextFetcher {
+    cache;
+    memoryEngine;
+    ucanService;
+    configService;
+    logger = new Logger(UserContextFetcher_1.name);
+    constructor(cache, memoryEngine, ucanService, configService) {
+        this.cache = cache;
+        this.memoryEngine = memoryEngine;
+        this.ucanService = ucanService;
+        this.configService = configService;
+        this.logger.log(`[UserContextFetcher] constructed — memoryEngine=${this.memoryEngine ? 'available' : 'null'}, hasSigningKey=${this.ucanService.hasSigningKey()}`);
+    }
+    async fetch(params) {
+        const { roomId, userDid, sessionId } = params;
+        this.logger.debug(`[UserContextFetcher] fetch begin — room=${roomId}, user=${userDid}, sessionid=${sessionId}`);
+        if (!this.memoryEngine) {
+            this.logger.warn(`[UserContextFetcher] skip — MemoryEngineService not configured (MEMORY_ENGINE_URL unset)`);
+            return undefined;
+        }
+        if (!this.ucanService.hasSigningKey()) {
+            this.logger.warn(`[UserContextFetcher] skip — UCAN signing key not loaded (no per-user invocation)`);
+            return undefined;
+        }
+        const cached = await this.cache.get(cacheKey(sessionId));
+        if (cached) {
+            this.logger.log(`[UserContextFetcher] cache hit — room=${roomId}, keys=${Object.keys(cached).length}`);
+            return cached;
+        }
+        this.logger.log(`[UserContextFetcher] cache miss — room=${roomId}`);
+        const engineUrl = this.configService.get('MEMORY_ENGINE_URL');
+        if (!engineUrl) {
+            this.logger.warn(`[UserContextFetcher] skip — MEMORY_ENGINE_URL not in ConfigService (but MemoryEngineService is set?)`);
+            return undefined;
+        }
+        let invocation;
+        try {
+            invocation = await this.ucanService.createServiceInvocation(engineUrl, userDid, 'ixo:memory');
+        }
+        catch (err) {
+            this.logger.warn(`[UserContextFetcher] UCAN invocation threw for room ${roomId}: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+        if (!invocation) {
+            this.logger.warn(`[UserContextFetcher] UCAN invocation returned null for room ${roomId} (did:web resolution failed?)`);
+            return undefined;
+        }
+        const oracleDid = this.configService.get('ORACLE_DID') ?? '';
+        this.logger.log(`[UserContextFetcher] calling gatherUserContext — engine=${engineUrl}, room=${roomId}, oracle=${oracleDid}`);
+        try {
+            const context = await this.memoryEngine.gatherUserContext({
+                oracleDid,
+                roomId,
+                oracleToken: '',
+                userToken: '',
+                oracleHomeServer: '',
+                userHomeServer: '',
+                ucanInvocation: invocation,
+            });
+            const widened = { ...context };
+            const keyCount = Object.keys(widened).length;
+            this.logger.log(`[UserContextFetcher] gather returned ${keyCount} key(s) for room ${roomId}: ${keyCount > 0 ? Object.keys(widened).join(', ') : '(empty)'}`);
+            await this.cache.set(cacheKey(sessionId), widened, CACHE_TTL_MS);
+            return widened;
+        }
+        catch (err) {
+            this.logger.warn(`[UserContextFetcher] gatherUserContext threw for room ${roomId}: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+    }
+};
+UserContextFetcher = UserContextFetcher_1 = __decorate([
+    Injectable(),
+    __param(0, Inject(CACHE_MANAGER)),
+    __param(1, Optional()),
+    __param(1, Inject(MemoryEngineService)),
+    __metadata("design:paramtypes", [Cache, Object, UcanService,
+        ConfigService])
+], UserContextFetcher);
+export { UserContextFetcher };

package/dist/modules/secrets/index.d.ts

@@ -0,0 +1,2 @@
+export { SecretsService, type SecretIndexEntry } from './secrets.service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/secrets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/secrets/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/modules/secrets/index.js

@@ -0,0 +1 @@
+export { SecretsService } from './secrets.service.js';

package/dist/modules/secrets/secrets.service.d.ts

@@ -0,0 +1,29 @@
+import { type JWK } from '@ixo/oracles-chain-client';
+import type { Cache } from 'cache-manager';
+export interface SecretIndexEntry {
+    name: string;
+    eventId: string;
+    publicKeyId: string;
+}
+export declare class SecretsService {
+    private static instance;
+    private cacheManager;
+    private encryptionKey;
+    private constructor();
+    setEncryptionKey(key: JWK): void;
+    setCacheManager(cache: Cache): void;
+    static getInstance(): SecretsService;
+    /**
+     * Get the secret index from room state events.
+     * Cheap operation — one API call per invocation.
+     */
+    getSecretIndex(roomId: string): Promise<SecretIndexEntry[]>;
+    private cacheKey;
+    /**
+     * Load secret values from timeline events, using cache where possible.
+     * Only fetches timeline events for secrets whose eventId has changed.
+     * Stale entries (deleted secrets) expire naturally via the 24h TTL.
+     */
+    loadSecretValues(roomId: string, index: SecretIndexEntry[]): Promise<Record<string, string>>;
+}
+//# sourceMappingURL=secrets.service.d.ts.map

package/dist/modules/secrets/secrets.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.service.d.ts","sourceRoot":"","sources":["../../../src/modules/secrets/secrets.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AASD,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IAExC,OAAO,CAAC,YAAY,CAAsB;IAG1C,OAAO,CAAC,aAAa,CAAoB;IAEzC,OAAO;IAEP,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAIhC,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAInC,MAAM,CAAC,WAAW,IAAI,cAAc;IAOpC;;;OAGG;IACG,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAwCjE,OAAO,CAAC,QAAQ;IAIhB;;;;OAIG;IACG,gBAAgB,CACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,EAAE,GACxB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CA6DnC"}

package/dist/modules/secrets/secrets.service.js

@@ -0,0 +1,107 @@
+import { decryptJWE } from '@ixo/oracles-chain-client';
+import { MatrixManager } from '@ixo/matrix';
+import { Logger } from '@nestjs/common';
+const TWENTY_FOUR_HOURS = 24 * 60 * 60 * 1000;
+export class SecretsService {
+    static instance;
+    cacheManager = null;
+    // TODO: Key rotation — change to Map<string, JWK> keyed by publicKeyId to support multiple keys
+    encryptionKey = null;
+    constructor() { }
+    setEncryptionKey(key) {
+        this.encryptionKey = key;
+    }
+    setCacheManager(cache) {
+        this.cacheManager = cache;
+    }
+    static getInstance() {
+        if (!SecretsService.instance) {
+            SecretsService.instance = new SecretsService();
+        }
+        return SecretsService.instance;
+    }
+    /**
+     * Get the secret index from room state events.
+     * Cheap operation — one API call per invocation.
+     */
+    async getSecretIndex(roomId) {
+        try {
+            const client = MatrixManager.getInstance().getClient();
+            if (!client) {
+                Logger.warn('[SecretsService] Matrix client not available');
+                return [];
+            }
+            // Fetch all room state and filter for secret index events.
+            // Matrix CS API has no endpoint to fetch all state events of a single type,
+            // so getRoomState (all state) + client-side filter is the only option.
+            const roomState = await client.mxClient.getRoomState(roomId);
+            const index = [];
+            for (const event of roomState) {
+                if (event.type !== 'ixo.room.secret.index')
+                    continue;
+                // Filter out deleted entries (empty content)
+                if (!event.content || Object.keys(event.content).length === 0)
+                    continue;
+                if (!event.content.eventId)
+                    continue;
+                index.push({
+                    name: event.state_key,
+                    eventId: event.content.eventId,
+                    publicKeyId: event.content.publicKeyId,
+                });
+            }
+            Logger.log(`[SecretsService] Found ${index.length} secret(s) in room ${roomId}: ${index.map((e) => e.name).join(', ')}`);
+            return index;
+        }
+        catch (error) {
+            Logger.error(`[SecretsService] Failed to get secret index for room ${roomId}:`, error);
+            return [];
+        }
+    }
+    cacheKey(roomId, name) {
+        return `secret:${roomId}:${name}`;
+    }
+    /**
+     * Load secret values from timeline events, using cache where possible.
+     * Only fetches timeline events for secrets whose eventId has changed.
+     * Stale entries (deleted secrets) expire naturally via the 24h TTL.
+     */
+    async loadSecretValues(roomId, index) {
+        const result = {};
+        const toFetch = [];
+        for (const entry of index) {
+            const cached = await this.cacheManager?.get(this.cacheKey(roomId, entry.name));
+            if (cached && cached.eventId === entry.eventId) {
+                // Cache hit — same eventId means value hasn't changed
+                result[entry.name] = cached.value;
+            }
+            else {
+                // Cache miss or eventId changed (secret was updated)
+                toFetch.push(entry);
+            }
+        }
+        if (toFetch.length > 0) {
+            Logger.log(`[SecretsService] Fetching ${toFetch.length} secret value(s) for room ${roomId}`);
+        }
+        for (const entry of toFetch) {
+            try {
+                const event = await MatrixManager.getInstance().getEventById(roomId, entry.eventId);
+                let value = event?.content
+                    ?.value ?? '';
+                if (!this.encryptionKey) {
+                    Logger.error(`[SecretsService] Secret "${entry.name}" is encrypted but no encryption key loaded — skipping`);
+                    continue;
+                }
+                // TODO: Key rotation — select correct key via entry.publicKeyId
+                value = await decryptJWE(value, this.encryptionKey);
+                Logger.log(`[SecretsService] Decrypted secret "${entry.name}" (${value.length} chars)`);
+                result[entry.name] = value;
+                await this.cacheManager?.set(this.cacheKey(roomId, entry.name), { value, eventId: entry.eventId }, TWENTY_FOUR_HOURS);
+            }
+            catch (error) {
+                Logger.error(`[SecretsService] Failed to fetch/decrypt secret "${entry.name}" (event ${entry.eventId}):`, error);
+            }
+        }
+        return result;
+    }
+}

package/dist/modules/sessions/dto/create-session.dto.d.ts

@@ -0,0 +1,6 @@
+export declare class CreateSessionDto {
+    did: string;
+    homeServer?: string;
+    slackThreadTs?: string;
+}
+//# sourceMappingURL=create-session.dto.d.ts.map

package/dist/modules/sessions/dto/create-session.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-session.dto.d.ts","sourceRoot":"","sources":["../../../../src/modules/sessions/dto/create-session.dto.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAgB;IAC3B,GAAG,EAAG,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/modules/sessions/dto/create-session.dto.js

@@ -0,0 +1,5 @@
+export class CreateSessionDto {
+    did;
+    homeServer;
+    slackThreadTs;
+}

package/dist/modules/sessions/dto/delete-session.dto.d.ts

@@ -0,0 +1,6 @@
+export declare class DeleteSessionDto {
+    did: string;
+    sessionId: string;
+    homeServer?: string;
+}
+//# sourceMappingURL=delete-session.dto.d.ts.map

package/dist/modules/sessions/dto/delete-session.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-session.dto.d.ts","sourceRoot":"","sources":["../../../../src/modules/sessions/dto/delete-session.dto.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAgB;IAC3B,GAAG,EAAG,MAAM,CAAC;IACb,SAAS,EAAG,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/modules/sessions/dto/delete-session.dto.js

@@ -0,0 +1,5 @@
+export class DeleteSessionDto {
+    did;
+    sessionId;
+    homeServer;
+}

package/dist/modules/sessions/dto/list-sessions.dto.d.ts

@@ -0,0 +1,7 @@
+export declare class ListSessionsDto {
+    did: string;
+    homeServer?: string;
+    limit?: number;
+    offset?: number;
+}
+//# sourceMappingURL=list-sessions.dto.d.ts.map

package/dist/modules/sessions/dto/list-sessions.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-sessions.dto.d.ts","sourceRoot":"","sources":["../../../../src/modules/sessions/dto/list-sessions.dto.ts"],"names":[],"mappings":"AAAA,qBAAa,eAAe;IAC1B,GAAG,EAAG,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/modules/sessions/dto/list-sessions.dto.js

@@ -0,0 +1,6 @@
+export class ListSessionsDto {
+    did;
+    homeServer;
+    limit;
+    offset;
+}

package/dist/modules/sessions/session-history-processor.service.d.ts

@@ -0,0 +1,48 @@
+import { MemoryEngineService, SessionManagerService } from '@ixo/common';
+import { ConfigService } from '@nestjs/config';
+import { type Cache } from 'cache-manager';
+import { MessagesService } from '../messages/messages.service.js';
+import { UcanService } from '../ucan/ucan.service.js';
+export interface ProcessSessionHistoryParams {
+    sessionId: string;
+    did: string;
+    oracleEntityDid: string;
+    homeServer?: string;
+}
+export declare class SessionHistoryProcessor {
+    private readonly messagesService;
+    private readonly memoryEngineService;
+    private readonly sessionManagerService;
+    private readonly configService;
+    private readonly cacheManager;
+    private readonly ucanService?;
+    private readonly logger;
+    constructor(messagesService: MessagesService, memoryEngineService: MemoryEngineService, sessionManagerService: SessionManagerService, configService: ConfigService, cacheManager: Cache, ucanService?: UcanService | undefined);
+    /**
+     * Process session history by sending messages to memory engine.
+     * Uses cache locking to prevent concurrent processing for the same session.
+     */
+    processSessionHistory(params: ProcessSessionHistoryParams): Promise<void>;
+    private processSessionHistoryWithRetry;
+    private processSessionHistoryInternal;
+    /**
+     * Transform LangChain messages into the role/content shape the
+     * memory engine expects. `userSpeakerLabel` and `oracleSpeakerLabel` become
+     * the `name` (and `role`) the memory engine sees for each message — these
+     * are what graphiti's extractor will use as the speaker entity in the graph,
+     * so they MUST be meaningful identities (not the literal strings
+     * "user"/"assistant"), otherwise every fact gets pinned to a generic
+     * placeholder node.
+     */
+    private transformMessagesToMemoryEngineFormat;
+    /**
+     * Resolve the user's display name for graphiti's speaker label. Cascade:
+     *   1. `userName` from preferences (caller passes it in — fetched once
+     *      alongside agentName)
+     *   2. Matrix profile displayname (looked up via @did-…:homeServer)
+     *   3. "Me" — safe fallback because each user has their own group_id
+     *      partition in graphiti, so a generic label can't collide cross-user.
+     */
+    private resolveUserDisplayName;
+}
+//# sourceMappingURL=session-history-processor.service.d.ts.map

package/dist/modules/sessions/session-history-processor.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-history-processor.service.d.ts","sourceRoot":"","sources":["../../../src/modules/sessions/session-history-processor.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAKzE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBACa,uBAAuB;IAIhC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa;IACP,OAAO,CAAC,QAAQ,CAAC,YAAY;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAR3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;gBAGhD,eAAe,EAAE,eAAe,EAChC,mBAAmB,EAAE,mBAAmB,EACxC,qBAAqB,EAAE,qBAAqB,EAC5C,aAAa,EAAE,aAAa,EACL,YAAY,EAAE,KAAK,EAC9B,WAAW,CAAC,EAAE,WAAW,YAAA;IAGxD;;;OAGG;IACG,qBAAqB,CACzB,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC;YAuBF,8BAA8B;YAiC9B,6BAA6B;IAgJ3C;;;;;;;;OAQG;IACH,OAAO,CAAC,qCAAqC;IAyD7C;;;;;;;OAOG;YACW,sBAAsB;CAwBrC"}