@rtc-agent/component 0.2.7-rc.3 → 0.2.8-rc.0

package/dist/controllers/mode.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/mode.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAC,kBAAkB,EAAE,sBAAsB,EAAC,MAAM,KAAK,CAAC;AACpE,OAAO,KAAK,EAAkB,WAAW,EAAC,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAc1D,qBAAa,cAAe,YAAW,kBAAkB;IACrD,IAAI,EAAE,sBAAsB,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAsC;IAEpD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAE9B,IAAI,KAAK,IAAI,gBAAgB,CAE5B;gBAEW,IAAI,EAAE,sBAAsB;IAWxC,aAAa;IACb,gBAAgB;IAEhB,qCAAqC;IACrC,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,QAAQ;CAYnB"}

package/dist/controllers/notification.controller.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Notification Controller
+ *
+ * Lightweight notification system: listens for new message events via UIUpdateBus,
+ * triggers sound alerts, toast notifications, and minimized icon animations
+ * based on focus detection logic.
+ *
+ * Architecture:
+ * - Subscribes to UIUpdateBus 'message' events (filtered by entity)
+ * - Queries the message's session via PersistenceLayer
+ * - Focus detection: no notification for the current session; notify for other sessions
+ * - Notification display: normal mode → Toast, minimized mode → icon animation
+ *
+ * Corresponds to: `NotificationContext` (defined in `contexts/notification.ts`).
+ * Provided by: `<rtc-agent>` (root)
+ * Consumed by: Components that need to be aware of unread notifications
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { NotificationContextValue, NotificationActions } from '../contexts/notification.js';
+import type { SessionController } from './session.controller.js';
+import type { MessageController } from './message.controller.js';
+import type { ToastController } from './toast.controller.js';
+import type { SettingsController } from './settings.controller.js';
+import type { WindowStateController } from './window-state.controller.js';
+import type { PersistenceLayer } from '@rtc-agent/persistence';
+export declare class NotificationController implements ReactiveController {
+    host: ReactiveControllerHost & HTMLElement;
+    sessionController?: SessionController;
+    messageController?: MessageController;
+    toastController?: ToastController;
+    windowStateController?: WindowStateController;
+    settingsController?: SettingsController;
+    persistence?: PersistenceLayer;
+    private _state;
+    readonly actions: NotificationActions;
+    get value(): NotificationContextValue;
+    private _busUnsubscribe?;
+    private _sounds;
+    /** Timer for deferred sound loading (non-critical sounds, cleaned up on unmount) */
+    private _deferredSoundTimer?;
+    /** Handle returned by requestIdleCallback, used in hostDisconnected to cancel untriggered idle callbacks. */
+    private _idleCallbackId?;
+    /** Notification throttle: prevent UI jank from rapid successive notifications */
+    private _lastNotifyTime;
+    private static readonly NOTIFY_THROTTLE_MS;
+    /** Fallback delay (ms) when `requestIdleCallback` is available but hasn't fired yet. */
+    private static readonly IDLE_FALLBACK_DELAY_MS;
+    /** Delay (ms) for deferred sound loading when `requestIdleCallback` is not available. */
+    private static readonly DEFERRED_SOUND_DELAY_MS;
+    /** AbortController for async operations, aborted on hostDisconnected to prevent stale operations */
+    private _abortController;
+    constructor(host: ReactiveControllerHost & HTMLElement);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Preload notification sounds
+     *
+     * Critical sounds (message) load immediately; non-critical sounds load deferred
+     * to optimize first-paint performance. Load failures degrade gracefully:
+     * Toast and animation features are unaffected.
+     *
+     * Note: sound file paths should be verified at build time; runtime load failures degrade gracefully.
+     */
+    private _preloadSounds;
+    private _loadSound;
+    private _playSound;
+    /**
+     * Subscribe to new message events from UIUpdateBus
+     *
+     * Uses entity-filtered subscription pattern (see rtc-input-area usage).
+     * Only listens for 'created' events on the content field (triggered on first message write).
+     */
+    private _subscribeToMessages;
+    private _handleNewMessage;
+    /**
+     * Determine whether a notification should be triggered
+     *
+     * Scenarios:
+     * - User is viewing session A, session B receives a new message → notify
+     * - User is viewing session A, session A receives a new message → do not notify
+     * - User is not viewing any session → notify for all new messages
+     * - User has disabled notifications → no notifications for any messages
+     */
+    private _shouldNotify;
+    private _triggerNotification;
+    private _showToast;
+    /**
+     * Navigate to the target session and clear notification state
+     *
+     * Flow: switch session → mark as read → dispatch rtc-notification-click event
+     */
+    private _navigateToSession;
+    /**
+     * Trigger minimized icon pulse animation
+     *
+     * Sets the data-notification attribute on the host element;
+     * CSS triggers animation via the `:host([data-notification])` selector.
+     * Animation persists until the user expands the window or clicks the bubble.
+     */
+    private _animateMinimizeIcon;
+    private _clearAnimation;
+    private _markAsRead;
+    private _clearAll;
+}
+//# sourceMappingURL=notification.controller.d.ts.map

