@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/themes.js

@@ -0,0 +1,307 @@
+/**
+ * Cordis-backed runtime theme contributions.
+ *
+ * Plugins only receive `register`; the host-facing snapshot/resolver lives in a
+ * module-local WeakMap and is exposed through `getHostThemes` to host code.
+ * Runtime palettes are deliberately kept separate from custom-theme file
+ * caches, so a file with the same name always wins in the static resolver.
+ */
+import { Service } from '@deepseek-ai/cordis';
+import { cleanRenderText } from './sanitize.js';
+import { activationFiber, assertCallerContext, bindCallerEffect, compositionRoot, concreteService, requirePluginCaller, } from './host-access.js';
+import { isThemeBase, isValidThemeColor } from '../customTheme.js';
+import { assertCapabilityShadowPolicy, } from '../adapter/kernel/runtime.js';
+import { adapterRuntimeFor } from '../adapter/kernel/runtime-context.js';
+import { AUTO_THEME_NAME, getTheme, normalizeThemeKey, isRetiredThemeKey, registerRuntimeThemeResolver, THEME_NAMES, } from '../theme.js';
+const NAME_PATTERN = /^[a-z][a-z0-9_-]*(?::[a-z][a-z0-9_-]*)?$/u;
+const MAX_NAME_LENGTH = 128;
+const DISPLAY_NAME_CELLS = 120;
+const MAX_RUNTIME_THEMES = 128;
+const RESERVED_NAMES = new Set([
+    AUTO_THEME_NAME,
+    'status',
+    ...THEME_NAMES,
+]);
+const NOOP = () => { };
+const hostThemes = new WeakMap();
+function warn(ctx, message) {
+    try {
+        ctx.logger.warn(`dsh-tui: ${message}`);
+    }
+    catch {
+        // A logger is observability only; malformed plugin data must stay inert.
+    }
+}
+function normalizeRuntimeName(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    if (/[\x00-\x1f\x7f-\x9f]/u.test(value))
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed === '' ||
+        trimmed.length > MAX_NAME_LENGTH ||
+        trimmed.includes('/') ||
+        trimmed.includes('\\'))
+        return undefined;
+    const normalized = trimmed.toLowerCase();
+    if (!NAME_PATTERN.test(normalized) || RESERVED_NAMES.has(normalized))
+        return undefined;
+    return normalized;
+}
+function validateDescriptor(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    const name = normalizeRuntimeName(raw.name);
+    if (name === undefined)
+        return undefined;
+    if (!isThemeBase(raw.base))
+        return undefined;
+    const base = raw.base;
+    let displayName = cleanRenderText(name, DISPLAY_NAME_CELLS);
+    if (raw.displayName !== undefined) {
+        if (typeof raw.displayName !== 'string')
+            return undefined;
+        const cleaned = cleanRenderText(raw.displayName, DISPLAY_NAME_CELLS);
+        if (cleaned !== '')
+            displayName = cleaned;
+    }
+    const colorsRaw = raw.colors;
+    const colors = {};
+    if (colorsRaw !== undefined) {
+        if (colorsRaw === null || typeof colorsRaw !== 'object' || Array.isArray(colorsRaw))
+            return undefined;
+        for (const [key, color] of Object.entries(colorsRaw)) {
+            if (isRetiredThemeKey(key))
+                continue;
+            const normalizedKey = normalizeThemeKey(key);
+            if (normalizedKey === undefined || !isValidThemeColor(color))
+                return undefined;
+            // Canonical names win over aliases regardless of object insertion order.
+            if (normalizedKey !== key && Object.prototype.hasOwnProperty.call(colors, normalizedKey))
+                continue;
+            colors[normalizedKey] = color;
+        }
+    }
+    return {
+        name,
+        displayName,
+        base,
+        colors: Object.freeze(colors),
+    };
+}
+function themeStateFor(runtime) {
+    const state = hostThemes.get(concreteService(runtime));
+    if (state === undefined)
+        throw new Error('tuiThemes host state is unavailable');
+    return state;
+}
+function emit(state) {
+    state.snapshot = Object.freeze([...state.entries.values()].map(entry => Object.freeze({
+        name: entry.name,
+        displayName: entry.displayName,
+        base: entry.base,
+        colors: entry.colors,
+    })));
+    for (const listener of [...state.listeners]) {
+        try {
+            listener();
+        }
+        catch {
+            // Host listeners are not allowed to take down registration or teardown.
+        }
+    }
+}
+function resolveRuntimeTheme(runtime, name) {
+    assertCapabilityShadowPolicy('host.themes.resolver', themeStateFor(runtime).runtime.mode, themeStateFor(runtime).runtime.slices);
+    let normalized;
+    try {
+        normalized = normalizeRuntimeName(name);
+    }
+    catch {
+        return undefined;
+    }
+    if (normalized === undefined)
+        return undefined;
+    return themeStateFor(runtime).entries.get(normalized)?.theme;
+}
+function subscribeRuntimeTheme(runtime, listener) {
+    const state = themeStateFor(runtime);
+    if (typeof listener !== 'function' || state.disposed)
+        return NOOP;
+    state.listeners.add(listener);
+    return () => {
+        state.listeners.delete(listener);
+    };
+}
+function recordThemeEffect(caller, identity, operation, name, result, errorCode) {
+    try {
+        caller.get('tuiEffectLedger')?.record({
+            operation,
+            resource: { kind: 'theme', id: name },
+            result,
+            ...(errorCode === undefined ? {} : { errorCode }),
+        }, identity);
+    }
+    catch {
+        // Ledger writes are explicitly best-effort and must not affect the seam.
+    }
+}
+/** `ctx.tuiThemes` — plugin runtime theme registry. */
+export class TuiThemeRuntime extends Service {
+    constructor(ctx) {
+        super(ctx, 'tuiThemes');
+        const runtime = this;
+        const state = {
+            hostContext: compositionRoot(ctx),
+            entries: new Map(),
+            listeners: new Set(),
+            snapshot: Object.freeze([]),
+            host: undefined,
+            resolverCleanup: undefined,
+            disposed: false,
+            runtime: adapterRuntimeFor(ctx),
+        };
+        hostThemes.set(this, state);
+        const hostThemeOwner = Object.freeze({ kind: 'host-theme-owner' });
+        state.host = Object.freeze({
+            register: (descriptor) => {
+                const state = themeStateFor(runtime);
+                if (state.disposed)
+                    return NOOP;
+                const validated = validateDescriptor(descriptor);
+                if (validated === undefined || state.entries.has(validated.name) || state.entries.size >= MAX_RUNTIME_THEMES) {
+                    return NOOP;
+                }
+                const entry = Object.freeze({
+                    ...validated,
+                    owner: hostThemeOwner,
+                    theme: Object.freeze({ ...getTheme(validated.base), ...validated.colors }),
+                });
+                state.entries.set(entry.name, entry);
+                emit(state);
+                return () => {
+                    const current = state.entries.get(entry.name);
+                    if (current !== entry || current.owner !== hostThemeOwner)
+                        return;
+                    state.entries.delete(entry.name);
+                    emit(state);
+                };
+            },
+            getSnapshot: () => themeStateFor(runtime).snapshot,
+            resolve: (name) => resolveRuntimeTheme(runtime, name),
+            subscribe: (listener) => subscribeRuntimeTheme(runtime, listener),
+        });
+        // The resolver is process-global for non-React consumers. Its token-safe
+        // cleanup means an older composition cannot clear a newer host's resolver.
+        state.resolverCleanup = registerRuntimeThemeResolver(name => resolveRuntimeTheme(runtime, name));
+        ctx.effect(() => () => {
+            if (state.disposed)
+                return;
+            state.disposed = true;
+            state.resolverCleanup?.();
+            state.resolverCleanup = undefined;
+            if (state.entries.size > 0) {
+                state.entries.clear();
+                emit(state);
+            }
+            state.listeners.clear();
+        });
+    }
+    /**
+     * Register one immutable runtime palette. Invalid and duplicate declarations
+     * warn and return an inert disposer; successful registrations are bound to
+     * the caller's Cordis activation and disappear with that activation.
+     */
+    register(descriptor, identity) {
+        assertCapabilityShadowPolicy('host.themes.register', themeStateFor(this).runtime.mode, themeStateFor(this).runtime.slices);
+        try {
+            const caller = requirePluginCaller(this.ctx, 'tuiThemes.register', this);
+            const state = themeStateFor(this);
+            const owner = activationFiber(caller);
+            if (owner === undefined || state.disposed) {
+                warn(caller, 'tuiThemes.register requires a live activation');
+                return NOOP;
+            }
+            if (identity !== undefined) {
+                try {
+                    assertCallerContext(caller, identity, 'tuiThemes.register', this);
+                }
+                catch {
+                    warn(caller, 'tuiThemes.register rejected an identity belonging to another activation');
+                    return NOOP;
+                }
+            }
+            let validated;
+            try {
+                validated = validateDescriptor(descriptor);
+            }
+            catch {
+                validated = undefined;
+            }
+            if (validated === undefined) {
+                warn(caller, 'tuiThemes.register rejected an invalid theme descriptor');
+                return NOOP;
+            }
+            const existing = state.entries.get(validated.name);
+            if (existing !== undefined) {
+                warn(caller, `tuiThemes.register rejected "${validated.name}" — already registered`);
+                recordThemeEffect(caller, identity, 'create', validated.name, 'failed', 'DUPLICATE_CONTRIBUTION_ID');
+                return NOOP;
+            }
+            if (state.entries.size >= MAX_RUNTIME_THEMES) {
+                warn(caller, `tuiThemes.register rejected "${validated.name}" — registry limit reached`);
+                return NOOP;
+            }
+            const entry = Object.freeze({
+                ...validated,
+                owner,
+                theme: Object.freeze({ ...getTheme(validated.base), ...validated.colors }),
+            });
+            state.entries.set(entry.name, entry);
+            emit(state);
+            recordThemeEffect(caller, identity, 'create', entry.name, 'applied');
+            let disposed = false;
+            const dispose = () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                const current = state.entries.get(entry.name);
+                if (current !== entry || current.owner !== owner)
+                    return;
+                state.entries.delete(entry.name);
+                emit(state);
+                recordThemeEffect(caller, identity, 'release', entry.name, 'applied');
+            };
+            // Binding can fail when the caller's activation is already tearing down;
+            // the entry is live at this point, so undo the registration before
+            // reporting failure — otherwise the theme outlives its plugin.
+            if (!bindCallerEffect(caller, dispose)) {
+                dispose();
+                return NOOP;
+            }
+            return dispose;
+        }
+        catch {
+            try {
+                this.ctx.logger.warn('dsh-tui: tuiThemes.register rejected malformed data');
+            }
+            catch {
+                // Never let a malformed plugin descriptor crash the TUI.
+            }
+            return NOOP;
+        }
+    }
+}
+/** Host-only accessor; intentionally omitted from `src/extensions.ts`. */
+export function getHostThemes(runtime) {
+    if (runtime === undefined)
+        return undefined;
+    try {
+        return themeStateFor(runtime).host;
+    }
+    catch {
+        return undefined;
+    }
+}
+export default TuiThemeRuntime;

