guideai-app 0.5.4-2 → 0.5.4-8

package/dist/devtools/learn/learnLiteTranscript.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { StoredMessage } from '../../utils/messageStorage';
+export type LearnLiteLine = {
+    kind: 'narration';
+    text: string;
+    key: string;
+} | {
+    kind: 'assistant';
+    text: string;
+    key: string;
+} | {
+    kind: 'click';
+    selector: string;
+    key: string;
+};
+export declare function buildLearnLiteLines(messages: StoredMessage[]): LearnLiteLine[];
+export type LearnLiteTranscriptProps = {
+    lines: LearnLiteLine[];
+    /** Clarifying phase — Q&A copy instead of capture listening hint. */
+    clarifying?: boolean;
+};
+export declare function LearnLiteTranscript({ lines, clarifying }: LearnLiteTranscriptProps): React.JSX.Element;

package/dist/devtools/learn/learnModeStyles.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Learn mode — capture chrome (`guideai-learn-*`) + devtools panel scoped under
+ * `[data-guideai-devtool="learn-panel"]` (uses shared `guideai-atd-*` chrome).
+ */
+export declare const learnModeStyles: () => string;

package/dist/devtools/learn/learnModeTypes.d.ts

@@ -0,0 +1,5 @@
+export type LearnPhase = 'off' | 'capturing' | 'capturing_paused' | 'clarifying' | 'generating';
+export declare function learnModeActiveForInit(phase: LearnPhase): boolean;
+export declare function learnCaptureOkClampPhase(phase: LearnPhase): string | null;
+/** Lite capture chrome (banner + lite transcript + toolbar); hides full transcript shell. */
+export declare function learnFocusModeActive(phase: LearnPhase, clarifyDone: boolean): boolean;

package/dist/devtools/learn/learnOrchestrationStub.d.ts

@@ -0,0 +1,5 @@
+import type { LearnModePanelProps } from './LearnModePanel';
+import type { LearnPhase } from './learnModeTypes';
+export declare const LEARN_PHASE_OFF: LearnPhase;
+/** Learn panel props before lazy orchestration loads (phase stays off). */
+export declare function createLearnOrchestrationStub(onRequestOrchestration: () => void): LearnModePanelProps;

package/dist/devtools/learn/learnPanelSyncFieldsEqual.d.ts

@@ -0,0 +1,3 @@
+import type { LearnModePanelProps } from './LearnModePanel';
+/** Serializable Learn panel fields — ignore callback identity when syncing shell state. */
+export declare function areLearnPanelSyncFieldsEqual(prev: LearnModePanelProps, next: LearnModePanelProps): boolean;

package/dist/devtools/learn/learnRealtimeSession.d.ts

@@ -0,0 +1,10 @@
+import type { MutableRefObject } from 'react';
+import type { RecordingStatus } from '../../types/GuideAI.types';
+export type LearnRealtimeSessionDeps = {
+    hasInitializedRef: MutableRefObject<boolean>;
+    startConversationSession: () => Promise<boolean>;
+    setStatus: (status: RecordingStatus) => void;
+    setIsConversationActive: (active: boolean) => void;
+};
+/** Ensure a realtime voice session for Learn capture / clarify (moved out of GuideAI). */
+export declare function createEnsureLearnRealtimeSession(deps: LearnRealtimeSessionDeps): () => Promise<boolean>;

package/dist/devtools/learn/learnRefBag.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Module-level learn refs for WebRTC / data-channel hot paths (no GuideAI re-renders).
+ * `useLearnMode` syncs these when phase changes.
+ */
+export declare const learnModeRef: {
+    current: boolean;
+};
+export declare const learnInitPhaseRef: {
+    current: "capture" | "clarify";
+};
+export declare const learnClarifyConversationIdRef: {
+    current: string | null;
+};
+export declare const learnCapturePhaseRef: {
+    current: string | null;
+};
+/**
+ * Capture-phase conversation id to reuse on connect. Normally `null` (each Start capture creates a
+ * fresh learn conversation); set only when restoring a capture session after a page reload so the
+ * reconnect re-attaches to the original conversation instead of forking a new one.
+ */
+export declare const learnCaptureConversationIdRef: {
+    current: string | null;
+};
+export declare const learnRefBag: {
+    learnModeRef: {
+        current: boolean;
+    };
+    learnInitPhaseRef: {
+        current: "capture" | "clarify";
+    };
+    learnClarifyConversationIdRef: {
+        current: string | null;
+    };
+    learnCapturePhaseRef: {
+        current: string | null;
+    };
+    learnCaptureConversationIdRef: {
+        current: string | null;
+    };
+};

