@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/backends/codex/session/history.js

@@ -0,0 +1,196 @@
+import { t } from '../../../i18n.js';
+import { arr, rec, str } from '../narrow.js';
+import { CLIENT, NOTIFY } from '../protocol/index.js';
+import { createItemContext } from '../translate/items.js';
+import { replayTurns } from '../translate/replay.js';
+/** Turns the first page replays. */
+export const HISTORY_PAGE_TURNS = 20;
+/** The `initialTurnsPage` request of `thread/resume`. */
+export const INITIAL_TURNS_PAGE = { limit: HISTORY_PAGE_TURNS, sortDirection: 'desc', itemsView: 'full' };
+/** The resume answer's first page as events (advancing `ctx`), and the
+ *  cursor of the next older page. */
+export function replayResumePage(response, ctx) {
+    const page = rec(response.initialTurnsPage);
+    const turns = page === undefined ? [...arr(rec(response.thread)?.turns)] : [...arr(page.data)].reverse();
+    const events = replayTurns(turns, ctx);
+    const cursor = str(page?.nextCursor) ?? str(response.turnsBackwardsCursor);
+    return { events, ...(cursor === undefined ? {} : { olderCursor: cursor }) };
+}
+const RECORD_TURNS_LIMIT = 1000;
+const RECORD_CHARS_LIMIT = 64 * 1024 * 1024;
+/** A synchronous bounded record over native full items, with one older page
+ * ready ahead of the user. No I/O, decoding, or live seq changes on older(). */
+export function createCodexTranscriptHistory(deps) {
+    let loaded = [];
+    let initial = [];
+    let cursor;
+    let cached;
+    let record;
+    let pending;
+    let abort;
+    let generation = 0;
+    let failures = 0;
+    let closed = false;
+    const weights = new Map();
+    let retainedChars = 0;
+    const freshContext = () => createItemContext({ cwd: deps.cwd, debug: deps.ctx.debug, now: deps.ctx.now, model: deps.ctx.model });
+    const replay = (turns) => replayTurns(turns, freshContext());
+    const keyOf = (turn) => str(turn.id) ?? '';
+    const bound = () => {
+        while (loaded.length > RECORD_TURNS_LIMIT || retainedChars > RECORD_CHARS_LIMIT) {
+            const removed = loaded.shift();
+            if (removed === undefined)
+                break;
+            const id = keyOf(removed);
+            retainedChars -= weights.get(id) ?? 0;
+            weights.delete(id);
+        }
+        record = undefined;
+    };
+    const retain = (turns) => {
+        loaded = turns;
+        weights.clear();
+        retainedChars = 0;
+        for (const turn of loaded) {
+            const weight = JSON.stringify(turn).length;
+            weights.set(keyOf(turn), weight);
+            retainedChars += weight;
+        }
+        bound();
+    };
+    const mergeTurn = (turn) => {
+        const id = keyOf(turn);
+        if (id === '')
+            return;
+        const at = loaded.findIndex(row => keyOf(row) === id);
+        if (at === -1)
+            loaded.push(turn);
+        else
+            loaded[at] = turn;
+        const weight = JSON.stringify(turn).length;
+        retainedChars += weight - (weights.get(id) ?? 0);
+        weights.set(id, weight);
+        bound();
+    };
+    const prefetch = () => {
+        if (closed || cursor === undefined || pending !== undefined || cached !== undefined || failures >= 3)
+            return;
+        const before = cursor;
+        const gen = generation;
+        const controller = new AbortController();
+        abort = controller;
+        const request = deps.hub.call(CLIENT.threadTurnsList, { threadId: deps.threadId, cursor: before, limit: HISTORY_PAGE_TURNS, sortDirection: 'desc', itemsView: 'full' }, { signal: controller.signal });
+        const task = request.then(answer => {
+            if (closed || generation !== gen)
+                return;
+            const page = rec(answer);
+            const known = new Set(loaded.map(keyOf));
+            const turns = [...arr(page?.data)].reverse().map(rec).filter((row) => row !== undefined && keyOf(row) !== '' && !known.has(keyOf(row)));
+            const next = str(page?.nextCursor);
+            cached = { turns, events: replay(turns), ...(next === undefined || next === before ? {} : { next }) };
+            failures = 0;
+        }, () => {
+            if (closed || generation !== gen)
+                return;
+            failures += 1;
+            deps.ctx.debug('codex: older history prefetch failed; cursor retained');
+            if (failures >= 3)
+                deps.notice?.({ type: 'notice', level: 'warning', key: 'codex-older-history', text: t('codex-history-fetch-failed') });
+        }).finally(() => { if (pending === task) {
+            pending = undefined;
+            abort = undefined;
+        } });
+        pending = task;
+    };
+    const initialize = (response, context) => {
+        generation += 1;
+        abort?.abort();
+        pending = undefined;
+        abort = undefined;
+        cached = undefined;
+        failures = 0;
+        const page = rec(response.initialTurnsPage);
+        const native = arr(page?.data ?? rec(response.thread)?.turns);
+        retain((page === undefined ? [...native] : [...native].reverse()).map(rec).filter((row) => row !== undefined));
+        const seed = replayResumePage(response, context);
+        initial = seed.events;
+        cursor = seed.olderCursor;
+        prefetch();
+    };
+    const capability = {
+        record: () => {
+            if (closed)
+                return undefined;
+            record ??= replay(loaded);
+            return record;
+        },
+        hasOlder: () => !closed && failures < 3 && (cached !== undefined || cursor !== undefined),
+        older: () => {
+            if (closed || failures >= 3)
+                return [];
+            if (cached === undefined) {
+                prefetch();
+                return [];
+            }
+            const page = cached;
+            cached = undefined;
+            const known = new Set(loaded.map(keyOf));
+            retain([...page.turns.filter(turn => !known.has(keyOf(turn))), ...loaded]);
+            cursor = page.next;
+            prefetch();
+            return page.events;
+        },
+    };
+    initialize(deps.response, deps.ctx);
+    return {
+        capability,
+        takeInitial() { const events = initial; initial = []; return events; },
+        reset: response => { if (!closed)
+            initialize(response, freshContext()); },
+        get turns() { return [...(cached?.turns ?? []), ...loaded]; },
+        previousTurnId(anchor) {
+            const turns = [...(cached?.turns ?? []), ...loaded];
+            const index = turns.findIndex(turn => arr(turn.items).some(item => str(rec(item)?.id) === anchor));
+            return index > 0 ? str(turns[index - 1]?.id) : undefined;
+        },
+        notification(method, params) {
+            if (closed || (str(params.threadId) !== undefined && params.threadId !== deps.threadId))
+                return;
+            if (method === NOTIFY.turnStarted || method === NOTIFY.turnCompleted) {
+                const turn = rec(params.turn);
+                const id = turn === undefined ? undefined : str(turn.id);
+                if (turn === undefined || id === undefined)
+                    return;
+                const existing = loaded.find(row => keyOf(row) === id);
+                const items = [...arr(existing?.items)];
+                const byId = new Map(items.map(item => [str(rec(item)?.id), item]));
+                for (const item of arr(turn.items)) {
+                    const itemId = str(rec(item)?.id);
+                    if (itemId === undefined)
+                        continue;
+                    // A summary cannot replace a completed full item's tool body.
+                    if (!byId.has(itemId))
+                        byId.set(itemId, item);
+                }
+                mergeTurn({ ...existing, ...turn, items: [...byId.values()] });
+            }
+            else if (method === NOTIFY.itemCompleted) {
+                const id = str(params.turnId);
+                const item = rec(params.item);
+                if (id === undefined || item === undefined)
+                    return;
+                const turn = loaded.find(row => keyOf(row) === id) ?? { id, status: 'inProgress', items: [] };
+                const items = [...arr(turn.items)];
+                const at = items.findIndex(row => str(rec(row)?.id) === str(item.id));
+                if (at === -1)
+                    items.push(item);
+                else {
+                    const prior = rec(items[at]);
+                    items[at] = prior === undefined ? item : { ...prior, ...item };
+                }
+                mergeTurn({ ...turn, items });
+            }
+        },
+        close() { closed = true; generation += 1; abort?.abort(); cached = undefined; loaded = []; initial = []; record = undefined; weights.clear(); },
+    };
+}