package/dist/controllers/notification.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/notification.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAC,kBAAkB,EAAE,sBAAsB,EAAC,MAAM,KAAK,CAAC;AAEpE,OAAO,KAAK,EAAC,wBAAwB,EAAqB,mBAAmB,EAAC,MAAM,6BAA6B,CAAC;AAElH,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AAkB7D,qBAAa,sBAAuB,YAAW,kBAAkB;IAC7D,IAAI,EAAE,sBAAsB,GAAG,WAAW,CAAC;IAG3C,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IAC9C,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAG/B,OAAO,CAAC,MAAM,CAAsD;IAEpE,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IAEtC,IAAI,KAAK,IAAI,wBAAwB,CAEpC;IAGD,OAAO,CAAC,eAAe,CAAC,CAAa;IACrC,OAAO,CAAC,OAAO,CAAuC;IACtD,oFAAoF;IACpF,OAAO,CAAC,mBAAmB,CAAC,CAAgC;IAC5D,6GAA6G;IAC7G,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,iFAAiF;IACjF,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAO;IACjD,wFAAwF;IACxF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAQ;IACtD,yFAAyF;IACzF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAO;IACtD,oGAAoG;IACpG,OAAO,CAAC,gBAAgB,CAAyB;gBAErC,IAAI,EAAE,sBAAsB,GAAG,WAAW;IAWtD,aAAa,IAAI,IAAI;IAKrB,gBAAgB,IAAI,IAAI;IAoBxB;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;IAuDtB,OAAO,CAAC,UAAU;IAuBlB,OAAO,CAAC,UAAU;IAqBlB;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;YAad,iBAAiB;IAyC/B;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,oBAAoB;IA0B5B,OAAO,CAAC,UAAU;IA0BlB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAK5B,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,SAAS;CAKpB"}