package/dist/devtools/learn/learnSessionStorage.d.ts

@@ -0,0 +1,23 @@
+import type { LearnPhase } from './learnModeTypes';
+/** Phases worth restoring after a reload — `off` / `generating` are never persisted directly. */
+export type RestorableLearnPhase = Extract<LearnPhase, 'capturing' | 'capturing_paused' | 'clarifying'>;
+export type PendingLearnSession = {
+    phase: RestorableLearnPhase;
+    /** Server learn conversation id (capture conversation; reused for clarify re-init + generate). */
+    conversationId: string;
+    /** Locked workspace slug for generate. */
+    workspaceSlug: string;
+    proposedTitle: string;
+    /** True once the admin clicked "Done clarifying" (focus exited; Generate available). */
+    clarifyDone: boolean;
+    /** Ms since epoch — when the session was last persisted. */
+    startedAt: number;
+};
+export declare function getPendingLearnSession(): PendingLearnSession | null;
+export declare function refreshLearnSessionActiveFlag(): void;
+/** Cheap, allocation-free check for hot paths (e.g. GuideAI auto-restore gate). */
+export declare function isLearnSessionActive(): boolean;
+/** True when sessionStorage holds a resumable learn session (no side effects). */
+export declare function hasPendingLearnSession(): boolean;
+export declare function setPendingLearnSession(session: PendingLearnSession): void;
+export declare function clearPendingLearnSession(): void;

package/dist/devtools/learn/learnWebRTCInit.d.ts

@@ -0,0 +1,20 @@
+export type LearnWebRTCPropToolDef = {
+    description: string;
+    parameters: object;
+};
+export type LearnWebRTCPropTools = Record<string, LearnWebRTCPropToolDef>;
+export type LearnWebRTCInitResolution = {
+    learnActive: boolean;
+    initializeEndpoint: string;
+    propToolsSerialized: Array<{
+        name: string;
+        description: string;
+        parameters: object;
+    }> | undefined;
+    learnPhase: 'capture' | 'clarify' | undefined;
+    learnConversationId: string | undefined;
+};
+/** Learn stop/capture reconnect closes the data channel before the peer connection. */
+export declare function shouldSkipChatResetOnDataChannelClose(isRenewingRealtimeSession: boolean): boolean;
+/** Resolves `/learn/initialize` vs `/initialize` and related payload fields from module-level learn refs. */
+export declare function resolveLearnWebRTCInit(apiBase: string, propTools?: LearnWebRTCPropTools): LearnWebRTCInitResolution;

package/dist/devtools/learn/learnWorkspaceContext.d.ts

@@ -0,0 +1,5 @@
+import type { StubWorkspaceOption } from '../../stubs/workspaces';
+export declare function resolveLearnWorkspaceContext(transcriptSessionMode: string, workspaceOptions: StubWorkspaceOption[], widgetAuthWorkspace?: string): {
+    workspaceSlug: string;
+    workspaceName: string;
+};

package/dist/devtools/learn/loadLearnOrchestration.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentType } from 'react';
+import type { LearnOrchestrationHostProps } from './LearnOrchestrationHost';
+export type LearnOrchestrationLoadResult = {
+    LearnOrchestrationHost: ComponentType<LearnOrchestrationHostProps>;
+};
+/**
+ * Dynamic entry for Learn orchestration (`useLearnMode`, capture chrome, focus callbacks).
+ * Loaded on first Learn tab open or Start capture — not on widget mount.
+ */
+export declare function loadLearnOrchestration(): Promise<LearnOrchestrationLoadResult>;

package/dist/devtools/learn/useLearnCaptureDuration.d.ts

