@interocitor/core 0.0.0-beta.10

package/dist/adapters/cloudflare.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cloudflare Worker + D1 Storage Adapter (Interocitor-native protocol)
+ *
+ * This adapter is a perfect-fit backend for Interocitor only.
+ * It does NOT parse XML and does NOT depend on WebDAV compatibility.
+ *
+ * Base URL shape:
+ *   https://<worker>/io/<prefix>
+ *
+ * The adapter derives:
+ *   wss://<worker>/notify/<prefix>  (WebSocket invalidations via InterocitorRelay DO)
+ */
+import type { StorageAdapter, FileEntry, RemoteInvalidationPayload, RemoteInvalidationHooks, StoredFileMetadata, StoredFileWriteOptions } from '../core/types.ts';
+export interface CloudflareAdapterConfig {
+    /** Worker IO base URL that includes prefix, e.g. https://worker/io/team-a */
+    baseUrl: string;
+    /** Optional bearer for server/cost protection (INTEROCITOR_ACCESS_TOKEN). */
+    token?: string;
+    /** Disable relay/WebSocket invalidations for this client. */
+    relayEnabled?: boolean;
+}
+/**
+ * Interocitor-native Cloudflare adapter for Worker + D1 based deployments.
+ *
+ * Use this when you want a purpose-fit backend with optional WebSocket-driven
+ * invalidation instead of a generic file protocol like WebDAV.
+ *
+ * @example
+ * ```ts
+ * const adapter = new CloudflareAdapter({
+ *   baseUrl: 'https://example.com/io/team-a',
+ *   token: 'optional-bearer-token',
+ * });
+ * ```
+ */
+/** Config shape embedded in QR payloads for CloudflareAdapter. Credentials excluded. */
+export interface CloudflareHandshakeConfig {
+    /** Worker IO base URL including the /io/<prefix> path segment. */
+    baseUrl: string;
+}
+export declare class CloudflareAdapter implements StorageAdapter {
+    readonly name = "cloudflare";
+    private readonly config;
+    private authenticated;
+    private ensuredFolders;
+    constructor(config: CloudflareAdapterConfig);
+    private headers;
+    private parseBaseUrl;
+    private get ioBaseUrl();
+    private get notifyUrl();
+    private ioUrl;
+    private fileUrl;
+    private storedFileUrl;
+    authenticate(): Promise<void>;
+    /**
+     * Returns the worker base URL (without credentials) for embedding in a QR payload.
+     * The scanner uses this to point their CloudflareAdapter at the same worker shard.
+     */
+    getHandshakeConfig(): string;
+    isAuthenticated(): boolean;
+    subscribeToInvalidations(onInvalidate: (payload: RemoteInvalidationPayload) => void, hooks?: RemoteInvalidationHooks): () => void;
+    ensureFolder(path: string): Promise<void>;
+    /** Drop the per-session ensureFolder cache. Call after mesh swap, poison,
+     *  or any state where a previous "this folder exists" observation must
+     *  not be trusted. */
+    resetFolderCache(): void;
+    listFiles(path: string): Promise<FileEntry[]>;
+    listFolders(path: string): Promise<string[]>;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array | string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    getFileMetadata(path: string): Promise<FileEntry | null>;
+    putStoredFile(path: string, data: Uint8Array | string, options?: StoredFileWriteOptions): Promise<StoredFileMetadata>;
+    getStoredFile(path: string): Promise<Uint8Array>;
+    deleteStoredFile(path: string): Promise<void>;
+    getStoredFileMetadata(path: string): Promise<StoredFileMetadata | null>;
+}
+//# sourceMappingURL=cloudflare.d.ts.map