package/lib/types/backends/codex/session/images.d.ts

@@ -0,0 +1,17 @@
+import type { ImageLimitsView } from '../../../agent/capabilities.js';
+import type { ImageRef } from '../../../agent/events.js';
+import { type Rec } from '../narrow.js';
+import type { UserInput } from '../protocol/index.js';
+export declare const CODEX_IMAGE_LIMITS: ImageLimitsView;
+/** Read and recheck staged facades before any turn/steer request is sent. */
+export declare function codexImageInputs(images: readonly ImageRef[], limits?: ImageLimitsView): Promise<UserInput[]>;
+/** No network fetches: only embedded supported-image data URLs are facades. */
+export declare function dataUrlImageFacade(id: string, url: string): ImageRef | undefined;
+/** Lazy local file view. A missing historical path still has a placeholder
+ * facade; read rejects normally, letting the shared preview show unavailable. */
+export declare function pathImageFacade(id: string, path: string, cwd: string): ImageRef;
+/** userMessage.content image/localImage blocks, in their durable order. */
+export declare function transcriptImages(content: unknown, idPrefix: string, cwd: string): ImageRef[];
+/** Native viewed/generated images. savedPath wins without decoding result. */
+export declare function itemImages(item: Rec, idPrefix: string, cwd: string): ImageRef[];
+//# sourceMappingURL=images.d.ts.map

