@runtypelabs/persona 3.34.1 → 3.35.0

package/src/utils/buttons.ts

@@ -283,7 +283,7 @@ export interface ComboButtonHandle {
 }
 
 /**
- * Creates a combo button — a clickable label with a chevron that opens a dropdown menu.
+ * Creates a combo button: a clickable label with a chevron that opens a dropdown menu.
  *
  * The entire label + chevron area acts as a single interactive unit with an optional
  * hover pill effect. Clicking anywhere on it toggles the dropdown.

package/src/utils/code-generators.ts

@@ -1380,7 +1380,7 @@ function generateScriptInstallerCode(config: any, options?: CodeGeneratorOptions
   // branch hoists every sibling key (Object.assign(scriptConfig, parsed)), while
   // a flat payload becomes the widget config wholesale and its siblings are
   // ignored. So whenever either is set we emit the nested `{ config, ...}` form
-  // with the option as a SIBLING of `config` — nesting `target` inside the
+  // with the option as a SIBLING of `config`: nesting `target` inside the
   // widget config would leave the widget mounted on `body`.
   const needsWrapper = Boolean(options?.windowKey || options?.target);
   const payload = needsWrapper

package/src/utils/composer-history.ts

@@ -36,7 +36,7 @@ export interface ComposerHistoryInput {
 export interface ComposerHistoryResult {
   /** Whether the key was consumed (caller should preventDefault). */
   handled: boolean;
-  /** New textarea value to apply — only present when it should change. */
+  /** New textarea value to apply: only present when it should change. */
   value?: string;
   /** Next navigation state. */
   state: ComposerHistoryState;
@@ -86,7 +86,7 @@ export function navigateComposerHistory(
       };
     }
 
-    // Already at the oldest entry — consume the key but don't change.
+    // Already at the oldest entry: consume the key but don't change.
     return { handled: true, state };
   }
 
@@ -104,7 +104,7 @@ export function navigateComposerHistory(
     };
   }
 
