@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/channel/subagent-projection.d.ts

@@ -0,0 +1,67 @@
+import type { Agent, AssistantStreamFrame } from '@deepseek-ai/dsh-agent';
+import { SubagentActivityStore } from '../subagents.js';
+import type { ChannelState, SubagentControl } from './types.js';
+/** Current-session subagent store, row projection and frame-batched stream
+ * bridge. The owning channel installs transport subscriptions; this module
+ * only accepts scoped events and never captures a replaceable agent itself.
+ *
+ * Discovery comes from three seams so the dashboard can mirror EVERY child
+ * the session dispatched (issue #966):
+ *  1. `subagent/start`/`subagent/end` bus edges — per-run lifecycle of
+ *     one-shot runs and continuable epochs, paired by `runId`;
+ *  2. parent-session durable events — `subagent/catalog` (child creation
+ *     fact, written for every child) and `tool-workflow/agent-start|end`
+ *     (workflow/ralph members, which never emit subagent edges) — received
+ *     live AND folded from the log at bind/resume so a restart no longer
+ *     blanks the panel;
+ *  3. lazy registry back-fill — a child session event or stream frame whose
+ *     session link was never established is resolved through the agents
+ *     registry on arrival, healing one-shot `lookupChild` misses.
+ * Transcript cards are gated to children discovered while LIVE: a resumed
+ * session's historical children appear in the dashboard without flooding the
+ * replayed transcript with cards that the durable log never contained. */
+export declare function createSubagentProjection(getState: () => Pick<ChannelState, 'rows' | 'subagents' | 'emit' | 'emitStream'>, deps: {
+    rowIds: {
+        value: number;
+    };
+    agent(): Agent;
+    subagents(): {
+        interrupt?(target: string, reason: unknown): void;
+    } | undefined;
+    /** Optional child metadata lookup; failures must not suppress spawning. */
+    lookupChild(id: string): {
+        status?: string;
+        session?: unknown;
+        options?: {
+            provider?: string;
+            model?: string;
+        };
+    } | undefined;
+}): {
+    store: SubagentActivityStore;
+    control: SubagentControl;
+    pendingTaskDescriptions: string[];
+    onSessionEvent: (session: unknown, event: {
+        type?: string;
+    }) => boolean;
+    onStreamFrame: (agent: unknown, frame: AssistantStreamFrame) => boolean;
+    onParentEvent: (event: unknown, historical?: boolean) => void;
+    bootstrapFromLog: (events: readonly unknown[]) => void;
+    onStart: (info: {
+        id: string;
+        runId?: string;
+        provider: string;
+        local?: boolean;
+    }) => void;
+    onEnd: (info: {
+        id: string;
+        runId?: string;
+        stopReason: string;
+        lastAssistantMessage?: unknown[];
+    }) => void;
+    syncNow: () => void;
+    flush: () => boolean;
+    dropRows: () => void;
+    reset: () => void;
+};
+//# sourceMappingURL=subagent-projection.d.ts.map

package/lib/types/dsh-adapter/channel/subagent-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-projection.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/subagent-projection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAEzE,OAAO,EAAE,qBAAqB,EAAsB,MAAM,iBAAiB,CAAA;AAC3E,OAAO,KAAK,EAAE,YAAY,EAAW,eAAe,EAAe,MAAM,YAAY,CAAA;AAErF;;;;;;;;;;;;;;;;;;0EAkB0E;AAC1E,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,YAAY,CAAC,EAChF,IAAI,EAAE;IACJ,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACzB,KAAK,IAAI,KAAK,CAAA;IACd,SAAS,IAAI;QAAE,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,GAAG,SAAS,CAAA;IAC9E,2EAA2E;IAC3E,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,GAAG,SAAS,CAAA;CAC7H;;;;8BA+CgC,OAAO,SAAS;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAG,OAAO;2BAgB9C,OAAO,SAAS,oBAAoB,KAAG,OAAO;2BA+D9C,OAAO,2BAAuB,IAAI;+BA0C9B,SAAS,OAAO,EAAE,KAAG,IAAI;oBAOpC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,KAAG,IAAI;kBAsB1E;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,oBAAoB,CAAC,EAAE,OAAO,EAAE,CAAA;KAAE,KAAG,IAAI;mBAjK5F,IAAI;iBAMN,OAAO;oBA+LJ,IAAI;iBACP,IAAI;EAEvB"}

package/lib/types/dsh-adapter/channel/subagent-projection.js