package/lib/types/backends/codex/session/images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"images.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/images.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAGxD,OAAO,EAAiB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAErD,eAAO,MAAM,kBAAkB,EAAE,eAO/B,CAAA;AAKF,6EAA6E;AAC7E,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,EAAE,MAAM,GAAE,eAAoC,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAoBtI;AAiBD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAMhF;AAED;iFACiF;AACjF,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAyB/E;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAY5F;AAED,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAQ/E"}

package/lib/types/backends/codex/session/images.js

@@ -0,0 +1,138 @@
+/** Codex image inputs and durable lazy facades (§5.17). Clipboard bytes are
+ * sent as data URLs so deleting a staged file cannot break history replay. */
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { basename, extname, resolve } from 'node:path';
+import { t } from '../../../i18n.js';
+import { probeImageSize } from '../../../utils/imageResize.js';
+import { arr, rec, str } from '../narrow.js';
+export const CODEX_IMAGE_LIMITS = Object.freeze({
+    mediaTypes: Object.freeze(['image/png', 'image/jpeg', 'image/gif', 'image/webp']),
+    maxImageBytes: 20 * 1024 * 1024,
+    maxImagesPerMessage: 20,
+    maxMessageImageBytes: 50 * 1024 * 1024,
+    maxImageDimension: 2048,
+    maxImagePixels: 2048 * 2048,
+});
+const PROBE_CHARS = 87_384;
+const PROBE_BYTES = 65_536;
+const extensionType = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp' };
+/** Read and recheck staged facades before any turn/steer request is sent. */
+export async function codexImageInputs(images, limits = CODEX_IMAGE_LIMITS) {
+    if (images.length > limits.maxImagesPerMessage)
+        throw new Error(t('codex-images-too-many', { n: limits.maxImagesPerMessage }));
+    const inputs = [];
+    let total = 0;
+    for (const image of images) {
+        const name = image.name ?? image.id;
+        const type = image.mediaType;
+        if (type === undefined || !CODEX_IMAGE_LIMITS.mediaTypes.includes(type) || !limits.mediaTypes.includes(type))
+            throw new Error(t('codex-image-type-refused', { name, type: type ?? '?' }));
+        let data;
+        try {
+            data = await image.read();
+        }
+        catch {
+            throw new Error(t('codex-image-unreadable', { name }));
+        }
+        if (data.byteLength > limits.maxImageBytes)
+            throw new Error(t('codex-image-too-large', { name, mb: Math.round(limits.maxImageBytes / (1024 * 1024)) }));
+        total += data.byteLength;
+        if (total > limits.maxMessageImageBytes)
+            throw new Error(t('codex-images-too-large', { mb: Math.round(limits.maxMessageImageBytes / (1024 * 1024)) }));
+        const size = probeImageSize(data);
+        const width = size?.width ?? image.width;
+        const height = size?.height ?? image.height;
+        if (width > limits.maxImageDimension || height > limits.maxImageDimension || width * height > limits.maxImagePixels)
+            throw new Error(t('codex-image-dimensions-refused', { name, px: limits.maxImageDimension }));
+        inputs.push({ type: 'image', url: 'data:' + type + ';base64,' + Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString('base64') });
+    }
+    return inputs;
+}
+function base64Facade(id, mediaType, data) {
+    let size;
+    const measure = () => {
+        if (size === undefined)
+            size = probeImageSize(Buffer.from(data.slice(0, PROBE_CHARS), 'base64')) ?? (data.length > PROBE_CHARS ? probeImageSize(Buffer.from(data, 'base64')) : null);
+        return size;
+    };
+    const padding = data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0;
+    return {
+        id, mediaType, bytes: Math.max(0, Math.floor(data.length * 3 / 4) - padding),
+        get width() { return measure()?.width ?? 1; },
+        get height() { return measure()?.height ?? 1; },
+        async read(signal) { signal?.throwIfAborted(); return new Uint8Array(Buffer.from(data, 'base64')); },
+    };
+}
+/** No network fetches: only embedded supported-image data URLs are facades. */
+export function dataUrlImageFacade(id, url) {
+    const prefix = /^data:(image\/(?:png|jpeg|gif|webp));base64,/iu.exec(url);
+    if (prefix === null)
+        return undefined;
+    const data = url.slice(prefix[0].length);
+    if (data === '' || data.length > Math.ceil(CODEX_IMAGE_LIMITS.maxImageBytes / 3) * 4 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(data) || data.length % 4 === 1)
+        return undefined;
+    return base64Facade(id, prefix[1].toLowerCase(), data);
+}
+/** Lazy local file view. A missing historical path still has a placeholder
+ * facade; read rejects normally, letting the shared preview show unavailable. */
+export function pathImageFacade(id, path, cwd) {
+    const absolute = resolve(cwd, path);
+    let metadata;
+    const measure = () => {
+        if (metadata !== undefined)
+            return metadata;
+        metadata = { width: 1, height: 1 };
+        let fd;
+        try {
+            const bytes = statSync(absolute).size;
+            fd = openSync(absolute, 'r');
+            const head = Buffer.alloc(Math.min(bytes, PROBE_BYTES));
+            const read = readSync(fd, head, 0, head.length, 0);
+            const size = probeImageSize(head.subarray(0, read));
+            metadata = { bytes, width: size?.width ?? 1, height: size?.height ?? 1 };
+        }
+        catch { /* A deleted path renders a square unavailable-image placeholder. */ }
+        finally {
+            if (fd !== undefined)
+                closeSync(fd);
+        }
+        return metadata;
+    };
+    return {
+        id, path: absolute, name: basename(absolute), mediaType: extensionType[extname(absolute).toLowerCase()],
+        get bytes() { return measure().bytes; },
+        get width() { return measure().width; },
+        get height() { return measure().height; },
+        read: signal => readFile(absolute, { signal }).then(data => new Uint8Array(data.buffer, data.byteOffset, data.byteLength)),
+    };
+}
+/** userMessage.content image/localImage blocks, in their durable order. */
+export function transcriptImages(content, idPrefix, cwd) {
+    const images = [];
+    arr(content).forEach((raw, index) => {
+        const block = rec(raw);
+        const id = idPrefix + '#' + index;
+        const url = str(block?.url);
+        const path = str(block?.path);
+        const image = block?.type === 'image' && url !== undefined ? dataUrlImageFacade(id, url)
+            : block?.type === 'localImage' && path !== undefined ? pathImageFacade(id, path, cwd) : undefined;
+        if (image !== undefined)
+            images.push(image);
+    });
+    return images;
+}
+/** Native viewed/generated images. savedPath wins without decoding result. */
+export function itemImages(item, idPrefix, cwd) {
+    if (item.type === 'imageView' && typeof item.path === 'string')
+        return [pathImageFacade(idPrefix, item.path, cwd)];
+    if (item.type !== 'imageGeneration' || item.status !== 'completed')
+        return [];
+    if (typeof item.savedPath === 'string' && item.savedPath !== '')
+        return [pathImageFacade(idPrefix, item.savedPath, cwd)];
+    if (typeof item.result !== 'string' || item.result === '')
+        return [];
+    const url = item.result.startsWith('data:') ? item.result : 'data:image/png;base64,' + item.result;
+    const image = dataUrlImageFacade(idPrefix, url);
+    return image === undefined ? [] : [image];
+}