package/dist/controllers/persistence.controller.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Persistence Controller
+ *
+ * Manages the PersistenceLayer lifecycle: creates it lazily, connects when
+ * auth succeeds, disconnects on logout or host teardown.
+ *
+ * Uses SharedWorker + Comlink architecture:
+ * - SharedWorker hosts PersistenceLayer, Centrifuge WebSocket, IndexedDB
+ * - Comlink bridge exposes a PersistenceLayer-compatible adapter (WorkerPersistenceAdapter)
+ * - MasterLock: Master Tab election via Web Locks API
+ *
+ * Corresponds to: no context (infrastructure concern, not UI state).
+ * Provided by: `<rtc-agent>` (root)
+ * Consumed by: other controllers (via `persistence.layer`)
+ */
+import type { ReactiveController } from 'lit';
+import { type PersistenceLayer } from '@rtc-agent/persistence';
+import type { ConnectionState, ConnectionStateEvent } from '@rtc-agent/client';
+import type { AuthController } from './auth.controller.js';
+import { WorkerBridge } from '../worker-bridge.js';
+import { MasterLock } from '../master-lock.js';
+export declare class PersistenceController implements ReactiveController {
+    private _layer?;
+    private _auth;
+    private _workerBridge?;
+    private _masterLock?;
+    private _databaseNameOverride?;
+    private _workerUrl?;
+    /**
+     * In-flight connection promise — prevents concurrent `connect()` calls from
+     * racing to create multiple SharedWorker / Centrifuge connections.
+     *
+     * Cleared on success (layer is set) or failure (so a retry can proceed).
+     */
+    private _connecting?;
+    /**
+     * Connection generation counter for race-condition prevention.
+     *
+     * When disconnect() clears `_connecting` while the underlying Promise is still
+     * in-flight, a subsequent connect() can set a new `_connecting`. When the OLD
+     * Promise finally resolves, its `finally` block would wrongly clear the NEW
+     * `_connecting`, leaving the new connection attempt invisible to the concurrency
+     * guard — leading to duplicate connection attempts and inconsistent state.
+     *
+     * Fix: each connection attempt captures the current generation; in `finally`,
+     * we only clear `_connecting` if the generation still matches. Any code path
+     * that invalidates an in-flight connection (disconnect) bumps the generation
+     * instead of just clearing `_connecting`, so stale Promises self-inhibit.
+     */
+    private _connectGeneration;
+    private static readonly MAX_CONNECT_RETRIES;
+    private static readonly CONNECT_RETRY_DELAY_MS;
+    constructor(host: {
+        addController(c: ReactiveController): void;
+    }, auth: AuthController);
+    /** Set custom database name prefix. Must be called before connect(). */
+    set databaseName(value: string | undefined);
+    /**
+     * Set custom SharedWorker URL.
+     *
+     * When the component is loaded from NPM, the worker file may not be accessible
+     * from the default location. Use this to specify a custom URL where the worker
+     * file is served (e.g., '/rtc-agent/shared-worker.js').
+     *
+     * Must be called before connect().
+     */
+    set workerUrl(value: string | undefined);
+    /** The PersistenceLayer instance. Only available after connect(). */
+    get layer(): PersistenceLayer | undefined;
+    /** Whether the persistence layer is connected. */
+    get isConnected(): boolean;
+    /**
+     * Get the WorkerBridge instance.
+     */
+    get workerBridge(): WorkerBridge | undefined;
+    /**
+     * Get the MasterLock instance.
+     *
+     * MasterLock wraps the Web Locks API for Master Tab election.
+     * Each Tab holds its own MasterLock and determines whether it is the Master.
+     * Only the Master Tab's RtcProcessor will execute RTC tool calls.
+     *
+     * @see docs/shared-worker-proposal.md §4.3
+     */
+    get masterLock(): MasterLock | undefined;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Create the PersistenceLayer and connect.
+     *
+     * Creates SharedWorker + Comlink bridge.
+     * The WorkerPersistenceAdapter wraps the Comlink proxy, presenting a
+     * PersistenceLayer-compatible interface to the rest of the application.
+     *
+     * Call this after auth succeeds (tokens are set in AuthController).
+     * Safe to call multiple times — subsequent calls are no-ops.
+     */
+    connect(): Promise<void>;
+    /**
+     * Create SharedWorker + Comlink bridge.
+     *
+     * The WorkerPersistenceAdapter wraps the Comlink proxy, presenting a
+     * PersistenceLayer-compatible interface to the rest of the application.
+     *
+     * Supports retries: if Worker initialization or connection fails, it will automatically retry.
+     */
+    private _connectWorker;
+    /**
+     * Single connection attempt
+     */
+    private _connectWorkerOnce;
+    /**
+     * Clean up a failed connection
+     */
+    private _cleanupFailedConnection;
+    /**
+     * Delay for the specified number of milliseconds
+     */
+    private _delay;
+    /**
+     * Disconnect and tear down the PersistenceLayer.
+     *
+     * - Increment the generation counter to invalidate the finally block of any old _connecting promise
+     * - Clear the _connecting promise to allow a new connection attempt
+     * - Reset offset first, then close the layer
+     * - Additionally release the MasterLock and destroy the WorkerBridge
+     *
+     * Call this on logout or when auth is lost.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current connection state.
+     *
+     * Retrieves the connection state via WorkerBridge.
+     */
+    getConnectionState(): Promise<ConnectionState>;
+    /**
+     * Listen for connection state changes.
+     *
+     * Subscribes to connection state change events broadcast by WorkerBridge.
+     * Returns a function that unsubscribes the listener.
+     */
+    onConnectionStateChange(listener: (event: ConnectionStateEvent) => void): () => void;
+}
+//# sourceMappingURL=persistence.controller.d.ts.map

