@deepseek-harness-tui/dsh-tui 0.10.0 → 0.10.2

package/lib/types/dsh-adapter/channel/mode-permission.js

@@ -0,0 +1,240 @@
+import { isCommandCompletionToken } from '../../commands.js';
+import { snapshotLiveSessionEvents } from '../compat/liveSession.js';
+import { t } from '../../i18n.js';
+import { modeDisplayName } from '../../sessionModes.js';
+import { PERMISSION_PRESET_CUSTOM, permissionPresetRuntime } from './permissions.js';
+/** Last durable permission preset identity (`permission/preset`), if any.
+ *  Registered by the harness permission preset service, never manufactured
+ *  by the TUI. */
+export function foldPermissionPreset(events) {
+    let preset;
+    for (const event of events) {
+        if (event.type === 'permission/preset') {
+            const value = event.data.preset;
+            if (typeof value === 'string')
+                preset = value;
+        }
+    }
+    return preset;
+}
+/** Effective sandbox of a mode target: its explicit atom, else the folded
+ *  session value, else the sandbox-policy service default. Unknown means the
+ *  bundle is not safely mappable. */
+export function effectiveSandboxForMode(ctx, spec, events) {
+    if (spec.sandbox !== undefined)
+        return spec.sandbox;
+    let folded;
+    for (const event of events) {
+        if (event.type === 'sandbox/mode') {
+            folded = event.data.mode;
+        }
+    }
+    if (folded === 'read-only' || folded === 'workspace-write' || folded === 'danger-full-access')
+        return folded;
+    try {
+        const sandbox = ctx.get('sandboxPolicy');
+        const value = sandbox?.defaultMode;
+        if (value === 'read-only' || value === 'workspace-write' || value === 'danger-full-access')
+            return value;
+    }
+    catch {
+        // Optional service; an unknown default means the target is not safely
+        // mappable.
+    }
+    return undefined;
+}
+/** Effective approval policy of a mode target: its explicit atom, else the
+ *  folded session value, else the approval service configuration. */
+export function effectiveApprovalForMode(ctx, spec, session) {
+    if (spec.approval !== undefined)
+        return spec.approval;
+    let folded;
+    for (const event of snapshotLiveSessionEvents(session)) {
+        if (event.type === 'approval/policy') {
+            folded = event.data.policy;
+        }
+    }
+    if (folded === 'ask' || folded === 'never')
+        return folded;
+    try {
+        const approval = ctx.get('approval');
+        const value = approval?.effectivePolicy?.(session) ?? approval?.config?.policy;
+        if (value === 'ask' || value === 'never')
+            return value;
+    }
+    catch {
+        // Optional service; an unknown default means the target is not safely
+        // mappable.
+    }
+    return undefined;
+}
+/**
+ * Durable `permission/preset` identity: readback, canonical mapping, the
+ * official switch path, and the pre-plan identity memory. Construction is
+ * inert — it acquires nothing and subscribes to nothing.
+ */
+export function createPermissionIdentity(ctx, deps) {
+    /** Durable preset identity captured when plan mode starts; an implicit plan
+     *  exit prefers returning to it over the canonical bundle of the restored
+     *  atoms, so the user lands back on their own preset (e.g. a third-party
+     *  `auto`), not on a look-alike static mode. */
+    const prePlanIdentity = new WeakMap();
+    const fold = (session) => foldPermissionPreset(snapshotLiveSessionEvents(session));
+    const canonicalForMode = (spec, session) => {
+        const sandbox = effectiveSandboxForMode(ctx, spec, snapshotLiveSessionEvents(session));
+        const approval = effectiveApprovalForMode(ctx, spec, session);
+        if (sandbox === undefined || approval === undefined)
+            return undefined;
+        return deps.roster.canonicalFor(sandbox, approval);
+    };
+    const targetConfirmed = (target, session) => {
+        if (fold(session) === target)
+            return true;
+        try {
+            const snapshot = deps.roster.readSnapshot(deps.agent());
+            if (snapshot !== undefined
+                && snapshot.current?.kind === 'preset'
+                && snapshot.current.value === target) {
+                return true;
+            }
+        }
+        catch {
+            // The registry may be unmounted mid-switch; the fold check above
+            // remains authoritative for the durable identity.
+        }
+        return false;
+    };
+    const confirmTarget = async (target, session, timeoutMs) => {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (session !== deps.agent().session)
+                return false;
+            if (targetConfirmed(target, session))
+                return true;
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
+        ctx.logger.warn(`dsh-tui: permission mode "${target}" was not confirmed by permissionPresets.current()/permission/preset`);
+        deps.notify(t('mode-permission-unconfirmed'), { color: 'warning' });
+        return false;
+    };
+    const apply = async (target) => {
+        if (!isCommandCompletionToken(target)) {
+            ctx.logger.warn(`dsh-tui: permission mode "${target}" skipped because its identity is not a safe command token`);
+            return false;
+        }
+        const agent = deps.agent();
+        const session = agent.session;
+        if (targetConfirmed(target, session))
+            return true;
+        let registered = false;
+        try {
+            registered = deps.commandService?.find(agent, 'permission') !== undefined;
+        }
+        catch {
+            registered = false;
+        }
+        if (!registered) {
+            // The same handler the official command drives; the TUI never appends
+            // a permission event itself.
+            let service;
+            try {
+                service = ctx.get('permissionPresets');
+            }
+            catch {
+                service = undefined;
+            }
+            const runtime = permissionPresetRuntime(service);
+            if (runtime !== undefined && typeof runtime.set === 'function') {
+                try {
+                    runtime.set(session, target);
+                }
+                catch (error) {
+                    ctx.logger.warn(`dsh-tui: permission mode "${target}" could not be applied by the permissionPresets service: ${error instanceof Error ? error.message : String(error)}`);
+                    deps.notify(t('mode-permission-invoke-failed'), { color: 'warning' });
+                    return false;
+                }
+                return await confirmTarget(target, session, 2000);
+            }
+            ctx.logger.warn(`dsh-tui: permission mode "${target}" skipped because /permission is not registered`);
+            deps.notify(t('mode-permission-unregistered'), { color: 'warning' });
+            return false;
+        }
+        const result = await deps.executeRegistryCommand('permission', ` ${target}`);
+        if (session !== deps.agent().session)
+            return false;
+        if (result === undefined) {
+            ctx.logger.warn(`dsh-tui: permission mode "${target}" could not invoke /permission`);
+            deps.notify(t('mode-permission-invoke-failed'), { color: 'warning' });
+            return false;
+        }
+        let availability = 'unavailable';
+        try {
+            availability = deps.roster.readSnapshot(deps.agent()) === undefined ? 'unavailable' : 'runtime';
+        }
+        catch {
+            // keep the default (fail-closed short grace)
+        }
+        return await confirmTarget(target, session, availability === 'runtime' ? 2000 : 300);
+    };
+    const canonicalizeForMode = async (spec, session) => {
+        // Static modes own a canonical permission identity. Leaving any OTHER
+        // durable identity behind (third-party preset OR a stale canonical, e.g.
+        // plan left `read-only` while atoms were restored to workspace-write)
+        // would make a static mode appear selected only because its
+        // sandbox/approval bundle happens to match, and would let the durable
+        // identity lie about the real policy.
+        const current = fold(session);
+        if (current === undefined || current === PERMISSION_PRESET_CUSTOM)
+            return true;
+        const canonical = canonicalForMode(spec, session);
+        if (canonical === undefined) {
+            ctx.logger.warn(`dsh-tui: static mode "${spec.id}" cannot safely clear permission identity "${current}"`);
+            deps.notify(t('mode-permission-no-canonical', { name: modeDisplayName(spec) }), { color: 'warning' });
+            return false;
+        }
+        if (canonical === current)
+            return true;
+        return apply(canonical);
+    };
+    const rememberPrePlanIdentity = (session) => {
+        // The runtime registry must still recognize the identity as current: a
+        // drifted knob combination reads back as custom and must fall back to the
+        // canonical bundle of the restored atoms.
+        const identity = fold(session);
+        if (identity === undefined || identity === PERMISSION_PRESET_CUSTOM) {
+            prePlanIdentity.delete(session);
+            return;
+        }
+        try {
+            const snapshot = deps.roster.readSnapshot(deps.agent());
+            if (snapshot === undefined) {
+                prePlanIdentity.delete(session);
+                return;
+            }
+            if (snapshot.current?.kind !== 'preset' || snapshot.current.value !== identity) {
+                prePlanIdentity.delete(session);
+                return;
+            }
+            if (!snapshot.options.some(option => option.value === identity)) {
+                prePlanIdentity.delete(session);
+                return;
+            }
+            prePlanIdentity.set(session, identity);
+        }
+        catch {
+            prePlanIdentity.delete(session);
+        }
+    };
+    return {
+        foldPermissionPreset: fold,
+        canonicalPermissionForMode: canonicalForMode,
+        permissionTargetConfirmed: (target, session) => targetConfirmed(target, session),
+        confirmPermissionTarget: (target, session, timeoutMs) => confirmTarget(target, session, timeoutMs),
+        applyPermissionIdentity: apply,
+        canonicalizeForMode,
+        rememberPrePlanIdentity,
+        prePlanPermissionIdentity: session => prePlanIdentity.get(session),
+        forgetPrePlanIdentity: session => { prePlanIdentity.delete(session); },
+        runPermissionPreset: name => apply(name.trim()),
+    };
+}

