@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.1

package/lib/types/backends/claude/translate/core.js

@@ -0,0 +1,447 @@
+import { t } from '../../../i18n.js';
+import { num, rec, str } from '../narrow.js';
+import { BASH_OUTPUT, narrationOf } from './content.js';
+import { createAttemptTranslator } from './attempts.js';
+import { createLaneTranslator } from './lanes.js';
+import { createMessageTranslator } from './messages.js';
+import { createSystemTranslator } from './system.js';
+import { createTaskTools } from './tasks.js';
+/** Create one translator; it serves exactly one session's stream. */
+export function createClaudeTranslator(options) {
+    const now = options.now ?? Date.now;
+    const debug = options.debug ?? (() => undefined);
+    let userRows = options.userRows;
+    let seq = options.start?.seq ?? 0;
+    let turn = options.start?.turn ?? 0;
+    let turnOpen = false;
+    let step = 0;
+    let stepOpen = false;
+    let attempt;
+    /** API message ids already settled (late duplicate blocks are ignored);
+     *  only the most recent {@link MAX_SETTLED_ATTEMPTS} are remembered. */
+    const settledAttempts = new Set();
+    const openCalls = new Map();
+    const inputs = new Map();
+    /** Registered inputs the CLI already started whose echo (the user row of
+     *  the replay fallback) has not arrived yet. */
+    const startedInputs = new Set();
+    /** Inputs the channel still shows as queued (pending previews). */
+    const pending = new Map();
+    /** The model and permission mode the session runs, as last confirmed
+     *  (init, status frames, `message_start`, or a control request the
+     *  session made — see `noteModel` / `noteMode`). */
+    let currentModel = options.start?.model ?? '';
+    let currentMode;
+    /** The next synthetic user message is a compaction summary. */
+    let summaryExpected = false;
+    /** A `/compact` this session pushed is in flight (manual trigger). */
+    let compactRequested = false;
+    /** A background task just reported: the CLI's next unprompted turn is the
+     *  model reacting to it (a notification turn, not a user turn). */
+    let notificationTurnExpected = false;
+    /**
+     * What each started task is, from its `task_started`: a subagent, a
+     * background job, or a foreground tool's progress report. Its
+     * `task_notification` ends exactly that (a foreground Bash ends nothing —
+     * its card settles with the tool result).
+     */
+    const taskKinds = new Map();
+    /** What each task's `task_started` said (a foreground Bash moved to the
+     *  background becomes a job then, with this description). */
+    const taskInfo = new Map();
+    /** The delegating `Agent` call (subagent lane) → its task id, once
+     *  `task_started` named it (a stop request needs the task id). */
+    const laneTasks = new Map();
+    /** Where each task writes its output, as the CLI reported it. */
+    const outputFiles = new Map();
+    /** Housekeeping / watcher tasks (`skip_transcript` / `ambient`). */
+    const hiddenTasks = new Set();
+    /** Why the CLI auto-denied a call (`system/permission_denied`), until its
+     *  error result lands on the card. */
+    const deniedReasons = new Map();
+    const tasks = createTaskTools(options);
+    /** Wall clock the open (or last) turn began (the activity fold's anchor). */
+    let turnTime = 0;
+    /** Main-lane tool results settled in the open turn (the fold's toolCount). */
+    let toolResults = 0;
+    /** The turn's latest complete ⏵ narration line (survives the attempt
+     *  that streamed it — the working line keeps narrating between responses,
+     *  like the DSH plugin's freshness window). */
+    let narrated;
+    const nextSeq = () => ++seq;
+    const { closeStep, openTurn, settleAttempt, ensureAttempt, delta, translateStream, translateResult, forceCloseTurn } = createAttemptTranslator({
+        now,
+        nextSeq,
+        settledAttempts,
+        get stepOpen() { return stepOpen; },
+        set stepOpen(value) { stepOpen = value; },
+        get step() { return step; },
+        set step(value) { step = value; },
+        get turn() { return turn; },
+        set turn(value) { turn = value; },
+        get turnOpen() { return turnOpen; },
+        set turnOpen(value) { turnOpen = value; },
+        get turnTime() { return turnTime; },
+        set turnTime(value) { turnTime = value; },
+        get toolResults() { return toolResults; },
+        set toolResults(value) { toolResults = value; },
+        get narrated() { return narrated; },
+        set narrated(value) { narrated = value; },
+        get notificationTurnExpected() { return notificationTurnExpected; },
+        set notificationTurnExpected(value) { notificationTurnExpected = value; },
+        get currentModel() { return currentModel; },
+        set currentModel(value) { currentModel = value; },
+        get attempt() { return attempt; },
+        set attempt(value) { attempt = value; },
+        get compactRequested() { return compactRequested; },
+        set compactRequested(value) { compactRequested = value; },
+    });
+    /** The user row for a confirmed input (lifecycle `started` / replay echo). */
+    const confirmInput = (out, uuid) => {
+        const input = inputs.get(uuid);
+        if (pending.delete(uuid))
+            out.push({ type: 'pending.changed', items: [...pending.values()], claimed: [uuid] });
+        // Started while a turn is open = folded into that turn: a user row, no
+        // new turn. Only an input this session pushed makes the
+        // turn the user's: an unknown uuid (another client's, a CLI-internal
+        // command) opens a system turn.
+        if (input === undefined) {
+            openTurn(out, 'system');
+            return;
+        }
+        openTurn(out, 'user', uuid);
+        inputs.delete(uuid);
+        startedInputs.delete(uuid);
+        if (input.text.trim() === '/compact')
+            return;
+        // A `!!` command's output sent on to the model (or the CLI's own bash
+        // mode output): not a bubble — its output row (the channel showed it
+        // live; a replay restores it).
+        const output = BASH_OUTPUT.exec(input.text);
+        if (output !== null) {
+            out.push({ type: 'user.message', id: uuid, anchor: uuid, seq: nextSeq(), turn, time: now(), source: 'command-output', text: output[1].trim(), blocks: [{ type: 'text', text: input.text }] });
+            return;
+        }
+        out.push({ type: 'user.message', id: uuid, anchor: uuid, seq: nextSeq(), turn, time: now(), source: 'user', text: input.text, blocks: [{ type: 'text', text: input.text }], ...(input.images === undefined || input.images.length === 0 ? {} : { images: input.images }) });
+    };
+    const translateLifecycle = (message) => {
+        const uuid = str(message.command_uuid);
+        const state = str(message.state);
+        if (uuid === undefined || state === undefined)
+            return [];
+        const out = [];
+        switch (state) {
+            case 'started':
+                if (userRows === 'lifecycle') {
+                    confirmInput(out, uuid);
+                    break;
+                }
+                // Echo fallback: the echo brings the row, but the turn is already
+                // the user's when the input is one this session pushed.
+                if (pending.delete(uuid))
+                    out.push({ type: 'pending.changed', items: [...pending.values()], claimed: [uuid] });
+                if (inputs.has(uuid)) {
+                    startedInputs.add(uuid);
+                    openTurn(out, 'user', uuid);
+                }
+                break;
+            case 'cancelled':
+            case 'discarded':
+            case 'refused':
+                inputs.delete(uuid);
+                startedInputs.delete(uuid);
+                if (pending.delete(uuid))
+                    out.push({ type: 'pending.changed', items: [...pending.values()], discarded: [uuid] });
+                if (state === 'refused')
+                    out.push({ type: 'notice', level: 'warning', text: t('claude-input-refused') });
+                break;
+            default:
+                // `queued` (the channel already shows the preview) / `completed`
+                // (the turn closes on `result`).
+                break;
+        }
+        return out;
+    };
+    /**
+     * The conversation is gone (a reset): the CLI continues under a new
+     * session id with a cleared context, so the old conversation's tasks,
+     * unsettled main-lane calls and expectation markers must
+     * not leak into the new one (the CLI reuses short task ids). Kept: the
+     * queued inputs (they still run), the monotonic turn / seq numbering (the
+     * projector binds by position), and background tasks that have not ended
+     * (their notification still arrives).
+     */
+    const clearMainCalls = () => {
+        for (const [callId, call] of openCalls)
+            if (call.lane === undefined)
+                openCalls.delete(callId);
+    };
+    const resetConversation = () => {
+        tasks.trackedTasks.clear();
+        tasks.taskSeq = 0;
+        for (const [callId, call] of openCalls)
+            if (call.lane === undefined)
+                openCalls.delete(callId);
+        deniedReasons.clear();
+        settledAttempts.clear();
+        summaryExpected = false;
+        compactRequested = false;
+        notificationTurnExpected = false;
+        narrated = undefined;
+        toolResults = 0;
+        // Foreground tasks of the old conversation are gone with it (their
+        // notification never comes); background ones keep their identity.
+        for (const [taskId, kind] of [...taskKinds]) {
+            if (kind !== 'foreground')
+                continue;
+            taskKinds.delete(taskId);
+            taskInfo.delete(taskId);
+            hiddenTasks.delete(taskId);
+            for (const [callId, laneTask] of [...laneTasks])
+                if (laneTask === taskId)
+                    laneTasks.delete(callId);
+        }
+    };
+    const { translateSystem, rateLimitNotice } = createSystemTranslator({
+        options,
+        taskKinds,
+        taskInfo,
+        laneTasks,
+        outputFiles,
+        hiddenTasks,
+        openCalls,
+        deniedReasons,
+        now,
+        debug,
+        openTurn,
+        delta,
+        forceCloseTurn,
+        get currentModel() { return currentModel; },
+        set currentModel(value) { currentModel = value; },
+        get currentMode() { return currentMode; },
+        set currentMode(value) { currentMode = value; },
+        get summaryExpected() { return summaryExpected; },
+        set summaryExpected(value) { summaryExpected = value; },
+        get notificationTurnExpected() { return notificationTurnExpected; },
+        set notificationTurnExpected(value) { notificationTurnExpected = value; },
+        get turnOpen() { return turnOpen; },
+        get compactRequested() { return compactRequested; },
+        get attempt() { return attempt; },
+    });
+    const { delegation, translateLane } = createLaneTranslator({
+        options,
+        openCalls,
+        outputFiles,
+        now,
+        nextSeq,
+        debug,
+        get seq() { return seq; },
+        get turn() { return turn; },
+        get step() { return step; },
+    });
+    const { translateAssistant, translateUser } = createMessageTranslator({
+        options,
+        inputs,
+        openCalls,
+        deniedReasons,
+        outputFiles,
+        tasks,
+        now,
+        nextSeq,
+        debug,
+        ensureAttempt,
+        settleAttempt,
+        confirmInput,
+        delegation,
+        get userRows() { return userRows; },
+        get seq() { return seq; },
+        get turn() { return turn; },
+        get step() { return step; },
+        get currentMode() { return currentMode; },
+        set currentMode(value) { currentMode = value; },
+        get toolResults() { return toolResults; },
+        set toolResults(value) { toolResults = value; },
+        get summaryExpected() { return summaryExpected; },
+        set summaryExpected(value) { summaryExpected = value; },
+    });
+    /** Translate one SDK message (declared or not). */
+    const translate = (raw) => {
+        const message = rec(raw);
+        const type = str(message?.type);
+        if (message === undefined || type === undefined)
+            return [];
+        // A subagent's lane: its own events, never the main transcript's.
+        const lane = str(message.parent_tool_use_id);
+        if (lane !== undefined && (type === 'assistant' || type === 'user' || type === 'stream_event'))
+            return translateLane(lane, type, message);
+        switch (type) {
+            case 'command_lifecycle':
+                return translateLifecycle(message);
+            case 'system':
+                return translateSystem(message);
+            case 'stream_event':
+                return translateStream(message);
+            case 'assistant':
+                return translateAssistant(message);
+            case 'user':
+                return translateUser(message);
+            case 'result':
+                return translateResult(message);
+            case 'tool_progress': {
+                const callId = str(message.tool_use_id);
+                if (callId === undefined || message.heartbeat === true)
+                    return [];
+                return [{ type: 'tool.progress', callId, elapsedMs: (num(message.elapsed_time_seconds) ?? 0) * 1000, ...(lane === undefined ? {} : { parentCallId: lane }) }];
+            }
+            case 'rate_limit_event': {
+                const info = rec(message.rate_limit_info);
+                const windows = Object.entries(rec(info?.unifiedWindows) ?? {}).flatMap(([name, value]) => {
+                    const utilization = num(rec(value)?.utilization);
+                    return utilization === undefined ? [] : [{ name, utilization, ...(num(rec(value)?.resetsAt) === undefined ? {} : { resetsAt: num(rec(value)?.resetsAt) }) }];
+                });
+                return [{ type: 'rate-limit', info: { windows } }, ...rateLimitNotice(info)];
+            }
+            case 'auth_status': {
+                // Progress output is the CLI's own sign-in flow (none in headless
+                // use); only an error is the user's business.
+                const error = str(message.error);
+                return error === undefined || error.trim() === '' ? [] : [{ type: 'notice', level: 'error', key: 'auth-status', text: t('claude-auth-status-error', { error }) }];
+            }
+            case 'conversation_reset': {
+                // Close whatever the old conversation left open first (an aborted
+                // turn.end before the reset clears the working line; the channel's
+                // reset then drops the row it would append), then drop its state.
+                const out = forceCloseTurn({ kind: 'aborted' });
+                resetConversation();
+                out.push({ type: 'session.reset', trigger: str(message.trigger) ?? 'reset' });
+                return out;
+            }
+            default:
+                debug(`claude: ${type} ignored`);
+                return [];
+        }
+    };
+    return {
+        translate,
+        forceCloseTurn,
+        /** A pushed input: its text becomes the user row once the CLI confirms
+         *  it; a queued placement is a pending preview until then. */
+        registerInput(uuid, text, placement, images) {
+            inputs.set(uuid, { text, placement, ...(images === undefined || images.length === 0 ? {} : { images }) });
+            if (placement === 'steer' || placement === 'followup')
+                pending.set(uuid, { id: uuid, text, placement });
+            if (text.trim() === '/compact')
+                compactRequested = true;
+        },
+        /** Forget an input the session failed to push. */
+        unregisterInput(uuid) {
+            inputs.delete(uuid);
+            startedInputs.delete(uuid);
+            pending.delete(uuid);
+        },
+        /** Pushed inputs the CLI has not started yet, in push order (a
+         *  reconnect re-delivers them to the new CLI). */
+        unstartedInputs() {
+            return [...inputs.keys()].filter(uuid => !startedInputs.has(uuid));
+        },
+        /** Queued-input previews the channel still shows (pending uuids, push
+         *  order): what an interrupt covered but has not confirmed deleted —
+         *  an answerless or failed interrupt reports them as still queued. */
+        pendingInputs() {
+            return [...pending.keys()];
+        },
+        /** Give up on inputs that can no longer be delivered: their previews
+         *  are retired as discarded. */
+        dropInputs(uuids) {
+            const discarded = [];
+            for (const uuid of uuids) {
+                inputs.delete(uuid);
+                startedInputs.delete(uuid);
+                if (pending.delete(uuid))
+                    discarded.push(uuid);
+            }
+            return discarded.length === 0 ? [] : [{ type: 'pending.changed', items: [...pending.values()], discarded }];
+        },
+        /** Switch the user-row source once the CLI's capabilities are known. */
+        setUserRows(mode) {
+            userRows = mode;
+        },
+        clearInterruptedCalls() { clearMainCalls(); },
+        /** The model as last confirmed ('' before the first init). */
+        get model() { return currentModel; },
+        /** The permission mode as last confirmed. */
+        get mode() { return currentMode; },
+        /** A model the session switched to by control request: tracked, and
+         *  reported once (a later identical init/message_start stays quiet). */
+        noteModel(model) {
+            if (model === '' || model === currentModel)
+                return [];
+            currentModel = model;
+            return [{ type: 'model.changed', model, source: 'user' }];
+        },
+        /** A permission mode the session set by control request (or started in). */
+        noteMode(mode) {
+            if (mode === currentMode)
+                return [];
+            currentMode = mode;
+            return [{ type: 'mode.changed', modeId: mode }];
+        },
+        get turnOpen() { return turnOpen; },
+        /** The task id a subagent / job id names: a task id itself, or the
+         *  delegating call of a subagent `task_started` already named. */
+        taskIdOf(id) {
+            if (taskKinds.has(id) || outputFiles.has(id))
+                return id;
+            return laneTasks.get(id);
+        },
+        /** The output file the CLI reported for a task. */
+        outputFileOf(taskId) {
+            return outputFiles.get(taskId);
+        },
+        /** The working-activity fold's inputs (see ClaudeActivityState): the
+         *  translator's own view of the stream, nothing re-parsed. */
+        activityState() {
+            // Read after every streamed delta: plain scans, no copies. Only this
+            // turn's calls count: a call the turn left unsettled is stale (the CLI
+            // moved on), so the working line never shows the last turn's tool.
+            let newest;
+            for (const call of openCalls.values())
+                if (call.turn === turn)
+                    newest = call;
+            // The first-created in_progress task that has a spinner line.
+            let inProgress;
+            for (const task of tasks.trackedTasks.values()) {
+                if (task.status !== 'in_progress' || task.activeForm === undefined || task.activeForm === '')
+                    continue;
+                if (inProgress === undefined || task.seq < inProgress.seq)
+                    inProgress = task;
+            }
+            return {
+                turnOpen,
+                turnStartedAt: turnTime,
+                openTool: newest === undefined ? undefined : { name: newest.name, input: newest.input },
+                toolCount: toolResults,
+                activeForm: inProgress?.activeForm,
+                narration: attempt === undefined ? narrated : narrationOf(attempt.streamText !== '' ? attempt.streamText : attempt.text) ?? narrated,
+            };
+        },
+        /** The last turn number used (a resumed session continues after it). */
+        get turnNumber() { return turn; },
+        /** The last event sequence number used. */
+        get seqNumber() { return seq; },
+        /** The tracked tasks as serializable resume seeds (replay.ts hands these
+         *  to the live translator of the resumed session). */
+        taskSeeds: tasks.taskSeeds,
+        /**
+         * Open the CLI's own turn that follows a task notification (replay: the
+         * transcript records it as a `task-notification` prompt; live, the
+         * `task_notification` frame arms the same turn). Closes nothing.
+         */
+        openNotificationTurn() {
+            const out = [];
+            notificationTurnExpected = true;
+            openTurn(out, 'system');
+            return out;
+        },
+    };
+}