package/lib/types/dsh-adapter/toast.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Plugin-facing transient notifications — a fire-and-forget toast shown on
+ * the host's existing notification surface (the same toasts the channel
+ * itself uses for decision vetoes and command outcomes).
+ *
+ * Same split as the status/dialog seams: a cordis-free sink container the
+ * host bridges onto `channel.notify`, plus a thin cordis service validating
+ * untrusted text and rate-limiting per plugin activation.
+ *
+ * Deliberately NOT part of the effect ledger: a toast is a transient
+ * display with no cleanup responsibility (it auto-expires), unlike keyed
+ * status contributions or registered scenes/renderers.
+ */
+import { Context, Service } from '@deepseek-ai/cordis';
+/** Sanitized toast request after runtime validation, ready for the host sink. */
+export interface TuiToastDelivery {
+    readonly text: string;
+    readonly color?: 'success' | 'warning' | 'error';
+    readonly timeoutMs: number;
+}
+/** Host-side consumer; bridged onto `channel.notify` by the TUI plugin row. */
+export type TuiToastSink = (delivery: TuiToastDelivery) => void;
+/** Plugin-facing options for {@link TuiToastRuntime.show}. */
+export interface TuiToastOptions {
+    /** Theme color key; omitted = neutral (dim). */
+    readonly color?: 'success' | 'warning' | 'error';
+    /** Auto-dismiss after this many ms. Clamped into [500, 12000]; plugins
+     * cannot create sticky toasts (timeoutMs 0/negative falls back to the
+     * 4000ms default) — a parked indicator is a host-only device (D-8). */
+    readonly timeoutMs?: number;
+}
+/** Cordis-free sink container. The host registers the only sink; plugin
+ * deliveries before/after a sink exists are dropped (returned as false). */
+export declare class TuiToastStore {
+    private sink;
+    private readonly probeSinks;
+    setSink(sink: TuiToastSink | undefined): void;
+    /** Whether a real production sink (the host's channel.notify bridge) is
+     * present. Used by the toast live probe to distinguish “host store exists”
+     * from “real production delivery path is actually wired”. */
+    hasSink(): boolean;
+    /** Host-only probe sink registration. Probe sinks are independent of the
+     * production sink, so a live probe never replaces or swallows production
+     * toast delivery. */
+    addProbeSink(sink: TuiToastSink): () => void;
+    /** Deliver only to host-only probe sinks, leaving the production sink
+     * completely untouched. Returns true when at least one probe sink received
+     * the delivery. */
+    deliverProbe(delivery: TuiToastDelivery): boolean;
+    deliver(delivery: TuiToastDelivery): boolean;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        tuiToast: TuiToastRuntime;
+    }
+}
+/**
+ * `ctx.tuiToast` — plugin-facing transient notifications. Invalid input,
+ * over-limit callers and sink-less hosts make `show` return `false` with a
+ * logger warning instead of throwing: a toast must never take the TUI down.
+ */
+export declare class TuiToastRuntime extends Service {
+    constructor(ctx: Context);
+    /**
+     * Show one transient toast. `text` is scalar-only (string/number/boolean
+     * coerced to string; anything else is refused — never rendered as
+     * "[object Object]"); control characters are stripped and the text is
+     * capped at 200 cells, exactly like host toast-bound plugin text.
+     *
+     * Returns `true` when the toast was delivered to a host sink. `false`
+     * means refused (non-scalar text, unknown color) or dropped (no sink —
+     * e.g. a headless composition — or the caller exceeded 20 toasts per
+     * minute; the first drop logs a sticky warning per activation).
+     */
+    show(text: string | number | boolean, options?: TuiToastOptions): boolean;
+}
+/** Host-only toast store accessor; not part of the package export map. */
+export declare function getHostToastStore(runtime: TuiToastRuntime | undefined): TuiToastStore | undefined;
+export default TuiToastRuntime;
+//# sourceMappingURL=toast.d.ts.map