@@ -0,0 +1,4 @@
+import type { ReactHooks } from '../../utils/reactHooks';
+import type { LearnPhase } from './learnModeTypes';
+/** Elapsed capture time in MM:SS, excluding paused intervals. */
+export declare function useLearnCaptureDuration(hooks: ReactHooks, phase: LearnPhase, capturePausedAt: number | null): string;

package/dist/devtools/learn/useLearnClickCapture.d.ts

@@ -0,0 +1,9 @@
+import type { ReactHooks } from '../../utils/reactHooks';
+import type { ConversationManager } from '../../utils/conversationManager';
+import type { DataChannelManager } from '../../utils/dataChannel';
+import type { LearnPhase } from './learnModeTypes';
+export declare function useLearnClickCapture(hooks: ReactHooks, params: {
+    phase: LearnPhase;
+    getConversationManager: () => ConversationManager | null;
+    getDataChannelManager: () => DataChannelManager | null;
+}): void;

package/dist/devtools/learn/useLearnMode.d.ts

@@ -0,0 +1,47 @@
+import type { ReactHooks } from '../../utils/reactHooks';
+import type { GuideAIEnvironment } from '../../types/GuideAI.types';
+import type { ConversationManager } from '../../utils/conversationManager';
+import type { DataChannelManager } from '../../utils/dataChannel';
+import { type LearnPhase } from './learnModeTypes';
+export type UseLearnModeParams = {
+    hooks: ReactHooks;
+    adminAvailable: boolean;
+    conversationIdRef: {
+        current: string | null;
+    };
+    getConversationManager: () => ConversationManager | null;
+    getDataChannelManager: () => DataChannelManager | null;
+    cleanupWebRTC: () => void;
+    ensureRealtimeSession: () => Promise<boolean>;
+    /** Whether the host widget has finished its initial setup (gates reload-restore reconnect). */
+    isWidgetInitialized: () => boolean;
+    /** Same as transcript Reset chat (`handleResetChat`), without confirm. */
+    performResetChat: () => void | Promise<void>;
+    handleToggleMute: () => void;
+    applyMicMuted: (muted: boolean) => void;
+    isMuted: boolean;
+    isAssistantPlaybackMuted: boolean;
+    handleToggleAssistantPlaybackMute: () => void;
+    workspaceSlug: string;
+    environment?: GuideAIEnvironment;
+    portalToken: string | null;
+    syncTranscriptFromStorage: () => void;
+};
+export type UseLearnModeResult = {
+    phase: LearnPhase;
+    learnFocusMode: boolean;
+    capturePausedAt: number | null;
+    proposedTitle: string;
+    setProposedTitle: (t: string) => void;
+    generatedWorkflowId: string | null;
+    adminWorkflowUrl: string | null;
+    clarifyDone: boolean;
+    startCapture: () => Promise<void>;
+    pauseCapture: () => void;
+    resumeCapture: () => void;
+    stopCapture: () => Promise<void>;
+    finishClarifying: () => Promise<void>;
+    generateWorkflow: () => Promise<void>;
+    cancelLearn: () => void;
+};
+export declare function useLearnMode(params: UseLearnModeParams): UseLearnModeResult;

package/dist/devtools/learn/useLearnMode.stub.d.ts

@@ -0,0 +1,3 @@
+import type { UseLearnModeParams, UseLearnModeResult } from './useLearnMode';
+/** No-op Learn hook when GUIDEAI_STRIP_DEVTOOLS=1 */
+export declare function useLearnMode(_params: UseLearnModeParams): UseLearnModeResult;

package/dist/devtools/panelLayout.d.ts

@@ -5,3 +5,9 @@ export declare const DEVTOOLS_PANEL_WIDTH_PX = 520;
  * Initial top-left for a right-aligned devtools dialog (avoids overlapping the widget).
  */
 export declare function getInitialRightAlignedPanelPosition(panelWidth: number, top?: number, margin?: number): DraggableDialogPosition;