package/lib/types/dsh-adapter/channel/mode-roster.d.ts

@@ -0,0 +1,51 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type SessionModeSpec } from '../../sessionModes.js';
+import { type PermissionPresetBundle } from './permissions.js';
+import type { PermissionPresetSnapshot } from './types.js';
+/** Durable identities the configured modes already own; a runtime preset with
+ *  one of them is the same switch by another route and never duplicated. */
+export declare function configuredPermissionIds(modes: readonly SessionModeSpec[]): ReadonlySet<string>;
+/** Canonical targets of the STATIC modes. On a stock table that is the three
+ *  built-in names; on renamed tables the deployment's own names for the same
+ *  bundles. They are never dynamic entries: the indicator would otherwise
+ *  snap to a dynamic look-alike instead of the static mode. */
+export declare function staticCanonicalTargets(modes: readonly SessionModeSpec[], bundles: readonly PermissionPresetBundle[]): ReadonlySet<string>;
+/** The mounted `permissionPresets` registry as a runtime snapshot, or
+ *  undefined when no runtime table is mounted (legacy/unavailable tables are
+ *  not a roster). Reads are fail-closed: a throwing registry is no roster. */
+export declare function readRuntimePermissionSnapshot(ctx: Context, target: Agent): PermissionPresetSnapshot | undefined;
+/** Warn at most once per (agent, identity, reason) — a registry that keeps
+ *  re-listing an unusable preset must not flood the log on every rebuild. */
+export declare function warnOnceForPermissionEntry(warned: Set<string>, warn: (message: string) => void, target: Agent, value: string, reason: string): void;
+/** The Shift+Tab roster: configured modes first, runtime presets appended. */
+export interface PermissionModeRoster {
+    /** LIVE roster. The array identity is stable and mutated in place, so a
+     *  consumer that captured it at construction always sees the latest
+     *  roster after {@link PermissionModeRoster.rebuild}. */
+    readonly modes: readonly SessionModeSpec[];
+    /** Re-read the runtime preset registry for `target` and re-derive. */
+    rebuild(target: Agent): void;
+    /** Runtime snapshot for `target`, undefined when no runtime table is mounted. */
+    readSnapshot(target: Agent): PermissionPresetSnapshot | undefined;
+    /** Canonical preset name for one effective sandbox/approval bundle. */
+    canonicalFor(sandbox: NonNullable<SessionModeSpec['sandbox']>, approval: NonNullable<SessionModeSpec['approval']>): string | undefined;
+}
+/**
+ * Dynamic session-mode roster (main's `sessionModes` / `rebuildSessionModes`).
+ *
+ * Runtime permission presets are appended AFTER the configured/default modes
+ * whenever the SERVICE snapshot is usable — no dependency on the external
+ * `/permission` command reaching this agent's registry, because switching
+ * falls back to the service's own write path when the command row is absent.
+ * Registry order is authoritative on first observation; later rebuilds
+ * preserve the relative order of identities already seen so unrelated
+ * command-registry churn cannot reshuffle Shift+Tab. Removed identities drop
+ * out and a later re-add is treated as new.
+ */
+export declare function createPermissionModeRoster(ctx: Context, deps: {
+    configuredModes: readonly SessionModeSpec[];
+    agent: () => Agent;
+    warn?: (message: string) => void;
+}): PermissionModeRoster;
+//# sourceMappingURL=mode-roster.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mode-roster.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/mode-roster.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAEnD,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAA0B,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAElF;4EAC4E;AAC5E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC,CAE9F;AAED;;;+DAG+D;AAC/D,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,OAAO,EAAE,SAAS,sBAAsB,EAAE,GACzC,WAAW,CAAC,MAAM,CAAC,CAQrB;AAED;;8EAE8E;AAC9E,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,KAAK,GACZ,wBAAwB,GAAG,SAAS,CAUtC;AAED;6EAC6E;AAC7E,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EACnB,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EAC/B,MAAM,EAAE,KAAK,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,IAAI,CAMN;AAED,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACnC;;6DAEyD;IACzD,QAAQ,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,CAAA;IAC1C,sEAAsE;IACtE,OAAO,CAAC,MAAM,EAAE,KAAK,GAAG,IAAI,CAAA;IAC5B,iFAAiF;IACjF,YAAY,CAAC,MAAM,EAAE,KAAK,GAAG,wBAAwB,GAAG,SAAS,CAAA;IACjE,uEAAuE;IACvE,YAAY,CACV,OAAO,EAAE,WAAW,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,EAChD,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,GACjD,MAAM,GAAG,SAAS,CAAA;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE;IACJ,eAAe,EAAE,SAAS,eAAe,EAAE,CAAA;IAC3C,KAAK,EAAE,MAAM,KAAK,CAAA;IAClB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CACjC,GACA,oBAAoB,CAgEtB"}