-  // Stepped past the newest entry — restore the saved draft and exit.
+  // Stepped past the newest entry: restore the saved draft and exit.
   return {
     handled: true,
     value: state.draft,

package/src/utils/dom-context.test.ts

@@ -181,7 +181,7 @@ describe("collectEnrichedPageContext", () => {
   it("handles empty body", () => {
     document.body.innerHTML = "";
     const result = collectEnrichedPageContext();
-    // May return body itself or empty — either is valid
+    // May return body itself or empty: either is valid
     expect(Array.isArray(result)).toBe(true);
   });
 
@@ -386,7 +386,7 @@ describe("formatEnrichedContext", () => {
         interactivity: "static",
         attributes: {},
         formattedSummary:
-          "[Shirt](/p/1) — $10\nselector: div.card\nactions: Add",
+          "[Shirt](/p/1): $10\nselector: div.card\nactions: Add",
       },
     ];
     const out = formatEnrichedContext(elements, { mode: "structured" });

package/src/utils/dom-context.ts

@@ -2,14 +2,14 @@
  * Enriched DOM context collection for providing richer page information to AI.
  *
  * Captures interactive elements, stable CSS selectors, ARIA roles, data attributes,
- * and visibility state — giving the LLM much better context than basic className/innerText.
+ * and visibility state: giving the LLM much better context than basic className/innerText.
  *
  * ## Modes
  *
  * - **structured** (default): collects candidates, scores them with optional {@link ParseRule}
  *   hooks, then applies `maxElements`. Rich containers (e.g. product cards) can surface
  *   before unrelated static noise.
- * - **simple**: legacy behavior — cap during traversal, interactive-first ordering, no rule
+ * - **simple**: legacy behavior: cap during traversal, interactive-first ordering, no rule
  *   scoring or {@link EnrichedPageElement.formattedSummary}.
  */
 
@@ -44,7 +44,7 @@ export type DomContextMode = "simple" | "structured";
 export interface ParseOptionsConfig {
   /**
    * `structured` (default): score candidates with rules, then apply `maxElements`.
-   * `simple`: legacy traversal cap and ordering only — rules are ignored (with a warning
+   * `simple`: legacy traversal cap and ordering only: rules are ignored (with a warning
    * if `rules` was passed on {@link DomContextOptions}).
    */
   mode?: DomContextMode;
@@ -294,9 +294,9 @@ export const defaultParseRules: ParseRule[] = [
       const ctas = extractCtaLabels(el);
       const head =
         href && title
-          ? `[${title}](${href})${price ? ` — ${price}` : ""}`
+          ? `[${title}](${href})${price ? `: ${price}` : ""}`
           : title
-            ? `${title}${price ? ` — ${price}` : ""}`
+            ? `${title}${price ? `: ${price}` : ""}`
             : price || enriched.text.trim().slice(0, 120);
       const lines = [
         head,
@@ -443,7 +443,7 @@ function isElementVisible(el: HTMLElement): boolean {
     if (style.display === "none") return false;
     if (style.visibility === "hidden") return false;
   } catch {
-    // getComputedStyle can fail in some environments — assume visible
+    // getComputedStyle can fail in some environments: assume visible
   }
 
   if (el.style.display === "none") return false;
@@ -801,7 +801,7 @@ function collectSimple(
  * - **Default (structured):** walks up to `maxCandidates` nodes, scores with
  *   {@link defaultParseRules} (or `rules`), suppresses redundant descendants when a
  *   formatting rule matches, then keeps the top `maxElements` by score (DOM order tie-break).
- * - **simple:** legacy path — stops once `maxElements` nodes are collected during traversal
+ * - **simple:** legacy path: stops once `maxElements` nodes are collected during traversal
  *   and sorts interactive before static.
  *
  * Pass `options: { mode: "simple" }` to disable rules. If `mode` is `simple` and `rules` is

package/src/utils/dom.test.ts

@@ -0,0 +1,67 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it } from "vitest";
+import { createNode, cx } from "./dom";
+
+describe("createNode", () => {
+  it("applies className, text, attributes, and inline styles", () => {
+    const el = createNode("button", {
+      className: "persona-foo persona-bar",
+      text: "Send",
+      attrs: { type: "submit", "data-persona-composer-submit": "" },
+      style: { display: "none", zIndex: "5" },
+    });
+
+    expect(el.tagName).toBe("BUTTON");
+    expect(el.className).toBe("persona-foo persona-bar");
+    expect(el.textContent).toBe("Send");
+    expect(el.getAttribute("type")).toBe("submit");
+    expect(el.getAttribute("data-persona-composer-submit")).toBe("");
+    expect(el.style.display).toBe("none");
+    expect(el.style.zIndex).toBe("5");
+  });
+
+  it("appends node and string children in order, skipping nullish values", () => {
+    const child = createNode("span", { text: "child" });
+    const parent = createNode("div", {}, child, "tail", null, undefined);
+
+    expect(parent.childNodes.length).toBe(2);
+    expect(parent.firstChild).toBe(child);
+    expect(parent.lastChild?.textContent).toBe("tail");
+  });
+
+  it("defaults to a bare element when no options are provided", () => {
+    const el = createNode("div");
+    expect(el.tagName).toBe("DIV");
+    expect(el.className).toBe("");
+    expect(el.childNodes.length).toBe(0);
+  });
+
+  it("skips nullish style values so conditionals can be inlined", () => {
+    const el = createNode("div", {
+      style: { display: "none", color: undefined, width: "10px" },
+    });
+    expect(el.style.display).toBe("none");
+    expect(el.style.width).toBe("10px");
+    // An undefined value must not be written (no literal "undefined").
+    expect(el.style.color).toBe("");
+  });
+});
+
+describe("cx", () => {
+  it("joins truthy fragments and drops falsy ones", () => {
+    expect(cx("a", false, "b", null, undefined, "", "c")).toBe("a b c");
+  });
+
+  it("supports inline conditional classes", () => {
+    const active = true;
+    const disabled = false;
+    expect(cx("base", active && "is-active", disabled && "is-disabled")).toBe(
+      "base is-active"
+    );
+  });
+
+  it("returns an empty string when every fragment is falsy", () => {
+    expect(cx(false, null, undefined, "")).toBe("");
+  });
+});

package/src/utils/dom.ts

@@ -28,6 +28,81 @@ export const createFragment = (): DocumentFragment => {
   return document.createDocumentFragment();
 };
 
+export interface CreateNodeOptions {
+  /** Sets `element.className`. */
+  className?: string;
+  /** Sets `element.textContent` before any `children` are appended. */
+  text?: string;
+  /** Attribute name → value pairs applied via `setAttribute`. */
+  attrs?: Record<string, string>;
+  /**
+   * Inline styles. Nullish (`undefined`/`null`) values are skipped so callers
+   * can inline conditionals (e.g. `borderColor: cfg.borderColor`) without an
+   * `if` per property. Note this only *sets* values, it never clears them, so
+   * prefer it for constructing fresh elements rather than re-styling live ones.
+   */
+  style?: Partial<CSSStyleDeclaration>;
+}
+
+/**
+ * Ergonomic element factory that bundles the className + attribute + style +
+ * children boilerplate the widget's DOM builders otherwise repeat by hand.
+ *
+ * `createElement` stays the right tool for the simple `(tag, className)` case;
+ * reach for `createNode` when a node also needs attributes, inline styles, or
+ * up-front children. Nullish `children` are skipped so callers can inline
+ * conditionals (e.g. `maybeIcon && el`).
+ */
+export const createNode = <K extends keyof HTMLElementTagNameMap>(
+  tag: K,
+  options: CreateNodeOptions = {},
+  ...children: Array<Node | string | null | undefined>
+): HTMLElementTagNameMap[K] => {
+  const element = document.createElement(tag);
+
+  if (options.className) {
+    element.className = options.className;
+  }
+  if (options.text !== undefined) {
+    element.textContent = options.text;
+  }
+  if (options.attrs) {
+    for (const [name, value] of Object.entries(options.attrs)) {
+      element.setAttribute(name, value);
+    }
+  }
+  if (options.style) {
+    const style = element.style as unknown as Record<string, string>;
+    const source = options.style as Record<string, string | null | undefined>;
+    for (const property of Object.keys(source)) {
+      const value = source[property];
+      if (value != null) {
+        style[property] = value;
+      }
+    }
+  }
+
+  const appendable = children.filter(
+    (child): child is Node | string => child != null
+  );
+  if (appendable.length > 0) {
+    element.append(...appendable);
+  }
+
+  return element;
+};
+
+/**
+ * Join truthy class-name fragments into a single space-separated string
+ * (the clsx / classnames pattern). Falsy fragments
+ * (`false` / `null` / `undefined` / `""`) are dropped, so conditional classes
+ * read inline as `cond && "persona-foo"` instead of imperative
+ * `classList.add(...)` branches.
+ */
+export const cx = (
+  ...parts: Array<string | false | null | undefined>
+): string => parts.filter(Boolean).join(" ");
+
 
 
 

package/src/utils/dropdown.ts

@@ -72,11 +72,11 @@ export function createDropdownMenu(options: CreateDropdownOptions): DropdownMenu
   menu.setAttribute("data-persona-theme-zone", "dropdown");
 
   if (portal) {
-    // Fixed positioning — menu is portaled outside the anchor's overflow context
+    // Fixed positioning: menu is portaled outside the anchor's overflow context
     menu.style.position = "fixed";
     menu.style.zIndex = String(PORTALED_OVERLAY_Z_INDEX);
   } else {
-    // Absolute positioning — menu lives inside the anchor
+    // Absolute positioning: menu lives inside the anchor
     menu.style.position = "absolute";
     menu.style.top = "100%";
     menu.style.marginTop = "4px";

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

@@ -239,7 +239,7 @@ describe("EventStreamBuffer", () => {
     expect(buf.getAll()).toEqual([]);
     expect(store.clear).toHaveBeenCalled();
 
-    // Simulate new session sending events — buffer should accept them
+    // Simulate new session sending events: buffer should accept them
     const newEvt = makeEvent("c", 3);
     buf.push(newEvt);
     expect(buf.getSize()).toBe(1);
@@ -253,7 +253,7 @@ describe("EventStreamBuffer", () => {
     buf.push(makeEvent("session1_a", 1));
     buf.push(makeEvent("session1_b", 2));
 
-    // Session reset happens (no clear called — buffer persists)
+    // Session reset happens (no clear called: buffer persists)
     // Session 2 events
     buf.push(makeEvent("session2_a", 3));
 

package/src/utils/message-fingerprint.test.ts

@@ -47,6 +47,15 @@ describe("computeMessageFingerprint", () => {
     expect(fp1).not.toBe(fp2);
   });
 
+  it("changes when voiceProcessing flips with identical text (transcript finalize)", () => {
+    // On transcript finalize, voiceProcessing goes true→false with the SAME
+    // text. The fingerprint must change so the live transcribing/thinking
+    // bubble is replaced by the finalized one instead of served from cache.
+    const fp1 = computeMessageFingerprint(makeMessage({ content: "hello there", voiceProcessing: true }), 0);
+    const fp2 = computeMessageFingerprint(makeMessage({ content: "hello there", voiceProcessing: false }), 0);
+    expect(fp1).not.toBe(fp2);
+  });
+
   it("changes when role changes", () => {
     const fp1 = computeMessageFingerprint(makeMessage({ role: "assistant" }), 0);
     const fp2 = computeMessageFingerprint(makeMessage({ role: "user" }), 0);

package/src/utils/message-fingerprint.ts

@@ -12,6 +12,7 @@ export type FingerprintableMessage = {
   role: string;
   content: string;
   streaming?: boolean;
+  voiceProcessing?: boolean;
   variant?: string;
   rawContent?: string;
   llmContent?: string;
@@ -49,6 +50,10 @@ export function computeMessageFingerprint(
     message.content?.length ?? 0,
     message.content?.slice(-32) ?? "",
     message.streaming ? "1" : "0",
+    // voiceProcessing flips true→false on transcript finalize, usually with the
+    // SAME text — so without it the cache would reuse the live transcribing/
+    // thinking bubble (waveform/dots) for the finalized message.
+    message.voiceProcessing ? "1" : "0",
     message.variant ?? "",
     message.rawContent?.length ?? 0,
     message.llmContent?.length ?? 0,

package/src/utils/morph.ts

@@ -33,7 +33,7 @@ export const morphMessages = (
           // Plugins actively mutating a node (e.g. glyph-cycle's tick loop)
           // opt out of morph entirely via this attribute. Unlike
           // `data-preserve-animation`, this is honored regardless of whether
-          // the new DOM carries the attribute — it's a runtime-only marker.
+          // the new DOM carries the attribute: it's a runtime-only marker.
           if (oldNode.hasAttribute("data-preserve-runtime")) {
             return false;
           }

package/src/utils/sanitize.ts

@@ -1,11 +1,13 @@
-import DOMPurify from "dompurify";
+import type * as DOMPurifyType from "dompurify";
+import { escapeHtml } from "../postprocessors";
+import { getMarkdownParsersSync } from "../markdown-parsers-loader";
 
 /**
  * A function that sanitizes an HTML string, returning safe HTML.
  */
 export type SanitizeFunction = (html: string) => string;
 
-const DEFAULT_PURIFY_CONFIG: DOMPurify.Config = {
+const DEFAULT_PURIFY_CONFIG: DOMPurifyType.Config = {
   // Tags safe for markdown-rendered content
   ALLOWED_TAGS: [
     // Headings & structure
@@ -41,7 +43,7 @@ const DEFAULT_PURIFY_CONFIG: DOMPurify.Config = {
   ],
 };
 
-/** Raster image data URI pattern — blocks SVG and other non-image types. */
+/** Raster image data URI pattern: blocks SVG and other non-image types. */
 const SAFE_DATA_URI = /^data:image\/(?:png|jpe?g|gif|webp|bmp|x-icon|avif)/i;
 
 /**
@@ -49,22 +51,36 @@ const SAFE_DATA_URI = /^data:image\/(?:png|jpe?g|gif|webp|bmp|x-icon|avif)/i;
  * Uses the global window when available (browser).
  */
 export const createDefaultSanitizer = (): SanitizeFunction => {
-  // DOMPurify needs a DOM context. In the browser, pass `window`.
-  // The widget only runs in browsers, so `window` is always available at runtime.
-  const purify = DOMPurify(typeof window !== "undefined" ? window : (undefined as never));
+  let purifyInstance: ReturnType<typeof DOMPurifyType.default> | null = null;
 
-  // Hook: strip data:image/svg+xml and other unsafe data: URIs from src/href
-  purify.addHook("uponSanitizeAttribute", (_node, data) => {
-    if (data.attrName === "src" || data.attrName === "href") {
-      const val = data.attrValue;
-      if (val.toLowerCase().startsWith("data:") && !SAFE_DATA_URI.test(val)) {
-        data.attrValue = "";
-        data.keepAttr = false;
-      }
+  return (html: string): string => {
+    const parsers = getMarkdownParsersSync();
+    if (!parsers) {
+      // If DOMPurify hasn't loaded yet, fall back to escaping HTML completely
+      // to remain safe until the module is available.
+      return escapeHtml(html);
     }
-  });
+    
+    if (!purifyInstance) {
+      const { DOMPurify } = parsers;
+      // DOMPurify needs a DOM context. In the browser, pass `window`.
+      // The widget only runs in browsers, so `window` is always available at runtime.
+      purifyInstance = DOMPurify(typeof window !== "undefined" ? window : (undefined as never));
 
-  return (html: string): string => purify.sanitize(html, DEFAULT_PURIFY_CONFIG) as string;
+      // Hook: strip data:image/svg+xml and other unsafe data: URIs from src/href
+      purifyInstance.addHook("uponSanitizeAttribute", (_node, data) => {
+        if (data.attrName === "src" || data.attrName === "href") {
+          const val = data.attrValue;
+          if (val.toLowerCase().startsWith("data:") && !SAFE_DATA_URI.test(val)) {
+            data.attrValue = "";
+            data.keepAttr = false;
+          }
+        }
+      });
+    }
+
+    return purifyInstance.sanitize(html, DEFAULT_PURIFY_CONFIG) as string;
+  };
 };
 
 /**

package/src/utils/sequence-buffer.test.ts

@@ -32,16 +32,16 @@ describe("SequenceReorderBuffer", () => {
 
   it("reorders leading out-of-order events (3, 1, 2 → 1, 2, 3)", () => {
     const buf = new SequenceReorderBuffer(emitter);
-    // seq=3 arrives first — should be buffered (3 > nextExpected=1)
+    // seq=3 arrives first: should be buffered (3 > nextExpected=1)
     buf.push("step_delta", { seq: 3, text: "c" });
     expect(emitted).toHaveLength(0);
 
-    // seq=1 arrives — matches nextExpected, emits, then drains seq=2 (not present), stops
+    // seq=1 arrives: matches nextExpected, emits, then drains seq=2 (not present), stops
     buf.push("step_delta", { seq: 1, text: "a" });
     expect(emitted).toHaveLength(1);
     expect(emitted[0].payload.text).toBe("a");
 
-    // seq=2 arrives — matches nextExpected=2, emits, drains seq=3 from buffer
+    // seq=2 arrives: matches nextExpected=2, emits, drains seq=3 from buffer
     buf.push("step_delta", { seq: 2, text: "b" });
     expect(emitted).toHaveLength(3);
     expect(emitted[1].payload.text).toBe("b");
@@ -69,7 +69,7 @@ describe("SequenceReorderBuffer", () => {
 
     expect(emitted).toHaveLength(1);
 
-    // Advance past gap timeout — seq=2 never arrives, flush seq=3 anyway
+    // Advance past gap timeout: seq=2 never arrives, flush seq=3 anyway
     vi.advanceTimersByTime(60);
 
     expect(emitted).toHaveLength(2);
@@ -96,7 +96,7 @@ describe("SequenceReorderBuffer", () => {
     buf.push("step_delta", { seq: 3, text: "c" });
     expect(emitted).toHaveLength(3);
 
-    // Now seq=1 arrives again — it's a duplicate (1 < nextExpected=4), still emitted
+    // Now seq=1 arrives again: it's a duplicate (1 < nextExpected=4), still emitted
     buf.push("step_delta", { seq: 1, text: "a-dup" });
     expect(emitted).toHaveLength(4);
     expect(emitted[3].payload.text).toBe("a-dup");
@@ -184,7 +184,7 @@ describe("SequenceReorderBuffer", () => {
 
   it("leading gap flushes via timeout when seq=1 never arrives", () => {
     const buf = new SequenceReorderBuffer(emitter, 50);
-    // Only seq=2 and seq=3 arrive — seq=1 is missing
+    // Only seq=2 and seq=3 arrive: seq=1 is missing
     buf.push("step_delta", { seq: 2, text: "b" });
     buf.push("step_delta", { seq: 3, text: "c" });
     expect(emitted).toHaveLength(0); // both buffered
@@ -232,7 +232,7 @@ describe("SequenceReorderBuffer", () => {
     buf.push("step_delta", { seq: 3, text: "first-at-3" });
     expect(emitted).toHaveLength(1);
 
-    // Second event with same seq=3 — prior one should be emitted out-of-order
+    // Second event with same seq=3: prior one should be emitted out-of-order
     buf.push("reason_delta", { seq: 3, text: "second-at-3" });
 
     expect(warnSpy).toHaveBeenCalledTimes(1);
@@ -244,7 +244,7 @@ describe("SequenceReorderBuffer", () => {
     expect(emitted).toHaveLength(2);
     expect(emitted[1].payload.text).toBe("first-at-3");
 
-    // seq=2 arrives — advances nextExpected through the buffered second-at-3
+    // seq=2 arrives: advances nextExpected through the buffered second-at-3
     buf.push("step_delta", { seq: 2, text: "b" });
     expect(emitted).toHaveLength(4);
     expect(emitted[2].payload.text).toBe("b");

package/src/utils/sequence-buffer.ts

@@ -19,7 +19,7 @@ export class SequenceReorderBuffer {
     //   - `agentContext.seq`: tool_start, tool_delta, tool_complete (agent loop)
     const seq = payload?.seq ?? payload?.sequenceIndex ?? payload?.agentContext?.seq;
 
-    // No seq field — emit immediately (backward compat).
+    // No seq field: emit immediately (backward compat).
     // If there are buffered events waiting for a gap to fill, flush them
     // first: the server sending an unsequenced event means it has moved on
     // and the missing seq numbers are not coming.
@@ -49,17 +49,17 @@ export class SequenceReorderBuffer {
       return;
     }
 
-    // If seq < nextExpected, it's a duplicate or late arrival — emit anyway (don't drop)
+    // If seq < nextExpected, it's a duplicate or late arrival: emit anyway (don't drop)
     if (seq < this.nextExpectedSeq!) {
       this.emitter(payloadType, payload);
       return;
     }
 
-    // seq > nextExpected — buffer it and start gap timer.
+    // seq > nextExpected: buffer it and start gap timer.
     // If another event with the same seq is already buffered, the server
     // broke its "seq is unique per stream" invariant. Rather than silently
     // overwrite (losing one event) or swallow the new one, emit the prior
-    // event immediately — out of order, but better than dropping it — and
+    // event immediately, out of order, but better than dropping it, and
     // warn so the issue is visible.
     const existing = this.buffer.get(seq);
     if (existing !== undefined) {

package/src/utils/smart-dom-adapter.test.ts

@@ -1,4 +1,4 @@
-// Pure mapper test — no DOM, no installed/vendored library at runtime (types only).
+// Pure mapper test: no DOM, no installed/vendored library at runtime (types only).
 import { describe, it, expect } from "vitest";
 import { smartDomResultToEnriched } from "./smart-dom-adapter";
 import { formatEnrichedContext } from "./dom-context";

package/src/utils/smart-dom-adapter.ts

@@ -2,8 +2,8 @@
  * Pure mapper: `@mcp-b/smart-dom-reader` output → Persona's {@link EnrichedPageElement}[].
  *
  * This module imports the smart-dom-reader types with `import type` ONLY, so the
- * library's runtime value is never pulled in here. That keeps the mapper — and its
- * unit test — free of any DOM and free of the (vendored) library at runtime; the
+ * library's runtime value is never pulled in here. That keeps the mapper, and its
+ * unit test: free of any DOM and free of the (vendored) library at runtime; the
  * types are erased during compilation.
  *
  * The smart-dom-reader returns a structured {@link SmartDOMResult} JSON object with
@@ -43,8 +43,7 @@ export interface SmartDomAdapterOptions {
 
 /**
  * Candidate selector types that resolve through `document.querySelector` (plain CSS).
- * Everything else smart-dom-reader can emit — `xpath` and text pseudo-selectors —
- * is not actionable via the current click loop, so it is skipped here.
+ * Everything else smart-dom-reader can emit, `xpath` and text pseudo-selectors,  * is not actionable via the current click loop, so it is skipped here.
  */
 const PLAIN_CSS_CANDIDATE_TYPES: ReadonlySet<ElementSelectorCandidate["type"]> =
   new Set(["id", "data-testid", "role-aria", "name", "class-path", "css-path"]);
@@ -119,7 +118,7 @@ function collectAttributes(el: ExtractedElement): Record<string, string> {
  * Returns true when the element sits under `excludeSelector` (e.g. the widget host).
  * smart-dom-reader has no exclude option and pierces shadow DOM by default, so this
  * guards against the widget reading its own UI. The check is a substring match across
- * the element's candidate selectors and ancestor chain — robust for the default
+ * the element's candidate selectors and ancestor chain: robust for the default
  * `.persona-host` class guard.
  */
 function isExcluded(el: ExtractedElement, excludeSelector: string): boolean {