+/** Clamp a stored / dragged position so the shell stays on-screen. */
+export declare function clampDevtoolsShellPosition(position: DraggableDialogPosition): DraggableDialogPosition;
+/**
+ * Restored shell position from localStorage, or the default right-aligned placement.
+ */
+export declare function getDevtoolsShellInitialPosition(): DraggableDialogPosition;

package/dist/devtools/silentMessages/silentMessageDebug.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Devtools "silent message" debug bus.
+ *
+ * Several GuideAI subsystems push context to the realtime LLM **without** showing a
+ * transcript line: hidden workspace greetings / workflow & resume steers, session-state
+ * notes (mic / playback unmuted), Static Context page blobs, Visual Context
+ * screenshots, the resume context replayed after a session restart (recent transcript +
+ * static-context snapshots sent once on refresh/reconnect), and the tool calls
+ * (function_call → function_call_output) the model runs against the page. When the
+ * operator turns on the **Show silent messages** developer-tools flag, those sends are
+ * surfaced as clickable entries in the transcript so they can be inspected (full text,
+ * pretty JSON, or the full-size screenshot).
+ *
+ * This module is the wire: emitters dispatch a `window` CustomEvent that
+ * `useSilentMessageDebug` listens to.
+ *
+ * PERFORMANCE CONTRACT (keep for every current and future emitter): this is a
+ * developer-only diagnostic and must never slow down or inhibit the normal user
+ * experience. Emission is **gated on the persisted "Show silent messages" flag**, so
+ * production users (who cannot reach this administrator-only toggle) pay nothing beyond
+ * a boolean check per hidden send — no classification, no string building, no JSON
+ * pretty-printing, no event allocation or dispatch. Any new emitter MUST check the flag
+ * first and return before doing any other work, and emitters must never throw into the
+ * send path they observe.
+ */
+/** Dispatched on `window` for every silent message sent to the realtime LLM. */
+export declare const SILENT_MESSAGE_DEBUG_EVENT = "guideai:silent-message";
+/** Dispatched on `window` when the "Show silent messages" flag is toggled. */
+export declare const SILENT_MESSAGE_DEBUG_FLAG_EVENT = "guideai:silent-message-flag";
+export type SilentMessageKind = 'steer' | 'session_note' | 'static_context' | 'resume_context' | 'screenshot' | 'tool_call' | 'tool_failure';
+export type SilentMessageDetailType = 'text' | 'json' | 'image';
+export interface SilentDebugMessage {
+    /** Unique per entry (timestamp + counter) so React keys stay stable across merges. */
+    id: string;
+    kind: SilentMessageKind;
+    /** Short badge label, e.g. "Steer", "Static context", "Screenshot". */
+    label: string;
+    /** One-line preview shown inline in the transcript. */
+    summary: string;
+    detailType: SilentMessageDetailType;
+    /** Full payload for the detail view: text, pretty-printed JSON, or an image data URL. */
+    detail: string;
+    timestamp: number;
+}
+/** Subset of {@link SilentDebugMessage} that callers provide; `id` is assigned on emit. */
+export type SilentDebugMessageInput = Omit<SilentDebugMessage, 'id'>;
+/**
+ * Classify a context-only realtime user-text send into a debug entry. Used by the
+ * shared text chokepoint (`sendSilentRealtimeUserNote`) so steers, session notes, and
+ * Static Context blobs all surface with the right label and detail rendering.
+ */
+export declare function classifySilentText(text: string): SilentDebugMessageInput | null;
+/**
+ * Dispatch a silent-message debug entry on `window`. No-op outside the browser or when
+ * the "Show silent messages" flag is off (the production default).
+ */
+export declare function emitSilentDebugMessage(input: SilentDebugMessageInput): void;
+/**
+ * Convenience wrapper: classify a context-only user-text send, then emit it.
+ * `summaryOverride` replaces the inline preview (e.g. the static-context trigger).
+ * Returns before classifying (JSON parse / pretty-print) when the flag is off.
+ */
+export declare function emitSilentDebugTextMessage(text: string, summaryOverride?: string): void;
+/**
+ * Emit a debug entry for the resume context replayed once after a realtime session is
+ * re-established (e.g. the user refreshed the page mid-conversation): the recent
+ * transcript plus the static-context page snapshots recorded before the restart.
+ * Returns before any string work when the flag is off (the production default), so the
+ * reconnect path pays only a boolean check.
+ */
+export declare function emitSilentDebugResumeContextMessage(text: string): void;
+/** Outcome of a realtime tool call for {@link emitSilentDebugToolCallMessage}. */
+export interface SilentToolCallOutcome {
+    /** Value returned by the tool handler; included in the detail view when present. */
+    result?: unknown;
+    /** Failure description; when set the entry is emitted as a "Tool failed" row. */
+    error?: string;
+}
+/**
+ * Emit a debug entry for a realtime tool call (`function_call` from the model).
+ * Returns before any JSON formatting when the flag is off (the production default),
+ * so the assistant tool path pays only a boolean check per call.
+ */
+export declare function emitSilentDebugToolCallMessage(name: string, argsJson: string, outcome?: SilentToolCallOutcome): void;
+/** Notify listeners that the "Show silent messages" flag changed. */
+export declare function emitSilentMessageDebugFlagChange(enabled: boolean): void;