@@ -0,0 +1,307 @@
+import { markChannelReadDirty } from '../../adapter/channel/read-view.js';
+import { SubagentActivityStore } from '../subagents.js';
+/** Current-session subagent store, row projection and frame-batched stream
+ * bridge. The owning channel installs transport subscriptions; this module
+ * only accepts scoped events and never captures a replaceable agent itself.
+ *
+ * Discovery comes from three seams so the dashboard can mirror EVERY child
+ * the session dispatched (issue #966):
+ *  1. `subagent/start`/`subagent/end` bus edges — per-run lifecycle of
+ *     one-shot runs and continuable epochs, paired by `runId`;
+ *  2. parent-session durable events — `subagent/catalog` (child creation
+ *     fact, written for every child) and `tool-workflow/agent-start|end`
+ *     (workflow/ralph members, which never emit subagent edges) — received
+ *     live AND folded from the log at bind/resume so a restart no longer
+ *     blanks the panel;
+ *  3. lazy registry back-fill — a child session event or stream frame whose
+ *     session link was never established is resolved through the agents
+ *     registry on arrival, healing one-shot `lookupChild` misses.
+ * Transcript cards are gated to children discovered while LIVE: a resumed
+ * session's historical children appear in the dashboard without flooding the
+ * replayed transcript with cards that the durable log never contained. */
+export function createSubagentProjection(getState, deps) {
+    const store = new SubagentActivityStore();
+    const rowsByAgentId = new Map();
+    const pendingTaskDescriptions = [];
+    /** Workflow member identity: `tool-workflow/agent-end` carries no childId,
+     * so member starts remember `runId:seq` → agentId for their settlement. */
+    const workflowMembers = new Map();
+    /** Children that earned a transcript card (live discovery only). */
+    const cardedIds = new Set();
+    let streamDirty = false;
+    const syncRows = (snapshot = store.snapshot()) => {
+        const state = getState();
+        for (const sub of snapshot) {
+            if (!cardedIds.has(sub.agentId))
+                continue;
+            let row = rowsByAgentId.get(sub.agentId);
+            if (!row) {
+                row = { id: deps.rowIds.value++, kind: 'subagent', text: sub.description, subagent: undefined };
+                rowsByAgentId.set(sub.agentId, row);
+                state.rows.push(row);
+            }
+            const view = {
+                agentId: sub.agentId, runId: sub.runId, description: sub.description,
+                provider: sub.provider, model: sub.model || 'default', effort: sub.effort,
+                status: sub.status, startedAt: sub.startedAt, completedAt: sub.completedAt,
+                durationMs: sub.completedAt ? sub.completedAt - sub.startedAt : Date.now() - sub.startedAt,
+                outputLines: sub.output.slice(-3), toolCalls: sub.toolCalls, tokens: sub.tokens,
+                summary: sub.summary, stopReason: sub.stopReason, error: sub.error,
+            };
+            row.subagent = view;
+            row.text = sub.description;
+            markChannelReadDirty(row);
+            markChannelReadDirty(state.rows);
+        }
+    };
+    const syncNow = () => {
+        streamDirty = false;
+        const snapshot = store.snapshot();
+        getState().subagents = snapshot;
+        syncRows(snapshot);
+    };
+    const flush = () => {
+        if (!streamDirty)
+            return false;
+        syncNow();
+        return true;
+    };
+    const onSessionEvent = (session, event) => {
+        let id = store.getSubagentIdBySession(session);
+        if (id === undefined)
+            id = backfillSessionLink(session);
+        if (id === undefined)
+            return false;
+        store.onSessionEvent(id, event);
+        if (event.type === 'assistant/chunk') {
+            streamDirty = true;
+            getState().emitStream();
+        }
+        else {
+            syncNow();
+            getState().emit();
+        }
+        return true;
+    };
+    // 0.1.5 live stream frames for child agents: the payload carries the Agent
+    // (not its session), so resolve the subagent through its bound session.
+    const onStreamFrame = (agent, frame) => {
+        const session = agent?.session;
+        let id = session !== undefined && session !== null ? store.getSubagentIdBySession(session) : undefined;
+        if (id === undefined && session !== undefined && session !== null)
+            id = backfillSessionLink(session);
+        if (id === undefined)
+            return false;
+        store.onStreamFrame(id, frame);
+        if (frame.type === 'chunk') {
+            streamDirty = true;
+            getState().emitStream();
+        }
+        else {
+            syncNow();
+            getState().emit();
+        }
+        return true;
+    };
+    /** Heal a missing session→agent link through the agents registry. The
+     * start-time lookup is one-shot; a miss (service not yet mounted, child not
+     * yet registered) previously left the child's events permanently
+     * unattributed — its row then never left `running`. Only rows the store
+     * already tracks are linked: the registry also holds peer top-level
+     * sessions (a parked `/bg` agent streams on the same bus) that must never
+     * become dashboard rows. */
+    const backfillSessionLink = (session) => {
+        const sessionId = session?.id;
+        if (typeof sessionId !== 'string' || !store.has(sessionId))
+            return undefined;
+        let child;
+        try {
+            child = deps.lookupChild(sessionId);
+        }
+        catch {
+            return undefined;
+        }
+        if (!child || child.session !== session)
+            return undefined;
+        // Registry presence is not liveness: a continuable child stays
+        // registered while idle. Only a running child upgrades a discovered row
+        // and earns a transcript card; the session link itself is established
+        // regardless so attribution heals the moment it starts streaming.
+        const running = child.status === 'running';
+        if (running && store.get(sessionId)?.status === 'unknown')
+            store.patch(sessionId, { status: 'running' });
+        store.linkSession(sessionId, session);
+        if (running)
+            cardedIds.add(sessionId);
+        return sessionId;
+    };
+    /** Register a discovered child and, when the agents registry currently
+     * holds it RUNNING (idle continuable children stay registered without
+     * being live), bind its session so streaming state flows. */
+    const discover = (childId, info) => {
+        let child;
+        try {
+            child = deps.lookupChild(childId);
+        }
+        catch {
+            child = undefined;
+        }
+        const running = child?.status === 'running';
+        store.onDiscovered(childId, {
+            label: info.label,
+            childCreatedAt: info.childCreatedAt,
+            live: running,
+            provider: info.provider ?? child?.options?.provider,
+            model: child?.options?.model,
+        });
+        if (info.runId !== undefined)
+            store.patch(childId, { runId: info.runId });
+        if (child?.session)
+            store.linkSession(childId, child.session);
+        if (running)
+            cardedIds.add(childId);
+    };
+    /** Durable session events stamp their own wall time; a fold from the log
+     * must not date a historical child at resume time. */
+    const eventTime = (event) => {
+        const time = event?.time;
+        return typeof time === 'number' ? time : undefined;
+    };
+    /** Parent-session durable discovery events, live or folded from the log. */
+    const onParentEvent = (event, historical = false) => {
+        if (!event || typeof event !== 'object')
+            return;
+        const ev = event;
+        const data = ev.data ?? {};
+        const childId = typeof data.childId === 'string' ? data.childId : undefined;
+        if (ev.type === 'subagent/catalog') {
+            if (childId === undefined)
+                return;
+            discover(childId, {
+                label: typeof data.label === 'string' ? data.label : undefined,
+                childCreatedAt: typeof data.childCreatedAt === 'number' ? data.childCreatedAt : eventTime(event),
+            });
+        }
+        else if (ev.type === 'tool-workflow/agent-start') {
+            if (childId === undefined || typeof data.runId !== 'string' || typeof data.seq !== 'number')
+                return;
+            const memberKey = `${data.runId}:${data.seq}`;
+            workflowMembers.set(memberKey, childId);
+            discover(childId, {
+                label: typeof data.label === 'string' ? data.label : undefined,
+                childCreatedAt: eventTime(event),
+                provider: 'workflow',
+                runId: memberKey,
+            });
+        }
+        else if (ev.type === 'tool-workflow/agent-end') {
+            if (typeof data.runId !== 'string' || typeof data.seq !== 'number')
+                return;
+            const agentId = workflowMembers.get(`${data.runId}:${data.seq}`);
+            if (agentId === undefined)
+                return;
+            // The durable end event stamps the historical wall time; folding it
+            // must close the member at that time, not at fold/resume time.
+            const endedAt = eventTime(event);
+            if (data.outcome === 'failed')
+                store.onFailed(agentId, 'failed', endedAt);
+            else if (data.outcome === 'cancelled')
+                store.onCancelled(agentId, 'cancelled', undefined, endedAt);
+            else
+                store.onCompleted(agentId, undefined, undefined, endedAt);
+        }
+        else {
+            return;
+        }
+        if (!historical) {
+            syncNow();
+            getState().emit();
+        }
+    };
+    /** Seed the dashboard from the durable parent log at bind/resume: catalog
+     * children and workflow members survive a restart. Historical children the
+     * registry no longer holds stay card-less (dashboard-only, `unknown`). */
+    const bootstrapFromLog = (events) => {
+        if (!Array.isArray(events))
+            return;
+        try {
+            for (const event of events)
+                onParentEvent(event, true);
+        }
+        catch { /* bootstrap is best-effort discovery; live events remain authoritative */ }
+        syncNow();
+    };
+    const onStart = (info) => {
+        if (!info?.id)
+            return;
+        // The fact that the host spawned a child is authoritative even when its
+        // optional discovery seam is absent, unloading, or throws.
+        store.onSpawned(info.id, info.provider || 'subagent', info.provider, {
+            runId: info.runId ?? info.id,
+            local: info.local,
+            startedAt: Date.now(),
+            description: pendingTaskDescriptions.shift(),
+        });
+        cardedIds.add(info.id);
+        try {
+            const child = deps.lookupChild(info.id);
+            if (child?.session) {
+                store.linkSession(info.id, child.session);
+                const model = child.options?.model ?? child.options?.provider;
+                if (model)
+                    store.patch(info.id, { model, provider: child.options?.provider ?? info.provider });
+            }
+        }
+        catch { /* child enrichment is optional; the spawn remains visible */ }
+        syncNow();
+        getState().emit();
+    };
+    const onEnd = (info) => {
+        if (!info?.id)
+            return;
+        // Host ordering guarantee: a continuable epoch's `subagent/end` may be
+        // published AFTER the next epoch's `subagent/start` already arrived (the
+        // parent delivery runs before the ownership release). An end that names a
+        // runId this row no longer holds belongs to that earlier epoch — the new
+        // run must keep running.
+        if (info.runId !== undefined) {
+            const current = store.get(info.id);
+            if (current?.runId !== undefined && current.runId !== info.runId)
+                return;
+        }
+        const output = Array.isArray(info.lastAssistantMessage)
+            ? info.lastAssistantMessage.map(block => typeof block === 'object' && block !== null && 'text' in block ? String(block.text ?? '') : '').filter(Boolean).join('\n')
+            : '';
+        store.flushOutput(info.id);
+        if (info.stopReason === 'completed')
+            store.onCompleted(info.id, output, info.stopReason);
+        else if (info.stopReason === 'cancelled' || info.stopReason === 'aborted')
+            store.onCancelled(info.id, info.stopReason, output);
+        else
+            store.onFailed(info.id, info.stopReason || 'Unknown error');
+        syncNow();
+        getState().emit();
+    };
+    const control = {
+        interrupt(agentId) {
+            const child = store.get(agentId);
+            const target = child?.sessionId ?? agentId;
+            const runtime = deps.subagents();
+            if (!runtime?.interrupt || !target)
+                return false;
+            try {
+                runtime.interrupt(target, { kind: 'ancestor', agent: deps.agent() });
+                store.onCancelled(agentId, 'interrupted');
+                syncNow();
+                getState().emit();
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+    const dropRows = () => { streamDirty = false; rowsByAgentId.clear(); };
+    const reset = () => { dropRows(); cardedIds.clear(); workflowMembers.clear(); pendingTaskDescriptions.length = 0; store.reset(); getState().subagents = []; };
+    return { store, control, pendingTaskDescriptions, onSessionEvent, onStreamFrame, onParentEvent, bootstrapFromLog, onStart, onEnd, syncNow, flush, dropRows, reset };
+}

package/lib/types/dsh-adapter/channel/transcript.d.ts

@@ -0,0 +1,73 @@
+import { type SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ChatRow, ToolResultView, ToolViewPresenter } from './types.js';
+export declare const ARGS_PREVIEW_LIMIT = 160;
+export declare const RESULT_PREVIEW_LIMIT = 240;
+/** Local `!`-command output cap (mirrors the result preview limit). */
+export declare const LOCAL_OUTPUT_LIMIT = 240;
+/**
+ * In-memory transcript window cap. Older rows beyond this count are FOLDED:
+ * their full-text fields (assistant/reasoning text, tool args/results) are
+ * dropped and only the preview/status metadata kept, so a long merge/deploy
+ * turn cannot grow the TUI's RAM without bound. The session log remains the
+ * complete source of truth (`/export` reads it, `/resume` replays it); the
+ * folded row keeps its kind/id so scrolling and selection stay stable.
+ */
+export declare const MAX_ROWS = 600;
+export declare function preview(text: string, limit: number): string;
+/**
+ * Fold the oldest rows beyond the transcript window cap: drop each row's
+ * full-text fields (assistant/reasoning text, tool args/results) and keep
+ * only its preview text, kind, id, and seq. Bounds the TUI's retained text
+ * without touching the session log (the source of truth for /export and
+ * loadOlder). Small local/notice/interrupt rows are left intact (they hold
+ * terminal-local text the log cannot restore). Restored rows are exempt so
+ * a loadOlder() restore is not instantly undone. Returns the number of rows
+ * folded.
+ */
+export declare function foldRows(rows: ChatRow[], cap: number, cursor?: {
+    rows: unknown;
+    index: number;
+}): number;
+/**
+ * Restore folded rows from the session log, newest folded batch first.
+ * Rebuilds each folded row's full text from its source events and clears
+ * the folded mark, keeping row ids, scroll anchors, and selection stable.
+ * `views` re-derives the tool presentation views foldRows dropped (the
+ * presenters live on the host plane, so the channel passes them in).
+ * Returns the number of rows restored.
+ */
+export declare function foldBack(rows: ChatRow[], events: readonly SessionEvent[], views?: ToolViewPresenter): number;
+/** Rebuild a folded row's full text from its source session event. */
+export declare function restoreRowFromEvent(row: ChatRow, event: SessionEvent): void;
+/** Render the durable tool-result payload, including provider error details. */
+export declare function toolResultText(event: SessionEvent<'tool/result'>): string;
+/** Phase badge for the harness goal card — mirrors the panel's PhaseBadge. */
+export declare const GOAL_RESULT_BADGE: Record<string, string>;
+/**
+ * Summary cards for the harness's goal/todo tools. Their results are machine
+ * JSON (`{"goal":{…}}` / `{"todos":[…]}`) that would otherwise dump under the
+ * tool card as a raw `⎿ {"goal":…}` line. Matched by tool-name substring AND
+ * payload shape, so unrelated tools and plain-text results pass through to
+ * the registry/raw-text path untouched. Runs on the live stream and replay.
+ */
+export declare function harnessToolResultView(name: string, data: SessionEvent<'tool/result'>['data']): ToolResultView | undefined;
+export declare function toolErrorText(event: SessionEvent<'tool/result'>): string;
+/** Restore a folded tool row's result text from its tool/result event. */
+export declare function restoreToolResult(row: ChatRow, event: SessionEvent<'tool/result'>): void;
+/**
+ * Prepare durable events for REPLAY (resume / rewind / model-switch fork):
+ * drop settled `assistant/chunk` stream deltas — the sealed
+ * `assistant/message` events carry the full text and reasoning blocks, so
+ * per-token chunks add nothing to the replayed transcript while costing a
+ * per-chunk renderEvent pass (a real 4.5MB session logs ~19k chunks against
+ * ~30 messages). The trailing chunk run AFTER the last message belongs to an
+ * unfinished step (crash-orphaned turn) and is kept, so a resumed session
+ * still shows its partial content. Storage-level packed rows
+ * (`text-chunks`/`reasoning-chunks`/`tool-call-chunks`) are dropped the
+ * same way — defensive: the jsonl reader expands them, but a future
+ * direct-pass path must not resurrect them. Replay-side tps sampling is
+ * lost with the chunks (a live metric; lastUsage comes from the message's
+ * own usage). Live events never go through this.
+ */
+export declare function prepareReplayEvents(events: readonly SessionEvent[]): SessionEvent[];
+//# sourceMappingURL=transcript.d.ts.map

package/lib/types/dsh-adapter/channel/transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/transcript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAG5E,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC,uEAAuE;AACvE,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,MAAM,CAAA;AAE3B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,OAAO,EAAE,EACf,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACxC,MAAM,CAsCR;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,YAAY,EAAE,EAAE,KAAK,CAAC,EAAE,iBAAiB,GAAG,MAAM,CA8C5G;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CA+B3E;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,CAAC,aAAa,CAAC,GAAG,MAAM,CAEzE;AAED,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAKpD,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,GACxC,cAAc,GAAG,SAAS,CA4C5B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,CAAC,aAAa,CAAC,GAAG,MAAM,CAMxE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,CAAC,aAAa,CAAC,GAAG,IAAI,CAUxF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,EAAE,CA2BnF"}