@runtypelabs/persona 4.24.0 → 4.26.0

package/src/utils/context-mention-manager.ts

@@ -95,16 +95,16 @@ const mentionKey = (sourceId: string, itemId: string) => `${sourceId}\u0000${ite
  * that's the controller's job.
  */
 export class ContextMentionManager {
-  private readonly opts: ContextMentionManagerOptions;
+  readonly #opts: ContextMentionManagerOptions;
   private readonly mentions: PendingMention[] = [];
 
   constructor(opts: ContextMentionManagerOptions) {
-    this.opts = opts;
-    this.updateRowVisibility();
+    this.#opts = opts;
+    this.#updateRowVisibility();
   }
 
-  private get maxMentions(): number {
-    return this.opts.mentionConfig.maxMentions ?? 8;
+  get #maxMentions(): number {
+    return this.#opts.mentionConfig.maxMentions ?? 8;
   }
 
   hasMentions(): boolean {
@@ -123,9 +123,9 @@ export class ContextMentionManager {
   ): boolean {
     const key = mentionKey(source.id, item.id);
     if (this.mentions.some((m) => m.key === key)) {
-      return this.reject(source, item, "duplicate");
+      return this.#reject(source, item, "duplicate");
     }
-    if (this.atLimit()) return this.reject(source, item, "limit");
+    if (this.atLimit()) return this.#reject(source, item, "limit");
 
     const ref = refFromItem(source, item);
     const pending: PendingMention = {
@@ -138,7 +138,7 @@ export class ContextMentionManager {
     };
     pending.chip = createMentionChip({
       ref,
-      config: this.opts.mentionConfig,
+      config: this.#opts.mentionConfig,
       onRemove: () => this.remove(key),
     });
     // Mention chips are always new when appended (a rebuild clears them with
@@ -149,17 +149,17 @@ export class ContextMentionManager {
       () => pending.chip?.el.removeAttribute("data-persona-chip-enter"),
       { once: true }
     );
-    this.opts.contextRow.appendChild(pending.chip.el);
+    this.#opts.contextRow.appendChild(pending.chip.el);
     // startPending pushes into this.mentions, which updateRowVisibility reads —
     // reversed order left the row hidden until the second chip.
-    this.startPending(pending);
-    this.updateRowVisibility();
+    this.#startPending(pending);
+    this.#updateRowVisibility();
     return true;
   }
 
   /** True when the mention limit is already reached (inline pre-insert gate). */
   atLimit(): boolean {
-    return this.mentions.length >= this.maxMentions;
+    return this.mentions.length >= this.#maxMentions;
   }
 
   /**
@@ -177,7 +177,7 @@ export class ContextMentionManager {
     source: AgentWidgetContextMentionSource,
     item: AgentWidgetContextMentionItem
   ): boolean {
-    if (this.atLimit()) return this.reject(source, item, "limit");
+    if (this.atLimit()) return this.#reject(source, item, "limit");
     return true;
   }
 
@@ -204,17 +204,17 @@ export class ContextMentionManager {
       args,
       reportStatus,
     };
-    this.startPending(pending);
+    this.#startPending(pending);
   }
 
   /** Fire the rejection hooks for a blocked mention and return false (add's sentinel). */
-  private reject(
+  #reject(
     source: AgentWidgetContextMentionSource,
     item: AgentWidgetContextMentionItem,
     reason: "duplicate" | "limit"
   ): false {
-    this.opts.mentionConfig.onMentionRejected?.(item, reason);
-    this.opts.emit?.("rejected", { sourceId: source.id, itemId: item.id, reason });
+    this.#opts.mentionConfig.onMentionRejected?.(item, reason);
+    this.#opts.emit?.("rejected", { sourceId: source.id, itemId: item.id, reason });
     return false;
   }
 
@@ -224,39 +224,39 @@ export class ContextMentionManager {
    * else starts the select-time resolve, keeping the promise so `finalize()`
    * awaits this exact resolve rather than firing a second one.
    */
-  private startPending(pending: PendingMention): void {
+  #startPending(pending: PendingMention): void {
     this.mentions.push(pending);
     if (pending.source.resolveOn === "submit") {
       pending.status = "ready";
       pending.chip?.setStatus("ready");
       pending.reportStatus?.("resolved");
     } else {
-      pending.resolvePromise = this.resolvePending(pending);
+      pending.resolvePromise = this.#resolvePending(pending);
     }
-    this.opts.announce(`Added ${pending.ref.label} to context`);
+    this.#opts.announce(`Added ${pending.ref.label} to context`);
   }
 
-  private buildResolveContext(
+  #buildResolveContext(
     signal: AbortSignal,
     args: string,
-    composerText = this.opts.getComposerText()
+    composerText = this.#opts.getComposerText()
   ) {
     return {
-      messages: this.opts.getMessages(),
-      config: this.opts.getConfig(),
+      messages: this.#opts.getMessages(),
+      config: this.#opts.getConfig(),
       composerText,
       args,
       signal,
     };
   }
 
-  private async resolvePending(pending: PendingMention): Promise<void> {
+  async #resolvePending(pending: PendingMention): Promise<void> {
     const abort = new AbortController();
     pending.abort = abort;
     try {
       const payload = await pending.source.resolve(
         pending.item,
-        this.buildResolveContext(abort.signal, pending.args)
+        this.#buildResolveContext(abort.signal, pending.args)
       );
       if (abort.signal.aborted) return;
       pending.payload = payload;
@@ -272,11 +272,11 @@ export class ContextMentionManager {
       pending.reportStatus?.("error");
       // Speak the failure through the ASSERTIVE region — the visual error state
       // (chip/token color) is otherwise silent for screen-reader users.
-      (this.opts.announceError ?? this.opts.announce)(
+      (this.#opts.announceError ?? this.#opts.announce)(
         `Couldn't attach ${pending.ref.label} to context`
       );