package/lib/types/dsh-adapter/toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/toast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAStD,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAA;AAE/D,8DAA8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;IAChD;;2EAEuE;IACvE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC5B;AAYD;4EAC4E;AAC5E,qBAAa,aAAa;IACxB,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0B;IAErD,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI;IAI7C;;iEAE6D;IAC7D,OAAO,IAAI,OAAO;IAIlB;;yBAEqB;IACrB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,IAAI;IAO5C;;uBAEmB;IACnB,YAAY,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO;IASjD,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO;CAK7C;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,QAAQ,EAAE,eAAe,CAAA;KAC1B;CACF;AAaD;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,OAAO;gBAC9B,GAAG,EAAE,OAAO;IAOxB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO;CAyD9E;AAQD,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAOjG;AAED,eAAe,eAAe,CAAA"}

package/lib/types/dsh-adapter/toast.js

@@ -0,0 +1,171 @@
+/**
+ * Plugin-facing transient notifications — a fire-and-forget toast shown on
+ * the host's existing notification surface (the same toasts the channel
+ * itself uses for decision vetoes and command outcomes).
+ *
+ * Same split as the status/dialog seams: a cordis-free sink container the
+ * host bridges onto `channel.notify`, plus a thin cordis service validating
+ * untrusted text and rate-limiting per plugin activation.
+ *
+ * Deliberately NOT part of the effect ledger: a toast is a transient
+ * display with no cleanup responsibility (it auto-expires), unlike keyed
+ * status contributions or registered scenes/renderers.
+ */
+import { Service } from '@deepseek-ai/cordis';
+import { cleanScalarText } from './sanitize.js';
+import { activationFiber, compositionRoot, concreteService, requirePluginCaller } from './host-access.js';
+import { assertCapabilityShadowPolicy, } from '../adapter/kernel/runtime.js';
+import { adapterRuntimeFor } from '../adapter/kernel/runtime-context.js';
+// Same caps as the channel's own toast-bound plugin text (NOTICE_CELLS).
+const TEXT_CELLS = 200;
+const TIMEOUT_DEFAULT_MS = 4000;
+const TIMEOUT_MIN_MS = 500;
+const TIMEOUT_MAX_MS = 12_000;
+// Per-activation sliding window: a runaway loop must not own the screen.
+const RATE_WINDOW_MS = 60_000;
+const RATE_LIMIT = 20;
+const COLORS = new Set(['success', 'warning', 'error']);
+/** Cordis-free sink container. The host registers the only sink; plugin
+ * deliveries before/after a sink exists are dropped (returned as false). */
+export class TuiToastStore {
+    sink;
+    probeSinks = new Set();
+    setSink(sink) {
+        this.sink = sink;
+    }
+    /** Whether a real production sink (the host's channel.notify bridge) is
+     * present. Used by the toast live probe to distinguish “host store exists”
+     * from “real production delivery path is actually wired”. */
+    hasSink() {
+        return this.sink !== undefined;
+    }
+    /** Host-only probe sink registration. Probe sinks are independent of the
+     * production sink, so a live probe never replaces or swallows production
+     * toast delivery. */
+    addProbeSink(sink) {
+        this.probeSinks.add(sink);
+        return () => {
+            this.probeSinks.delete(sink);
+        };
+    }
+    /** Deliver only to host-only probe sinks, leaving the production sink
+     * completely untouched. Returns true when at least one probe sink received
+     * the delivery. */
+    deliverProbe(delivery) {
+        let delivered = false;
+        for (const sink of this.probeSinks) {
+            sink(delivery);
+            delivered = true;
+        }
+        return delivered;
+    }
+    deliver(delivery) {
+        if (this.sink === undefined)
+            return false;
+        this.sink(delivery);
+        return true;
+    }
+}
+const hostToastStores = new WeakMap();
+/**
+ * `ctx.tuiToast` — plugin-facing transient notifications. Invalid input,
+ * over-limit callers and sink-less hosts make `show` return `false` with a
+ * logger warning instead of throwing: a toast must never take the TUI down.
+ */
+export class TuiToastRuntime extends Service {
+    constructor(ctx) {
+        super(ctx, 'tuiToast');
+        compositionRoot(ctx);
+        const state = { store: new TuiToastStore(), windows: new Map(), warned: new Set(), runtime: adapterRuntimeFor(ctx) };
+        hostToastStores.set(this, state);
+    }
+    /**
+     * Show one transient toast. `text` is scalar-only (string/number/boolean
+     * coerced to string; anything else is refused — never rendered as
+     * "[object Object]"); control characters are stripped and the text is
+     * capped at 200 cells, exactly like host toast-bound plugin text.
+     *
+     * Returns `true` when the toast was delivered to a host sink. `false`
+     * means refused (non-scalar text, unknown color) or dropped (no sink —
+     * e.g. a headless composition — or the caller exceeded 20 toasts per
+     * minute; the first drop logs a sticky warning per activation).
+     */
+    show(text, options = {}) {
+        assertCapabilityShadowPolicy('host.toast.show', toastStateFor(this).runtime.mode, toastStateFor(this).runtime.slices);
+        let caller;
+        try {
+            caller = requirePluginCaller(this.ctx, 'tuiToast.show', this);
+        }
+        catch {
+            this.ctx.logger.warn('dsh-tui: tuiToast.show requires a live non-root plugin activation');
+            return false;
+        }
+        const state = toastStateFor(this);
+        if (typeof text !== 'string' && typeof text !== 'number' && typeof text !== 'boolean') {
+            caller.logger.warn('dsh-tui: tuiToast.show rejected non-scalar text');
+            return false;
+        }
+        const cleaned = cleanScalarText(text, TEXT_CELLS);
+        if (cleaned === '') {
+            caller.logger.warn('dsh-tui: tuiToast.show rejected empty text');
+            return false;
+        }
+        let color;
+        if (options.color !== undefined) {
+            if (!COLORS.has(options.color)) {
+                caller.logger.warn(`dsh-tui: tuiToast.show rejected unknown color "${String(options.color)}"`);
+                return false;
+            }
+            color = options.color;
+        }
+        let timeoutMs = TIMEOUT_DEFAULT_MS;
+        if (options.timeoutMs !== undefined) {
+            if (options.timeoutMs <= 0) {
+                // Sticky toasts are a host-only device; fall back, don't fail —
+                // the plugin asked to be seen, not to park an indicator forever.
+                caller.logger.warn('dsh-tui: tuiToast.show ignores sticky timeoutMs (host-only); using the 4000ms default');
+            }
+            else {
+                timeoutMs = Math.min(TIMEOUT_MAX_MS, Math.max(TIMEOUT_MIN_MS, Math.floor(options.timeoutMs)));
+            }
+        }
+        const owner = activationFiber(caller);
+        if (owner === undefined) {
+            caller.logger.warn('dsh-tui: tuiToast.show requires a live activation owner');
+            return false;
+        }
+        const now = Date.now();
+        const window = state.windows.get(owner) ?? [];
+        while (window.length > 0 && now - window[0] >= RATE_WINDOW_MS)
+            window.shift();
+        if (window.length >= RATE_LIMIT) {
+            if (!state.warned.has(owner)) {
+                state.warned.add(owner);
+                caller.logger.warn(`dsh-tui: tuiToast.show rate-limited an activation to ${RATE_LIMIT}/min; further toasts in this window are dropped silently`);
+            }
+            state.windows.set(owner, window);
+            return false;
+        }
+        window.push(now);
+        state.windows.set(owner, window);
+        return state.store.deliver({ text: cleaned, ...(color === undefined ? {} : { color }), timeoutMs });
+    }
+}
+function toastStateFor(runtime) {
+    const state = hostToastStores.get(concreteService(runtime));
+    if (state === undefined)
+        throw new Error('tuiToast host store is unavailable');
+    return state;
+}
+/** Host-only toast store accessor; not part of the package export map. */
+export function getHostToastStore(runtime) {
+    if (runtime === undefined)
+        return undefined;
+    try {
+        return hostToastStores.get(concreteService(runtime))?.store;
+    }
+    catch {
+        return undefined;
+    }
+}
+export default TuiToastRuntime;