package/dist/controllers/persistence.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/persistence.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,KAAK,CAAC;AAE5C,OAAO,EACH,KAAK,gBAAgB,EAMxB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAC,eAAe,EAAE,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AAG7E,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AAKzD,OAAO,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAwM7C,qBAAa,qBAAsB,YAAW,kBAAkB;IAC5D,OAAO,CAAC,MAAM,CAAC,CAAmB;IAClC,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,aAAa,CAAC,CAAe;IACrC,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,UAAU,CAAC,CAAS;IAE5B;;;;;OAKG;IACH,OAAO,CAAC,WAAW,CAAC,CAAgB;IAEpC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,kBAAkB,CAAK;IAE/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAK;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAQ;gBAGlD,IAAI,EAAE;QAAC,aAAa,CAAC,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAA;KAAC,EAClD,IAAI,EAAE,cAAc;IAMxB,wEAAwE;IACxE,IAAI,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAEzC;IAED;;;;;;;;OAQG;IACH,IAAI,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAEtC;IAED,qEAAqE;IACrE,IAAI,KAAK,IAAI,gBAAgB,GAAG,SAAS,CAExC;IAED,kDAAkD;IAClD,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,YAAY,GAAG,SAAS,CAE3C;IAED;;;;;;;;OAQG;IACH,IAAI,UAAU,IAAI,UAAU,GAAG,SAAS,CAEvC;IAED,aAAa;IAIb,gBAAgB;IAIhB;;;;;;;;;OASG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA6D9B;;;;;;;OAOG;YACW,cAAc;IA2B5B;;OAEG;YACW,kBAAkB;IA2FhC;;OAEG;YACW,wBAAwB;IAYtC;;OAEG;IACH,OAAO,CAAC,MAAM;IAId;;;;;;;;;OASG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAyEjC;;;;OAIG;IACG,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC;IAOpD;;;;;OAKG;IACH,uBAAuB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,MAAM,IAAI;CAOvF"}

package/dist/controllers/session-tab.controller.d.ts

@@ -0,0 +1,85 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { SessionTabState, SessionTabActions, SessionStatus } from '../types/index.js';
+export declare class SessionTabController implements ReactiveController {
+    host: ReactiveControllerHost;
+    private _state;
+    readonly actions: SessionTabActions;
+    get value(): {
+        state: SessionTabState;
+        actions: SessionTabActions;
+    };
+    constructor(host: ReactiveControllerHost);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Filter out invalid tabs (session has been deleted or does not exist)
+     *
+     * Called after session list is loaded from IndexedDB to clean up stale persisted tabs.
+     * Tabs with `isUnsaved === true` are kept even if their sessionId is not in the DB
+     * (they are drafts not yet persisted).
+     * Returns true if any tab was removed (caller may need to update UI).
+     */
+    filterInvalidTabs(validSessionIds: Set<string>): boolean;
+    /**
+     * Sync existing tab titles with the latest titles from sessions
+     *
+     * The DB is the authoritative source for titles. Session changes pushed via UIUpdateBus
+     * (user renames or server-generated) are written to DB first; this method syncs the
+     * latest DB titles to tabs.
+     *
+     * Skip conditions:
+     * - Tab's session is not in the DB (e.g., unsaved tab, newTitle is undefined)
+     * - DB returns an empty title
+     * - DB title is identical to the tab's current title (no change)
+     */
+    updateTabTitles(sessionTitleMap: Map<string, string>): boolean;
+    /**
+     * Sync existing tab statuses with the latest statuses from sessions
+     *
+     * The DB is the authoritative source for status (written by server turn lifecycle events).
+     * Called during _loadSessions to ensure tab statuses match the DB.
+     */
+    syncTabStatuses(sessionStatusMap: Map<string, SessionStatus>): boolean;
+    private _isPlaceholderTitle;
+    /** Find the current unsaved tab, returns the first tab with isUnsaved === true. */
+    private _findUnsavedTab;
+    /** Mark a specific tab as saved. */
+    private _markSaved;
+    /** Update the session runtime status (active/idle/closed) of a specific tab. */
+    private _updateTabStatus;
+    private _openOrActivate;
+    private _closeTab;
+    private _setActiveTab;
+    private _clearAll;
+    /**
+     * Write activeSessionId to localStorage
+     *
+     * Only runs in browser environments (SSR-safe); any errors are silently ignored
+     * (e.g., private mode quota is 0).
+     */
+    private _persistActiveSessionId;
+    /**
+     * Read the last active tab's sessionId from localStorage
+     *
+     * Used to decide which tab should have activate: true when restoring the tabs cycle.
+     * Returns null if localStorage is empty or unavailable.
+     */
+    private _getStoredActiveSessionId;
+    /**
+     * Set transient UI params for a tab (initialInputValue, noticeMessage)
+     *
+     * Also increments initialValueVersion to ensure input-area's updated() is triggered
+     * even when old and new values are identical (defends against Lit dirty-check skipping).
+     */
+    private _setTransientParams;
+    /** Clear transient UI params for a specific tab. */
+    private _clearTransientParams;
+    /**
+     * Restore active tab from localStorage
+     *
+     * Only restores when the stored sessionId is in the current tab list; otherwise no change.
+     * Used to restore the user's last active tab after a browser refresh.
+     */
+    private _restoreActiveFromStorage;
+}
+//# sourceMappingURL=session-tab.controller.d.ts.map