-      this.opts.mentionConfig.onMentionResolveError?.(pending.item, error);
-      this.opts.emit?.("resolve-error", {
+      this.#opts.mentionConfig.onMentionResolveError?.(pending.item, error);
+      this.#opts.emit?.("resolve-error", {
         sourceId: pending.source.id,
         itemId: pending.item.id,
       });
@@ -289,8 +289,8 @@ export class ContextMentionManager {
     const [pending] = this.mentions.splice(index, 1);
     pending.abort?.abort();
     pending.chip?.el.remove();
-    this.updateRowVisibility();
-    this.opts.announce(`Removed ${pending.ref.label} from context`);
+    this.#updateRowVisibility();
+    this.#opts.announce(`Removed ${pending.ref.label} from context`);
   }
 
   /** Currently tracked refs, in order. Read-only: does not detach anything. */
@@ -312,7 +312,7 @@ export class ContextMentionManager {
       m.chip?.el.remove();
     }
     this.mentions.length = 0;
-    this.updateRowVisibility();
+    this.#updateRowVisibility();
   }
 
   /**
@@ -330,12 +330,12 @@ export class ContextMentionManager {
   collectForSubmit(): { refs: AgentWidgetContextMentionRef[]; finalize: () => Promise<MentionSubmitBundle> } {
     const snapshot = [...this.mentions];
     const refs = snapshot.map((m) => m.ref);
-    const composerText = this.opts.getComposerText();
+    const composerText = this.#opts.getComposerText();
 
     // Detach: empty the composer chip row without aborting resolves.
     for (const m of snapshot) m.chip?.el.remove();
     this.mentions.length = 0;
-    this.updateRowVisibility();
+    this.#updateRowVisibility();
 
     const finalize = async (): Promise<MentionSubmitBundle> => {
       // Resolve every mention concurrently: submit-deferred sources resolve now;
@@ -346,7 +346,7 @@ export class ContextMentionManager {
             if (m.source.resolveOn === "submit") {
               return await m.source.resolve(
                 m.item,
-                this.buildResolveContext(new AbortController().signal, m.args, composerText)
+                this.#buildResolveContext(new AbortController().signal, m.args, composerText)
               );
             }
             if (m.resolvePromise) await m.resolvePromise;
@@ -355,13 +355,13 @@ export class ContextMentionManager {
             // A throwing host `onMentionResolveError` must not reject the whole
             // bundle — guard the callback so one bad item just drops.
             try {
-              this.opts.mentionConfig.onMentionResolveError?.(m.item, error);
+              this.#opts.mentionConfig.onMentionResolveError?.(m.item, error);
             } catch (cbError) {
               if (typeof console !== "undefined") {
                 console.warn("[Persona] onMentionResolveError callback threw", cbError);
               }
             }
-            this.opts.emit?.("resolve-error", {
+            this.#opts.emit?.("resolve-error", {
               sourceId: m.source.id,
               itemId: m.item.id,
             });
@@ -398,7 +398,7 @@ export class ContextMentionManager {
               formatMentionBlock(
                 { label: m.ref.label, text: payload.llmAppend, ref: m.ref, item: m.item },
                 blocks.length,
-                this.opts.mentionConfig.llmFormat
+                this.#opts.mentionConfig.llmFormat
               )
             );
           } catch (error) {
@@ -425,7 +425,7 @@ export class ContextMentionManager {
    * The row is shared with the composer's mode chips, so visibility follows the
    * row's children, never this manager's mention count.
    */