package/lib/types/backends/codex/session/input.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Input placement, the client follow-up queue and cancel receipts of one
+ * Codex thread (docs/codex-backend-design.md §5.7, D8, D9).
+ *
+ * - Idle: every placement starts a turn (`turn/start`).
+ * - A turn running (or starting): `steer` joins it (`turn/steer` with the
+ *   expected turn id; a turn that cannot take it falls back to the queue,
+ *   said once); `turn` / `followup` wait in the client queue and start one
+ *   at a time after `turn/completed`; `now` goes to the queue front and
+ *   interrupts the running turn.
+ * - Nothing is shown optimistically: an input becomes a user row when its
+ *   `userMessage` item carries its client id back (then `pending.changed`
+ *   claims it); a turn that fails to start discards it.
+ * - Cancel: the queue lives in this process, so every receipt is
+ *   `confirmed`. Codex drops a steer the turn has not taken yet when the
+ *   turn is interrupted (C0 V6): a `user` cancel queues those again in
+ *   order (they still run next), an `interrupt` cancel drops them with the
+ *   queue (the channel docks its copies).
+ * - An interrupt that never completes the turn is force-closed after
+ *   `forceSettleMs` (a stuck relay, F29).
+ */
+import type { AgentEvent } from '../../../agent/events.js';
+import type { AgentInput, CancelCause, CancelReceipt, SubmitPlacement } from '../../../agent/session.js';
+import { type Rec } from '../narrow.js';
+import type { UserInput } from '../protocol/index.js';
+import type { RpcClock } from '../rpc/client.js';
+export interface InputQueueDeps {
+    readonly threadId: string;
+    call<R = unknown>(method: string, params: unknown): Promise<R>;
+    emit(events: readonly AgentEvent[]): void;
+    debug(message: string): void;
+    /** Per-turn overrides (`turn/start` settings; C2 fills them). */
+    overrides(): Rec;
+    /** Retire a rejected experimental setting; never retry the user's input. */
+    startFailed?(error: unknown, overrides: Rec): void;
+    closed(): boolean;
+    /** The open turn could not be settled by the server: close it here. */
+    forceClose(): void;
+    readonly clock: RpcClock;
+    readonly forceSettleMs: number;
+}
+/** The model-facing input of a submission: every text block as its own
+ *  text input (the first is what the user typed), in block order. */
+export declare function userInputOf(input: AgentInput): UserInput[];
+export declare function createInputQueue(deps: InputQueueDeps): {
+    readonly activeTurnId: string | undefined;
+    /** Whether a turn runs or is being started. */
+    busy(): boolean;
+    submit(input: AgentInput, placement: SubmitPlacement, wireInput?: readonly UserInput[]): Promise<{
+        readonly accepted: boolean;
+        readonly reason?: string;
+    }>;
+    cancel(cause: CancelCause): Promise<CancelReceipt>;
+    /** Pull a queued input back before it is sent. */
+    remove(id: string): boolean;
+    /** A user message carried this client id back: the input ran. */
+    claim(clientId: string): AgentEvent | undefined;
+    onTurnStarted(turnId: string): void;
+    onTurnCompleted: (turnId: string | undefined, interrupted: boolean) => void;
+    /** Re-queue a rejection's reason as the next turn (D10). */
+    enqueueFollowup(id: string, text: string): void;
+    /** The connection dropped: the running turn is gone, the queue stays. */
+    connectionLost(): readonly AgentEvent[];
+    connectionRestored(): void;
+    /** The connection is gone for good: the parked queue is discarded (their
+     *  pending rows say so) and later submits fail fast instead of parking
+     *  forever behind an offline flag nothing will ever clear. */
+    permanentLoss(): readonly AgentEvent[];
+    /** Dispose: forget everything, stop the timer. */
+    close(): void;
+    /** Interrupt the running turn (best-effort, dispose path). */
+    interrupt: () => Promise<boolean>;
+};
+export type InputQueue = ReturnType<typeof createInputQueue>;
+//# sourceMappingURL=input.d.ts.map