package/dist/controllers/session-tab.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-tab.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/session-tab.controller.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAC,kBAAkB,EAAE,sBAAsB,EAAC,MAAM,KAAK,CAAC;AACpE,OAAO,KAAK,EAAa,eAAe,EAAE,iBAAiB,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAOrG,qBAAa,oBAAqB,YAAW,kBAAkB;IAC3D,IAAI,EAAE,sBAAsB,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAsD;IAEpE,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IAEpC,IAAI,KAAK,IAAI;QAAC,KAAK,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,iBAAiB,CAAA;KAAC,CAEhE;gBAEW,IAAI,EAAE,sBAAsB;IA2BxC,aAAa;IACb,gBAAgB;IAEhB;;;;;;;OAOG;IACH,iBAAiB,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO;IAyBxD;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IA6B9D;;;;;OAKG;IACH,eAAe,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,OAAO;IAoBtE,OAAO,CAAC,mBAAmB;IAI3B,mFAAmF;IACnF,OAAO,CAAC,eAAe;IAIvB,oCAAoC;IACpC,OAAO,CAAC,UAAU;IAalB,gFAAgF;IAChF,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,eAAe;IAmEvB,OAAO,CAAC,SAAS;IAyBjB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,SAAS;IAMjB;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;;;;OAKG;IACH,OAAO,CAAC,yBAAyB;IASjC;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAiB3B,oDAAoD;IACpD,OAAO,CAAC,qBAAqB;IAa7B;;;;;OAKG;IACH,OAAO,CAAC,yBAAyB;CAiBpC"}

package/dist/controllers/session-tree.controller.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Session Tree Controller
+ *
+ * Builds a hierarchical tree from a flat session list:
+ * - Sessions with empty rootClientSessionId become root nodes
+ * - Remaining sessions are grouped by rootClientSessionId under their corresponding root node's children
+ *
+ * Manages expand/collapse state. Tree is rebuilt via rebuildTree() when session list changes.
+ *
+ * Corresponds to: `SessionTreeContext` (contexts/session-tree.ts)
+ * Consumed by: <rtc-session-tree>, <rtc-session-tree-item>
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { SessionTreeState, SessionTreeActions } from '../types/index.js';
+export declare class SessionTreeController implements ReactiveController {
+    host: ReactiveControllerHost;
+    private _state;
+    /** Expanded state Map: sessionId → isExpanded. Default is all collapsed. */
+    private _expanded;
+    readonly actions: SessionTreeActions;
+    get value(): {
+        state: SessionTreeState;
+        actions: SessionTreeActions;
+    };
+    constructor(host: ReactiveControllerHost);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private _restoreExpanded;
+    private _persistExpanded;
+    private _toggleExpand;
+    private _setExpanded;
+    /**
+     * Rebuild tree using currently cached sessions and expand state
+     *
+     * During rebuildTree, sessions are updated but expand state (_expanded) is preserved.
+     * This method reads the latest expand state from _expanded to rebuild.
+     */
+    private _rebuildTreeFromCache;
+    private _cachedSessions?;
+    private _rebuildTree;
+    private _buildTree;
+    private _buildNode;
+}
+//# sourceMappingURL=session-tree.controller.d.ts.map