package/lib/types/dsh-adapter/trajectory/aggregate.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Trajectory aggregate — the hotspot view's data and the session totals.
+ *
+ * The ledger answers "what happened, in order". This module answers the other
+ * question a long session raises: **where did the time go**. Chronological
+ * order is the worst order for that, so everything here is grouped and ranked
+ * instead: cost per tool, cost per model phase (decode vs. waiting for the
+ * first token vs. retry backoff), cost per turn.
+ *
+ * Three details make the numbers trustworthy rather than merely plausible:
+ *
+ * - **Own duration only.** A turn's cost is its own bracket, never the sum of
+ *   its children — summing both would double-count every tool inside it.
+ * - **No fabricated spans.** A step that produced no stream output (no
+ *   `assistant/chunk` pre-0.1.5, no embedded settlement stream since — the
+ *   request failed, or the log predates chunk capture) contributes no TTFT and
+ *   no decode sample rather than a zero that would drag the average down.
+ * - **Bursts expand.** A folded run is one ledger row but N calls; the counts
+ *   and totals here are over calls, so `count` matches what actually ran.
+ */
+import type { HotspotRow, HotspotSort, TrajAggregate, TrajNode } from './types.js';
+import type { TrajBuild } from './projection.js';
+/**
+ * Visit every logical call in ledger order, expanding burst rows.
+ *
+ * @param nodes - The folded ledger.
+ * @param visit - Receives each call node plus the ledger index of the row it
+ *   is displayed under (the burst row's index, for folded members).
+ */
+export declare function forEachCall(nodes: readonly TrajNode[], visit: (node: TrajNode, ledgerIndex: number) => void): void;
+/**
+ * Rank hotspot rows by the active sort key.
+ *
+ * Ties break on label so the order is total — an unstable order would make
+ * rows jump between frames while the session streams.
+ */
+export declare function sortRows(rows: readonly HotspotRow[], sort: HotspotSort): HotspotRow[];
+/**
+ * Derive the hotspot groups and session totals from a projection.
+ *
+ * @param build - The current projection.
+ * @param sort - Ranking key for the tool and turn groups.
+ * @returns Ranked groups plus the counters the scene header and status badge
+ *   read. Pure: nothing here mutates the build.
+ */
+export declare function aggregate(build: TrajBuild, sort?: HotspotSort): TrajAggregate;
+//# sourceMappingURL=aggregate.d.ts.map

package/lib/types/dsh-adapter/trajectory/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/trajectory/aggregate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ,EAA0B,MAAM,YAAY,CAAA;AAC1G,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAK5D;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,GACnD,IAAI,CASN;AAqCD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,EAAE,CAIrF;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,GAAE,WAAwB,GAAG,aAAa,CAuGzF"}