@runtypelabs/persona 4.24.0 → 4.26.0

package/src/utils/throughput-tracker.ts

@@ -123,8 +123,8 @@ function defaultClock(): number {
  * event via {@link processEvent}; read the current state via {@link getMetric}.
  */
 export class ThroughputTracker {
-  private metric: ThroughputMetric = { status: "idle" };
-  private run: ThroughputRunStats | null = null;
+  #metric: ThroughputMetric = { status: "idle" };
+  #run: ThroughputRunStats | null = null;
   private readonly now: () => number;
 
   constructor(now: () => number = defaultClock) {
@@ -136,47 +136,47 @@ export class ThroughputTracker {
     // clock on each read. The view polls this every ~200ms, so without this a
     // pause between deltas would keep showing the stale rate from the last
     // event; recomputing lets the displayed tok/s decay as time passes.
-    const run = this.run;
+    const run = this.#run;
     if (
       run &&
-      this.metric.status === "running" &&
+      this.#metric.status === "running" &&
       run.firstDeltaAt !== undefined &&
-      this.metric.outputTokens !== undefined
+      this.#metric.outputTokens !== undefined
     ) {
       const durationMs = this.now() - run.firstDeltaAt;
       return {
-        ...this.metric,
+        ...this.#metric,
         durationMs,
         tokensPerSecond: calculateTokensPerSecond(
-          this.metric.outputTokens,
+          this.#metric.outputTokens,
           durationMs
         ),
       };
     }
-    return this.metric;
+    return this.#metric;
   }
 
   /** Reset back to idle (e.g. when the chat is cleared). */
   reset(): void {
-    this.run = null;
-    this.metric = { status: "idle" };
+    this.#run = null;
+    this.#metric = { status: "idle" };
   }
 
-  private startRun(now: number): void {
-    this.run = {
+  #startRun(now: number): void {
+    this.#run = {
       startedAt: now,
       visibleCharCount: 0,
       exactOutputTokens: 0,
     };
-    this.metric = { status: "running" };
+    this.#metric = { status: "running" };
   }
 
   processEvent(eventType: string, payload: unknown): void {
     if (!isRecord(payload)) {
       // Non-object payloads can still signal lifecycle (e.g. bare "execution_error").
-      if (eventType === "execution_error" && this.run) {
-        this.run = null;
-        this.metric = { status: "error" };
+      if (eventType === "execution_error" && this.#run) {
+        this.#run = null;
+        this.#metric = { status: "error" };
       }
       return;
     }
@@ -186,13 +186,13 @@ export class ThroughputTracker {
 
     if (type === "execution_start") {
       // New request: start fresh, discarding any incomplete prior run.
-      this.startRun(now);
+      this.#startRun(now);
       return;
     }
 
     if (STEP_START_EVENTS.has(type)) {
       // Mid-request step marker: only begin a run if none is active.
-      if (!this.run) this.startRun(now);
+      if (!this.#run) this.#startRun(now);
       return;
     }
 
@@ -201,8 +201,8 @@ export class ThroughputTracker {
       if (!text) return;
 
       // Lazily start a run if the stream began without a recognized start event.
-      if (!this.run) this.startRun(now);
-      const stats = this.run!;
+      if (!this.#run) this.#startRun(now);
+      const stats = this.#run!;
 
       stats.firstDeltaAt ??= now;
       stats.visibleCharCount += text.length;
@@ -214,7 +214,7 @@ export class ThroughputTracker {
         stats.exactOutputTokens +
         estimateTokensFromCharCount(stats.visibleCharCount);
       const durationMs = now - stats.firstDeltaAt;
-      this.metric = {
+      this.#metric = {
         status: "running",
         tokensPerSecond: calculateTokensPerSecond(outputTokens, durationMs),
         outputTokens,
@@ -227,8 +227,8 @@ export class ThroughputTracker {
     if (INTERMEDIATE_COMPLETE_EVENTS.has(type)) {
       // Accumulate exact usage but keep the run going: these fire per
       // step/turn, not at the end of the whole run.
-      if (!this.run) return;
-      const stats = this.run;
+      if (!this.#run) return;
+      const stats = this.#run;
       const exact = getOutputTokens(payload);
       if (exact !== undefined) {
         stats.exactOutputTokens += exact;
@@ -242,8 +242,8 @@ export class ThroughputTracker {
       const outputTokens =
         stats.exactOutputTokens +
         estimateTokensFromCharCount(stats.visibleCharCount);
-      const durationMs = this.resolveDuration(stats, payload, now);
-      this.metric = {
+      const durationMs = this.#resolveDuration(stats, payload, now);
+      this.#metric = {
         status: "running",
         tokensPerSecond: calculateTokensPerSecond(outputTokens, durationMs),
         outputTokens,
@@ -254,8 +254,8 @@ export class ThroughputTracker {
     }
 
     if (type === "execution_complete") {
-      if (!this.run) return;
-      const stats = this.run;
+      if (!this.#run) return;
+      const stats = this.#run;
       // Prefer exact output tokens from this terminal event, else accumulated
       // usage from intermediate completes, else the text estimate.
       const terminalExact = getOutputTokens(payload);
@@ -270,22 +270,22 @@ export class ThroughputTracker {
         terminalExact !== undefined || stats.exactOutputTokens > 0
           ? "usage"
           : "estimate";
-      const durationMs = this.resolveDuration(stats, payload, now);
-      this.metric = {
+      const durationMs = this.#resolveDuration(stats, payload, now);
+      this.#metric = {
         status: "complete",
         tokensPerSecond: calculateTokensPerSecond(outputTokens, durationMs),
         outputTokens,
         durationMs,
         source,
       };
-      this.run = null;
+      this.#run = null;
       return;
     }
 
     if (type === "execution_error" || (type === "error" && payload.recoverable === false)) {
-      if (!this.run) return;
-      this.run = null;
-      this.metric = { status: "error" };
+      if (!this.#run) return;
+      this.#run = null;
+      this.#metric = { status: "error" };
     }
   }
 
@@ -294,7 +294,7 @@ export class ThroughputTracker {
    * threshold; otherwise fall back to provider execution time, then to the
    * whole-request duration.
    */
-  private resolveDuration(
+  #resolveDuration(
     stats: ThroughputRunStats,
     payload: Record<string, unknown>,
     now: number

package/src/utils/virtual-scroller.ts

@@ -6,146 +6,146 @@ export interface VirtualScrollerOptions {
 }
 
 export class VirtualScroller {
-  private container: HTMLElement;
-  private rowHeight: number;
-  private overscan: number;
-  private renderRow: (index: number) => HTMLElement;
-  private totalCount = 0;
-  private spacer: HTMLElement;
-  private viewport: HTMLElement;
-  private visibleRows: Map<number, HTMLElement> = new Map();
-  private scrollRAF: number | null = null;
-  private isAutoScrolling = false;
-  private onScroll: () => void;
+  #container: HTMLElement;
+  #rowHeight: number;
+  #overscan: number;
+  #renderRow: (index: number) => HTMLElement;
+  #totalCount = 0;
+  #spacer: HTMLElement;
+  #viewport: HTMLElement;
+  #visibleRows: Map<number, HTMLElement> = new Map();
+  #scrollRAF: number | null = null;
+  #isAutoScrolling = false;
+  #onScroll: () => void;
 
   constructor(options: VirtualScrollerOptions) {
-    this.container = options.container;
-    this.rowHeight = options.rowHeight ?? 40;
-    this.overscan = options.overscan ?? 5;
-    this.renderRow = options.renderRow;
+    this.#container = options.container;
+    this.#rowHeight = options.rowHeight ?? 40;
+    this.#overscan = options.overscan ?? 5;
+    this.#renderRow = options.renderRow;
 
     // Create spacer (provides full scrollable height)
-    this.spacer = document.createElement("div");
-    this.spacer.style.position = "relative";
-    this.spacer.style.width = "100%";
-    this.spacer.style.height = "0px";
+    this.#spacer = document.createElement("div");
+    this.#spacer.style.position = "relative";
+    this.#spacer.style.width = "100%";
+    this.#spacer.style.height = "0px";
 
     // Create viewport (holds visible rows)
-    this.viewport = document.createElement("div");
-    this.viewport.style.position = "absolute";
-    this.viewport.style.top = "0";
-    this.viewport.style.left = "0";
-    this.viewport.style.right = "0";
+    this.#viewport = document.createElement("div");
+    this.#viewport.style.position = "absolute";
+    this.#viewport.style.top = "0";
+    this.#viewport.style.left = "0";
+    this.#viewport.style.right = "0";
 
-    this.spacer.appendChild(this.viewport);
-    this.container.appendChild(this.spacer);
+    this.#spacer.appendChild(this.#viewport);
+    this.#container.appendChild(this.#spacer);
 
     // Throttled scroll handler via RAF
-    this.onScroll = () => {
-      if (this.scrollRAF !== null) return;
-      this.scrollRAF = requestAnimationFrame(() => {
-        this.scrollRAF = null;
+    this.#onScroll = () => {
+      if (this.#scrollRAF !== null) return;
+      this.#scrollRAF = requestAnimationFrame(() => {
+        this.#scrollRAF = null;
         this.render();
       });
     };
 
-    this.container.addEventListener("scroll", this.onScroll);
+    this.#container.addEventListener("scroll", this.#onScroll);
   }
 
   setTotalCount(count: number): void {
-    this.totalCount = count;
-    this.spacer.style.height = `${count * this.rowHeight}px`;
+    this.#totalCount = count;
+    this.#spacer.style.height = `${count * this.#rowHeight}px`;
     // Always invalidate cached rows: data may have changed even at the same count
-    for (const [, el] of this.visibleRows) {
+    for (const [, el] of this.#visibleRows) {
       el.remove();
     }
-    this.visibleRows.clear();
+    this.#visibleRows.clear();
     this.render();
   }
 
   render(): void {
-    if (this.totalCount === 0) {
+    if (this.#totalCount === 0) {
       // Clear all visible rows
-      for (const [, el] of this.visibleRows) {
+      for (const [, el] of this.#visibleRows) {
         el.remove();
       }
-      this.visibleRows.clear();
+      this.#visibleRows.clear();
       return;
     }
 
-    const scrollTop = this.container.scrollTop;
-    const containerHeight = this.container.clientHeight;
+    const scrollTop = this.#container.scrollTop;
+    const containerHeight = this.#container.clientHeight;
 
     const startIndex = Math.max(
       0,
-      Math.floor(scrollTop / this.rowHeight) - this.overscan
+      Math.floor(scrollTop / this.#rowHeight) - this.#overscan
     );
     const endIndex = Math.min(
-      this.totalCount,
-      Math.ceil((scrollTop + containerHeight) / this.rowHeight) + this.overscan
+      this.#totalCount,
+      Math.ceil((scrollTop + containerHeight) / this.#rowHeight) + this.#overscan
     );
 
     // Add new rows that should be visible
     for (let i = startIndex; i < endIndex; i++) {
-      if (!this.visibleRows.has(i)) {
-        const row = this.renderRow(i);
+      if (!this.#visibleRows.has(i)) {
+        const row = this.#renderRow(i);
         row.style.position = "absolute";
         row.style.top = "0";
         row.style.left = "0";
         row.style.right = "0";
-        row.style.height = `${this.rowHeight}px`;
-        row.style.transform = `translateY(${i * this.rowHeight}px)`;
-        this.viewport.appendChild(row);
-        this.visibleRows.set(i, row);
+        row.style.height = `${this.#rowHeight}px`;
+        row.style.transform = `translateY(${i * this.#rowHeight}px)`;
+        this.#viewport.appendChild(row);
+        this.#visibleRows.set(i, row);
       }
     }
 
     // Remove rows that are no longer visible
-    for (const [index, el] of this.visibleRows) {
+    for (const [index, el] of this.#visibleRows) {
       if (index < startIndex || index >= endIndex) {
         el.remove();
-        this.visibleRows.delete(index);
+        this.#visibleRows.delete(index);
       }
     }
   }
 
   scrollToBottom(smooth?: boolean): void {
-    this.isAutoScrolling = true;
-    const target = this.spacer.offsetHeight - this.container.clientHeight;
+    this.#isAutoScrolling = true;
+    const target = this.#spacer.offsetHeight - this.#container.clientHeight;
     if (smooth) {
-      this.container.scrollTo({ top: target, behavior: "smooth" });
+      this.#container.scrollTo({ top: target, behavior: "smooth" });
     } else {
-      this.container.scrollTop = target;
+      this.#container.scrollTop = target;
     }
     // Reset flag after scroll settles
     requestAnimationFrame(() => {
-      this.isAutoScrolling = false;
+      this.#isAutoScrolling = false;
     });
   }
 
   isNearBottom(threshold = 50): boolean {
     return (
-      this.container.scrollHeight -
-        this.container.scrollTop -
-        this.container.clientHeight <
+      this.#container.scrollHeight -
+        this.#container.scrollTop -
+        this.#container.clientHeight <
       threshold
     );
   }
 
   getIsAutoScrolling(): boolean {
-    return this.isAutoScrolling;
+    return this.#isAutoScrolling;
   }
 
   destroy(): void {
-    this.container.removeEventListener("scroll", this.onScroll);
-    if (this.scrollRAF !== null) {
-      cancelAnimationFrame(this.scrollRAF);
-      this.scrollRAF = null;
+    this.#container.removeEventListener("scroll", this.#onScroll);
+    if (this.#scrollRAF !== null) {
+      cancelAnimationFrame(this.#scrollRAF);
+      this.#scrollRAF = null;
     }
-    for (const [, el] of this.visibleRows) {
+    for (const [, el] of this.#visibleRows) {
       el.remove();
     }
-    this.visibleRows.clear();
-    this.spacer.remove();
+    this.#visibleRows.clear();
+    this.#spacer.remove();
   }
 }

package/src/utils/visitor-store.test.ts

@@ -422,4 +422,54 @@ describe("visitor store", () => {
     expect(b).toBe("b");
     expect(window.localStorage.getItem(leaseKey)).toBeNull();
   }, 20_000);
+
+  it("rejects a lease waiter destroyed before another tab releases the lock", async () => {
+    const { leaseKey } = await visitorStoreKeys(CLIENT_TOKEN, PREFIX);
+    // A live foreign lease: the waiter would normally poll until it expires.
+    window.localStorage.setItem(
+      leaseKey,
+      JSON.stringify({ ownerNonce: "other-tab", expiresAt: Date.now() + 8_000 })
+    );
+    const store = makeStore();
+    await store.ready;
+    const fn = vi.fn(async () => "minted");
+
+    const pending = store.withFirstInitLock(fn);
+    await flush();
+    expect(fn).not.toHaveBeenCalled();
+
+    const started = Date.now();
+    store.destroy();
+
+    await expect(pending).rejects.toThrow(/destroyed/);
+    // destroy() wakes the waiter; it must not sit out the 500ms poll floor.
+    expect(Date.now() - started).toBeLessThan(400);
+    expect(fn).not.toHaveBeenCalled();
+    expect(window.localStorage.getItem(leaseKey)).toContain("other-tab");
+  });
+
+  it("rejects a Web Locks waiter destroyed before its turn", async () => {
+    installFakeLocks();
+    const store = makeStore();
+    await store.ready;
+
+    let releaseFirst: () => void = () => {};
+    const firstGate = new Promise<void>((resolve) => {
+      releaseFirst = resolve;
+    });
+    const first = store.withFirstInitLock(async () => {
+      await firstGate;
+      return "a";
+    });
+    const second = vi.fn(async () => "b");
+    const pending = store.withFirstInitLock(second);
+    await flush();
+
+    store.destroy();
+    releaseFirst();
+
+    expect(await first).toBe("a");
+    await expect(pending).rejects.toThrow(/destroyed/);
+    expect(second).not.toHaveBeenCalled();
+  });
 });

package/src/utils/visitor-store.ts

@@ -196,18 +196,35 @@ export const createVisitorStore = (
     }
   };
 
+  /**
+   * A first init still queued behind another tab's lock when this store is
+   * destroyed must not run: it would mint a visitor and write the token and
+   * session after teardown, racing the replacement store for the same keys.
+   * The in-flight `withFirstInitLock` rejects instead; `destroy()` wakes any
+   * lease waiter so the rejection is immediate rather than up to a poll late.
+   */
+  const leaseWaiters = new Set<() => void>();
+  const runGuarded = <T>(fn: () => Promise<T>): Promise<T> =>
+    destroyed
+      ? Promise.reject(
+          new Error("Visitor store destroyed before its first init could start")
+        )
+      : fn();
+
   /** Storage-change wakeup with a timeout floor; same-tab writers fire no event. */
   const waitForLeaseChange = (timeoutMs: number) =>
     new Promise<void>((resolve) => {
       const timer = setTimeout(done, timeoutMs);
       function done() {
         clearTimeout(timer);
+        leaseWaiters.delete(done);
         window.removeEventListener("storage", wake);
         resolve();
       }
       function wake(event: StorageEvent) {
         if (event.key === null || event.key === leaseKey) done();
       }
+      leaseWaiters.add(done);
       window.addEventListener("storage", wake);
     });
 
@@ -216,7 +233,7 @@ export const createVisitorStore = (
       .toString(36)
       .slice(2)}`;
     const deadline = Date.now() + LEASE_WAIT_CAP_MS;
-    while (Date.now() < deadline) {
+    while (!destroyed && Date.now() < deadline) {
       const store = localStore();
       if (!store) break;
       const now = Date.now();
@@ -246,14 +263,14 @@ export const createVisitorStore = (
       }
       heldLeaseNonce = nonce;
       try {
-        return await fn();
+        return await runGuarded(fn);
       } finally {
         heldLeaseNonce = null;
         removeOwnLease(nonce);
       }
     }
     // Cap or storage loss: proceed unlocked, the documented rare-race mode.
-    return fn();
+    return runGuarded(fn);
   };
 
   return {
@@ -310,10 +327,10 @@ export const createVisitorStore = (
         globalThis.navigator as Navigator & { locks?: LockManagerLike }
       )?.locks;
       if (locks?.request) {
-        return locks.request(lockName, () => fn());
+        return locks.request(lockName, () => runGuarded(fn));
       }
       // No-persistence and degraded-memory modes cannot coordinate tabs.
-      if (!localStore()) return fn();
+      if (!localStore()) return runGuarded(fn);
       return leaseLock(fn);
     },
 
@@ -332,6 +349,7 @@ export const createVisitorStore = (
         window.removeEventListener("storage", onStorage);
       }
       if (heldLeaseNonce) removeOwnLease(heldLeaseNonce);
+      for (const wake of [...leaseWaiters]) wake();
     },
   };
 };

package/src/voice/__fixtures__/voice-wire/README.md

@@ -0,0 +1 @@
+Browser voice wire v1 fixtures (`runtype-browser-v1`, contract Amendment 5.1), copied from core #9522's schema fixtures. One JSON frame per file: `server/` is what core sends, `client/` is what a client sends. `voice.test.ts` feeds every server frame through the provider and checks the client frames Persona sends against `client/`. Refresh them from core when the wire changes.

package/src/voice/__fixtures__/voice-wire/client/cancel.json

@@ -0,0 +1,3 @@
+{
+  "type": "cancel"
+}

package/src/voice/__fixtures__/voice-wire/client/context.json

@@ -0,0 +1,4 @@
+{
+  "type": "context",
+  "text": "Conversation so far:\nUser: Hi\nAssistant: Hello! How can I help?"
+}

package/src/voice/__fixtures__/voice-wire/client/delegation_result.json

@@ -0,0 +1,6 @@
+{
+  "type": "delegation_result",
+  "delegationId": "del_1",
+  "status": "completed",
+  "text": "Your pickup order is placed for 6:30 pm."
+}

package/src/voice/__fixtures__/voice-wire/client/delegation_update.json

@@ -0,0 +1,6 @@
+{
+  "type": "delegation_update",
+  "delegationId": "del_1",
+  "status": "pending_approval",
+  "text": "Placing a pickup order needs your approval in the chat. Briefly tell the user what you're about to do and ask them to approve or decline it in the chat. Don't claim it's done."
+}

package/src/voice/__fixtures__/voice-wire/client/ping.json

@@ -0,0 +1,3 @@
+{
+  "type": "ping"
+}

package/src/voice/__fixtures__/voice-wire/client/playback_progress.json

@@ -0,0 +1,5 @@
+{
+  "type": "playback_progress",
+  "turnId": "utt_2",
+  "playedMs": 1830
+}

package/src/voice/__fixtures__/voice-wire/client/start.json

@@ -0,0 +1,3 @@
+{
+  "type": "start"
+}

package/src/voice/__fixtures__/voice-wire/server/artifact.json

@@ -0,0 +1,11 @@
+{
+  "type": "artifact",
+  "turnId": "turn_2",
+  "executionId": "exec_1",
+  "event": {
+    "type": "artifact_start",
+    "id": "art_1",
+    "artifactType": "markdown",
+    "title": "Menu"
+  }
+}

package/src/voice/__fixtures__/voice-wire/server/attached.json

@@ -0,0 +1,4 @@
+{
+  "type": "attached",
+  "idleMs": 30000
+}

package/src/voice/__fixtures__/voice-wire/server/audio_clear.json

@@ -0,0 +1,4 @@
+{
+  "type": "audio_clear",
+  "reason": "barge_in"
+}

package/src/voice/__fixtures__/voice-wire/server/audio_end.json

@@ -0,0 +1,3 @@
+{
+  "type": "audio_end"
+}

package/src/voice/__fixtures__/voice-wire/server/delegation_cancelled.json

@@ -0,0 +1,5 @@
+{
+  "type": "delegation_cancelled",
+  "delegationId": "del_1",
+  "reason": "deadline"
+}

package/src/voice/__fixtures__/voice-wire/server/delegation_completed.json

@@ -0,0 +1,8 @@
+{
+  "type": "delegation_completed",
+  "delegationId": "del_1",
+  "turnId": "del_1",
+  "speak": true,
+  "text": "Today we have tomato soup and a grilled cheese.",
+  "final": true
+}

package/src/voice/__fixtures__/voice-wire/server/delegation_started.json

@@ -0,0 +1,15 @@
+{
+  "type": "delegation_started",
+  "delegationId": "del_1",
+  "turnId": "del_1",
+  "input": {
+    "text": "What's on the menu today?",
+    "userUtteranceIds": ["utt_1"],
+    "messages": [
+      {
+        "role": "user",
+        "content": "What's on the menu today?"
+      }
+    ]
+  }
+}

package/src/voice/__fixtures__/voice-wire/server/error.json

@@ -0,0 +1,6 @@
+{
+  "type": "error",
+  "error": "Voice processing error",
+  "code": "VOICE_CALL_PROTOCOL",
+  "fatal": true
+}

package/src/voice/__fixtures__/voice-wire/server/metrics.json

@@ -0,0 +1,10 @@
+{
+  "type": "metrics",
+  "llm_ms": 820,
+  "tts_ms": 310,
+  "first_audio_ms": 1050,
+  "total_ms": 1400,
+  "first_synthesis_ms": 900,
+  "first_text_ms": 400,
+  "incremental": true
+}

package/src/voice/__fixtures__/voice-wire/server/pong.json

@@ -0,0 +1,3 @@
+{
+  "type": "pong"
+}