package/dist/devtools/silentMessages/useSilentMessageDebug.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Collects silent/hidden LLM messages for the devtools "Show silent messages" transcript
+ * view. Only accumulates while the persisted flag is enabled (emitters are also gated on
+ * the same flag, so nothing is even dispatched for production users — this developer
+ * tool must never slow the normal user experience) so the transcript can interleave
+ * these entries (steers, session notes, static context, the post-refresh resume context,
+ * screenshots, tool calls and tool failures) with normal messages. Disabling the flag
+ * clears any collected entries.
+ * See `silentMessageDebug.ts` for the emitters.
+ */
+import { type SilentDebugMessage } from './silentMessageDebug';
+export interface UseSilentMessageDebugResult {
+    enabled: boolean;
+    entries: SilentDebugMessage[];
+    toggle: () => void;
+    clear: () => void;
+}
+export declare function useSilentMessageDebug(React: typeof import('react')): UseSilentMessageDebugResult;

package/dist/devtools/transcriptDevtoolsMenuProps.d.ts

@@ -0,0 +1,33 @@
+/** Shell toggle control inside transcript ⋯ → Developer tools. */
+export type DeveloperToolsShellControl = {
+    shellOpen: boolean;
+    onToggleShell: () => void;
+} | null;
+import type { GuideAIEnvironment } from '../types/GuideAI.types';
+/** Grouped devtools props for TranscriptBox / TranscriptTextInput / TranscriptToolbar. */
+export type TranscriptDevtoolsMenuProps = {
+    /** Full Developer tools section in ⋯ (extension admin or embed after admin login). */
+    sectionVisible: boolean;
+    shellControl: DeveloperToolsShellControl;
+    /** Open in admin flyout (conversation / workflow). */
+    adminPortal?: {
+        getServerConversationId: () => string | null;
+        environment?: GuideAIEnvironment;
+    };
+    login: {
+        /** Embed: Developer login row after hidden unlock, before admin sign-in. */
+        visible: boolean;
+        onOpen: () => void;
+        showLogout: boolean;
+        onLogout: () => void;
+    };
+    unlock: {
+        /** Embed: triple-click transcript workflow title. No-op in extension. */
+        onToolbarTitleClick: () => void;
+    };
+    /** Surface silent/hidden LLM messages (steers, static context, screenshots) in the transcript. */
+    silentMessages?: {
+        enabled: boolean;
+        onToggle: () => void;
+    };
+};

package/dist/devtools/transcriptMoreMenu/DeveloperToolsAdminPortalFlyout.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { GuideAIEnvironment } from '../../types/GuideAI.types';
+type DeveloperToolsAdminPortalFlyoutProps = {
+    open: boolean;
+    flyoutStyle: React.CSSProperties | null;
+    usePortal: boolean;
+    ReactDOM?: {
+        createPortal: (children: React.ReactNode, container: Element) => React.ReactNode;
+    };
+    listRef: React.RefObject<HTMLUListElement>;
+    themePortalProps: {
+        'data-guideai-theme'?: string;
+    };
+    getServerConversationId: () => string | null;
+    widgetEnvironment?: GuideAIEnvironment;
+    onCloseMenu: () => void;
+};
+/** Portaled Open in admin submenu (⋯ → Developer tools). */
+export declare function DeveloperToolsAdminPortalFlyout({ open, flyoutStyle, usePortal, ReactDOM, listRef, themePortalProps, getServerConversationId, widgetEnvironment, onCloseMenu, }: DeveloperToolsAdminPortalFlyoutProps): React.ReactNode;
+export {};