package/dist/adapters/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../src/adapters/cloudflare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAElK,MAAM,WAAW,uBAAuB;IACtC,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAiBD;;;;;;;;;;;;;GAaG;AACH,wFAAwF;AACxF,MAAM,WAAW,yBAAyB;IACxC,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,iBAAkB,YAAW,cAAc;IACtD,QAAQ,CAAC,IAAI,gBAAgB;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,aAAa,CAAS;IAM9B,OAAO,CAAC,cAAc,CAA0B;gBAEpC,MAAM,EAAE,uBAAuB;IAI3C,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,YAAY;IAWpB,OAAO,KAAK,SAAS,GAMpB;IAED,OAAO,KAAK,SAAS,GAWpB;IAED,OAAO,CAAC,KAAK;IAKb,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,aAAa;IAMf,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBnC;;;OAGG;IACH,kBAAkB,IAAI,MAAM;IAK5B,eAAe,IAAI,OAAO;IAI1B,wBAAwB,CACtB,YAAY,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,IAAI,EAC1D,KAAK,CAAC,EAAE,uBAAuB,GAC9B,MAAM,IAAI;IAsFP,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAe/C;;0BAEsB;IACtB,gBAAgB,IAAI,IAAI;IAIlB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAqB7C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAe5C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAa3C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcjE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAuBxD,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAgBzH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAMhD,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7C,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;CAW9E"}

package/dist/adapters/cloudflare.js