package/lib/types/dsh-adapter/channel/mode-roster.js

@@ -0,0 +1,119 @@
+import { isCommandCompletionToken } from '../../commands.js';
+import { canonicalPresetFor, permissionCycleEntry, permissionModeSpec, stablePermissionRosterOrder, } from '../../sessionModes.js';
+import { permissionBundlesFromService, permissionPresetSnapshotFromService, } from './permissions.js';
+/** Durable identities the configured modes already own; a runtime preset with
+ *  one of them is the same switch by another route and never duplicated. */
+export function configuredPermissionIds(modes) {
+    return new Set(modes.flatMap(spec => spec.permission === undefined ? [] : [spec.permission]));
+}
+/** Canonical targets of the STATIC modes. On a stock table that is the three
+ *  built-in names; on renamed tables the deployment's own names for the same
+ *  bundles. They are never dynamic entries: the indicator would otherwise
+ *  snap to a dynamic look-alike instead of the static mode. */
+export function staticCanonicalTargets(modes, bundles) {
+    const targets = new Set();
+    for (const spec of modes) {
+        if (spec.permission !== undefined || spec.sandbox === undefined || spec.approval === undefined)
+            continue;
+        const canonical = canonicalPresetFor(spec.sandbox, spec.approval, bundles);
+        if (canonical !== undefined)
+            targets.add(canonical);
+    }
+    return targets;
+}
+/** The mounted `permissionPresets` registry as a runtime snapshot, or
+ *  undefined when no runtime table is mounted (legacy/unavailable tables are
+ *  not a roster). Reads are fail-closed: a throwing registry is no roster. */
+export function readRuntimePermissionSnapshot(ctx, target) {
+    let service;
+    try {
+        service = ctx.get('permissionPresets');
+    }
+    catch {
+        return undefined;
+    }
+    if (service === undefined)
+        return undefined;
+    const snapshot = permissionPresetSnapshotFromService(service, target.session);
+    return snapshot.availability === 'runtime' ? snapshot : undefined;
+}
+/** Warn at most once per (agent, identity, reason) — a registry that keeps
+ *  re-listing an unusable preset must not flood the log on every rebuild. */
+export function warnOnceForPermissionEntry(warned, warn, target, value, reason) {
+    const key = `${String(target.id)}:${value}:${reason}`;
+    if (warned.has(key))
+        return;
+    if (warned.size >= 200)
+        warned.clear();
+    warned.add(key);
+    warn(`dsh-tui: permission preset "${value}" skipped from Shift+Tab (${reason})`);
+}
+/**
+ * Dynamic session-mode roster (main's `sessionModes` / `rebuildSessionModes`).
+ *
+ * Runtime permission presets are appended AFTER the configured/default modes
+ * whenever the SERVICE snapshot is usable — no dependency on the external
+ * `/permission` command reaching this agent's registry, because switching
+ * falls back to the service's own write path when the command row is absent.
+ * Registry order is authoritative on first observation; later rebuilds
+ * preserve the relative order of identities already seen so unrelated
+ * command-registry churn cannot reshuffle Shift+Tab. Removed identities drop
+ * out and a later re-add is treated as new.
+ */
+export function createPermissionModeRoster(ctx, deps) {
+    const warn = deps.warn ?? ((message) => ctx.logger.warn(message));
+    const configuredIds = configuredPermissionIds(deps.configuredModes);
+    const warned = new Set();
+    const order = new WeakMap();
+    // Mutated in place: a consumer that captured this array keeps observing the
+    // live roster across rebuilds (see the interface contract).
+    const modes = [...deps.configuredModes];
+    const bundlesOf = () => {
+        let service;
+        try {
+            service = ctx.get('permissionPresets');
+        }
+        catch {
+            return [];
+        }
+        return service === undefined ? [] : permissionBundlesFromService(service);
+    };
+    const canonicalFor = (sandbox, approval) => canonicalPresetFor(sandbox, approval, bundlesOf());
+    const rebuild = (target) => {
+        const snapshot = readRuntimePermissionSnapshot(ctx, target);
+        const excluded = staticCanonicalTargets(deps.configuredModes, bundlesOf());
+        const candidates = new Map();
+        if (snapshot !== undefined) {
+            for (const option of snapshot.options) {
+                if (excluded.has(option.value)) {
+                    warnOnceForPermissionEntry(warned, warn, target, option.value, 'canonical target');
+                    continue;
+                }
+                if (!isCommandCompletionToken(option.value)) {
+                    warnOnceForPermissionEntry(warned, warn, target, option.value, 'unsafe command token');
+                    continue;
+                }
+                const decision = permissionCycleEntry(option, configuredIds);
+                if (!decision.accepted) {
+                    warnOnceForPermissionEntry(warned, warn, target, option.value, decision.reason);
+                    continue;
+                }
+                candidates.set(option.value, option);
+            }
+        }
+        const next = stablePermissionRosterOrder(order.get(target.session) ?? [], [...candidates.keys()]);
+        order.set(target.session, next);
+        const dynamic = [];
+        for (const value of next) {
+            const option = candidates.get(value);
+            if (option !== undefined)
+                dynamic.push(permissionModeSpec(option));
+        }
+        modes.length = 0;
+        for (const spec of [...deps.configuredModes, ...dynamic])
+            modes.push(spec);
+    };
+    // Main rebuilds once at construction, before the roster is first read.
+    rebuild(deps.agent());
+    return { modes, rebuild, readSnapshot: target => readRuntimePermissionSnapshot(ctx, target), canonicalFor };
+}