package/lib/types/backends/claude/translate/events.d.ts

@@ -0,0 +1,9 @@
+/** Declare which Agent Domain events the Claude backend emits. */
+import type { AgentEventType } from '../../../agent/events.js';
+/**
+ * The Claude backend's decision for every Agent Domain event type (checked by
+ * `verify:agent-domain`): a new `AgentEvent` variant fails `tsc` here until
+ * this backend decides whether it emits it.
+ */
+export declare function claudeEmits(type: AgentEventType): boolean;
+//# sourceMappingURL=events.d.ts.map

package/lib/types/backends/claude/translate/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/translate/events.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAE9D;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAuEzD"}

package/lib/types/backends/claude/translate/events.js

@@ -0,0 +1,77 @@
+/**
+ * The Claude backend's decision for every Agent Domain event type (checked by
+ * `verify:agent-domain`): a new `AgentEvent` variant fails `tsc` here until
+ * this backend decides whether it emits it.
+ */
+export function claudeEmits(type) {
+    switch (type) {
+        case 'session.ready':
+        case 'session.title':
+        case 'session.reset':
+        case 'session.status':
+        case 'turn.start':
+        case 'turn.end':
+        case 'step.start':
+        case 'step.end':
+        case 'user.message':
+        case 'pending.changed':
+        case 'assistant.attempt.start':
+        case 'assistant.delta':
+        case 'assistant.message':
+        case 'tool.call':
+        case 'tool.result':
+        case 'tool.progress':
+        case 'subagent.start':
+        case 'subagent.progress':
+        case 'subagent.end':
+        case 'task.start':
+        case 'task.update':
+        case 'task.end':
+        case 'tasks.snapshot':
+        case 'compaction.start':
+        case 'compaction.end':
+        case 'context.capacity':
+        case 'model.changed':
+        case 'mode.changed':
+        case 'commands.changed':
+        case 'todo.write':
+        case 'notice':
+        case 'rate-limit':
+        // The session's `/color` (prefs-backed, session.ts).
+        case 'session.color':
+            return true;
+        // The SendMessage relay observation: emitted when the call arrives and
+        // again when its result settles.
+        case 'agent.message':
+            return true;
+        // Emitted by the session's permission bridge (permissions.ts), not by
+        // this translator: the prompts arrive through `canUseTool`.
+        case 'permission.request':
+        case 'permission.settled':
+        case 'question.request':
+        case 'question.settled':
+            return true;
+        // Unsupported events or not a Claude concept (DSH
+        // goals, presets, request headers, system prompt text, plugin events,
+        // compaction summary progress, task output reads).
+        case 'assistant.attempt.end':
+        case 'task.output':
+        // Optional, unused: the SDK reports no incremental tool output (only
+        // `tool_progress` elapsed time).
+        case 'tool.output':
+        case 'compaction.progress':
+        case 'usage':
+        case 'context.usage':
+        case 'effort.changed':
+        case 'goal.change':
+        case 'preset.selected':
+        case 'system.prompt':
+        case 'request.header':
+        case 'custom':
+            return false;
+        default: {
+            const unhandled = type;
+            return unhandled;
+        }
+    }
+}