package/dist/devtools/transcriptMoreMenu/DeveloperToolsLoggerFlyout.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+type DeveloperToolsLoggerFlyoutProps = {
+    open: boolean;
+    flyoutStyle: React.CSSProperties | null;
+    usePortal: boolean;
+    ReactDOM?: {
+        createPortal: (children: React.ReactNode, container: Element) => React.ReactNode;
+    };
+    listRef: React.RefObject<HTMLUListElement>;
+    themePortalProps: {
+        'data-guideai-theme'?: string;
+    };
+};
+/** Portaled Console debugger submenu (⋯ → Developer tools). */
+export declare function DeveloperToolsLoggerFlyout({ open, flyoutStyle, usePortal, ReactDOM, listRef, themePortalProps, }: DeveloperToolsLoggerFlyoutProps): React.ReactNode;
+export {};

package/dist/devtools/transcriptMoreMenu/DeveloperToolsMicPresetFlyout.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { MicPresetId } from '../../types/audioConfig.types';
+import type { DevtoolsDebugFlyoutId } from './devtoolsFlyoutTypes';
+type DeveloperToolsMicPresetFlyoutProps = {
+    moreMenuOpen: boolean;
+    debugFlyout: null | DevtoolsDebugFlyoutId;
+    flyoutStyle: React.CSSProperties | null;
+    usePortal: boolean;
+    ReactDOM?: {
+        createPortal: (children: React.ReactNode, container: Element) => React.ReactNode;
+    };
+    listRef: React.RefObject<HTMLUListElement>;
+    themePortalProps: {
+        'data-guideai-theme'?: string;
+    };
+    micPreset: MicPresetId;
+    onApplyMicPreset?: (preset: MicPresetId) => void;
+    onCloseFlyout: () => void;
+    onCloseMenu: () => void;
+};
+export declare function DeveloperToolsMicPresetFlyout({ moreMenuOpen, debugFlyout, flyoutStyle, usePortal, ReactDOM, listRef, themePortalProps, micPreset, onApplyMicPreset, onCloseFlyout, onCloseMenu, }: DeveloperToolsMicPresetFlyoutProps): React.ReactNode;
+export {};

package/dist/devtools/transcriptMoreMenu/ThemePresetSwatch.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { GuideAIThemePreset } from '../../themes/themeTokens.types';
+type ThemePresetSwatchProps = {
+    preset: Pick<GuideAIThemePreset, 'tokens'>;
+};
+/** Accent dot for the devtools theme picker (light/dark grouping is in section headers). */
+export declare function ThemePresetSwatch({ preset }: ThemePresetSwatchProps): React.JSX.Element;
+export {};

package/dist/devtools/transcriptMoreMenu/TranscriptDeveloperToolsMenuItems.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { DeveloperToolsShellControl } from '../transcriptDevtoolsMenuProps';
+import type { DevtoolsDebugFlyoutId } from './devtoolsFlyoutTypes';
+type TranscriptDeveloperToolsMoreMenuItemsProps = {
+    sectionVisible: boolean;
+    shellControl: DeveloperToolsShellControl;
+    loginVisible: boolean;
+    onOpenLogin: () => void;
+    showLogout: boolean;
+    onLogout: () => void;
+    onCloseMenu: () => void;
+    debugFlyout: null | DevtoolsDebugFlyoutId;
+    setDebugFlyout: React.Dispatch<React.SetStateAction<null | DevtoolsDebugFlyoutId>>;
+    loggerFlyoutTriggerRef: React.RefObject<HTMLButtonElement>;
+    adminPortalFlyoutTriggerRef: React.RefObject<HTMLButtonElement>;
+    themeFlyoutTriggerRef: React.RefObject<HTMLButtonElement>;
+    getServerConversationId?: () => string | null;
+    silentMessages?: {
+        enabled: boolean;
+        onToggle: () => void;
+    };
+};
+/** Developer login + Developer tools rows in transcript ⋯. */
+export declare function TranscriptDeveloperToolsMoreMenuItems({ sectionVisible, shellControl, loginVisible, onOpenLogin, showLogout, onLogout, onCloseMenu, debugFlyout, setDebugFlyout, loggerFlyoutTriggerRef, adminPortalFlyoutTriggerRef, themeFlyoutTriggerRef, getServerConversationId, silentMessages, }: TranscriptDeveloperToolsMoreMenuItemsProps): React.JSX.Element;
+export {};