package/lib/types/backends/codex/session/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,0BAA0B,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAExG,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAG5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAahD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAC9D,IAAI,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAAA;IACzC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,iEAAiE;IACjE,SAAS,IAAI,GAAG,CAAA;IAChB,4EAA4E;IAC5E,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,GAAG,IAAI,CAAA;IAClD,MAAM,IAAI,OAAO,CAAA;IACjB,uEAAuE;IACvE,UAAU,IAAI,IAAI,CAAA;IAClB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;CAC/B;AAED;qEACqE;AACrE,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,CAQ1D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;IA6JjD,+CAA+C;YACvC,OAAO;kBAEK,UAAU,aAAa,eAAe,cAAc,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;kBAyB5I,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IAsBxD,kDAAkD;eACvC,MAAM,GAAG,OAAO;IAO3B,iEAAiE;oBACjD,MAAM,GAAG,UAAU,GAAG,SAAS;0BAKzB,MAAM,GAAG,IAAI;8BAnGJ,MAAM,GAAG,SAAS,eAAe,OAAO,KAAG,IAAI;IAwG9E,4DAA4D;wBACxC,MAAM,QAAQ,MAAM,GAAG,IAAI;IAK/C,yEAAyE;sBACvD,SAAS,UAAU,EAAE;0BASjB,IAAI;IAK1B;;kEAE8D;qBAC7C,SAAS,UAAU,EAAE;IAQtC,kDAAkD;aACzC,IAAI;IAMb,8DAA8D;qBArKpC,OAAO,CAAC,OAAO,CAAC;EAwK7C;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA"}