package/dist/controllers/session-tree.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-tree.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/session-tree.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAC,kBAAkB,EAAE,sBAAsB,EAAC,MAAM,KAAK,CAAC;AACpE,OAAO,KAAK,EAA2B,gBAAgB,EAAE,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAStG,qBAAa,qBAAsB,YAAW,kBAAkB;IAC5D,IAAI,EAAE,sBAAsB,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAqC;IACnD,4EAA4E;IAC5E,OAAO,CAAC,SAAS,CAA8B;IAE/C,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IAErC,IAAI,KAAK,IAAI;QAAC,KAAK,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,kBAAkB,CAAA;KAAC,CAElE;gBAEW,IAAI,EAAE,sBAAsB;IAaxC,aAAa;IACb,gBAAgB;IAIhB,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,YAAY;IAMpB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAQ7B,OAAO,CAAC,eAAe,CAAC,CAAY;IAEpC,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,UAAU;IA4BlB,OAAO,CAAC,UAAU;CAWrB"}

package/dist/controllers/session.controller.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Session Controller
+ *
+ * Encapsulates session management: create, switch, rename, delete.
+ * Dispatches public `rtc-session-*` events on the host for external consumers.
+ *
+ * When switching sessions, also reloads messages for the new session (via messageController reference).
+ * This cross-controller communication is handled by the root component wiring.
+ *
+ * Corresponds to: `sessionContext` (defined in `contexts/session.ts`).
+ * Provided by: `<rtc-agent>` (root)
+ * Consumed by: `<rtc-session-header>`, `<rtc-session-panel>`, `<rtc-content-area>`
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { SessionActions } from '../types/index.js';
+import type { SessionContextValue } from '../contexts/session.js';
+import type { PersistenceLayer } from '@rtc-agent/persistence';
+export declare class SessionController implements ReactiveController {
+    host: ReactiveControllerHost & EventTarget;
+    private _state;
+    readonly actions: SessionActions;
+    /** Called when session switches — root wires this to MessageController. */
+    onSessionSwitch?: () => void;
+    /**
+     * Persistence layer reference (injected by root after connect).
+     *
+     * When set, rename/delete operations are persisted to IndexedDB + synced to server.
+     * When unset, rename/delete operate in-memory only (offline / pre-connect fallback).
+     */
+    persistence?: PersistenceLayer;
+    get value(): SessionContextValue;
+    constructor(host: ReactiveControllerHost & EventTarget);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private _createSession;
+    private _switchSession;
+    private _renameSession;
+    private _deleteSession;
+    /**
+     * Notify backend to close session
+     *
+     * Only sends RPC notification, does not change local state (Tab close is handled by caller).
+     * On failure, only logs error; caller decides how to handle it.
+     */
+    private _closeSession;
+    /**
+     * Reopen a closed session (transparent reopen)
+     *
+     * Calls backend openSession API to change session state from closed back to idle/active.
+     * After backend returns updates, applyUpdates handles local state sync.
+     */
+    private _reopenSession;
+    private _reset;
+    private _clearCurrentSession;
+    private _setCurrentSession;
+    private _setSessions;
+}
+//# sourceMappingURL=session.controller.d.ts.map

package/dist/controllers/session.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/session.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAC,kBAAkB,EAAE,sBAAsB,EAAC,MAAM,KAAK,CAAC;AACpE,OAAO,KAAK,EAAwB,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AAK7D,qBAAa,iBAAkB,YAAW,kBAAkB;IACxD,IAAI,EAAE,sBAAsB,GAAG,WAAW,CAAC;IAE3C,OAAO,CAAC,MAAM,CAA4C;IAE1D,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IAEjC,2EAA2E;IAC3E,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAE7B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAE/B,IAAI,KAAK,IAAI,mBAAmB,CAE/B;gBAEW,IAAI,EAAE,sBAAsB,GAAG,WAAW;IAkBtD,aAAa;IACb,gBAAgB;IAEhB,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,cAAc;YAeR,cAAc;YA2Bd,cAAc;IAkD5B;;;;;OAKG;YACW,aAAa;IAsB3B;;;;;OAKG;YACW,cAAc;IAe5B,OAAO,CAAC,MAAM;IAKd,OAAO,CAAC,oBAAoB;IAO5B,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,YAAY;CAKvB"}