package/dist/devtools/transcriptMoreMenu/TranscriptDeveloperToolsThemeFlyout.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+type DeveloperToolsThemeFlyoutProps = {
+    open: boolean;
+    flyoutStyle: React.CSSProperties | null;
+    usePortal: boolean;
+    ReactDOM?: {
+        createPortal: (children: React.ReactNode, container: Element) => React.ReactNode;
+    };
+    listRef: React.RefObject<HTMLUListElement>;
+    onCloseMenu: () => void;
+};
+export declare function DeveloperToolsThemeFlyout({ open, flyoutStyle, usePortal, ReactDOM, listRef, onCloseMenu, }: DeveloperToolsThemeFlyoutProps): React.ReactNode;
+export {};

package/dist/devtools/transcriptMoreMenu/TranscriptMoreMenuDevtools.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { MicPresetId } from '../../types/audioConfig.types';
+import type { TranscriptDevtoolsMenuProps } from '../transcriptDevtoolsMenuProps';
+import type { TranscriptMoreMenuDebugFlyoutRefs } from './useTranscriptMoreMenuDebugFlyouts';
+import type { DevtoolsDebugFlyoutId } from './devtoolsFlyoutTypes';
+export type TranscriptMoreMenuDevtoolsMenuProps = {
+    transcriptDevtools?: TranscriptDevtoolsMenuProps;
+    micPreset: MicPresetId;
+    onApplyMicPreset?: (preset: MicPresetId) => void;
+    debugFlyout: null | DevtoolsDebugFlyoutId;
+    setDebugFlyout: React.Dispatch<React.SetStateAction<null | DevtoolsDebugFlyoutId>>;
+    refs: TranscriptMoreMenuDebugFlyoutRefs;
+    onCloseMenu: () => void;
+};
+export type TranscriptMoreMenuDevtoolsPortalsProps = Omit<TranscriptMoreMenuDevtoolsMenuProps, 'setDebugFlyout'> & {
+    moreMenuOpen: boolean;
+    flyoutStyle: React.CSSProperties | null;
+    closeFlyout: () => void;
+    usePortal: boolean;
+    ReactDOM?: {
+        createPortal: (children: React.ReactNode, container: Element) => React.ReactNode;
+    };
+};
+/** Transcript ⋯ menu rows for mic preset + developer tools (inside the more-menu `<ul>`). */
+export declare function TranscriptMoreMenuDevtools({ transcriptDevtools, micPreset, onApplyMicPreset, debugFlyout, setDebugFlyout, refs, onCloseMenu, }: TranscriptMoreMenuDevtoolsMenuProps): React.JSX.Element | null;
+/** Portaled debug flyouts — mount next to the transcript more menu portal. */
+export declare function TranscriptMoreMenuDevtoolsPortals({ transcriptDevtools, micPreset, onApplyMicPreset, moreMenuOpen, debugFlyout, flyoutStyle, refs, onCloseMenu, closeFlyout, usePortal, ReactDOM, }: TranscriptMoreMenuDevtoolsPortalsProps): React.JSX.Element;

package/dist/devtools/transcriptMoreMenu/devtoolsFlyoutTypes.d.ts

@@ -0,0 +1 @@
+export type DevtoolsDebugFlyoutId = 'logger' | 'micPreset' | 'adminPortal' | 'theme';

