@interocitor/core 0.0.0-beta.10

package/dist/adapters/webdav.js

@@ -0,0 +1,323 @@
+/**
+ * WebDAV Storage Adapter
+ *
+ * For self-hosted clouds: Nextcloud, ownCloud, or any WebDAV server.
+ * "My own cloud" option — user runs their own server.
+ *
+ * WebDAV is HTTP-based, works from any browser.
+ * Most implementations support Basic auth or Bearer tokens.
+ */
+/**
+ * Browser-friendly WebDAV adapter for Nextcloud, ownCloud, and compatible DAV servers.
+ *
+ * @example
+ * ```ts
+ * const adapter = new WebDAVAdapter({
+ *   baseUrl: 'https://cloud.example.com/remote.php/dav/files/alice',
+ *   auth: { username: 'alice', password: 'APP_PASSWORD' },
+ * });
+ * ```
+ */
+export class WebDAVAdapter {
+    constructor(config) {
+        this.name = 'webdav';
+        this.authenticated = false;
+        // Per-session cache of folders we have already MKCOL'd. WebDAV folders
+        // are stable for the life of the mesh; a caller (Interocitor.connect)
+        // re-runs the same 4-folder ensureFolder loop on every reload, which
+        // costs 4 sequential MKCOL round-trips for no benefit. Cache wipes on
+        // explicit `resetFolderCache()` (mesh swap / poison) or process exit.
+        this.ensuredFolders = new Set();
+        this.config = config;
+    }
+    url(path) {
+        const base = this.config.baseUrl.replace(/\/$/, '');
+        const clean = path.startsWith('/') ? path : '/' + path;
+        return base + clean;
+    }
+    authHeader() {
+        const auth = this.config.auth;
+        if ('token' in auth) {
+            return `Bearer ${auth.token}`;
+        }
+        return `Basic ${btoa(`${auth.username}:${auth.password}`)}`;
+    }
+    headers(extra) {
+        return {
+            Authorization: this.authHeader(),
+            ...extra,
+        };
+    }
+    async authenticate() {
+        // Verify credentials by doing a PROPFIND on root
+        const res = await fetch(this.url('/'), {
+            method: 'PROPFIND',
+            headers: this.headers({ Depth: '0' }),
+        });
+        if (res.status === 207 || res.ok) {
+            this.authenticated = true;
+        }
+        else if (res.status === 401) {
+            throw new Error('WebDAV authentication failed');
+        }
+        else {
+            throw new Error(`WebDAV error: ${res.status}`);
+        }
+    }
+    /**
+     * Returns the WebDAV base URL (without credentials) for embedding in a QR payload.
+     * The scanner uses this to point their WebDAVAdapter at the same server.
+     * Auth (username/password or token) must be configured separately by the user.
+     */
+    getHandshakeConfig() {
+        return JSON.stringify({ baseUrl: this.config.baseUrl });
+    }
+    isAuthenticated() {
+        return this.authenticated;
+    }
+    async ensureFolder(path) {
+        if (this.ensuredFolders.has(path))
+            return;
+        const parts = path.split('/').filter(Boolean);
+        let current = '';
+        for (const part of parts) {
+            current += '/' + part;
+            if (this.ensuredFolders.has(current))
+                continue; // ancestor cached
+            const res = await fetch(this.url(current), {
+                method: 'MKCOL',
+                headers: this.headers(),
+            });
+            // 201 Created, 405 Already Exists — both fine
+            if (!res.ok && res.status !== 405) {
+                throw new Error(`Failed to create folder ${current}: ${res.status}`);
+            }
+            this.ensuredFolders.add(current);
+        }
+        this.ensuredFolders.add(path);
+    }
+    /** Drop the per-session ensureFolder cache. Call after mesh swap, poison,
+     *  or any state where we cannot trust a previous "this folder exists"
+     *  observation. */
+    resetFolderCache() {
+        this.ensuredFolders.clear();
+    }
+    async listFiles(folderPath) {
+        const res = await fetch(this.url(folderPath), {
+            method: 'PROPFIND',
+            headers: this.headers({
+                Depth: '1',
+                'Content-Type': 'application/xml',
+            }),
+            body: `<?xml version="1.0" encoding="UTF-8"?>
+        <d:propfind xmlns:d="DAV:">
+          <d:prop>
+            <d:getcontentlength/>
+            <d:getlastmodified/>
+            <d:resourcetype/>
+            <d:getetag/>
+          </d:prop>
+        </d:propfind>`,
+        });
+        if (res.status !== 207) {
+            throw new Error(`PROPFIND failed: ${res.status}`);
+        }
+        const xml = await res.text();
+        return this.parsePropfindResponse(xml, folderPath);
+    }
+    parsePropfindResponse(xml, basePath) {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(xml, 'application/xml');
+        const responses = doc.getElementsByTagNameNS('DAV:', 'response');
+        const entries = [];
+        for (let i = 0; i < responses.length; i++) {
+            const response = responses[i];
+            const href = response.getElementsByTagNameNS('DAV:', 'href')[0]?.textContent || '';
+            // Skip the folder itself (first response)
+            if (i === 0)
+                continue;
+            // Skip sub-folders
+            const resourceType = response.getElementsByTagNameNS('DAV:', 'collection');
+            if (resourceType.length > 0)
+                continue;
+            const size = response.getElementsByTagNameNS('DAV:', 'getcontentlength')[0]?.textContent || '0';
+            const modified = response.getElementsByTagNameNS('DAV:', 'getlastmodified')[0]?.textContent || '';
+            const etag = response.getElementsByTagNameNS('DAV:', 'getetag')[0]?.textContent || undefined;
+            // Extract filename from href
+            const name = decodeURIComponent(href.split('/').filter(Boolean).pop() || '');
+            entries.push({
+                name,
+                path: `${basePath}/${name}`,
+                size: parseInt(size, 10),
+                modifiedTime: modified ? new Date(modified).toISOString() : '',
+                etag,
+            });
+        }
+        return entries;
+    }
+    async listFolders(folderPath) {
+        const res = await fetch(this.url(folderPath), {
+            method: 'PROPFIND',
+            headers: this.headers({
+                Depth: '1',
+                'Content-Type': 'application/xml',
+            }),
+            body: `<?xml version="1.0" encoding="UTF-8"?>
+        <d:propfind xmlns:d="DAV:">
+          <d:prop>
+            <d:resourcetype/>
+          </d:prop>
+        </d:propfind>`,
+        });
+        if (res.status !== 207)
+            return [];
+        const xml = await res.text();
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(xml, 'application/xml');
+        const responses = doc.getElementsByTagNameNS('DAV:', 'response');
+        const folders = [];
+        for (let i = 1; i < responses.length; i++) {
+            const response = responses[i];
+            const isCollection = response.getElementsByTagNameNS('DAV:', 'collection').length > 0;
+            if (!isCollection)
+                continue;
+            const href = response.getElementsByTagNameNS('DAV:', 'href')[0]?.textContent || '';
+            const name = decodeURIComponent(href.split('/').filter(Boolean).pop() || '');
+            if (name)
+                folders.push(name);
+        }
+        return folders;
+    }
+    async readFile(path) {
+        const res = await fetch(this.url(path), {
+            method: 'GET',
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to read ${path}: ${res.status}`);
+        const buffer = await res.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    async writeFile(path, data) {
+        const body = typeof data === 'string'
+            ? new TextEncoder().encode(data)
+            : data;
+        const res = await fetch(this.url(path), {
+            method: 'PUT',
+            headers: this.headers({ 'Content-Type': 'application/octet-stream' }),
+            body: body,
+        });
+        if (!res.ok && res.status !== 201 && res.status !== 204) {
+            throw new Error(`Failed to write ${path}: ${res.status}`);
+        }
+    }
+    async deleteFile(path) {
+        const res = await fetch(this.url(path), {
+            method: 'DELETE',
+            headers: this.headers(),
+        });
+        // 204 No Content or 404 Not Found — both acceptable
+        if (!res.ok && res.status !== 404) {
+            throw new Error(`Failed to delete ${path}: ${res.status}`);
+        }
+    }
+    parentDir(path) {
+        const clean = path.startsWith('/') ? path : `/${path}`;
+        const idx = clean.lastIndexOf('/');
+        return idx <= 0 ? '/' : clean.slice(0, idx);
+    }
+    storedMetaPath(path) {
+        return `${path}.interocitor-meta.json`;
+    }
+    async putStoredFile(path, data, options = {}) {
+        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        await this.ensureFolder(this.parentDir(path));
+        await this.writeFile(path, bytes);
+        const file = await this.getFileMetadata(path);
+        const now = new Date().toISOString();
+        const meta = {
+            name: file?.name ?? path.split('/').pop() ?? path,
+            path,
+            size: file?.size ?? bytes.byteLength,
+            modifiedTime: file?.modifiedTime ?? now,
+            etag: file?.etag,
+            uploadedAt: now,
+            uploadedByDeviceId: options.uploadedByDeviceId,
+            plaintextSize: options.plaintextSize,
+            storedSize: bytes.byteLength,
+            contentType: options.contentType,
+            useCount: 0,
+        };
+        await this.writeFile(this.storedMetaPath(path), JSON.stringify(meta));
+        return meta;
+    }
+    async getStoredFile(path) {
+        const bytes = await this.readFile(path);
+        const meta = await this.getStoredFileMetadata(path);
+        if (meta) {
+            await this.writeFile(this.storedMetaPath(path), JSON.stringify({
+                ...meta,
+                lastAccessedAt: new Date().toISOString(),
+                useCount: (meta.useCount ?? 0) + 1,
+            }));
+        }
+        return bytes;
+    }
+    async deleteStoredFile(path) {
+        await this.deleteFile(path);
+        try {
+            await this.deleteFile(this.storedMetaPath(path));
+        }
+        catch { }
+    }
+    async getStoredFileMetadata(path) {
+        try {
+            const raw = await this.readFile(this.storedMetaPath(path));
+            return JSON.parse(new TextDecoder().decode(raw));
+        }
+        catch {
+            const file = await this.getFileMetadata(path);
+            return file ? { ...file, storedSize: file.size } : null;
+        }
+    }
+    async getFileMetadata(path) {
+        const res = await fetch(this.url(path), {
+            method: 'PROPFIND',
+            headers: this.headers({
+                Depth: '0',
+                'Content-Type': 'application/xml',
+            }),
+            body: `<?xml version="1.0" encoding="UTF-8"?>
+        <d:propfind xmlns:d="DAV:">
+          <d:prop>
+            <d:getcontentlength/>
+            <d:getlastmodified/>
+            <d:getetag/>
+          </d:prop>
+        </d:propfind>`,
+        });
+        if (res.status === 404)
+            return null;
+        if (res.status !== 207)
+            return null;
+        const xml = await res.text();
+        // PROPFIND with Depth:0 on a file returns one entry for itself
+        // but our parser skips index 0, so we handle it differently
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(xml, 'application/xml');
+        const response = doc.getElementsByTagNameNS('DAV:', 'response')[0];
+        if (!response)
+            return null;
+        const size = response.getElementsByTagNameNS('DAV:', 'getcontentlength')[0]?.textContent || '0';
+        const modified = response.getElementsByTagNameNS('DAV:', 'getlastmodified')[0]?.textContent || '';
+        const etag = response.getElementsByTagNameNS('DAV:', 'getetag')[0]?.textContent || undefined;
+        const name = path.split('/').filter(Boolean).pop() || '';
+        return {
+            name,
+            path,
+            size: parseInt(size, 10),
+            modifiedTime: modified ? new Date(modified).toISOString() : '',
+            etag,
+        };
+    }
+}

package/dist/core/codec.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Codec — encryption/decryption of change and snapshot payloads.
+ *
+ * Extracted from Interocitor to keep the orchestrator lean.
+ * Not part of the public API.
+ */
+import type { ChangeEntry, Manifest, Snapshot, LocalStoreAdapter } from './types.ts';
+export interface CodecState {
+    encryptionKey: CryptoKey | null;
+    encrypted: boolean;
+    manifest: Manifest | null;
+}
+export declare function encodeForCloud(state: CodecState, plaintext: string): Promise<string>;
+export declare function decodeFromCloud(state: CodecState, data: string): Promise<string>;
+export declare function assertExpectedMeshId(local: LocalStoreAdapter, manifest: Manifest | null, meshId: string): Promise<void>;
+export declare function encodeChangePayload(state: CodecState, entry: ChangeEntry): Promise<string>;
+export declare function decodeChangePayload(state: CodecState, local: LocalStoreAdapter, data: string, path: string): Promise<ChangeEntry>;
+export declare function encodeSnapshotPayload(state: CodecState, snapshot: Snapshot): Promise<string>;
+export declare function decodeSnapshotPayload(state: CodecState, local: LocalStoreAdapter, data: string, path: string): Promise<Snapshot>;
+//# sourceMappingURL=codec.d.ts.map

package/dist/core/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/core/codec.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,QAAQ,EAGR,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,SAAS,GAAG,IAAI,CAAC;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC3B;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG1F;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BtF;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,QAAQ,GAAG,IAAI,EACzB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAQhG;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,WAAW,CAAC,CAgBtB;AAED,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAQlG;AAED,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,QAAQ,CAAC,CAgBnB"}

package/dist/core/codec.js

@@ -0,0 +1,102 @@
+/**
+ * Codec — encryption/decryption of change and snapshot payloads.
+ *
+ * Extracted from Interocitor to keep the orchestrator lean.
+ * Not part of the public API.
+ */
+import { encryptEntry, decryptEntry } from "../crypto/encryption.js";
+export async function encodeForCloud(state, plaintext) {
+    if (!state.encrypted || !state.encryptionKey)
+        return plaintext;
+    return encryptEntry(state.encryptionKey, plaintext);
+}
+export async function decodeFromCloud(state, data) {
+    if (!state.encrypted || !state.encryptionKey)
+        return data;
+    try {
+        return await decryptEntry(state.encryptionKey, data);
+    }
+    catch (err) {
+        // Re-throw with explicit context. Decode errors at this layer mean the
+        // active key cannot decrypt this payload — either the wrong key was
+        // loaded, or the payload was written under a different key (mesh swap,
+        // passphrase rotated, two devices bound to same dbName but different
+        // passphrases). Caller wraps this in poisonRemote with the file path.
+        const reason = err instanceof Error ? err.message : String(err);
+        let keyFingerprint = '<unknown>';
+        try {
+            const raw = await crypto.subtle.exportKey('raw', state.encryptionKey);
+            const hash = await crypto.subtle.digest('SHA-256', raw);
+            const bytes = new Uint8Array(hash);
+            const hex = Array.from(bytes.slice(0, 6)).map(b => b.toString(16).padStart(2, '0')).join('');
+            keyFingerprint = `sha256-${hex}`;
+        }
+        catch { /* ignore */ }
+        console.log('[interocitor:decode] decodeFromCloud() — DECRYPT FAIL', {
+            keyFingerprint,
+            meshId: state.manifest?.meshId,
+            payloadFirst32: data.slice(0, 32),
+            payloadLen: data.length,
+            reason,
+        });
+        const e = new Error(`Decryption failed: payload not decryptable with the active mesh key (${reason}). The remote was likely written under a different key/mesh.`);
+        e.cause = err;
+        throw e;
+    }
+}
+export async function assertExpectedMeshId(local, manifest, meshId) {
+    if (!meshId) {
+        throw new Error('Remote mesh is missing meshId');
+    }
+    const manifestMeshId = manifest?.meshId;
+    if (manifestMeshId && manifestMeshId !== meshId) {
+        throw new Error(`Remote mesh mismatch: expected ${manifestMeshId}, got ${meshId}`);
+    }
+    const storedMeshId = await local.getMeta('meshId');
+    if (typeof storedMeshId === 'string' && storedMeshId && storedMeshId !== meshId) {
+        throw new Error(`Remote mesh mismatch: expected ${storedMeshId}, got ${meshId}`);
+    }
+    await local.setMeta('meshId', meshId);
+}
+export async function encodeChangePayload(state, entry) {
+    const meshId = state.manifest?.meshId;
+    if (!meshId) {
+        throw new Error('Cannot encode change payload before manifest is loaded');
+    }
+    const payload = { meshId, kind: 'change', entry };
+    return encodeForCloud(state, JSON.stringify(payload));
+}
+export async function decodeChangePayload(state, local, data, path) {
+    const decoded = await decodeFromCloud(state, data);
+    const payload = JSON.parse(decoded);
+    const payloadRecord = payload;
+    if ('mesh' in payloadRecord && !('meshId' in payloadRecord)) {
+        throw new Error(`Remote change payload has invalid shape: ${path}`);
+    }
+    if (payload.kind !== 'change' || !payload.entry) {
+        throw new Error(`Remote change payload has invalid shape: ${path}`);
+    }
+    await assertExpectedMeshId(local, state.manifest, String(payload.meshId || ''));
+    return payload.entry;
+}
+export async function encodeSnapshotPayload(state, snapshot) {
+    const meshId = state.manifest?.meshId;
+    if (!meshId) {
+        throw new Error('Cannot encode snapshot payload before manifest is loaded');
+    }
+    const payload = { meshId, kind: 'snapshot', snapshot };
+    return encodeForCloud(state, JSON.stringify(payload));
+}
+export async function decodeSnapshotPayload(state, local, data, path) {
+    const decoded = await decodeFromCloud(state, data);
+    const payload = JSON.parse(decoded);
+    const payloadRecord = payload;
+    if ('mesh' in payloadRecord && !('meshId' in payloadRecord)) {
+        throw new Error(`Remote snapshot payload has invalid shape: ${path}`);
+    }
+    if (payload.kind !== 'snapshot' || !payload.snapshot) {
+        throw new Error(`Remote snapshot payload has invalid shape: ${path}`);
+    }
+    await assertExpectedMeshId(local, state.manifest, String(payload.meshId || ''));
+    return payload.snapshot;
+}

package/dist/core/compaction.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Compaction — snapshot + manifest rotation + change file pruning.
+ *
+ * Concurrency note:
+ * - No built-in lock or CAS on manifest pointer.
+ * - Concurrent compaction can race and overwrite the pointer.
+ * - Recommended: acquire a remote lease (e.g. mainline/compact-lock.json)
+ *   and abort if another compactor is active, or if manifest generation
+ *   changes after the lease is acquired.
+ *
+ * Extracted from Interocitor. Not part of the public API.
+ */
+import type { StorageAdapter, LocalStoreAdapter, Manifest, Row, SyncEvent } from './types.ts';
+import type { HLC } from './types.ts';
+import type { CodecState } from './codec.ts';
+export interface CompactContext {
+    adapter: StorageAdapter;
+    local: LocalStoreAdapter;
+    remotePath: string;
+    manifest: Manifest;
+    codecState: CodecState;
+    hlc: HLC;
+    deviceId: string;
+    serverId: string;
+    emit: (event: SyncEvent) => void;
+    pull: () => Promise<void>;
+    offlineGraceMs?: number;
+}
+export declare function compact(ctx: CompactContext): Promise<Manifest>;
+export interface RehydrateContext {
+    adapter: StorageAdapter;
+    local: LocalStoreAdapter;
+    codecState: CodecState;
+    manifest: Manifest | null;
+    hlc: HLC;
+    deviceId: string;
+    tables: Record<string, Record<string, Row>>;
+    knownTables: Set<string>;
+    emit: (event: SyncEvent) => void;
+    poisonRemote: (error: unknown, path?: string) => Promise<Error>;
+    pull: () => Promise<void>;
+}
+/** Returns the updated HLC after rehydration. */
+export declare function rehydrate(ctx: RehydrateContext): Promise<HLC>;
+//# sourceMappingURL=compaction.d.ts.map

package/dist/core/compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../src/core/compaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EACjB,QAAQ,EAGR,GAAG,EACH,SAAS,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAItC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,iBAAiB,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC;IACvB,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IACjC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAkCD,wBAAsB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsGpE;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,iBAAiB,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAC5C,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IACjC,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IAChE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,iDAAiD;AACjD,wBAAsB,SAAS,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,CAiDnE"}