package/dist/controllers/settings.controller.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Settings Controller
+ *
+ * Encapsulates global settings state with localStorage persistence.
+ * Handles DOM side effects (theme, fontSize) and multi-tab synchronization.
+ * Follows the same pattern as ModeController.
+ *
+ * Corresponds to: `SettingsContext` (defined in `contexts/settings.ts`).
+ * Provided by: `<rtc-agent>` (root)
+ * Consumed by: `<rtc-settings-layout>`, each feature component
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { SettingsActions, SettingsContextValue } from '../contexts/settings.js';
+export declare class SettingsController implements ReactiveController {
+    host: ReactiveControllerHost & HTMLElement;
+    private _state;
+    readonly actions: SettingsActions;
+    private _storageListener?;
+    private _themeMediaQuery?;
+    private _themeMediaListener?;
+    get value(): SettingsContextValue;
+    constructor(host: ReactiveControllerHost & HTMLElement);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /** Remove all global event listeners (safe to call even if nothing was added). */
+    private _removeGlobalListeners;
+    /** Restore settings from localStorage with validation */
+    private _restore;
+    private _update;
+    private _reset;
+    /** Persist settings to localStorage */
+    private _persist;
+    /** Apply DOM side effects only for changed properties */
+    private _applyDiff;
+    /** Apply theme to rtc-agent element's theme attribute */
+    private _applyTheme;
+    /** Apply font size as CSS variable on document root */
+    private _applyFontSize;
+    /** Handle multi-tab synchronization via storage event */
+    private _handleStorageChange;
+    /** Validate theme value */
+    private _validateTheme;
+    /** Validate and clamp font size */
+    private _validateFontSize;
+}
+//# sourceMappingURL=settings.controller.d.ts.map

package/dist/controllers/settings.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/settings.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAC,kBAAkB,EAAE,sBAAsB,EAAC,MAAM,KAAK,CAAC;AACpE,OAAO,KAAK,EAER,eAAe,EACf,oBAAoB,EACvB,MAAM,yBAAyB,CAAC;AAOjC,qBAAa,kBAAmB,YAAW,kBAAkB;IACzD,IAAI,EAAE,sBAAsB,GAAG,WAAW,CAAC;IAE3C,OAAO,CAAC,MAAM,CAA8C;IAE5D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAElC,OAAO,CAAC,gBAAgB,CAAC,CAAa;IACtC,OAAO,CAAC,gBAAgB,CAAC,CAAiB;IAC1C,OAAO,CAAC,mBAAmB,CAAC,CAAa;IAEzC,IAAI,KAAK,IAAI,oBAAoB,CAEhC;gBAEW,IAAI,EAAE,sBAAsB,GAAG,WAAW;IAetD,aAAa;IA6Bb,gBAAgB;IAMhB,kFAAkF;IAClF,OAAO,CAAC,sBAAsB;IAW9B,yDAAyD;IACzD,OAAO,CAAC,QAAQ;IAqBhB,OAAO,CAAC,OAAO;IAgBf,OAAO,CAAC,MAAM;IAQd,uCAAuC;IACvC,OAAO,CAAC,QAAQ;IAShB,yDAAyD;IACzD,OAAO,CAAC,UAAU;IAWlB,yDAAyD;IACzD,OAAO,CAAC,WAAW;IAgBnB,uDAAuD;IACvD,OAAO,CAAC,cAAc;IAStB,yDAAyD;IACzD,OAAO,CAAC,oBAAoB;IAO5B,2BAA2B;IAC3B,OAAO,CAAC,cAAc;IAOtB,mCAAmC;IACnC,OAAO,CAAC,iBAAiB;CAI5B"}