package/dist/devtools/transcriptMoreMenu/index.d.ts

@@ -0,0 +1,2 @@
+export { TranscriptMoreMenuDevtools, TranscriptMoreMenuDevtoolsPortals, } from './TranscriptMoreMenuDevtools';
+export { useTranscriptMoreMenuDebugFlyouts } from './useTranscriptMoreMenuDebugFlyouts';

package/dist/devtools/transcriptMoreMenu/readWindowGuideAILogger.d.ts

@@ -0,0 +1,12 @@
+import type { LoggerComponentKey } from '../../utils/logger';
+type WindowGuideAILogger = {
+    enable?: () => void;
+    disable?: () => void;
+    getStatus?: () => {
+        manualEnabled: boolean;
+        components: Record<LoggerComponentKey, boolean>;
+    };
+    setComponentEnabled?: (c: LoggerComponentKey, enabled: boolean) => void;
+};
+export declare function readWindowGuideAILogger(): WindowGuideAILogger | undefined;
+export {};

package/dist/devtools/transcriptMoreMenu/useTranscriptMoreMenuDebugFlyouts.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { DevtoolsDebugFlyoutId } from './devtoolsFlyoutTypes';
+export type TranscriptMoreMenuDebugFlyoutRefs = {
+    loggerFlyoutTriggerRef: React.RefObject<HTMLButtonElement>;
+    adminPortalFlyoutTriggerRef: React.RefObject<HTMLButtonElement>;
+    themeFlyoutTriggerRef: React.RefObject<HTMLButtonElement>;
+    micPresetFlyoutTriggerRef: React.RefObject<HTMLButtonElement>;
+    loggerDebugFlyoutListRef: React.RefObject<HTMLUListElement>;
+    adminPortalFlyoutListRef: React.RefObject<HTMLUListElement>;
+    themeFlyoutListRef: React.RefObject<HTMLUListElement>;
+    micPresetFlyoutListRef: React.RefObject<HTMLUListElement>;
+};
+export declare function useTranscriptMoreMenuDebugFlyouts(moreMenuOpen: boolean, moreMenuPlacement: {
+    left: number;
+    bottom: number;
+    minWidth: number;
+} | null): {
+    debugFlyout: DevtoolsDebugFlyoutId | null;
+    setDebugFlyout: React.Dispatch<React.SetStateAction<DevtoolsDebugFlyoutId | null>>;
+    flyoutStyle: React.CSSProperties | null;
+    refs: TranscriptMoreMenuDebugFlyoutRefs;
+    outsideClickRefs: React.RefObject<HTMLUListElement>[];
+    closeFlyout: () => void;
+};

package/dist/devtools/useDraggableDialog.d.ts

@@ -7,14 +7,21 @@ interface UseDraggableDialogParams {
     initialPosition: () => DraggableDialogPosition;
     minVisibleWidth: number;
     minVisibleHeight: number;
+    /** When set, used during drag instead of minVisibleWidth/Height (e.g. measured panel size). */
+    clampSize?: () => {
+        width: number;
+        height: number;
+    };
     ignoreSelector?: string;
+    /** Called when the user finishes a drag (pointer up) with the settled position. */
+    onPositionSettled?: (position: DraggableDialogPosition) => void;
     /**
      * Host dialog handles drag/position; keep hook API stable with a fixed `{0,0}` position
      * and inert drag handlers (e.g. panels nested in {@link DeveloperToolsShell}).
      */
     embedded?: boolean;
 }
-export declare function useDraggableDialog(React: typeof import('react'), { initialPosition, minVisibleWidth, minVisibleHeight, ignoreSelector, embedded, }: UseDraggableDialogParams): {
+export declare function useDraggableDialog(React: typeof import('react'), { initialPosition, minVisibleWidth, minVisibleHeight, clampSize, ignoreSelector, onPositionSettled, embedded, }: UseDraggableDialogParams): {
     position: DraggableDialogPosition;
     setPosition: import("react").Dispatch<import("react").SetStateAction<DraggableDialogPosition>>;
     dialogRef: import("react").MutableRefObject<HTMLDivElement | null>;