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

package/lib/types/dsh-adapter/channel/binding-events.js

@@ -1,13 +1,54 @@
 import { carrierKeyOf } from '@deepseek-ai/dsh-scope';
-import { isTokenDelta, tokenDeltaChars } from './usage.js';
+import { t } from '../../i18n.js';
+import { runningPresetOf } from '../presets.js';
+import { agentCapabilityEvidence, resolveAgentCapabilities } from './capabilities.js';
+import { createSessionBatchRouter, createSessionBinder } from './core/binding-feed.js';
 /**
- * Foreground transcript listeners capture a binding generation. Child event
- * listeners instead span the Channel owner, keeping parked reducers current
- * across rebinds. Both paths own registrations incrementally and fence retained
- * callbacks; only ChannelProjection presents the foreground transcript.
+ * Foreground transcript listeners capture a binding generation: the bound
+ * `AgentSession`'s event batches feed the shared projector, and the DSH
+ * specialists read the raw main-session events through `native.dsh`. Child
+ * (subagent) event listeners instead span the Channel owner, keeping parked
+ * reducers current across rebinds. Both paths own registrations incrementally
+ * and fence retained callbacks; only the projector presents the foreground
+ * transcript.
  */
 export function createBindingEvents(ctx, deps) {
     let subagentsInstalled = false;
+    /**
+     * Preset of the last binding we announced a capability gap for. The gap is a
+     * property of the agent's PRESET, so it is reported once per entry into a
+     * preset that lacks it (a rebind to the SAME preset — /model, /rewind —
+     * stays quiet; switching away and back reports again). Facts come from
+     * `channel/capabilities.ts`, never from a preset-id list: a user preset that
+     * adds compaction/pruning back gets no warning at all.
+     *
+     * A session recording NO preset (rosterless bare `cordis.yml`, or an embed
+     * that composes its own leaf) stays silent: nothing there attributes the
+     * missing services to a preset choice, and the command-list annotation plus
+     * the use-time refusal already say it when it matters. Only the id, not its
+     * contents, is read here.
+     */
+    let announcedPreset;
+    let announced = false;
+    const announceCapabilityGap = () => {
+        const agent = deps.binding.agent;
+        const presetId = runningPresetOf(agent.session);
+        if (presetId === undefined)
+            return;
+        if (announced && presetId === announcedPreset)
+            return;
+        announced = true;
+        announcedPreset = presetId;
+        const capabilities = resolveAgentCapabilities(agentCapabilityEvidence(ctx, agent));
+        if (capabilities.compaction && capabilities.pruner)
+            return;
+        const key = capabilities.compaction
+            ? 'capability-gap-pruner'
+            : capabilities.pruner
+                ? 'capability-gap-compaction'
+                : 'capability-gap-compaction-pruner';
+        deps.state.notify(t(key), { color: 'warning', timeoutMs: 12000 });
+    };
     const installSubagents = () => {
         if (subagentsInstalled)
             return;
@@ -38,24 +79,26 @@ export function createBindingEvents(ctx, deps) {
                 deps.subagents.forget?.(agent);
         }));
     };