-  private updateRowVisibility(): void {
-    syncComposerChipRow(this.opts.contextRow);
+  #updateRowVisibility(): void {
+    syncComposerChipRow(this.#opts.contextRow);
   }
 }

package/src/utils/context-mention-orchestrator.ts

@@ -76,6 +76,22 @@ export interface ContextMentionOrchestrator {
   destroy: () => void;
 }
 
+export type ContextMentionOrchestratorDeps = {
+  loadContextMentions: typeof loadContextMentions;
+  loadContextMentionsInline: typeof loadContextMentionsInline;
+  renderLucideIcon: typeof renderLucideIcon;
+  createMentionButton: typeof createMentionButton;
+};
+
+// Call through the live module bindings (not captured references) so spies
+// and late re-registration keep working.
+const defaultDeps: ContextMentionOrchestratorDeps = {
+  loadContextMentions: () => loadContextMentions(),
+  loadContextMentionsInline: () => loadContextMentionsInline(),
+  renderLucideIcon: (...args) => renderLucideIcon(...args),
+  createMentionButton: (...args) => createMentionButton(...args),
+};
+
 export function createContextMentionOrchestrator(opts: {
   config: AgentWidgetConfig;
   textarea: HTMLTextAreaElement;
@@ -94,7 +110,19 @@ export function createContextMentionOrchestrator(opts: {
    * Omit and the orchestrator creates a standalone row the caller must place.
    */
   chipRow?: HTMLElement;
+  /**
+   * Stateful collaborators (chunk loaders, icon registry, tooltip-backed
+   * button). The IIFE/CDN build loads this module in the lazy `ui-extras`
+   * chunk and passes core's instances so the chunk never uses its own copies.
+   */
+  deps?: ContextMentionOrchestratorDeps;
 }): ContextMentionOrchestrator | null {
+  const {
+    loadContextMentions,
+    loadContextMentionsInline,
+    renderLucideIcon,
+    createMentionButton,
+  } = opts.deps ?? defaultDeps;
   const mentionConfig = opts.config.contextMentions;
   if (!mentionConfig?.enabled) return null;
 

package/src/utils/event-stream-buffer.ts

@@ -2,70 +2,70 @@ import type { SSEEventRecord } from "../types";
 import type { EventStreamStore } from "./event-stream-store";
 
 export class EventStreamBuffer {
-  private buffer: SSEEventRecord[];
-  private head = 0;
-  private count = 0;
-  private totalCaptured = 0;
-  private eventTypesSet = new Set<string>();
-  private readonly maxSize: number;
-  private readonly store: EventStreamStore | null;
+  #buffer: SSEEventRecord[];
+  #head = 0;
+  #count = 0;
+  #totalCaptured = 0;
+  #eventTypesSet = new Set<string>();
+  readonly #maxSize: number;
+  readonly #store: EventStreamStore | null;
 
   constructor(maxSize = 2000, store: EventStreamStore | null = null) {
-    this.maxSize = maxSize;
-    this.buffer = new Array(maxSize);
-    this.store = store;
+    this.#maxSize = maxSize;
+    this.#buffer = new Array(maxSize);
+    this.#store = store;
   }
 
   push(event: SSEEventRecord): void {
-    this.buffer[this.head] = event;
-    this.head = (this.head + 1) % this.maxSize;
-    if (this.count < this.maxSize) {
-      this.count++;
+    this.#buffer[this.#head] = event;
+    this.#head = (this.#head + 1) % this.#maxSize;
+    if (this.#count < this.#maxSize) {
+      this.#count++;
     }
-    this.totalCaptured++;
-    this.eventTypesSet.add(event.type);
-    this.store?.put(event);
+    this.#totalCaptured++;
+    this.#eventTypesSet.add(event.type);
+    this.#store?.put(event);
   }
 
   getAll(): SSEEventRecord[] {
-    if (this.count === 0) return [];
-    if (this.count < this.maxSize) {
-      return this.buffer.slice(0, this.count);
+    if (this.#count === 0) return [];
+    if (this.#count < this.#maxSize) {
+      return this.#buffer.slice(0, this.#count);
     }
     // Buffer is full, items wrap around
     return [
-      ...this.buffer.slice(this.head, this.maxSize),
-      ...this.buffer.slice(0, this.head)
+      ...this.#buffer.slice(this.#head, this.#maxSize),
+      ...this.#buffer.slice(0, this.#head)
     ];
   }
 
   async restore(): Promise<number> {
-    if (!this.store) return 0;
-    const events = await this.store.getAll();
+    if (!this.#store) return 0;
+    const events = await this.#store.getAll();
     if (events.length === 0) return 0;
 
     // Take the most recent maxSize events (store returns sorted by timestamp)
-    const toLoad = events.length > this.maxSize
-      ? events.slice(events.length - this.maxSize)
+    const toLoad = events.length > this.#maxSize
+      ? events.slice(events.length - this.#maxSize)
       : events;
 
     // Populate the ring buffer without writing back to the store
     for (const event of toLoad) {
-      this.buffer[this.head] = event;
-      this.head = (this.head + 1) % this.maxSize;
-      if (this.count < this.maxSize) {
-        this.count++;
+      this.#buffer[this.#head] = event;
+      this.#head = (this.#head + 1) % this.#maxSize;
+      if (this.#count < this.#maxSize) {
+        this.#count++;
       }
-      this.eventTypesSet.add(event.type);
+      this.#eventTypesSet.add(event.type);
     }
-    this.totalCaptured = events.length;
+    this.#totalCaptured = events.length;
 
     return toLoad.length;
   }
 
   getAllFromStore(): Promise<SSEEventRecord[]> {
-    if (this.store) {
-      return this.store.getAll();
+    if (this.#store) {
+      return this.#store.getAll();
     }
     return Promise.resolve(this.getAll());
   }
@@ -77,36 +77,36 @@ export class EventStreamBuffer {
   }
 
   getSize(): number {
-    return this.count;
+    return this.#count;
   }
 
   getTotalCaptured(): number {
-    return this.totalCaptured;
+    return this.#totalCaptured;
   }
 
   getEvictedCount(): number {
-    return this.totalCaptured - this.count;
+    return this.#totalCaptured - this.#count;
   }
 
   clear(): void {
-    this.buffer = new Array(this.maxSize);
-    this.head = 0;
-    this.count = 0;
-    this.totalCaptured = 0;
-    this.eventTypesSet.clear();
-    this.store?.clear();
+    this.#buffer = new Array(this.#maxSize);
+    this.#head = 0;
+    this.#count = 0;
+    this.#totalCaptured = 0;
+    this.#eventTypesSet.clear();
+    this.#store?.clear();
   }
 
   destroy(): void {
-    this.buffer = [];
-    this.head = 0;
-    this.count = 0;
-    this.totalCaptured = 0;
-    this.eventTypesSet.clear();
-    this.store?.destroy();
+    this.#buffer = [];
+    this.#head = 0;
+    this.#count = 0;
+    this.#totalCaptured = 0;
+    this.#eventTypesSet.clear();
+    this.#store?.destroy();
   }
 
   getEventTypes(): string[] {
-    return Array.from(this.eventTypesSet);
+    return Array.from(this.#eventTypesSet);
   }
 }

package/src/utils/event-stream-store.ts

@@ -1,33 +1,33 @@
 import type { SSEEventRecord } from "../types";
 
 export class EventStreamStore {
-  private db: IDBDatabase | null = null;
-  private pendingWrites: SSEEventRecord[] = [];
-  private flushScheduled = false;
-  private isDestroyed = false;
-  private readonly dbName: string;
-  private readonly storeName: string;
+  #db: IDBDatabase | null = null;
+  #pendingWrites: SSEEventRecord[] = [];
+  #flushScheduled = false;
+  #isDestroyed = false;
+  readonly #dbName: string;
+  readonly #storeName: string;
 
   constructor(dbName = "persona-event-stream", storeName = "events") {
-    this.dbName = dbName;
-    this.storeName = storeName;
+    this.#dbName = dbName;
+    this.#storeName = storeName;
   }
 
   open(): Promise<void> {
     return new Promise((resolve, reject) => {
       try {
-        const request = indexedDB.open(this.dbName, 1);
+        const request = indexedDB.open(this.#dbName, 1);
 
         request.onupgradeneeded = () => {
           const db = request.result;
-          if (!db.objectStoreNames.contains(this.storeName)) {
-            const store = db.createObjectStore(this.storeName, { keyPath: "id" });
+          if (!db.objectStoreNames.contains(this.#storeName)) {
+            const store = db.createObjectStore(this.#storeName, { keyPath: "id" });
             store.createIndex("timestamp", "timestamp", { unique: false });
           }
         };
 
         request.onsuccess = () => {
-          this.db = request.result;
+          this.#db = request.result;
           resolve();
         };
 
@@ -41,19 +41,19 @@ export class EventStreamStore {
   }
 
   put(event: SSEEventRecord): void {
-    if (!this.db || this.isDestroyed) return;
-    this.pendingWrites.push(event);
-    if (!this.flushScheduled) {
-      this.flushScheduled = true;
-      queueMicrotask(() => this.flushWrites());
+    if (!this.#db || this.#isDestroyed) return;
+    this.#pendingWrites.push(event);
+    if (!this.#flushScheduled) {
+      this.#flushScheduled = true;
+      queueMicrotask(() => this.#flushWrites());
     }
   }
 
   putBatch(events: SSEEventRecord[]): void {
-    if (!this.db || this.isDestroyed || events.length === 0) return;
+    if (!this.#db || this.#isDestroyed || events.length === 0) return;
     try {
-      const tx = this.db.transaction(this.storeName, "readwrite");
-      const store = tx.objectStore(this.storeName);
+      const tx = this.#db.transaction(this.#storeName, "readwrite");
+      const store = tx.objectStore(this.#storeName);
       for (const event of events) {
         store.put(event);
       }
@@ -64,13 +64,13 @@ export class EventStreamStore {
 
   getAll(): Promise<SSEEventRecord[]> {
     return new Promise((resolve, reject) => {
-      if (!this.db) {
+      if (!this.#db) {
         resolve([]);
         return;
       }
       try {
-        const tx = this.db.transaction(this.storeName, "readonly");
-        const store = tx.objectStore(this.storeName);
+        const tx = this.#db.transaction(this.#storeName, "readonly");
+        const store = tx.objectStore(this.#storeName);
         const index = store.index("timestamp");
         const request = index.getAll();
 
@@ -89,13 +89,13 @@ export class EventStreamStore {
 
   getCount(): Promise<number> {
     return new Promise((resolve, reject) => {
-      if (!this.db) {
+      if (!this.#db) {
         resolve(0);
         return;
       }
       try {
-        const tx = this.db.transaction(this.storeName, "readonly");
-        const store = tx.objectStore(this.storeName);
+        const tx = this.#db.transaction(this.#storeName, "readonly");
+        const store = tx.objectStore(this.#storeName);
         const request = store.count();
 
         request.onsuccess = () => {
@@ -113,14 +113,14 @@ export class EventStreamStore {
 
   clear(): Promise<void> {
     return new Promise((resolve, reject) => {
-      if (!this.db) {
+      if (!this.#db) {
         resolve();
         return;
       }
-      this.pendingWrites = [];
+      this.#pendingWrites = [];
       try {
-        const tx = this.db.transaction(this.storeName, "readwrite");
-        const store = tx.objectStore(this.storeName);
+        const tx = this.#db.transaction(this.#storeName, "readwrite");
+        const store = tx.objectStore(this.#storeName);
         const request = store.clear();
 
         request.onsuccess = () => {
@@ -137,19 +137,19 @@ export class EventStreamStore {
   }
 
   close(): void {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
+    if (this.#db) {
+      this.#db.close();
+      this.#db = null;
     }
   }
 
   destroy(): Promise<void> {
-    this.isDestroyed = true;
-    this.pendingWrites = [];
+    this.#isDestroyed = true;
+    this.#pendingWrites = [];
     this.close();
     return new Promise((resolve, reject) => {
       try {
-        const request = indexedDB.deleteDatabase(this.dbName);
+        const request = indexedDB.deleteDatabase(this.#dbName);
 
         request.onsuccess = () => {
           resolve();
@@ -164,14 +164,14 @@ export class EventStreamStore {
     });
   }
 
-  private flushWrites(): void {
-    this.flushScheduled = false;
-    if (!this.db || this.isDestroyed || this.pendingWrites.length === 0) return;
-    const toWrite = this.pendingWrites;
-    this.pendingWrites = [];
+  #flushWrites(): void {
+    this.#flushScheduled = false;
+    if (!this.#db || this.#isDestroyed || this.#pendingWrites.length === 0) return;
+    const toWrite = this.#pendingWrites;
+    this.#pendingWrites = [];
     try {
-      const tx = this.db.transaction(this.storeName, "readwrite");
-      const store = tx.objectStore(this.storeName);
+      const tx = this.#db.transaction(this.#storeName, "readwrite");
+      const store = tx.objectStore(this.#storeName);
       for (const event of toWrite) {
         store.put(event);
       }