@@ -0,0 +1,325 @@
+/**
+ * Cloudflare Worker + D1 Storage Adapter (Interocitor-native protocol)
+ *
+ * This adapter is a perfect-fit backend for Interocitor only.
+ * It does NOT parse XML and does NOT depend on WebDAV compatibility.
+ *
+ * Base URL shape:
+ *   https://<worker>/io/<prefix>
+ *
+ * The adapter derives:
+ *   wss://<worker>/notify/<prefix>  (WebSocket invalidations via InterocitorRelay DO)
+ */
+export class CloudflareAdapter {
+    constructor(config) {
+        this.name = 'cloudflare';
+        this.authenticated = false;
+        // Per-session cache of folders we have already ensured. Cloudflare's
+        // /ensure-folder is idempotent but a POST per folder per connect is
+        // pure round-trip overhead — Interocitor.connect re-runs the same
+        // 4-folder loop on every reload. Cache wipes via `resetFolderCache()`
+        // (mesh swap / poison) or process exit.
+        this.ensuredFolders = new Set();
+        this.config = { ...config, baseUrl: config.baseUrl.replace(/\/$/, ''), relayEnabled: config.relayEnabled ?? true };
+    }
+    headers(extra) {
+        const base = {};
+        if (this.config.token) {
+            base.Authorization = `Bearer ${this.config.token}`;
+        }
+        return { ...base, ...extra };
+    }
+    parseBaseUrl() {
+        const base = /^https?:\/\//i.test(this.config.baseUrl)
+            ? this.config.baseUrl
+            : new URL(this.config.baseUrl, 'http://interocitor').toString();
+        const u = new URL(base);
+        if (!u.pathname.includes('/io/')) {
+            throw new Error('CloudflareAdapter baseUrl must include /io/<prefix>');
+        }
+        return u;
+    }
+    get ioBaseUrl() {
+        const u = this.parseBaseUrl();
+        if (!/^https?:\/\//i.test(this.config.baseUrl)) {
+            return `${u.pathname}${u.search}${u.hash}`.replace(/\/$/, '');
+        }
+        return u.toString().replace(/\/$/, '');
+    }
+    get notifyUrl() {
+        const u = this.parseBaseUrl();
+        u.pathname = u.pathname.replace('/io/', '/notify/');
+        u.protocol = u.protocol === 'https:' ? 'wss:' : 'ws:';
+        if (this.config.token) {
+            u.searchParams.set('access_token', this.config.token);
+        }
+        if (!/^https?:\/\//i.test(this.config.baseUrl)) {
+            return `${u.pathname}${u.search}${u.hash}`.replace(/\/$/, '');
+        }
+        return u.toString().replace(/\/$/, '');
+    }
+    ioUrl(pathname) {
+        const clean = pathname.startsWith('/') ? pathname : `/${pathname}`;
+        return `${this.ioBaseUrl}${clean}`;
+    }
+    fileUrl(path) {
+        const u = new URL(this.ioUrl('/file'));
+        u.searchParams.set('path', path);
+        return u.toString();
+    }
+    storedFileUrl(path) {
+        const u = new URL(this.ioUrl('/stored-file'));
+        u.searchParams.set('path', path);
+        return u.toString();
+    }
+    async authenticate() {
+        const res = await fetch(this.ioUrl('/health'), {
+            method: 'GET',
+            headers: this.headers(),
+        });
+        if (res.ok) {
+            this.authenticated = true;
+            return;
+        }
+        if (res.status === 401 || res.status === 403) {
+            throw new Error('Cloudflare Worker auth failed — check your access token');
+        }
+        throw new Error(`Cloudflare Worker unreachable: HTTP ${res.status}`);
+    }
+    /**
+     * Returns the worker base URL (without credentials) for embedding in a QR payload.
+     * The scanner uses this to point their CloudflareAdapter at the same worker shard.
+     */
+    getHandshakeConfig() {
+        const cfg = { baseUrl: this.config.baseUrl };
+        return JSON.stringify(cfg);
+    }
+    isAuthenticated() {
+        return this.authenticated;
+    }
+    subscribeToInvalidations(onInvalidate, hooks) {
+        if (this.config.relayEnabled === false) {
+            hooks?.onClose?.();
+            return () => { };
+        }
+        let ws = null;
+        let cancelled = false;
+        let backoffMs = 1000;
+        const MAX_BACKOFF_MS = 30000;
+        // Attempts where the socket closed before ever opening (failed upgrade).
+        // After MAX_FAILED_UPGRADES consecutive such failures we back off to a long
+        // cooldown interval rather than hammering (e.g. DO free-tier exhaustion).
+        // Once the cooldown elapses we try again — self-healing if the server recovers.
+        let failedUpgradeStreak = 0;
+        const MAX_FAILED_UPGRADES = 5;
+        const COOLDOWN_MS = 60 * 60 * 1000; // 1 hour
+        const connect = () => {
+            if (cancelled)
+                return;
+            let opened = false;
+            try {
+                ws = new WebSocket(this.notifyUrl);
+            }
+            catch (error) {
+                hooks?.onError?.(error);
+                failedUpgradeStreak++;
+                scheduleReconnect();
+                return;
+            }
+            ws.onopen = () => {
+                opened = true;
+                failedUpgradeStreak = 0;
+                backoffMs = 1000;
+                hooks?.onReady?.();
+            };
+            ws.onmessage = (e) => {
+                try {
+                    const msg = JSON.parse(e.data);
+                    if (msg.type === 'invalidation' || msg.type === 'invalidate' || msg.type === 'compact') {
+                        onInvalidate(msg);
+                    }
+                }
+                catch {
+                    onInvalidate({ type: 'unknown', path: '/', ts: Date.now() });
+                }
+            };
+            ws.onerror = (event) => {
+                hooks?.onError?.(event);
+            };
+            ws.onclose = () => {
+                if (!opened) {
+                    // The upgrade itself failed (server returned non-101, e.g. 500/503).
+                    failedUpgradeStreak++;
+                }
+                if (!cancelled) {
+                    hooks?.onClose?.();
+                    if (failedUpgradeStreak >= MAX_FAILED_UPGRADES) {
+                        // Back off to a long cooldown then try again — self-healing if the
+                        // server recovers (e.g. DO free-tier resets).
+                        failedUpgradeStreak = 0;
+                        backoffMs = 1000;
+                        setTimeout(() => connect(), COOLDOWN_MS);
+                        return;
+                    }
+                    scheduleReconnect();
+                }
+            };
+        };
+        const scheduleReconnect = () => {
+            if (cancelled)
+                return;
+            setTimeout(() => connect(), backoffMs);
+            backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+        };
+        connect();
+        return () => {
+            cancelled = true;
+            try {
+                ws?.close(1000, 'unsubscribed');
+            }
+            catch { }
+            ws = null;
+        };
+    }
+    async ensureFolder(path) {
+        if (this.ensuredFolders.has(path))
+            return;
+        const res = await fetch(this.ioUrl('/ensure-folder'), {
+            method: 'POST',
+            headers: this.headers({ 'Content-Type': 'application/json; charset=utf-8' }),
+            body: JSON.stringify({ path }),
+        });
+        if (!res.ok && res.status !== 405) {
+            throw new Error(`Failed to ensure folder ${path}: HTTP ${res.status}`);
+        }
+        this.ensuredFolders.add(path);
+    }
+    /** Drop the per-session ensureFolder cache. Call after mesh swap, poison,
+     *  or any state where a previous "this folder exists" observation must
+     *  not be trusted. */
+    resetFolderCache() {
+        this.ensuredFolders.clear();
+    }
+    async listFiles(path) {
+        const res = await fetch(this.ioUrl('/list-files'), {
+            method: 'POST',
+            headers: this.headers({ 'Content-Type': 'application/json; charset=utf-8' }),
+            body: JSON.stringify({ path }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to list files for ${path}: HTTP ${res.status}`);
+        }
+        const payload = await res.json();
+        return (payload.files ?? []).map((f) => ({
+            name: f.name,
+            path: f.path,
+            size: f.size,
+            modifiedTime: f.modifiedTime,
+            etag: f.etag,
+        }));
+    }
+    async listFolders(path) {
+        const res = await fetch(this.ioUrl('/list-folders'), {
+            method: 'POST',
+            headers: this.headers({ 'Content-Type': 'application/json; charset=utf-8' }),
+            body: JSON.stringify({ path }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to list folders for ${path}: HTTP ${res.status}`);
+        }
+        const payload = await res.json();
+        return payload.folders ?? [];
+    }
+    async readFile(path) {
+        const res = await fetch(this.fileUrl(path), {
+            method: 'GET',
+            headers: this.headers(),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to read ${path}: HTTP ${res.status}`);
+        }
+        return new Uint8Array(await res.arrayBuffer());
+    }
+    async writeFile(path, data) {
+        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        const res = await fetch(this.fileUrl(path), {
+            method: 'PUT',
+            headers: this.headers({ 'Content-Type': 'application/octet-stream' }),
+            body: bytes,
+        });
+        if (!res.ok && res.status !== 201 && res.status !== 204) {
+            throw new Error(`Failed to write ${path}: HTTP ${res.status}`);
+        }
+    }
+    async deleteFile(path) {
+        const res = await fetch(this.fileUrl(path), {
+            method: 'DELETE',
+            headers: this.headers(),
+        });
+        if (!res.ok && res.status !== 404 && res.status !== 405) {
+            throw new Error(`Failed to delete ${path}: HTTP ${res.status}`);
+        }
+    }
+    async getFileMetadata(path) {
+        const res = await fetch(this.ioUrl('/metadata'), {
+            method: 'POST',
+            headers: this.headers({ 'Content-Type': 'application/json; charset=utf-8' }),
+            body: JSON.stringify({ path }),
+        });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            return null;
+        const payload = await res.json();
+        const f = payload.file;
+        if (!f)
+            return null;
+        return {
+            name: f.name,
+            path: f.path,
+            size: f.size,
+            modifiedTime: f.modifiedTime,
+            etag: f.etag,
+        };
+    }
+    async putStoredFile(path, data, options = {}) {
+        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        const res = await fetch(this.storedFileUrl(path), {
+            method: 'PUT',
+            headers: this.headers({
+                'Content-Type': options.contentType || 'application/octet-stream',
+                'X-Interocitor-Device-Id': options.uploadedByDeviceId || '',
+                'X-Interocitor-Plaintext-Size': String(options.plaintextSize ?? bytes.byteLength),
+            }),
+            body: bytes,
+        });
+        if (!res.ok)
+            throw new Error(`Failed to upload stored file ${path}: HTTP ${res.status}`);
+        const payload = await res.json();
+        return payload.file;
+    }
+    async getStoredFile(path) {
+        const res = await fetch(this.storedFileUrl(path), { method: 'GET', headers: this.headers() });
+        if (!res.ok)
+            throw new Error(`Failed to read stored file ${path}: HTTP ${res.status}`);
+        return new Uint8Array(await res.arrayBuffer());
+    }
+    async deleteStoredFile(path) {
+        const res = await fetch(this.storedFileUrl(path), { method: 'DELETE', headers: this.headers() });
+        if (!res.ok && res.status !== 404)
+            throw new Error(`Failed to delete stored file ${path}: HTTP ${res.status}`);
+    }
+    async getStoredFileMetadata(path) {
+        const res = await fetch(this.ioUrl('/stored-file-metadata'), {
+            method: 'POST',
+            headers: this.headers({ 'Content-Type': 'application/json; charset=utf-8' }),
+            body: JSON.stringify({ path }),
+        });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            return null;
+        const payload = await res.json();
+        return payload.file ?? null;
+    }
+}

package/dist/adapters/google-drive.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Google Drive Storage Adapter
+ *
+ * Uses Google Drive API v3 via OAuth2 with `drive.file` scope.
+ * The app can only see files it created or the user explicitly shared.
+ *
+ * Requires: Google API client ID from Google Cloud Console.
+ * Auth flow: Google Identity Services (GIS) popup or redirect.
+ */
+import type { StorageAdapter, FileEntry } from '../core/types.ts';
+interface GoogleDriveConfig {
+    clientId: string;
+    /** Redirect URI for OAuth (default: current origin) */
+    redirectUri?: string;
+}
+/**
+ * Google Drive adapter using the browser OAuth token flow.
+ *
+ * This is the easiest zero-infrastructure option when your users already live
+ * in Google Workspace or personal Drive.
+ *
+ * @example
+ * ```ts
+ * const adapter = new GoogleDriveAdapter({ clientId: 'YOUR_GOOGLE_CLIENT_ID' });
+ * const engine = new Interocitor(adapter, { remotePath: '/MyApp' });
+ * ```
+ */
+export declare class GoogleDriveAdapter implements StorageAdapter {
+    readonly name = "google-drive";
+    private config;
+    private accessToken;
+    private fileIdCache;
+    private folderIdCache;
+    constructor(config: GoogleDriveConfig);
+    authenticate(): Promise<void>;
+    /** Set token directly (for apps that handle their own OAuth flow). */
+    setAccessToken(token: string): void;
+    /**
+     * Returns the Google OAuth clientId for embedding in a QR payload.
+     * The scanner uses this to configure their GoogleDriveAdapter.
+     * The OAuth flow (and resulting access token) is performed separately by the user.
+     */
+    getHandshakeConfig(): string;
+    isAuthenticated(): boolean;
+    private verifyToken;
+    private headers;
+    /**
+     * Resolve a path like "/Interocitor/changes/dev_abc.ndjson"
+     * to a Google Drive file ID by walking the folder tree.
+     */
+    private resolveFileId;
+    private resolveFolderId;
+    ensureFolder(path: string): Promise<void>;
+    listFiles(folderPath: string): Promise<FileEntry[]>;
+    listFolders(folderPath: string): Promise<string[]>;
+    readFile(path: string): Promise<Uint8Array>;
+    writeFile(path: string, data: Uint8Array | string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    getFileMetadata(path: string): Promise<FileEntry | null>;
+    /** Clear caches (useful after compaction deletes files). */
+    clearCache(): void;
+}
+export {};
+//# sourceMappingURL=google-drive.d.ts.map

package/dist/adapters/google-drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-drive.d.ts","sourceRoot":"","sources":["../../src/adapters/google-drive.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAMlE,UAAU,iBAAiB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IACvD,QAAQ,CAAC,IAAI,kBAAkB;IAE/B,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,WAAW,CAAuB;IAG1C,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,aAAa,CAAkC;gBAE3C,MAAM,EAAE,iBAAiB;IAM/B,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAkDnC,sEAAsE;IACtE,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKnC;;;;OAIG;IACH,kBAAkB,IAAI,MAAM;IAI5B,eAAe,IAAI,OAAO;YAIZ,WAAW;IAWzB,OAAO,CAAC,OAAO;IAOf;;;OAGG;YACW,aAAa;YAyCb,eAAe;IAiCvB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6CzC,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAwBnD,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAclD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAc3C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4EjE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAoB9D,4DAA4D;IAC5D,UAAU,IAAI,IAAI;CAInB"}