-    const reconcileRetiredProjection = (status) => {
-        if (!deps.state.working)
-            return;
-        ctx.logger.warn(`dsh-tui: agent became ${status} while the channel still projected an open turn; releasing volatile UI gates`);
-        deps.inputConvergence.cancelInFlight = false;
-        deps.state.cancelPending = false;
-        deps.state.working = false;
-        deps.state.activeToolCount = 0;
-        deps.projector.settleStreaming();
-        deps.projector.updateSpinnerMode();
-    };
-    const bind = () => {
-        try {
-            deps.state.agentBindingGeneration = deps.binding.bind();
-            installSubagents();
-            deps.inputConvergence.cancelInFlight = false;
-            deps.inputConvergence.interruptSeq += 1;
+    /**
+     * The DSH half of every bind (core/binding-feed.ts runs it): the owner-level
+     * child listeners once, then per binding the activity seed, the model
+     * selection reset, the preferred effort and mode refresh, the model
+     * selection waterfalls, and the raw durable-event subscribers. Registered
+     * before the core's session subscription, so each raw event reaches the
+     * DSH specialists before the projector folds it.
+     */
+    const hooks = {
+        // This composition maintains mode/effort/command facts through its own
+        // specialists, and replays its seed synchronously at adoption.
+        ownsSessionFacts: true,
+        onGeneration() {
+            // DSH specialists attach only to a DSH session.
+            if (deps.binding.session.capabilities.native.dsh !== undefined)
+                installSubagents();
+        },
+        onBind({ capture, current, register }) {
             deps.seedActivity?.(deps.binding.agent.session);
+            deps.seedContextOccupancy?.(deps.binding.agent.session);
             deps.modelActions.selection.current = undefined;
             deps.modelActions.selection.assembled = undefined;
             if (deps.binding.agent.options?.model === undefined && deps.state.provider !== '' && deps.state.model !== '') {
@@ -63,19 +106,18 @@ export function createBindingEvents(ctx, deps) {
             }
             void deps.modelActions.applyPreferredEffort();
             deps.modeActions.refreshMode();
-            const capture = deps.binding.capture();
-            const session = capture.agent.session;
-            const current = () => deps.owner.current() && deps.binding.isCurrent(capture);
-            const register = (dispose) => {
-                deps.binding.subscribe(dispose);
-                return dispose;
-            };
-            const on = (...args) => register(ctx.on(...args));
+            // Entering/resuming a session whose preset serves neither automatic
+            // compaction nor tool-result pruning changes what the user can expect
+            // from a long session; say it once, here, before the turn starts.
+            announceCapabilityGap();
+            const native = capture.session.capabilities.native.dsh;
+            if (native === undefined)
+                return;
             // Keep the upstream assembly/request pairing, but own each listener as
             // soon as it is installed. The upstream combined disposer is too late
             // if request registration throws, and its post-await assembly write is
             // unsafe after a rebind (including A→B→A ABA).
-            const disposeAssembly = capture.agent.ctx.on('system-prompt/assemble', async (_assembly, _context, next) => {
+            const disposeAssembly = native.agent.ctx.on('system-prompt/assemble', async (_assembly, _context, next) => {
                 const selected = deps.selection.current;
                 const assembled = await next();
                 if (!current())
@@ -93,7 +135,7 @@ export function createBindingEvents(ctx, deps) {
                 };
             });
             register(disposeAssembly);
-            const disposeRequest = capture.agent.ctx.on('agent/request', async (_payload, next) => {
+            const disposeRequest = native.agent.ctx.on('agent/request', async (_payload, next) => {
                 const resolved = await next();
                 if (!current())
                     return resolved;
@@ -109,110 +151,34 @@ export function createBindingEvents(ctx, deps) {
                 };
             });
             register(disposeRequest);
-            on('agent/status', ({ agent: subject, status }) => {
-                if (!current() || subject !== capture.agent)
-                    return;
-                deps.state.status = status;
-                if (status === 'idle')
-                    reconcileRetiredProjection('idle');
-                deps.state.emit();
-            });
-            on('agent/disposed', ({ agent: subject }) => {
-                if (!current() || subject !== capture.agent)
-                    return;
-                deps.state.status = 'disposed';
-                reconcileRetiredProjection('disposed');
-                deps.state.emit();
-            });
-            /**
-             * The inbox removed one message. Both events retire the pending
-             * preview, but ONLY a discard retires an attached-context entry:
-             * `agent/inbox/claimed` fires while the loop claims the batch, BEFORE
-             * the resident `agent/pre-step` listener can append the attachment —
-             * retiring there would delete the context before it is ever injected
-             * (dsh-agent-loop: `inbox.claim()` → claimed event → `agent/pre-step`).
-             */
-            const retirePending = (payload, alsoRetireAttachment = false) => {
-                if (!current() || payload.agent !== capture.agent)
-                    return;
-                const messageId = payload.message?.id;
-                if (typeof messageId !== 'string')
-                    return;
-                if (alsoRetireAttachment)
-                    deps.retireAttachment?.(messageId);
-                const before = deps.state.pending.length;
-                deps.state.pending = deps.state.pending.filter(item => item.id !== messageId);
-                if (deps.state.pending.length !== before)
-                    deps.state.emit();
-            };
-            on('agent/inbox/claimed', retirePending);
-            on('agent/inbox/discarded', payload => retirePending(payload, true));
-            on('session/event', (subject, event) => {
+            // Raw durable events for the DSH specialists. Registered before the
+            // session subscription, so each event reaches them before the
+            // projector folds it.
+            register(native.subscribeRaw(event => {
                 if (!current())
                     return;
-                const isMainSession = subject === session;
-                if (!isMainSession)
-                    return;
-                deps.messageObserver?.publish(subject, event);
-                deps.modeActions.onSessionEvent(subject, event);
-                deps.projector.renderEvent(event);
-                if (event.type === 'assistant/chunk')
-                    deps.state.emitStream();
-                else
-                    deps.state.emit();
-            });
-            // 0.1.5 live streaming: per-token chunks are transient attempt frames
-            // on this agent-scoped channel; the durable settlement still arrives
-            // through `session/event` above. Pre-0.1.5 hosts never emit it — the
-            // subscription simply stays silent there and chunks keep arriving as
-            // `assistant/chunk` session events.
-            on('agent/assistant-stream', ({ agent: subject, frame }) => {
-                if (!current())
-                    return;
-                if (subject !== capture.agent)
-                    return;
-                deps.projector.renderStreamFrame(frame);
-                if (frame.type === 'chunk')
-                    deps.state.emitStream();
-                else if (frame.type === 'end')
-                    deps.state.emit();
-            });
-            /**
-             * Live compaction progress. The summarizer is one `ctx.llm.stream()`
-             * call, so its chunks are the only work signal a compaction has between
-             * `compaction/start` and `compaction/end` (dsh-llm tags the call
-             * `purpose: 'compaction'`, and a manual one runs while the session is
-             * idle, so it cannot be confused with the foreground turn's stream).
-             * Everything else passes through untouched: the original iterable is
-             * returned for any other purpose or session.
-             */
-            const disposeCompactionStream = ctx.on('llm/stream', (options, next) => {
-                const stream = next();
-                if (options.purpose !== 'compaction')
-                    return stream;
-                if (options.sessionId === undefined || String(options.sessionId) !== String(session.id))
-                    return stream;
-                return (async function* compactionStream() {
-                    for await (const chunk of stream) {
-                        const compaction = deps.state.compaction;
-                        if (compaction !== undefined && isTokenDelta(chunk)) {
-                            deps.state.compaction = {
-                                ...compaction,
-                                phase: 'summary',
-                                outputChars: compaction.outputChars + tokenDeltaChars(chunk),
-                            };
-                            deps.state.emitStream();
-                        }
-                        yield chunk;
-                    }
-                })();
-            });
-            register(disposeCompactionStream);
-        }
-        catch (error) {
-            deps.owner.dispose();
-            throw error;
-        }
+                deps.messageObserver?.publish(native.agent.session, event);
+                deps.modeActions.onSessionEvent(native.agent.session, event);
+            }));
+        },
     };
-    return { bind };
+    // Direct regressions drive this owner alone: the same binder the channel
+    // feed runs, over the projector they hand in.
+    const router = createSessionBatchRouter({
+        state: deps.state,
+        projector: deps.projector,
+        inputConvergence: deps.inputConvergence,
+        retireAttachment: deps.retireAttachment,
+        warn: message => ctx.logger.warn(message),
+    });
+    const binder = createSessionBinder({
+        owner: deps.owner,
+        binding: deps.binding,
+        state: deps.state,
+        inputConvergence: deps.inputConvergence,
+        route: router.route,
+        hooks: () => hooks,
+    });
+    return { bind: binder.bind, hooks };
 }
+export { createSessionBatchRouter } from './core/binding-feed.js';

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

@@ -1,25 +1,39 @@
 import type { Agent, AgentHandle } from '@deepseek-ai/dsh-agent';
+import type { AgentSession } from '../../agent/session.js';
 import type { ChannelOwner } from './owner.js';
 export interface BindingCapture {
-    readonly agent: Agent;
+    readonly session: AgentSession;
+    /** DSH convenience: the captured session's agent; undefined off DSH. */
+    readonly agent: Agent | undefined;
     readonly generation: number;
 }
 export interface BindingCommit {
-    readonly agent: Agent;
+    readonly session: AgentSession;
+    readonly agent: Agent | undefined;
     readonly handle: AgentHandle | undefined;
     readonly generation: number;
 }
 type PreviousDisposition = 'dispose' | 'park';
 /**
- * Sole writer of the attached Agent/handle identity and binding generation.
+ * Sole writer of the attached session identity and binding generation.
  *
- * A prepared handle remains owned by this cell until its synchronous adoption
- * tail returns.  The tail is deliberately callback-shaped: it cannot leave a
- * committed identity waiting for a microtask watchdog to infer whether setup
- * completed, and a throw always revokes the transaction immediately.
+ * The cell holds an `AgentSession` of any backend and every identity rule
+ * below is decided on that session object (plus the generation, which every
+ * adoption advances). `agent`/`handle` are DSH convenience views of
+ * `capabilities.native.dsh` for the DSH specialists (`undefined` on a
+ * non-DSH session); a DSH session's lifetime is still keyed by its handle, so
+ * two wrappers of one owned agent close it once. A prepared session remains
+ * owned by this cell until its synchronous adoption tail returns. The tail
+ * is deliberately callback-shaped: it cannot leave a committed identity
+ * waiting for a microtask watchdog to infer whether setup completed, and a
+ * throw always revokes the transaction immediately.
  */
-export declare function createChannelBinding(initial: Agent, handle: AgentHandle | undefined, owner: ChannelOwner): {
-    readonly agent: Agent;
+export declare function createChannelBinding(initial: AgentSession, owner: ChannelOwner): {
+    readonly session: AgentSession;
+    /** DSH convenience: `capabilities.native.dsh.agent` of the bound session;
+     *  undefined when the bound session is not a DSH session. */
+    readonly agent: Agent | undefined;
+    /** DSH convenience: the bound session's lifetime handle, if it owns one. */
     readonly handle: AgentHandle | undefined;
     readonly generation: number;
     capture(): BindingCapture;
@@ -33,7 +47,7 @@ export declare function createChannelBinding(initial: Agent, handle: AgentHandle
      * handle is known to have stopped writing before the caller gives its
      * ledger reservation back.
      */
-    prepare(capture: BindingCapture, create: () => Promise<AgentHandle>): Promise<AgentHandle>;
+    prepare(capture: BindingCapture, create: () => Promise<AgentSession>): Promise<AgentSession>;
     /**
      * Dispose an uncommitted candidate exactly once and WAIT for the close.
      *
@@ -42,17 +56,50 @@ export declare function createChannelBinding(initial: Agent, handle: AgentHandle
      * only be released once the handle has actually stopped writing. A live
      * handle that this cell never owned is inert here.
      */
-    abandon(candidate: AgentHandle): Promise<void>;
+    abandon(candidate: AgentSession): Promise<void>;
+    /**
+     * Close the bound session at channel release when this cell owns its
+     * lifetime: any session that is not a DSH session (a backend session no
+     * host registry disposes; for the Claude backend, its CLI child). A DSH
+     * session's lifetime belongs to its handle's owner, never to the UI
+     * release. Deferred one microtask, so release itself never awaits or
+     * throws; idempotent with every other close of the same session.
+     */
+    releaseOwned(): void;
     /** A registry may retain an agent while its async handle close drains. */
     waitForDisposal(sessionId: string): Promise<void>;
     /** Perform one explicit synchronous prepared-handle adoption transaction. */
-    adopt: <T>(candidate: AgentHandle, capture: BindingCapture, tail: (previous: BindingCommit, disposition: (next: PreviousDisposition) => void) => T) => T;
-    /** Perform one explicit synchronous already-live-agent adoption transaction. */
-    switchTo: <T>(agent: Agent, nextHandle: AgentHandle | undefined, tail: (previous: BindingCommit, disposition: (next: PreviousDisposition) => void) => T) => T;
+    adopt: <T>(candidate: AgentSession, capture: BindingCapture, tail: (previous: BindingCommit, disposition: (next: PreviousDisposition) => void) => T) => T;
+    /** Perform one explicit synchronous already-live-session adoption transaction. */
+    switchTo: <T>(next: AgentSession, tail: (previous: BindingCommit, disposition: (next: PreviousDisposition) => void) => T) => T;
     bind(): number;
     subscribe(dispose: () => void): void;
     clearSubscriptions: (afterEach?: () => void) => unknown;
 };
 export type ChannelBinding = ReturnType<typeof createChannelBinding>;
+/** A capture taken through the DSH view: its agent is always present. */
+export interface DshBindingCapture extends BindingCapture {
+    readonly agent: Agent;
+}
+/** A commit seen through the DSH view: the replaced session's agent. */
+export interface DshBindingCommit extends BindingCommit {
+    readonly agent: Agent;
+}
+type Disposition = (next: PreviousDisposition) => void;
+/**
+ * The binding as the DSH specialists see it: `agent` (and every capture's
+ * agent) is the bound DSH agent. The specialists attach only when the bound
+ * session is a DSH session, so reading `agent` through this view on a
+ * non-DSH binding is a wiring bug and throws loudly instead of handing a
+ * specialist `undefined`.
+ */
+export type DshChannelBinding = Omit<ChannelBinding, 'agent' | 'capture' | 'adopt' | 'switchTo'> & {
+    readonly agent: Agent;
+    capture(): DshBindingCapture;
+    adopt<T>(candidate: AgentSession, capture: BindingCapture, tail: (previous: DshBindingCommit, disposition: Disposition) => T): T;
+    switchTo<T>(next: AgentSession, tail: (previous: DshBindingCommit, disposition: Disposition) => T): T;
+};
+/** Wrap a binding for the DSH specialists (a live view, not a snapshot). */
+export declare function dshChannelBinding(binding: ChannelBinding): DshChannelBinding;
 export {};
 //# sourceMappingURL=binding.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/binding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,KAAK,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAAA;AAE7C;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,KAAK,EAAE,YAAY;;;;eAsM1F,cAAc;uBACN,cAAc;IAEjC;;;;;;;;OAQG;qBACoB,cAAc,UAAU,MAAM,OAAO,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;IAkBhG;;;;;;;OAOG;uBACsB,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpD,0EAA0E;+BACzC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvD,6EAA6E;YA7JhE,CAAC,aACH,WAAW,WACb,cAAc,QACjB,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,KAAK,CAAC,KACrF,CAAC;IA2JF,gFAAgF;eAlGhE,CAAC,SACV,KAAK,cACA,WAAW,GAAG,SAAS,QAC7B,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,KAAK,CAAC,KACrF,CAAC;;uBA4GiB,MAAM,IAAI;qCAvNS,MAAM,IAAI,KAAG,OAAO;EA0N7D;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA"}
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/binding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAOD,KAAK,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAAA;AAE7C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY;;IA4M3E;iEAC6D;oBAChD,KAAK,GAAG,SAAS;IAC9B,4EAA4E;;;eAGjE,cAAc;uBACN,cAAc;IAEjC;;;;;;;;OAQG;qBACoB,cAAc,UAAU,MAAM,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IAkBlG;;;;;;;OAOG;uBACsB,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD;;;;;;;OAOG;oBACa,IAAI;IAMpB,0EAA0E;+BACzC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvD,6EAA6E;YA/KhE,CAAC,aACH,YAAY,WACd,cAAc,QACjB,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,KAAK,CAAC,KACrF,CAAC;IA6KF,kFAAkF;eApHlE,CAAC,QACX,YAAY,QACZ,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,KAAK,CAAC,KACrF,CAAC;;uBA+HiB,MAAM,IAAI;qCA/OS,MAAM,IAAI,KAAG,OAAO;EAkP7D;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,yEAAyE;AACzE,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CACtB;AAED,wEAAwE;AACxE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CACtB;AAED,KAAK,WAAW,GAAG,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI,CAAA;AAEtD;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC,GAAG;IACjG,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,OAAO,IAAI,iBAAiB,CAAA;IAC5B,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,KAAK,CAAC,GAAG,CAAC,CAAA;IAChI,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,KAAK,CAAC,GAAG,CAAC,CAAA;CACtG,CAAA;AAED,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,CA8B5E"}