@khorsheed/dsh-context-lens 0.0.0-stage → 0.1.0

package/lib/types/client/preset-visibility.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The preset-composition visibility of the context-lens surfaces — the
+ * registration-level gate for the right-Sidebar tab type and its two entry
+ * points (the turn action row, the session-header utility).
+ *
+ * The criterion answers "can THIS session reach the context-lens
+ * capture" over the two grant paths this package's own row can take
+ * (the canvas double-check template, `docs/plugin-visibility.md` 判据轴):
+ *
+ * 1. **Profile-root mount** (this package's own cordis.patch.yml — the only
+ *   shape the bundle patch ships): the inventory's `entries` carry an
+ *   ENABLED `@khorsheed/dsh-context-lens` row → visible for every
+ *   session. This is the common case; capture is deployment-wide.
+ * 2. **Preset mount** (a composition that instead names the row from a
+ *   preset's agent.cordis.yml): visible exactly when the CURRENT session's
+ *   preset composition names that row.
+ *
+ * Every unreadable path fails OPEN (visible): no pluginInventory namespace,
+ * a pending/failed RPC, a missing or `broken` preset group, a session with
+ * no preset, and the no-session home state (a frame-level surface has no
+ * preset input until a session exists — showing there is the neutral state,
+ * not a leak).
+ *
+ * Hidden means NOT registered: the guide enumerates the tab-type registry,
+ * opened tabs are stored per session (an ungranted session's layout never
+ * held one), and a kind with no registrant renders the host's designed
+ * `tab.unavailable` fallback ("a real state, not a defect").
+ * @module @khorsheed/dsh-context-lens/client/preset-visibility
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+/** The criterion's row: this package's own composition entry (root-mounted by its bundle patch). */
+export declare const REQUEST_INSPECTOR_ROW_MODULE = "@khorsheed/dsh-context-lens";
+/**
+ * Minimal structural mirror of the official pluginInventory snapshot — the
+ * entries slice (root grants) plus the agentPresets slice (preset grants),
+ * duck-typed and host-version tolerant.
+ */
+export interface InspectorPluginInventorySnapshot {
+    readonly entries?: readonly {
+        readonly moduleName: string;
+        readonly enabled?: boolean;
+    }[];
+    readonly agentPresets?: readonly {
+        readonly id: string;
+        readonly broken?: string;
+        readonly rows: readonly {
+            readonly moduleName: string;
+            readonly enabled?: boolean;
+        }[];
+    }[];
+}
+/**
+ * The surfaces' visibility controller: one inventory fetch per page
+ * (composition data changes only with preset files, which a reload re-reads
+ * anyway), re-evaluated by the toggles on every session switch.
+ */
+export declare class InspectorTabVisibility {
+    private readonly ctx;
+    /** The inventory answer; null while pending/failed and on namespace-less hosts. */
+    private composition;
+    private readonly listeners;
+    /**
+     * @param ctx - client root context.
+     * @param pluginInventory - the OFFICIAL namespace, probed through ctx.get
+     *   (never injected — declaring it would pend the whole client on a host
+     *   without it, and the criterion must fail open there).
+     */
+    constructor(ctx: Context, pluginInventory: {
+        list: () => Promise<RemoteResult<InspectorPluginInventorySnapshot>>;
+    } | undefined);
+    show(sessionId: SessionId | undefined): boolean;
+    /** Subscribe to criterion-input changes (session switches, the inventory answer). */
+    subscribe(listener: () => void): () => void;
+    private notify;
+}
+/**
+ * One registration's toggle (the room template): registered exactly while the
+ * criterion passes for the current session, disposed otherwise. Works for the
+ * sidebarRightTabs registry (a direct inject) and for a `ctx.slots.inject`
+ * registration alike — both return their disposer synchronously.
+ */
+export declare class RegistrationToggle {
+    private readonly register;
+    private readonly show;
+    private dispose;
+    private ready;
+    /**
+     * @param register - mounts the entry and returns its disposer.
+     * @param show - the current decision (re-read on every sync).
+     */
+    constructor(register: () => () => void, show: () => boolean);
+    /** The registry is reachable — decisions may register now. */
+    setReady(ready: boolean): void;
+    /** Re-evaluate: register while shown and ready, dispose otherwise. */
+    sync(): void;
+}
+//# sourceMappingURL=preset-visibility.d.ts.map

package/lib/types/client/preset-visibility.js

@@ -0,0 +1,108 @@
+/** The criterion's row: this package's own composition entry (root-mounted by its bundle patch). */
+export const REQUEST_INSPECTOR_ROW_MODULE = '@khorsheed/dsh-context-lens';
+/** The current session's agent preset, the dual read per host line. */
+function presetOf(row) {
+    const value = row
+        ?.projectionValues?.agentPreset
+        ?? row?.agentPreset;
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * The surfaces' visibility controller: one inventory fetch per page
+ * (composition data changes only with preset files, which a reload re-reads
+ * anyway), re-evaluated by the toggles on every session switch.
+ */
+export class InspectorTabVisibility {
+    ctx;
+    /** The inventory answer; null while pending/failed and on namespace-less hosts. */
+    composition = null;
+    listeners = new Set();
+    /**
+     * @param ctx - client root context.
+     * @param pluginInventory - the OFFICIAL namespace, probed through ctx.get
+     *   (never injected — declaring it would pend the whole client on a host
+     *   without it, and the criterion must fail open there).
+     */
+    constructor(ctx, pluginInventory) {
+        this.ctx = ctx;
+        if (pluginInventory !== undefined) {
+            void pluginInventory.list().then(result => {
+                if (!result.ok)
+                    return;
+                this.composition = result.value ?? null;
+                this.notify();
+            }).catch(() => { });
+        }
+        // Session switches re-decide the registrations (the guide enumerates
+        // registrations, not components).
+        ctx.effect(() => ctx.sessions.list.subscribe(() => { this.notify(); }), 'context-lens: visibility session follower');
+    }
+    show(sessionId) {
+        if (this.composition === null)
+            return true;
+        // Path 1: a root-mounted capture row serves every session — a
+        // deployment-level constant, checked before any per-session question.
+        if (this.composition.entries?.some(row => row.moduleName === REQUEST_INSPECTOR_ROW_MODULE && row.enabled === true) === true)
+            return true;
+        if (sessionId === undefined)
+            return true;
+        const preset = presetOf(this.ctx.sessions.list.getSnapshot().byId[sessionId]);
+        if (preset === undefined)
+            return true;
+        const group = this.composition.agentPresets?.find(candidate => candidate.id === preset);
+        if (group === undefined || group.broken !== undefined)
+            return true;
+        // Path 2: the preset-mounted row grants this session.
+        return group.rows.some(row => row.moduleName === REQUEST_INSPECTOR_ROW_MODULE && row.enabled !== false);
+    }
+    /** Subscribe to criterion-input changes (session switches, the inventory answer). */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    notify() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+/**
+ * One registration's toggle (the room template): registered exactly while the
+ * criterion passes for the current session, disposed otherwise. Works for the
+ * sidebarRightTabs registry (a direct inject) and for a `ctx.slots.inject`
+ * registration alike — both return their disposer synchronously.
+ */
+export class RegistrationToggle {
+    register;
+    show;
+    dispose;
+    ready = false;
+    /**
+     * @param register - mounts the entry and returns its disposer.
+     * @param show - the current decision (re-read on every sync).
+     */
+    constructor(register, show) {
+        this.register = register;
+        this.show = show;
+    }
+    /** The registry is reachable — decisions may register now. */
+    setReady(ready) {
+        this.ready = ready;
+        if (!ready && this.dispose !== undefined) {
+            this.dispose();
+            this.dispose = undefined;
+        }
+        this.sync();
+    }
+    /** Re-evaluate: register while shown and ready, dispose otherwise. */
+    sync() {
+        if (!this.ready)
+            return;
+        if (this.show()) {
+            this.dispose ??= this.register();
+        }
+        else if (this.dispose !== undefined) {
+            this.dispose();
+            this.dispose = undefined;
+        }
+    }
+}

package/lib/types/client/scroll-sync.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Conversation scroll-sync over the chat view's DOM anchors — the sanctioned
+ * last-resort pattern (AGENTS.md: a DOM anchor must carry a fallback). There
+ * is no public slot/service for conversation scrolling (the capability is
+ * internal to ui-chat's ChatView `use-chat-viewport.ts`); the seam is
+ * registered in docs/upstream-seam-registry.md (S20) with this anchor as the
+ * recorded workaround.
+ *
+ * The anchors are the host's own: `[data-conversation-scroll]` marks the
+ * conversation scrollport (ui-conversation ConversationContent), and turn
+ * rows carry `[data-chat-turn="<hostTurn>"]` (ui-chat ChatNodeSeat /
+ * ChatGroupSeat — the same selector `scrollToTurnAtOrAfter` uses). The panel's
+ * real turns key on the host turn number (`TurnListItem.hostTurn`), so the
+ * anchor lookup needs no mapping; purpose pseudo-turns have no hostTurn and
+ * never scroll.
+ *
+ * Every failure path is a silent no-op: no conversation mounted, the turn
+ * paged out of the virtualized list, a missing scroll primitive — nothing
+ * here may throw.
+ *
+ * @module @khorsheed/dsh-context-lens/client/scroll-sync
+ */
+/** The conversation scrollport selector (ui-conversation ConversationContent). */
+export declare const CONVERSATION_SCROLLPORT = "[data-conversation-scroll]";
+/**
+ * Eligible turn rows: the host's own filter from `scrollToTurnAtOrAfter`
+ * (skips hidden rows and rows nested inside a hidden subtree).
+ */
+export declare const TURN_ROW_ELIGIBLE = "[data-chat-turn]:not([hidden]):not([hidden] *)";
+/** The motion preference; a host without matchMedia (jsdom) defaults to smooth. */
+export declare function preferredScrollBehavior(): 'smooth' | 'auto';
+/** Whether the chat has rendered this host turn's anchor row (a jump can land on it). */
+export declare function hasTurnAnchor(hostTurn: number, root?: ParentNode): boolean;
+/**
+ * Scroll the conversation so one host turn's anchor row leads the viewport:
+ * the exact `[data-chat-turn="<turn>"]` row first; a paged-out turn lands on
+ * the nearest mounted turn ≥ it in DOM order (the host's
+ * `scrollToTurnAtOrAfter` semantics); no eligible row is a silent no-op.
+ * @param hostTurn - the host's turn number (`TurnListItem.hostTurn`).
+ * @param root - the DOM scope (document in production).
+ * @param behavior - scroll motion (respects prefers-reduced-motion by default).
+ * @returns whether anything scrolled.
+ */
+export declare function scrollConversationToTurn(hostTurn: number, root?: ParentNode, behavior?: 'smooth' | 'auto'): boolean;
+/**
+ * Scroll the conversation to its floor (the 最新 button): the scrollport's
+ * own `scrollTo` when present, else the largest mounted turn row as the
+ * anchor fallback. No conversation mounted is a silent no-op.
+ * @param root - the DOM scope (document in production).
+ * @param behavior - scroll motion (respects prefers-reduced-motion by default).
+ * @returns whether anything scrolled.
+ */
+export declare function scrollConversationToBottom(root?: ParentNode, behavior?: 'smooth' | 'auto'): boolean;
+//# sourceMappingURL=scroll-sync.d.ts.map

package/lib/types/client/scroll-sync.js

@@ -0,0 +1,118 @@
+/**
+ * Conversation scroll-sync over the chat view's DOM anchors — the sanctioned
+ * last-resort pattern (AGENTS.md: a DOM anchor must carry a fallback). There
+ * is no public slot/service for conversation scrolling (the capability is
+ * internal to ui-chat's ChatView `use-chat-viewport.ts`); the seam is
+ * registered in docs/upstream-seam-registry.md (S20) with this anchor as the
+ * recorded workaround.
+ *
+ * The anchors are the host's own: `[data-conversation-scroll]` marks the
+ * conversation scrollport (ui-conversation ConversationContent), and turn
+ * rows carry `[data-chat-turn="<hostTurn>"]` (ui-chat ChatNodeSeat /
+ * ChatGroupSeat — the same selector `scrollToTurnAtOrAfter` uses). The panel's
+ * real turns key on the host turn number (`TurnListItem.hostTurn`), so the
+ * anchor lookup needs no mapping; purpose pseudo-turns have no hostTurn and
+ * never scroll.
+ *
+ * Every failure path is a silent no-op: no conversation mounted, the turn
+ * paged out of the virtualized list, a missing scroll primitive — nothing
+ * here may throw.
+ *
+ * @module @khorsheed/dsh-context-lens/client/scroll-sync
+ */
+/** The conversation scrollport selector (ui-conversation ConversationContent). */
+export const CONVERSATION_SCROLLPORT = '[data-conversation-scroll]';
+/**
+ * Eligible turn rows: the host's own filter from `scrollToTurnAtOrAfter`
+ * (skips hidden rows and rows nested inside a hidden subtree).
+ */
+export const TURN_ROW_ELIGIBLE = '[data-chat-turn]:not([hidden]):not([hidden] *)';
+/** The motion preference; a host without matchMedia (jsdom) defaults to smooth. */
+export function preferredScrollBehavior() {
+    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
+        return 'smooth';
+    return window.matchMedia('(prefers-reduced-motion: reduce)').matches ? 'auto' : 'smooth';
+}
+/** The on-screen conversation's scrollport, or null when no conversation is mounted. */
+function scrollport(root) {
+    try {
+        return root.querySelector(CONVERSATION_SCROLLPORT);
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether the chat has rendered this host turn's anchor row (a jump can land on it). */
+export function hasTurnAnchor(hostTurn, root = document) {
+    try {
+        return (scrollport(root) ?? root).querySelector(`[data-chat-turn="${hostTurn}"]:not([hidden]):not([hidden] *)`) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Scroll the conversation so one host turn's anchor row leads the viewport:
+ * the exact `[data-chat-turn="<turn>"]` row first; a paged-out turn lands on
+ * the nearest mounted turn ≥ it in DOM order (the host's
+ * `scrollToTurnAtOrAfter` semantics); no eligible row is a silent no-op.
+ * @param hostTurn - the host's turn number (`TurnListItem.hostTurn`).
+ * @param root - the DOM scope (document in production).
+ * @param behavior - scroll motion (respects prefers-reduced-motion by default).
+ * @returns whether anything scrolled.
+ */
+export function scrollConversationToTurn(hostTurn, root = document, behavior = preferredScrollBehavior()) {
+    try {
+        const scope = scrollport(root) ?? root;
+        const exact = scope.querySelector(`[data-chat-turn="${hostTurn}"]:not([hidden]):not([hidden] *)`);
+        if (exact !== null) {
+            exact.scrollIntoView({ behavior, block: 'start' });
+            return true;
+        }
+        for (const row of scope.querySelectorAll(TURN_ROW_ELIGIBLE)) {
+            const value = Number(row.dataset.chatTurn);
+            if (Number.isSafeInteger(value) && value >= hostTurn) {
+                row.scrollIntoView({ behavior, block: 'start' });
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Scroll the conversation to its floor (the 最新 button): the scrollport's
+ * own `scrollTo` when present, else the largest mounted turn row as the
+ * anchor fallback. No conversation mounted is a silent no-op.
+ * @param root - the DOM scope (document in production).
+ * @param behavior - scroll motion (respects prefers-reduced-motion by default).
+ * @returns whether anything scrolled.
+ */
+export function scrollConversationToBottom(root = document, behavior = preferredScrollBehavior()) {
+    try {
+        const port = scrollport(root);
+        if (port !== null && typeof port.scrollTo === 'function') {
+            ;
+            port.scrollTo({ top: port.scrollHeight, behavior });
+            return true;
+        }
+        let latest = null;
+        let max = Number.NEGATIVE_INFINITY;
+        for (const row of (port ?? root).querySelectorAll(TURN_ROW_ELIGIBLE)) {
+            const value = Number(row.dataset.chatTurn);
+            if (Number.isSafeInteger(value) && value >= max) {
+                max = value;
+                latest = row;
+            }
+        }
+        if (latest === null)
+            return false;
+        latest.scrollIntoView({ behavior, block: 'end' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/lib/types/client/timing.d.ts

@@ -0,0 +1,29 @@
+import type { AgentScopeOverview, TurnTiming } from '../types.ts';
+/** Partition one agent's elapsed time. Concurrent spans share their overlap, never double-count it. */
+export declare function scopeTiming(timing: TurnTiming, scope: AgentScopeOverview): {
+    total: number;
+    model: number;
+    exec: number;
+    think: number;
+    gaps: number;
+    gapsHead: number;
+    gapsBetween: number;
+    gapsTail: number;
+    overlap: number;
+    tools: {
+        tool: string;
+        calls: number;
+        errors: number;
+        think: number;
+        args: number;
+        exec: number;
+        total: number;
+    }[];
+    non: {
+        wait: Map<number, number>;
+        text: Map<number, number>;
+        direct: Map<number, number>;
+        slack: Map<number, number>;
+    };
+};
+//# sourceMappingURL=timing.d.ts.map

package/lib/types/client/timing.js

@@ -0,0 +1,117 @@
+/** Partition one agent's elapsed time. Concurrent spans share their overlap, never double-count it. */
+export function scopeTiming(timing, scope) {
+    const lanes = timing.lanes.filter((l) => l.scopeId === scope.scopeId && l.durationMs >= 0);
+    const start = scope.kind === 'main'
+        ? (timing.startedAt ?? scope.startedAt)
+        : scope.startedAt;
+    const end = scope.kind === 'main'
+        ? start + timing.totalMs
+        : (scope.endedAt ??
+            Math.max(start, ...lanes.map((l) => l.startedAt + l.durationMs)));
+    const points = [
+        ...new Set([
+            start,
+            end,
+            ...lanes.flatMap((l) => [
+                Math.max(start, l.startedAt),
+                Math.min(end, l.startedAt + l.durationMs),
+            ]),
+        ]),
+    ]
+        .filter((t) => t >= start && t <= end)
+        .sort((a, b) => a - b);
+    const amounts = new Map();
+    let gaps = 0, overlap = 0;
+    // Idle time splits by where it sits: before the first activity, between
+    // activities, or after the last one (a turn the host closed long after its
+    // final request reads very differently from slow tools).
+    const firstAt = lanes.length ? Math.min(...lanes.map((l) => l.startedAt)) : end;
+    const lastAt = lanes.length ? Math.max(...lanes.map((l) => l.startedAt + l.durationMs)) : start;
+    let gapsHead = 0, gapsTail = 0;
+    for (let i = 1; i < points.length; i++) {
+        const a = points[i - 1], b = points[i];
+        const active = lanes.filter((l) => l.startedAt < b && l.startedAt + l.durationMs > a);
+        if (!active.length) {
+            gaps += b - a;
+            if (b <= firstAt)
+                gapsHead += b - a;
+            else if (a >= lastAt)
+                gapsTail += b - a;
+        }
+        if (active.length > 1)
+            overlap += b - a;
+        for (const lane of active)
+            amounts.set(lane, (amounts.get(lane) ?? 0) + (b - a) / active.length);
+    }
+    const tools = new Map();
+    const get = (tool) => {
+        let row = tools.get(tool);
+        if (!row) {
+            row = { tool, calls: 0, errors: 0, think: 0, args: 0, exec: 0, total: 0 };
+            tools.set(tool, row);
+        }
+        return row;
+    };
+    const non = {
+        wait: new Map(),
+        text: new Map(),
+        direct: new Map(),
+        slack: new Map(),
+    };
+    const put = (key, seq, ms) => non[key].set(seq, (non[key].get(seq) ?? 0) + ms);
+    let model = 0, exec = 0, think = 0;
+    for (const request of scope.requests) {
+        const rs = lanes.filter((l) => l.requestSeq === request.seq);
+        const args = rs.filter((l) => l.kind === 'tool-args' && l.tool !== undefined);
+        const executions = rs.filter((l) => l.kind === 'tool-exec' && l.tool !== undefined);
+        const calls = args.length ? args : executions;
+        for (const call of calls)
+            get(call.tool).calls++;
+        for (const lane of rs) {
+            const ms = amounts.get(lane) ?? 0;
+            if (lane.kind === 'tool-exec') {
+                exec += ms;
+                if (lane.tool) {
+                    const row = get(lane.tool);
+                    row.exec += ms;
+                    if (lane.isError)
+                        row.errors++;
+                }
+            }
+            else {
+                model += ms;
+                if (lane.kind === 'reasoning') {
+                    think += ms;
+                    if (calls.length)
+                        for (const call of calls)
+                            get(call.tool).think += ms / calls.length;
+                    else
+                        put('direct', request.seq, ms);
+                }
+                else if (lane.kind === 'tool-args' && lane.tool)
+                    get(lane.tool).args += ms;
+                else
+                    put(lane.kind === 'wait'
+                        ? 'wait'
+                        : lane.kind === 'text'
+                            ? 'text'
+                            : 'slack', request.seq, ms);
+            }
+        }
+    }
+    for (const row of tools.values())
+        row.total = row.think + row.args + row.exec;
+    return {
+        total: Math.max(0, end - start),
+        model,
+        exec,
+        think,
+        gaps,
+        gapsHead,
+        gapsBetween: Math.max(0, gaps - gapsHead - gapsTail),
+        gapsTail,
+        overlap,
+        tools: [...tools.values()],
+        non,
+    };
+}

package/lib/types/client/wire.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The four verbs' wire face, at FULL descriptor arity: the gateway runtime
+ * enforces each verb's declared parameter count exactly (`prepareInvocation`
+ * throws before any network traffic on a mismatch — a trailing optional
+ * parameter counts), so every call passes the trailing `filter` explicitly.
+ * The panel never filters; server-side consumers pass their own allow-list.
+ *
+ * @module @khorsheed/dsh-context-lens/client/wire
+ */
+import type { InspectorRemote, InspectorTabInjected } from './contract.ts';
+/** The injected face's verbs over the generated Remote, always at full arity. */
+export declare function inspectorWire(remote: InspectorRemote): InspectorTabInjected;
+//# sourceMappingURL=wire.d.ts.map

package/lib/types/client/wire.js

@@ -0,0 +1,11 @@
+/** The injected face's verbs over the generated Remote, always at full arity. */
+export function inspectorWire(remote) {
+    return {
+        getSessionTrend: sessionId => remote.getSessionTrend(sessionId, undefined),
+        listTurns: sessionId => remote.listTurns(sessionId, undefined),
+        loadTurns: (sessionId, end) => remote.loadTurns(sessionId, end, undefined),
+        getTurn: (sessionId, turnSeq) => remote.getTurn(sessionId, turnSeq, undefined),
+        getRequest: (sessionId, seq) => remote.getRequest(sessionId, seq, undefined),
+        getTurnTiming: (sessionId, turnSeq) => remote.getTurnTiming(sessionId, turnSeq, undefined),
+    };
+}

package/lib/types/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Request-inspector plugin, host half: provides the capture service core and
+ * mounts its Remote face. All capture rides read-only listeners — the
+ * `llm/stream` waterfall tee, `system-prompt/assemble` section attribution,
+ * `session/event` turn/tool correlation — plus a lazy child-log lane through
+ * `sessionPersistence` for fresh-process subagent runs. The plugin observes
+ * requests; it never rewrites them, and a capture failure never touches the
+ * model path.
+ *
+ * @module @khorsheed/dsh-context-lens
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type InspectorConfig } from './service.ts';
+export { RequestInspectorRemoteService } from './remote.ts';
+export type { RequestInspectorRemoteConfig } from './remote.ts';
+export { InspectorService } from './service.ts';
+export type { InspectorConfig } from './service.ts';
+export * from './types.ts';
+/** Cordis plugin name used by loader diagnostics. */
+export declare const name = "context-lens";
+/**
+ * Plugin body: provide the service core, then mount the Remote data face.
+ *
+ * No `static inject`: every seam the capture touches is an event name or a
+ * probed service, so a composition missing one (no persistence backend, a host
+ * without these events) simply yields an empty panel instead of a failed boot.
+ *
+ * @param ctx - owning Cordis context.
+ * @param config - optional plugin config.
+ */
+export declare function apply(ctx: Context, config?: InspectorConfig): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,25 @@
+import { InspectorService } from "./service.js";
+import { RequestInspectorRemoteService } from "./remote.js";
+export { RequestInspectorRemoteService } from "./remote.js";
+export { InspectorService } from "./service.js";
+export * from "./types.js";
+/** Cordis plugin name used by loader diagnostics. */
+export const name = 'context-lens';
+/**
+ * Plugin body: provide the service core, then mount the Remote data face.
+ *
+ * No `static inject`: every seam the capture touches is an event name or a
+ * probed service, so a composition missing one (no persistence backend, a host
+ * without these events) simply yields an empty panel instead of a failed boot.
+ *
+ * @param ctx - owning Cordis context.
+ * @param config - optional plugin config.
+ */
+export function apply(ctx, config = {}) {
+    const service = new InspectorService(ctx, config);
+    ctx.provide('requestInspector', service);
+    ctx.plugin(RequestInspectorRemoteService, {});
+    ctx.effect(() => () => {
+        service.dispose();
+    }, 'context-lens: capture shutdown');
+}