@memberjunction/ng-conversations 5.40.1 → 5.41.0

package/dist/lib/components/realtime/realtime-session-overlay.component.d.ts

@@ -0,0 +1,491 @@
+import { EventEmitter, OnDestroy, AfterViewInit } from '@angular/core';
+import { UserInfo } from '@memberjunction/core';
+import { VoiceConnectionState } from '../../services/realtime-session.service';
+import { ParsedDelegationArtifact } from '../../services/delegation-result-parser';
+import { RealtimeSessionReview } from '../../services/realtime-session-review.service';
+import { RealtimeSessionState } from './realtime-session-state';
+import { RealtimeDisclosureModel, RealtimeUxDensity } from './realtime-disclosure';
+import { RealtimeChannelTabRegistration } from './realtime-surface-tabs.model';
+import { WhiteboardState } from '@memberjunction/ng-whiteboard';
+import * as i0 from "@angular/core";
+/**
+ * A request to open an entity record, emitted by the call overlay's gear-gated developer
+ * links ("Open run" / "Open session"). The Generic host (chat area) converts it onto its
+ * existing `openEntityRecord` output chain — the package never navigates itself (no Router).
+ */
+export interface RealtimeNavigateRequest {
+    /** Entity to open (e.g. `MJ: AI Agent Runs`, `MJ: AI Agent Sessions`). */
+    EntityName: string;
+    /** ID of the record to open. */
+    RecordID: string;
+}
+/**
+ * A request to RESUME a reviewed session as a NEW live call, emitted by review mode's
+ * "Start live session" button. The host (chat area) clears its review state and starts a
+ * voice session through the same path the composer's mic uses, passing
+ * {@link LastSessionId} so the server chains the new session to the reviewed one
+ * (restoring saved channel states such as the whiteboard via `PriorChannelStatesJson`).
+ */
+export interface RealtimeStartLiveRequest {
+    /** Agent the resumed session should front (review Config `targetAgentID`, else the session's `AgentID`). */
+    TargetAgentId: string;
+    /** Conversation the reviewed session was bound to, when any. */
+    ConversationId: string | null;
+    /** The reviewed session's id — chained as the new session's `lastSessionId`. */
+    LastSessionId: string;
+}
+/**
+ * The "call mode" overlay for a live real-time voice session. Hosted by the
+ * conversation chat area (`<mj-conversation-chat-area>`) behind `Active$`, it fills the
+ * conversation panel IN PLACE (`position:absolute; inset:0` over the panel — not a
+ * fixed app-wide dialog), replacing the conversation view including the composer.
+ *
+ * Two-column layout:
+ *  - MAIN column — {@link RealtimeAgentBannerComponent} (the unified APP-BAR: identity +
+ *    turn-state + the disclosure-gated action cluster), the unified
+ *    {@link RealtimeSessionThreadComponent} (or the level-0 pure-audio hero), the channel
+ *    strip, and {@link RealtimeComposerComponent} (the bottom dock: phone-call strip ⇄
+ *    fused minis+composer).
+ *  - RIGHT PANEL — {@link RealtimeSurfaceTabsComponent}: the TABBED surface panel.
+ *    Tab 1 "Activity" hosts the session activity rail; one tab opens per ARTIFACT a
+ *    delegated run produces (auto-focused + flashed on arrival, viewed read-only via the
+ *    standard artifact viewer); ONE TAB PER INTERACTIVE CHANNEL the session resolved from
+ *    the `MJ: AI Agent Channels` registry. Collapsible to a slim strip at the panel level.
+ *
+ * INTERACTIVE CHANNELS ARE PLUGINS — this shell is channel-agnostic. It subscribes
+ * {@link RealtimeSessionService.ActiveChannels$} and registers one surface tab per
+ * {@link BaseRealtimeChannelClient} (key/title/icon from the plugin); the tab pane creates
+ * the plugin's surface component dynamically and the PLUGIN wires its own inputs/outputs.
+ * The only channel-generic affordance the shell owns is the FOCUS layout: any channel may
+ * request it (via its context's `SetFocusMode` → {@link RealtimeSessionService.ChannelFocus$}),
+ * which collapses the main call column (`.board-focus`) and shows the floating call pill.
+ *
+ * Owns the shared {@link RealtimeSessionState} — the SINGLE merge of the service's
+ * caption/delegation/narration streams — and passes it to both thread and rail via
+ * inputs, so neither duplicates subscription logic.
+ *
+ * DEVELOPER MODE: the controls row's gear toggles {@link DevMode} (per-session, off by
+ * default, never persisted), revealing "Open run" links on delegation cards / rail items
+ * and an "Open session" link in the banner. Clicking one emits {@link NavigateRequest}
+ * and MINIMIZES the call (via {@link RealtimeSessionService.SetMinimized}) — the session
+ * stays live while the host navigates to the record.
+ *
+ * SESSION REVIEW MODE: when the host supplies {@link ReviewData} (a loaded
+ * `RealtimeSessionReview`) and NO live session is active, the overlay renders what went
+ * down in that PAST session instead of a live call: the banner shows a "Session review"
+ * badge + lifecycle range + close-reason chip; the SAME thread/rail components render the
+ * historical caption turns and delegated-run cards (via
+ * {@link RealtimeSessionState.LoadHistoricalItems}); a read-only Whiteboard tab is
+ * registered ONLY when the session saved a parseable Whiteboard channel state. Everything
+ * live is DEAD in review — no mic, no captions stream, no composer, no channel strip; the
+ * controls collapse to a single "Start live session" button ({@link StartLiveRequested},
+ * which resumes by chaining `lastSessionId`) and a Close button ({@link ReviewClosed}).
+ */
+export declare class RealtimeSessionOverlayComponent implements AfterViewInit, OnDestroy {
+    private _agentName;
+    /**
+     * True while the call is MINIMIZED: the overlay hides itself (CSS, not destruction) so
+     * the host can show its floating "on call" pill WITHOUT losing this shell's merged
+     * session state (delegation cards ride non-replaying streams) or view state (dev mode,
+     * expanded chips, scroll position). The host binds this from `Minimized$`.
+     */
+    Hidden: boolean;
+    /** Display name of the agent the voice session fronts (e.g. "Sage"). */
+    set AgentName(value: string);
+    get AgentName(): string;
+    /** The signed-in user, threaded to the surface panel's artifact viewer. */
+    CurrentUser: UserInfo | null;
+    /** The active environment id, threaded to the surface panel's artifact viewer. */
+    EnvironmentID: string;
+    /**
+     * SESSION REVIEW data: when set (and no live session is active) the overlay renders
+     * the reviewed past session instead of a live call. Setting it populates the shared
+     * {@link State} with the historical thread and prepares the read-only whiteboard tab;
+     * clearing it returns the state to its live-merge baseline.
+     */
+    set ReviewData(value: RealtimeSessionReview | null);
+    get ReviewData(): RealtimeSessionReview | null;
+    /** Emitted after the call ends so the host can react (visibility is driven by Active$). */
+    Ended: EventEmitter<void>;
+    /**
+     * Emitted when a gear-gated developer link asks to open an entity record. The host is
+     * expected to bubble this through its standard record-open path (the chat area re-emits
+     * it on `openEntityRecord`, which Explorer routes via `NavigationService`). The overlay
+     * minimizes itself first so the live call survives the navigation.
+     */
+    NavigateRequest: EventEmitter<RealtimeNavigateRequest>;
+    /**
+     * Review mode's "Start live session": the host clears its review state and resumes the
+     * reviewed session as a new live call (chaining `LastSessionId` to restore channel states).
+     */
+    StartLiveRequested: EventEmitter<RealtimeStartLiveRequest>;
+    /** Review mode's Close: the host clears its review state, returning to the conversation. */
+    ReviewClosed: EventEmitter<void>;
+    private voice;
+    private cdr;
+    private _reviewData;
+    /**
+     * Set by {@link OnStartLive} just before emitting {@link StartLiveRequested}, so the
+     * ReviewData→null transition that follows is recognized as a REVIEW→LIVE CONTINUATION
+     * (keep the historical thread + append the "Resumed live session" divider) rather than
+     * a plain review close (clear everything).
+     */
+    private pendingLiveContinuation;
+    /** The reviewed chain's history artifacts, registered as unfocused surface tabs. */
+    private reviewArtifacts;
+    /**
+     * True while the surface panel carries the REVIEW-registered (template-based, read-only)
+     * Whiteboard tab. Drives the review→live continuation edge: when the resumed live
+     * session's channel set resolves WITHOUT a Whiteboard channel, the stale review tab is
+     * removed (see {@link cleanupStaleReviewBoardTab}); when it resolves WITH one, the live
+     * plugin re-registers the same key and the tab upgrades in place.
+     */
+    private reviewWhiteboardTabRegistered;
+    /** True while the overlay renders a PAST session (review data set, no live call). */
+    get IsReviewing(): boolean;
+    /**
+     * The reviewed session's rehydrated whiteboard, when it saved a parseable Whiteboard
+     * channel state — rendered read-only by the review whiteboard tab. Null = no tab.
+     */
+    ReviewWhiteboard: WhiteboardState | null;
+    /** Shared session state — single source for the thread AND the activity rail. */
+    readonly State: RealtimeSessionState;
+    /**
+     * PROGRESSIVE DISCLOSURE: the levels/milestones model behind the pure-audio-first UX
+     * (see {@link RealtimeDisclosureModel}). Loaded from UserInfoEngine at construction;
+     * content events ({@link onSessionStateChanged}, {@link onChannelActivity}) raise the
+     * volatile session level; milestones ratchet + persist when the call ends. REVIEW mode
+     * bypasses disclosure entirely — a past session always renders the full console.
+     */
+    readonly Disclosure: RealtimeDisclosureModel;
+    /**
+     * The strip's Details peek: shows the surface panel ON DEMAND while it isn't earned yet
+     * (disclosure level < 2) — Activity and channel surfaces exist before their content
+     * does. Cleared automatically once content earns the panel for real.
+     */
+    DetailsPeek: boolean;
+    /**
+     * Whether the typed-input dock is open — a TWO-WAY user door (the strip's Type
+     * control / the T hotkey open it; the dock's hide control closes it), volatile and
+     * reset per session. Typing never becomes permanent chrome.
+     */
+    ComposerOpen: boolean;
+    /** Live turn-state from the session service — drives the banner + connecting screen. */
+    readonly ConnectionState$: import("rxjs").Observable<VoiceConnectionState>;
+    /** Server-reported realtime model name for the active session — shown subtly in the banner. */
+    readonly ModelName$: import("rxjs").Observable<string | null>;
+    /**
+     * Whether the conversation renders as TEXT (the thread) or stays voice-first (the
+     * orb hero). A PERSISTED per-user preference (`mj.realtimeVoice.captions.v1`) —
+     * default OFF: voice-first, the orb owns the screen until the user opts into text.
+     */
+    ShowCaptions: boolean;
+    /** UserInfoEngine key for the persisted captions (text-vs-orb) preference. */
+    private static readonly CaptionsPrefKey;
+    /**
+     * Whether developer affordances (open-record links) are revealed. Per-session view
+     * state on this shell — off by default, reset with the overlay, never persisted.
+     */
+    DevMode: boolean;
+    /** ID of the live server-side agent session record, for the banner's dev link. */
+    get SessionID(): string | null;
+    /**
+     * The tabbed surface panel (right panel) — channel registrations are forwarded to it.
+     * A SETTER because the panel is disclosure-gated (`@if`): it can be created LATE (the
+     * first delegation / channel activity reveals it mid-call), at which point any queued
+     * channel registrations and a pending auto-reveal must flush to the fresh instance.
+     */
+    private surfaceTabs?;
+    private set surfaceTabsRef(value);
+    /** The bottom dock — the T-to-type hotkey focuses its input. */
+    private composer?;
+    /** Channel keys already auto-revealed this session (first activity only). */
+    private revealedChannelKeys;
+    /** Auto-reveal that arrived before the (disclosure-gated) panel rendered. */
+    private pendingRevealKey;
+    /** Previous Active$ value — edges drive disclosure session begin/ratchet. */
+    private prevActive;
+    /** Template hosting the read-only review whiteboard (root-level, so always resolvable). */
+    private reviewBoardTpl?;
+    /** Channel registrations received before the surface panel rendered (flushed in ngAfterViewInit). */
+    private pendingChannelTabs;
+    /** True once the view (and the review-board template ref) exists. */
+    private viewReady;
+    /**
+     * True while a channel surface is in FOCUS mode: the main call column collapses
+     * (`.board-focus` on the overlay) and a compact floating call pill (orb + state +
+     * mute / show-thread / end) rides over the surface.
+     */
+    ChannelFocusMode: boolean;
+    /** Mic-muted state reflected on the focus pill's mute button. */
+    FocusPillMuted: boolean;
+    /** The channel currently holding the focus layout (the pill's exit routes back to it). */
+    private focusChannel;
+    private subs;
+    constructor();
+    ngAfterViewInit(): void;
+    /** Whether the surface panel is collapsed to its slim strip (reported by the panel). */
+    PanelCollapsed: boolean;
+    /** Wide tier active (a content tab is focused) — drives the DEFAULT width only. */
+    PanelWide: boolean;
+    /** The user's explicit dragged width (persisted); null = follow the default tiers. */
+    private userPanelWidth;
+    /** Current expanded panel width in px (rendered as the panel's inline width). */
+    PanelWidthPx: number;
+    /** True while the resize handle is mid-drag (brand-tints the handle). */
+    IsPanelResizing: boolean;
+    private panelResizeStartX;
+    private panelResizeStartWidth;
+    private boundPanelResizeMove;
+    private boundPanelResizeEnd;
+    private hostRef;
+    private ngZone;
+    /** The panel's rendered width: slim strip when collapsed, otherwise the current width. */
+    get PanelAreaSize(): number;
+    /** Resizing is meaningless while collapsed or when the surface fills (focus mode). */
+    get PanelResizeDisabled(): boolean;
+    OnPanelCollapsedChange(collapsed: boolean): void;
+    /** Wide-tier flips only move the DEFAULT width — an explicit user width always wins. */
+    OnPanelWideChanged(wide: boolean): void;
+    /** Mousedown on the resize handle: capture the start state and track the pointer document-wide. */
+    OnPanelResizeStart(event: MouseEvent): void;
+    /** Live drag: panel width follows the pointer delta, clamped to [min, 70% of the overlay]. */
+    private onPanelResizeMove;
+    /**
+     * Release: a genuine DRAG adopts the width as the user's explicit preference and
+     * persists it (debounced); a bare CLICK (movement under the tolerance) restores the
+     * start width and persists nothing — the handle never snaps on a click.
+     */
+    private onPanelResizeEnd;
+    /** Double-click the handle: back to the default tier width; persist the reset. */
+    OnPanelResizeReset(): void;
+    /** Removes the document-wide drag listeners and restores the body cursor/selection. */
+    private teardownPanelResize;
+    /**
+     * The overlay's measurable width for clamping. The component host is
+     * `display: contents` (zero rect) — measure the rendered `.call-overlay` div instead.
+     */
+    private hostWidth;
+    /** Reads the persisted width once per overlay instance (no-op when the engine isn't configured). */
+    private loadPanelWidthPref;
+    /** Persists the width preference server-side (debounced); reset serializes {"width":null}. */
+    private persistPanelWidth;
+    /**
+     * True while the PURE-AUDIO hero (the orb) owns the main column. The captions
+     * preference IS the text-vs-orb switch: captions off (the voice-first default) shows
+     * the breathing orb at ANY disclosure level; captions on shows the thread. Review
+     * always shows the thread.
+     */
+    get ShowHero(): boolean;
+    /**
+     * Whether the surface-panel area renders. The tabs have their OWN control (the
+     * Details toggle, plus the board auto-reveal and artifact-view requests) — they are
+     * deliberately DECOUPLED from typing/disclosure levels: revealing the composer must
+     * never surprise the user with the whole tab panel.
+     */
+    get ShowPanelArea(): boolean;
+    /** The Details (tabs) toggle is always offered while live — it's the panel's one door. */
+    get ShowDetailsControl(): boolean;
+    /** Reads the persisted disclosure milestones (tolerant; defaults to day one). */
+    private loadDisclosurePref;
+    /** Reads the persisted text-vs-orb preference (tolerant; default = voice-first OFF). */
+    private loadCaptionsPref;
+    /** Persists the text-vs-orb preference (debounced, best-effort). */
+    private persistCaptionsPref;
+    /** Persists the disclosure milestones server-side (debounced, best-effort). */
+    private persistDisclosure;
+    /**
+     * Merged-state change: re-render only. DELIBERATELY no disclosure raise — per product
+     * direction, content never flips the console open: a running delegation is narrated
+     * aloud, a finished artifact lands as a GLOWING (unfocused) tab, and the ONLY thing
+     * that auto-reveals is a channel's first agent activity (the whiteboard demands eyes).
+     * A pure-audio user stays in pure audio until THEY ask for more.
+     */
+    private onSessionStateChanged;
+    /**
+     * The agent ACTED on a channel (a tool call routed to its local executor — e.g. the
+     * first whiteboard write). THE ONE AUTO-REVEAL: the surface panel opens (as a peek —
+     * the left column stays exactly as it was, pure audio included) with the channel's tab
+     * focused and flashed, exactly once per channel — so the user discovers the board the
+     * moment it comes alive. Disclosure levels are NOT raised: no text, no composer, no
+     * extra chrome — just the board.
+     */
+    private onChannelActivity;
+    /** Active$ edges: session start resets the volatile level; session end ratchets + persists. */
+    private onActiveChanged;
+    /** Per-frame smoothing state (attack/decay envelopes + direction hysteresis). */
+    private readonly audioSmoother;
+    private audioRafHandle;
+    /** Last attribute values written (attributes are only touched on change). */
+    private lastAudioLive;
+    private lastVoiceDirection;
+    /** Starts the sampling loop (idempotent). Runs outside Angular — no CD per frame. */
+    private startAudioVisualLoop;
+    /** Stops the loop and returns the overlay to turn-state-driven animation. */
+    private stopAudioVisualLoop;
+    /** The rendered `.call-overlay` element (the :host is display:contents). */
+    private overlayElement;
+    /** Writes one smoothed frame as CSS vars/attributes (attributes only on change). */
+    private applyAudioVisualFrame;
+    /** The strip's Details control: peek at (or hide) the surface panel on demand. */
+    OnDetailsToggled(): void;
+    /** The gear popover picked an interface density — apply + persist immediately. */
+    OnDensityChanged(density: RealtimeUxDensity): void;
+    /** The hero's "Show the conversation" affordance — turns the text preference on. */
+    OnTextReveal(): void;
+    /**
+     * The app-bar's "Pure audio": returns to the orb-only surface AND makes it stick —
+     * it sets the persisted interface density to `simple` (the same setting the gear
+     * writes), so a refresh / next call still opens pure audio. In-session reveals
+     * ("Show the conversation", T-to-type, Details) remain available and stay ephemeral;
+     * the gear's density control switches back to Standard/Pro/Auto whenever wanted.
+     */
+    OnPureAudio(): void;
+    /** App-bar Minimize: hide the call view (CSS) — the call stays fully live. */
+    OnMinimize(): void;
+    /** App-bar / strip End: tear the session down, then notify the host. */
+    OnEndCall(): Promise<void>;
+    /** Maps the realtime state onto the hero orb's `data-state` (active turn-states only). */
+    HeroOrbState(state: VoiceConnectionState): 'speaking' | 'listening' | 'thinking';
+    /** Short first-person status line for the pure-audio hero. */
+    HeroStateLabel(state: VoiceConnectionState): string;
+    /**
+     * T-TO-TYPE: pressing T during a live call reveals the composer (raising disclosure to
+     * the engaged level when needed) and focuses its input — typing always exists, it just
+     * whispers until used. Ignored while review/minimized, with modifiers, or when an
+     * editable element already has focus.
+     */
+    OnDocumentKeydown(event: KeyboardEvent): void;
+    /**
+     * True when the event target is a native text-editing element (an input, textarea, or contentEditable),
+     * where a bare letter should type — not trigger the T-to-type shortcut.
+     *
+     * @param eventTarget The keydown event's target.
+     * @returns Whether the target is an editable element.
+     */
+    private isEditableTarget;
+    /**
+     * True when a surface that opts into capturing keyboard input currently holds focus — notably the Remote
+     * Browser live canvas, which marks itself with `data-mj-capture-keys` while the user is driving it. When it
+     * has focus, the overlay's global shortcuts (T-to-type) must stand down so the user's keystrokes land in the
+     * remote browser, not the local composer. Decoupled by an attribute contract so the overlay needs no direct
+     * reference to the surface component.
+     *
+     * @returns Whether a keyboard-capturing surface is focused.
+     */
+    private isKeyboardCapturingSurfaceFocused;
+    /**
+     * The composer dock opened (strip Type control / T hotkey) or closed (the dock's hide
+     * control). Opening raises the 'engaged' milestone for the cross-session ratchet —
+     * but the dock itself stays a per-session, user-owned toggle either way.
+     */
+    OnComposerOpenChanged(open: boolean): void;
+    ngOnDestroy(): void;
+    /**
+     * Registers (or updates) an INTERACTIVE-CHANNEL tab on the surface panel. The overlay
+     * calls it for every registry-resolved plugin; hosts may also call it for bespoke
+     * template-based panes. Until a registration supplies a plugin / template, the tab
+     * renders the "coming online…" placeholder (re-register the same `Key` to upgrade).
+     * Safe to call before the panel has rendered — registrations are queued and flushed.
+     */
+    RegisterChannelTab(registration: RealtimeChannelTabRegistration): void;
+    /**
+     * A done delegation card / rail entry asked to view a produced artifact's tab — an
+     * EXPLICIT user request, so it may open the (otherwise Details-controlled) panel.
+     */
+    OnOpenArtifactRequested(artifact: ParsedDelegationArtifact): void;
+    /**
+     * Registers one surface tab per active channel plugin THAT HAS A SURFACE (key/title/icon from the
+     * plugin). Server-only channels ({@link BaseRealtimeChannelClient.HasSurface} === `false`) render no
+     * tab — their tools + perception are already wired by the session service; there is simply nothing
+     * to show in the surface panel.
+     */
+    private registerChannelTabs;
+    /**
+     * REVIEW→LIVE continuation edge: when the resumed live session resolves its channel set
+     * WITHOUT a Whiteboard channel, the review-registered read-only board tab is now a dead
+     * surface — remove it (Activity regains focus if it was active). When the set HAS a
+     * Whiteboard channel, the plugin registration above upgrades the same tab key in place,
+     * so the review flag is simply released. Review ARTIFACT tabs are deliberately kept —
+     * they are wanted carryover into the live session.
+     */
+    private cleanupStaleReviewBoardTab;
+    /** Forwards channel registrations that arrived before the panel existed. */
+    private flushPendingChannelTabs;
+    /**
+     * The captions toggle = the persisted text-vs-orb switch: on → the thread renders
+     * (raising the text disclosure milestone); off → the orb hero owns the screen again,
+     * at any level. Persisted per-user so the choice survives refresh and devices.
+     */
+    OnCaptionsToggled(on: boolean): void;
+    /** Reflect the gear toggle from the controls into the dev affordances. */
+    OnDevModeToggled(on: boolean): void;
+    /** A dev link asked to open a delegated agent run record. */
+    OnOpenRunRequested(runId: string): void;
+    /** The banner's dev link asked to open the live agent session record. */
+    OnOpenSessionRequested(sessionId: string): void;
+    /** Review banner convenience accessors (null-safe against the review data). */
+    get ReviewStartedAt(): Date | null;
+    get ReviewClosedAt(): Date | null;
+    get ReviewCloseReason(): string | null;
+    /** The reviewed session record's id — feeds the banner's dev "Open session" link. */
+    get ReviewSessionID(): string | null;
+    /**
+     * Review controls: resume the reviewed session as a NEW live call (host handles the
+     * start). Flags the upcoming ReviewData→null transition as a CONTINUATION so the
+     * historical thread is kept (divider appended) instead of cleared.
+     */
+    OnStartLive(): void;
+    /** Review controls: close the review (host clears its review state). */
+    OnReviewClose(): void;
+    /**
+     * Enters review: replaces the shared state's thread with the historical items (all
+     * chain legs, dividers between legs), names the cards after the reviewed agent,
+     * rehydrates the saved whiteboard (when any), and registers the chain's history
+     * ARTIFACTS as unfocused surface tabs.
+     */
+    private enterReview;
+    /**
+     * Leaves review. Two distinct exits:
+     *  - REVIEW→LIVE CONTINUATION ({@link OnStartLive} was clicked): KEEP the historical
+     *    thread and append the "Resumed live session" divider so the new live items read
+     *    as a new section of the same conversation. Artifact tabs are left in place — the
+     *    chain's artifacts carry into the live session.
+     *  - plain CLOSE: clear everything so the conversation view returns clean.
+     */
+    private exitReview;
+    /** Registers the reviewed chain's history artifacts as UNFOCUSED artifact tabs (idempotent). */
+    private registerReviewArtifactTabs;
+    /**
+     * Rehydrates the reviewed session's saved Whiteboard channel state. TOLERANT: a missing
+     * or malformed state returns null — review simply shows no whiteboard tab.
+     */
+    private parseReviewWhiteboard;
+    /**
+     * Registers the read-only review whiteboard tab (no-op without a board / template) —
+     * FOCUSED: the session's channel surface is what the reviewer came to see; the
+     * Activity rail stays available but is never the default focus.
+     */
+    private registerReviewBoardTab;
+    /**
+     * A working delegation card's ✕ asked to cancel that delegated run — EXPLICIT user
+     * intent (barge-in never cancels work, by deliberate policy). The service calls the
+     * server cancel channel and flips the card to a failed "Cancelled by user" result.
+     */
+    OnCancelDelegation(callId: string): void;
+    /** Minimizes the live call (it stays running) and asks the host to open the record. */
+    private requestNavigate;
+    /** A channel requested (or released) the focus layout via its host context. */
+    private onChannelFocus;
+    /** Focus pill: toggle the mic mute. */
+    OnFocusPillMute(): void;
+    /** Focus pill: leave focus mode (show the thread column again). */
+    OnFocusPillExit(): void;
+    /** Focus pill: end the call (mirrors the controls row's End button). */
+    OnFocusPillEnd(): Promise<void>;
+    /** Short status line for the focus pill (first person — the co-agent owns the work). */
+    FocusStateLabel(state: VoiceConnectionState): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RealtimeSessionOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RealtimeSessionOverlayComponent, "mj-realtime-session-overlay", never, { "Hidden": { "alias": "Hidden"; "required": false; }; "AgentName": { "alias": "AgentName"; "required": false; }; "CurrentUser": { "alias": "CurrentUser"; "required": false; }; "EnvironmentID": { "alias": "EnvironmentID"; "required": false; }; "ReviewData": { "alias": "ReviewData"; "required": false; }; }, { "Ended": "Ended"; "NavigateRequest": "NavigateRequest"; "StartLiveRequested": "StartLiveRequested"; "ReviewClosed": "ReviewClosed"; }, never, never, true, never>;
+}
+//# sourceMappingURL=realtime-session-overlay.component.d.ts.map

package/dist/lib/components/realtime/realtime-session-overlay.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime-session-overlay.component.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/realtime/realtime-session-overlay.component.ts"],"names":[],"mappings":"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"}