package/dist/controllers/skill.controller.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Skill Controller
+ *
+ * Lightweight ReactiveController that manages integration between the Skill system and components
+ *
+ * Responsibilities:
+ * - Holds a FunctionRegistry instance reference
+ * - Subscribes to eventBus events to drive UI updates (toast, confirm)
+ * - Exposes actions to the host application
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { FunctionRegistry } from '../core/function-registry.js';
+import type { SkillContextValue } from '../contexts/skill.js';
+/**
+ * SkillController actions
+ */
+export interface SkillActions {
+    /** Get FunctionRegistry instance */
+    getRegistry(): FunctionRegistry | null;
+    /** Set FunctionRegistry instance (called by host application) */
+    setRegistry(registry: FunctionRegistry): void;
+}
+/**
+ * SkillController configuration
+ */
+export interface SkillControllerConfig {
+    /** Toast callback (injected by components) */
+    onToast?: (message: string, type: 'info' | 'success' | 'error') => void;
+    /** Confirm request callback (injected by components) */
+    onConfirmRequest?: (requestId: string, path: string, message: string) => void;
+}
+/**
+ * SkillController
+ *
+ * Manages integration between the Skill system and components
+ */
+export declare class SkillController implements ReactiveController {
+    private _host;
+    private _registry;
+    private _config;
+    /** Event unsubscribe functions */
+    private _unsubscribes;
+    constructor(host: ReactiveControllerHost, config?: SkillControllerConfig);
+    /**
+     * Current state (for Context use)
+     */
+    get value(): SkillContextValue;
+    /**
+     * Actions (for host application to call)
+     */
+    get actions(): SkillActions;
+    /**
+     * Create rtcAgentAPI Proxy and inject into ToolRegistry
+     *
+     * This method bridges FunctionRegistry and ToolRegistry:
+     * - callFunction/readFile/writeFile/listDir map to registry.execute and virtualFS
+     * - Proxy's get trap forwards to registry's group proxy, supporting chain calls (rtcAgent.task.create())
+     */
+    private _bridgeToolRegistry;
+    /**
+     * Set configuration (for deferred callback injection)
+     */
+    setConfig(config: SkillControllerConfig): void;
+    /**
+     * ReactiveController: host connected
+     */
+    hostConnected(): void;
+    /**
+     * ReactiveController: host disconnected
+     */
+    hostDisconnected(): void;
+    /**
+     * Subscribe to eventBus events
+     */
+    private _subscribeEvents;
+    /**
+     * Respond to confirm request (called by components)
+     */
+    respondToConfirm(requestId: string, confirmed: boolean): void;
+}
+//# sourceMappingURL=skill.controller.d.ts.map

package/dist/controllers/skill.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/skill.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,KAAK,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAM9D;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,WAAW,IAAI,gBAAgB,GAAG,IAAI,CAAC;IACvC,iEAAiE;IACjE,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,8CAA8C;IAC9C,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,KAAK,IAAI,CAAC;IACxE,wDAAwD;IACxD,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/E;AAED;;;;GAIG;AACH,qBAAa,eAAgB,YAAW,kBAAkB;IACxD,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,OAAO,CAA6B;IAE5C,kCAAkC;IAClC,OAAO,CAAC,aAAa,CAAyB;gBAElC,IAAI,EAAE,sBAAsB,EAAE,MAAM,CAAC,EAAE,qBAAqB;IAMxE;;OAEG;IACH,IAAI,KAAK,IAAI,iBAAiB,CAI7B;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,YAAY,CAY1B;IAED;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAmB3B;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI;IAI9C;;OAEG;IACH,aAAa,IAAI,IAAI;IAKrB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAQxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAyBxB;;OAEG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;CAG9D"}

package/dist/controllers/status-bar.controller.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Status Bar Controller
+ *
+ * Derives status bar information from EditorAreaController.
+ * Read-only: does not modify editor state, only computes display data.
+ *
+ * Design points:
+ * - Depends on EditorAreaController to get current active tab
+ * - Infers file type from file path
+ * - Infers save status from isDirty
+ * - Cursor position is passed through directly
+ *
+ * Debug HTML can directly use this Controller to drive the status bar component.
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { StatusBarInfo } from '../types/index.js';
+import type { EditorAreaController } from './editor-area.controller.js';
+export declare class StatusBarController implements ReactiveController {
+    private _host;
+    private _editorController;
+    constructor(host: ReactiveControllerHost, editorController: EditorAreaController);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Compute current status bar information
+     *
+     * Derived from EditorAreaController's activeTab.
+     * Returns empty state when no active tab (saveStatus='none').
+     */
+    get info(): StatusBarInfo;
+}
+//# sourceMappingURL=status-bar.controller.d.ts.map

package/dist/controllers/status-bar.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-bar.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/status-bar.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAC,kBAAkB,EAAE,sBAAsB,EAAC,MAAM,KAAK,CAAC;AACpE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,6BAA6B,CAAC;AA2BtE,qBAAa,mBAAoB,YAAW,kBAAkB;IAC1D,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,iBAAiB,CAAuB;gBAEpC,IAAI,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,oBAAoB;IAMhF,aAAa;IAEb,gBAAgB;IAEhB;;;;;OAKG;IACH,IAAI,IAAI,IAAI,aAAa,CAkBxB;CACJ"}