package/lib/types/dsh-adapter/channel/model-actions.d.ts

@@ -0,0 +1,46 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type LlmModelInfo } from '@deepseek-ai/dsh-llm';
+import type { Agent, ModelSelectionRef } from '@deepseek-ai/dsh-agent';
+import type { CommandCompletionNode } from '../../commands.js';
+import type { createChannelBinding } from './binding.js';
+import type { ChannelOwner } from './owner.js';
+import type { ChannelState, EffortOption, PresetOption } from './types.js';
+type Binding = ReturnType<typeof createChannelBinding>;
+/**
+ * Route metadata, effort preference and preset/model catalog actions.
+ * This owns the async catalog caches and their generation fences; callers only
+ * compose its surface into ChannelState after the state has been constructed.
+ */
+export declare function createModelActions(ctx: Context, state: Pick<ChannelState, 'provider' | 'model' | 'reasoningEffort' | 'effortLevels' | 'agentPreset' | 'working' | 'emit'>, deps: {
+    owner: Pick<ChannelOwner, 'current'>;
+    binding: Pick<Binding, 'capture' | 'isCurrent'>;
+    selection: ModelSelectionRef;
+    initialEffort?: string;
+    agent(): Agent;
+    notify: ChannelState['notify'];
+}): {
+    selection: ModelSelectionRef;
+    applyPreferredEffort: () => Promise<void>;
+    refreshEffortLevels: () => void;
+    listEfforts: () => Promise<{
+        efforts: readonly EffortOption[];
+        defaultEffort: string | undefined;
+    }>;
+    setEffort: (id: string) => Promise<boolean>;
+    setDefaultEffort: (id: string | undefined) => void;
+    warmEffortLevels: () => void;
+    listModels: () => Promise<readonly LlmModelInfo[]>;
+    listProviders: () => Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    dropModelNodeCache: () => void;
+    warmModelNodes: () => void;
+    modelNodes: () => readonly CommandCompletionNode[];
+    warmPresetOptions: () => void;
+    presetOptions: () => readonly PresetOption[];
+    listPresets: () => Promise<readonly PresetOption[]>;
+    switchPreset: (presetId: string) => Promise<boolean>;
+};
+export {};
+//# sourceMappingURL=model-actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-actions.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/channel/model-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAC3E,OAAO,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AACtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAM9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE1E,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,OAAO,GAAG,iBAAiB,GAAG,cAAc,GAAG,aAAa,GAAG,SAAS,GAAG,MAAM,CAAC,EACzH,IAAI,EAAE;IACJ,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAA;IACpC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,WAAW,CAAC,CAAA;IAC/C,SAAS,EAAE,iBAAiB,CAAA;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,IAAI,KAAK,CAAA;IACd,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;CAC/B;;gCA2CsC,OAAO,CAAC,IAAI,CAAC;+BAWpB,IAAI;uBAmBN,OAAO,CAAC;QAAE,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;QAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;oBAWjF,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;2BAoBxB,MAAM,GAAG,SAAS,KAAG,IAAI;4BAM1B,IAAI;sBAeV,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;;YAvHnB,MAAM;cAAQ,MAAM;;8BA4HzB,IAAI;0BACR,IAAI;;6BASD,IAAI;;uBAOJ,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;6BAQxB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;EAkChE"}