package/lib/types/backends/claude/translate/lanes.d.ts

@@ -0,0 +1,31 @@
+/** Translate subagent lanes without touching main-lane attempt state. */
+import type { AgentEvent } from '../../../agent/events.js';
+import { type Rec } from '../narrow.js';
+import type { ClaudeTranslatorOptions } from './types.js';
+/**
+ * The output path a backgrounded command's acknowledgement names: the rest
+ * of its line, cut after `<taskId>.output` (the sentence that follows on the
+ * same line is not part of it), else after the first `.output` that ends a
+ * word. Undefined when the text names none.
+ */
+export declare function backgroundOutputPath(text: string, taskId: string): string | undefined;
+export declare function createLaneTranslator(context: {
+    readonly options: ClaudeTranslatorOptions;
+    readonly seq: number;
+    readonly turn: number;
+    readonly step: number;
+    readonly openCalls: Map<string, {
+        readonly name: string;
+        readonly input: unknown;
+        readonly turn: number;
+        readonly lane?: string;
+    }>;
+    readonly outputFiles: Map<string, string>;
+    now(): number;
+    nextSeq(): number;
+    debug(message: string): void;
+}): {
+    delegation: (callId: string, input: unknown) => AgentEvent;
+    translateLane: (lane: string, type: string, message: Rec) => AgentEvent[];
+};
+//# sourceMappingURL=lanes.d.ts.map

package/lib/types/backends/claude/translate/lanes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/translate/lanes.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,0BAA0B,CAAA;AAC5E,OAAO,EAAiB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAItD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAMzD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOrF;AAaD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAA;IACzC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClI,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,GAAG,IAAI,MAAM,CAAA;IACb,OAAO,IAAI,MAAM,CAAA;IACjB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;yBAO6B,MAAM,SAAS,OAAO,KAAG,UAAU;0BAqBlC,MAAM,QAAQ,MAAM,WAAW,GAAG,KAAG,UAAU,EAAE;EA6G/E"}