@agent-native/core 0.98.4 → 0.98.5

package/corpus/core/src/demo/config.ts

@@ -1,12 +1,12 @@
 /**
  * Demo mode gate.
  *
- * Demo mode replaces email addresses and numbers in every action result with
- * deterministic fake data — for both the UI and what the agent sees — while
- * preserving names, free text, labels, IDs, dates, URLs, and structure so the
- * app keeps working. The redaction WALK (see ./redact.ts) is expensive on
- * large payloads, so callers MUST gate it behind this function and only walk
- * when it returns true.
+ * Demo mode replaces every email address with `anonymous@builder.io` and
+ * anonymizes numbers in every action result — for both the UI and what the
+ * agent sees — while preserving names, free text, labels, IDs, dates, URLs,
+ * and structure so the app keeps working. The redaction WALK (see ./redact.ts)
+ * is expensive on large payloads, so callers MUST gate it behind this function
+ * and only walk when it returns true.
  *
  * This gate itself is intentionally cheap:
  *   - An env-forced deployment (a hosted demo site) short-circuits with zero

package/corpus/core/src/demo/fetch-interceptor.ts

@@ -46,10 +46,19 @@ const SKIP_SUBSTRINGS = [
   "/_agent-native/runs",
 ];
 
-// Raw rrweb payloads are playback data, not ordinary app UI records. Walking
-// and cloning their huge DOM/event trees on the main thread stalls playback
-// and can corrupt replay fidelity. Small list/summary/manifest responses stay
-// eligible so rendered visitor identities are still anonymized.
+// Raw rrweb payloads are playback data, not ordinary app UI records. Skipping
+// these is not just a perf optimization that avoids walking/cloning huge
+// DOM/event trees on the main thread: demo number
+// redaction previously ran over this exact raw replay JSON and faked any
+// integer >= 1000 it found — Meta/ViewportResize widths, pointer x/y
+// coordinates, and numeric values inside `_cssText` and SVG attributes. That
+// was the root cause of the 2026-07 "ultra-wide replay" bugs (stages
+// rendered thousands of pixels wide, frozen/teleporting cursors, giant
+// icons) even though every stored recording was always geometrically sane —
+// the corruption happened at *view* time, not at capture/storage time. Small
+// list/summary/manifest responses stay eligible so rendered visitor identities
+// are still anonymized. NEVER remove the raw payload skips or broaden them to
+// metadata endpoints that the UI renders directly.
 const RAW_REPLAY_PAYLOAD_RE =
   /\/api\/session-replay\/recordings\/[^/?#]+\/(?:chunks(?:\/[^/?#]+)?|events)(?:[/?#]|$)/;
 const RAW_AGENT_REPLAY_EVENTS_RE =

package/corpus/core/src/demo/redact.ts

@@ -1,13 +1,12 @@
 /**
  * Pure, dependency-free, deterministic demo-mode redactor.
  *
- * Replaces sensitive values (emails and free numbers) with stable fake
- * substitutes so a demo looks coherent — the same input always maps to the
- * same fake. Crucially, it NEVER rewrites identifiers, structural tokens, or
- * timestamps. Names and other free text are deliberately left alone because
- * guessing whether arbitrary text is a person's name is too inaccurate. The
- * string redactor uses a protect-first strategy (mask IDs with opaque
- * placeholders before any transform runs, restore them byte-identical
+ * Replaces every email with one canonical anonymous address and free numbers
+ * with stable fake substitutes. Crucially, it NEVER rewrites identifiers,
+ * structural tokens, or timestamps. Names and other free text are deliberately
+ * left alone because guessing whether arbitrary text is a person's name is too
+ * inaccurate. The string redactor uses a protect-first strategy (mask IDs with
+ * opaque placeholders before any transform runs, restore them byte-identical
  * afterwards), and the structure-aware walker additionally protects leaf
  * values by key name.
  */
@@ -58,10 +57,6 @@ function seededRng(value: string, salt: string): () => number {
   return mulberry32(seedFn());
 }
 
-function pick<T>(rng: () => number, pool: readonly T[]): T {
-  return pool[Math.floor(rng() * pool.length) % pool.length];
-}
-
 /* ------------------------------------------------------------------ *
  * Stable mapping cache (bounded, TTL, leak-free)
  *
@@ -157,150 +152,19 @@ function memoFake(
   return value;
 }
 
-/* ------------------------------------------------------------------ *
- * Curated name pools
- * ------------------------------------------------------------------ */
-
-const FIRST_NAMES: readonly string[] = [
-  "Jane",
-  "John",
-  "Alex",
-  "Maria",
-  "Sam",
-  "Olivia",
-  "Liam",
-  "Emma",
-  "Noah",
-  "Ava",
-  "Lucas",
-  "Mia",
-  "Ethan",
-  "Sofia",
-  "Mason",
-  "Isla",
-  "Leo",
-  "Aria",
-  "Henry",
-  "Zoe",
-  "Owen",
-  "Nora",
-  "Caleb",
-  "Lily",
-  "Ryan",
-  "Ruby",
-  "Adam",
-  "Chloe",
-  "Eli",
-  "Hazel",
-  "Max",
-  "Iris",
-  "Ben",
-  "Clara",
-  "Theo",
-  "Maya",
-  "Felix",
-  "Elena",
-  "Jonah",
-  "Greta",
-];
-
-const LAST_NAMES: readonly string[] = [
-  "Doe",
-  "Smith",
-  "Johnson",
-  "Lee",
-  "Brown",
-  "Garcia",
-  "Miller",
-  "Davis",
-  "Wilson",
-  "Moore",
-  "Taylor",
-  "Anderson",
-  "Thomas",
-  "Jackson",
-  "White",
-  "Harris",
-  "Martin",
-  "Clark",
-  "Lewis",
-  "Walker",
-  "Hall",
-  "Young",
-  "King",
-  "Wright",
-  "Hill",
-  "Green",
-  "Adams",
-  "Baker",
-  "Nelson",
-  "Carter",
-  "Mitchell",
-  "Perez",
-  "Roberts",
-  "Turner",
-  "Phillips",
-  "Campbell",
-  "Parker",
-  "Evans",
-  "Edwards",
-  "Collins",
-];
-
 /* ------------------------------------------------------------------ *
  * Fake value generators (deterministic in value + salt)
  * ------------------------------------------------------------------ */
 
-// Realistic-looking but safe stand-in domains: real consumer providers (the
-// local part is fake, so no real mailbox is implied) plus the canonical
-// reserved fictional-company domains (Contoso/Fabrikam/Northwind), which read
-// as real businesses but are intentional placeholders. No example.com.
-const FAKE_EMAIL_DOMAINS: readonly string[] = [
-  "gmail.com",
-  "outlook.com",
-  "icloud.com",
-  "yahoo.com",
-  "proton.me",
-  "hey.com",
-  "fastmail.com",
-  "contoso.com",
-  "fabrikam.com",
-  "northwind.com",
-  "acme.io",
-  "globex.net",
-];
+export const DEMO_ANONYMOUS_EMAIL = "anonymous@builder.io";
 
 function fakeEmail(original: string, salt: string): string {
-  return memoFake("email", original.toLowerCase(), salt, () => {
-    const rng = seededRng(`email:${original.toLowerCase()}`, salt);
-    const first = pick(rng, FIRST_NAMES).toLowerCase();
-    const last = pick(rng, LAST_NAMES).toLowerCase();
-    const domain = pick(rng, FAKE_EMAIL_DOMAINS);
-    // Vary the local part so addresses don't all look templated.
-    const shape = Math.floor(rng() * 6);
-    let local: string;
-    switch (shape) {
-      case 0:
-        local = `${first}.${last}`;
-        break;
-      case 1:
-        local = `${first}${last}`;
-        break;
-      case 2:
-        local = `${first[0]}${last}`;
-        break;
-      case 3:
-        local = `${first}.${last}${1 + Math.floor(rng() * 89)}`;
-        break;
-      case 4:
-        local = `${first}_${last}`;
-        break;
-      default:
-        local = `${last}.${first}`;
-        break;
-    }
-    return `${local}@${domain}`;
-  });
+  return memoFake(
+    "email",
+    original.toLowerCase(),
+    salt,
+    () => DEMO_ANONYMOUS_EMAIL,
+  );
 }
 
 /**

package/corpus/core/src/extensions/html-shell.ts

@@ -1,3 +1,5 @@
+import { buildSessionReplayIframeBootstrap } from "./session-replay-iframe.js";
+
 const EXTENSION_IFRAME_CSP_BASE =
   "default-src 'none'; script-src 'self' https://cdn.jsdelivr.net 'unsafe-eval' 'unsafe-inline'; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://fonts.googleapis.com; font-src https://fonts.gstatic.com; connect-src 'self'; img-src 'self' data: blob:; media-src 'self' data: blob:; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none';";
 
@@ -744,6 +746,7 @@ export function buildExtensionHtml(
 	      }
 	    });
 	  </script>
+	${buildSessionReplayIframeBootstrap()}
 	</head>
 	<body${extensionId ? ` data-extension-id="${extensionIdAttr}" data-tool-id="${extensionIdAttr}"` : ""} class="text-foreground">
 	${content}

package/corpus/core/src/extensions/session-replay-iframe.ts

@@ -0,0 +1,131 @@
+import {
+  isTrustedSessionReplayIframeParentOrigin,
+  SESSION_REPLAY_IFRAME_PROBE,
+  SESSION_REPLAY_IFRAME_START,
+  SESSION_REPLAY_IFRAME_STOP,
+} from "../session-replay-iframe-protocol.js";
+
+export const RRWEB_RECORD_IFRAME_CDN_URL =
+  "https://cdn.jsdelivr.net/npm/@rrweb/record@2.1.0/umd/record.min.js";
+export const RRWEB_RECORD_IFRAME_SRI =
+  "sha384-MrD66HBNSykaP2N95+6hQCFlF5oH2tvL3TD/zyvHNkP/sAFWZx98DX9MEDy8MdVT";
+
+/**
+ * Installs the cooperative side of rrweb's cross-origin iframe protocol.
+ * Nothing is fetched or recorded until a trusted first-party parent asks the
+ * frame to start. rrweb then forwards its events directly to that parent.
+ */
+export function buildSessionReplayIframeBootstrap(): string {
+  const probeType = JSON.stringify(SESSION_REPLAY_IFRAME_PROBE);
+  const startType = JSON.stringify(SESSION_REPLAY_IFRAME_START);
+  const stopType = JSON.stringify(SESSION_REPLAY_IFRAME_STOP);
+  const scriptUrl = JSON.stringify(RRWEB_RECORD_IFRAME_CDN_URL);
+  const integrity = JSON.stringify(RRWEB_RECORD_IFRAME_SRI);
+
+  return `<script>
+    (function() {
+      var recorderStop = null;
+      var recorderLoad = null;
+      var startGeneration = 0;
+      var isTrustedParentOrigin = ${isTrustedSessionReplayIframeParentOrigin.toString()};
+
+      function stopRecorder() {
+        startGeneration += 1;
+        if (typeof recorderStop === 'function') {
+          try { recorderStop(); } catch (_) {}
+        }
+        recorderStop = null;
+      }
+
+      function getRecord() {
+        return window.rrwebRecord && typeof window.rrwebRecord.record === 'function'
+          ? window.rrwebRecord.record
+          : null;
+      }
+
+      function loadRecorder() {
+        if (recorderLoad) return recorderLoad;
+        recorderLoad = new Promise(function(resolve, reject) {
+          var script = document.createElement('script');
+          script.src = ${scriptUrl};
+          script.integrity = ${integrity};
+          script.crossOrigin = 'anonymous';
+          script.referrerPolicy = 'no-referrer';
+          script.async = true;
+          script.onload = function() {
+            var record = getRecord();
+            if (record) resolve(record);
+            else reject(new Error('rrweb recorder did not initialize'));
+          };
+          script.onerror = function() {
+            recorderLoad = null;
+            reject(new Error('rrweb recorder failed to load'));
+          };
+          document.head.appendChild(script);
+        });
+        return recorderLoad;
+      }
+
+      function validOptions(options) {
+        return !!options &&
+          typeof options === 'object' &&
+          typeof options.blockSelector === 'string' &&
+          typeof options.ignoreSelector === 'string' &&
+          typeof options.maskTextSelector === 'string' &&
+          typeof options.maskAllInputs === 'boolean' &&
+          typeof options.recordCanvas === 'boolean' &&
+          typeof options.collectFonts === 'boolean' &&
+          typeof options.inlineImages === 'boolean' &&
+          !!options.sampling && typeof options.sampling === 'object';
+      }
+
+      function startRecorder(options) {
+        if (!validOptions(options)) return;
+        stopRecorder();
+        var generation = startGeneration;
+        loadRecorder().then(function(record) {
+          if (generation !== startGeneration) return;
+          recorderStop = record({
+            blockSelector: options.blockSelector,
+            ignoreSelector: options.ignoreSelector,
+            maskTextClass: options.maskTextClass,
+            maskTextSelector: options.maskTextSelector,
+            maskAllInputs: options.maskAllInputs,
+            maskInputOptions: options.maskInputOptions,
+            recordCanvas: options.recordCanvas,
+            collectFonts: options.collectFonts,
+            inlineImages: options.inlineImages,
+            sampling: options.sampling,
+            recordCrossOriginIframes: true
+          }) || null;
+        }).catch(function() {});
+      }
+
+      window.addEventListener('message', function(event) {
+        if (event.source !== window.parent || !isTrustedParentOrigin(event.origin, window.location.href)) return;
+        var message = event.data;
+        if (!message || typeof message !== 'object') return;
+        if (message.type === ${startType}) startRecorder(message.options);
+        else if (message.type === ${stopType}) stopRecorder();
+      });
+      window.addEventListener('pagehide', stopRecorder);
+
+      if (window.parent !== window) {
+        window.parent.postMessage({ type: ${probeType} }, '*');
+      }
+    })();
+  </script>`;
+}
+
+export function injectSessionReplayIframeBootstrap(html: string): string {
+  const bootstrap = buildSessionReplayIframeBootstrap();
+  const headClose = html.search(/<\/head\s*>/i);
+  if (headClose >= 0) {
+    return `${html.slice(0, headClose)}${bootstrap}${html.slice(headClose)}`;
+  }
+  const bodyOpen = html.search(/<body(?:\s[^>]*)?>/i);
+  if (bodyOpen >= 0) {
+    return `${html.slice(0, bodyOpen)}${bootstrap}${html.slice(bodyOpen)}`;
+  }
+  return `${bootstrap}${html}`;
+}

package/corpus/core/src/scripts/agent-engines/list-agent-engines.ts

@@ -15,8 +15,6 @@ import {
   normalizeModelForEngine,
 } from "../../agent/engine/index.js";
 import type { ActionTool } from "../../agent/types.js";
-import { resolveHostedDefaultModelExperiment } from "../../observability/hosted-model-experiment.js";
-import { getRequestUserEmail } from "../../server/request-context.js";
 import { getSetting } from "../../settings/index.js";
 
 export const tool: ActionTool = {
@@ -84,24 +82,13 @@ export async function run(args: Record<string, string> = {}): Promise<string> {
         ? current?.model
         : undefined;
   const currentEngineName = currentEntry?.name ?? "anthropic";
-  let currentModel =
+  const currentModel =
     currentEntry && !envUnavailable
       ? normalizeModelForEngine(
           currentEntry,
           currentModelCandidate ?? currentEntry.defaultModel,
         )
       : (currentModelCandidate ?? DEFAULT_MODEL);
-  const hostedExperiment =
-    currentEntry && !currentModelCandidate
-      ? resolveHostedDefaultModelExperiment({
-          userId: getRequestUserEmail(),
-          engineName: currentEntry.name,
-          isDefaultModelSelection: true,
-          supportedModels: currentEntry.supportedModels,
-        })
-      : null;
-  if (hostedExperiment) currentModel = hostedExperiment.model;
-
   const result = {
     engines: engines.map((e) => ({
       name: e.name,
@@ -119,12 +106,6 @@ export async function run(args: Record<string, string> = {}): Promise<string> {
       : {
           engine: currentEngineName,
           model: currentModel,
-          ...(hostedExperiment
-            ? {
-                modelSelectionSource: "experiment",
-                experimentAssignment: hostedExperiment.assignment,
-              }
-            : {}),
         },
   };
 

package/corpus/core/src/session-replay-iframe-protocol.ts

@@ -0,0 +1,58 @@
+export const SESSION_REPLAY_IFRAME_ATTRIBUTE =
+  "data-agent-native-session-replay";
+export const SESSION_REPLAY_IFRAME_PROBE = "agent-native-session-replay:probe";
+export const SESSION_REPLAY_IFRAME_START = "agent-native-session-replay:start";
+export const SESSION_REPLAY_IFRAME_STOP = "agent-native-session-replay:stop";
+
+export interface SessionReplayIframePrivacyOptions {
+  blockSelector: string;
+  ignoreSelector: string;
+  maskTextClass?: string | RegExp;
+  maskTextSelector: string;
+  maskAllInputs: boolean;
+  maskInputOptions?: Record<string, boolean>;
+  recordCanvas: boolean;
+  collectFonts: boolean;
+  inlineImages: boolean;
+  sampling: Record<string, unknown>;
+}
+
+export interface SessionReplayIframeProbeMessage {
+  type: typeof SESSION_REPLAY_IFRAME_PROBE;
+}
+
+export interface SessionReplayIframeStartMessage {
+  type: typeof SESSION_REPLAY_IFRAME_START;
+  options: SessionReplayIframePrivacyOptions;
+}
+
+export interface SessionReplayIframeStopMessage {
+  type: typeof SESSION_REPLAY_IFRAME_STOP;
+}
+
+export type SessionReplayIframeMessage =
+  | SessionReplayIframeProbeMessage
+  | SessionReplayIframeStartMessage
+  | SessionReplayIframeStopMessage;
+
+/**
+ * `srcdoc` HTML came from the immediate parent, so that parent already owns the
+ * document being rendered. Server-rendered extension URLs are stricter: only a
+ * parent on the render URL's origin may activate recording. That supports
+ * custom app domains without allowing an external embed host to make an opaque
+ * extension frame disclose its DOM through rrweb's postMessage transport.
+ */
+export function isTrustedSessionReplayIframeParentOrigin(
+  parentOrigin: string,
+  frameHref: string,
+): boolean {
+  if (frameHref === "about:srcdoc") {
+    return parentOrigin !== "null" && parentOrigin !== "";
+  }
+  try {
+    const frameOrigin = new URL(frameHref).origin;
+    return frameOrigin !== "null" && parentOrigin === frameOrigin;
+  } catch {
+    return false;
+  }
+}

package/corpus/core/src/shared/reasoning-effort.ts

@@ -170,6 +170,41 @@ function isClaudeReasoningModel(model: string) {
   return opusMatch ? parseInt(opusMatch[1], 10) >= 6 : false;
 }
 
+/**
+ * Anthropic's adaptive-thinking API is only available on the newer Claude
+ * model families. Claude Haiku 4.5 is reasoning-capable, but it still
+ * requires the legacy manual `budget_tokens` configuration.
+ */
+export function supportsClaudeAdaptiveThinking(model: string | undefined) {
+  if (!model) return false;
+  const id = model.toLowerCase().replace(/^anthropic\//, "");
+  if (id.includes("fable-5") || id.includes("mythos-5")) return true;
+  if (id.includes("sonnet-5") || id.includes("sonnet-4-6")) return true;
+  const opusMatch = id.match(/opus-4[-.](\d+)/);
+  return opusMatch ? parseInt(opusMatch[1], 10) >= 6 : false;
+}
+
+/**
+ * Map the shared reasoning ladder to Anthropic's manual thinking budgets for
+ * models that do not support adaptive thinking (currently Claude Haiku 4.5).
+ */
+export function anthropicManualThinkingBudget(effort: ReasoningEffort) {
+  switch (effort) {
+    case "low":
+      return 1_024;
+    case "medium":
+      return 4_096;
+    case "high":
+      return 8_000;
+    case "xhigh":
+      return 16_000;
+    case "max":
+      return 32_000;
+    default:
+      return 4_096;
+  }
+}
+
 function supportsClaudeXHigh(model: string) {
   const id = model.toLowerCase().replace(/^anthropic\//, "");
   // Models that support the xhigh effort tier (built-in extended thinking via

package/corpus/core/src/styles/agent-conversation.css

@@ -493,6 +493,32 @@
   -webkit-mask-image: linear-gradient(to bottom, transparent, black 1.5rem);
 }
 
+.agent-chat-collapse {
+  display: grid;
+  grid-template-rows: 1fr;
+  opacity: 1;
+  transition:
+    grid-template-rows 200ms var(--ease-collapse),
+    opacity 150ms ease-out;
+}
+
+.agent-chat-collapse[data-state="closed"] {
+  grid-template-rows: 0fr;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.agent-chat-collapse__content {
+  min-height: 0;
+  overflow: hidden;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .agent-chat-collapse {
+    transition-duration: 0.01ms;
+  }
+}
+
 /* ─── Agent-Markdown (AssistantChat react-markdown render surface) ─────────── */
 /* These classes are applied by the SmoothMarkdownText/MarkdownText components  */
 /* in the AssistantChat/AssistantChatInner tree. The shiki dual-theme rules      */

package/corpus/core/src/templates/workspace-core/.agents/skills/observability/SKILL.md

@@ -158,21 +158,6 @@ The agent loop reads active experiments via `resolveActiveExperimentConfig()` an
 
 Compute results with `POST /_agent-native/observability/experiments/:id/results`.
 
-#### First-party hosted default-model rollout
-
-First-party apps on `agent-native.com` automatically run the July 2026
-default-model experiment for authenticated users on the Builder engine:
-
-- 80% `claude-sonnet-5`
-- 20% `gpt-5-6-luna`
-- Assignment is sticky by normalized user email and shared across templates.
-- The rollout applies only when the user, app, and deployment have not selected
-  a model. Explicit model choices and BYO provider engines always win.
-- Set `AGENT_NATIVE_HOSTED_MODEL_EXPERIMENT=off` for an emergency rollback, or
-  `true` to exercise the rollout on a non-first-party preview.
-- `$ai_generation` tracking includes `experiment_id`,
-  `experiment_variant`, and `model_selection_source` for central analysis.
-
 In production, experiment management routes require the caller's email in the
 comma-separated `AGENT_NATIVE_EXPERIMENT_ADMIN_EMAILS` allowlist. This gate is
 separate from normal app/org admin roles because an experiment affects every

package/corpus/templates/analytics/.agents/skills/session-replay/SKILL.md

@@ -125,23 +125,29 @@ agent answers about browser recordings in the Analytics template.
   historical replays and resolve external imports/fonts at capture before
   blocking the recorded resource origins. Do not diagnose current font loss as
   CSP without checking the deployed response headers first.
-- Let rrweb own normal iframe sizing via Meta / ViewportResize, and keep the
-  outer wrapper in that same coordinate system for fit-to-stage scaling. Some
-  legacy recordings contain demonstrably corrupt 4,000–7,500px-wide viewport
-  values from ordinary desktop sessions. Only widths of at least 4,000px with
-  aspect ratios above 4:1 are recovered to a 16:10 viewport; real 32:9 and
-  mobile portrait captures remain untouched. The resize handler applies the
-  recovery to **both** rrweb's iframe and the outer stage. This includes the
-  historical 3,000–3,999px-wide, sub-1,000px-high malformed shape; do not
-  narrow the guard back to only 4,000px+ recordings.
-  Never remove this recovery, clamp only one layer, or broadly rewrite event
-  geometry: those changes repeatedly recreated the ribbon/clipping regression.
-- The malformed-viewport recovery's sole event-data exception is pointer
-  geometry: project MouseMove, TouchMove, Drag, and MouseInteraction x/y into
-  the corrected camera and clamp impossible coordinates. Correcting the iframe
-  without its paired pointer projection makes rrweb cast valid target ids
-  thousands of pixels off-stage. Normal-viewport pointer events must retain
-  their original object references and exact coordinates.
+- Let rrweb own iframe sizing entirely via Meta / ViewportResize, and keep the
+  outer wrapper on the exact same raw dimensions for fit-to-stage scaling.
+  Player geometry and pointer coordinates are fully stock and untouched — do
+  not add width/aspect-ratio "recovery" heuristics or pointer-coordinate
+  projection. There is no such thing as a stored recording with corrupt
+  viewport geometry: a census of all production recordings found zero stored
+  widths >= 3,000px. The 2026-07 "ultra-wide replay" bugs (stages rendered
+  3,000–9,500px wide, frozen/teleporting cursors, giant icons) were caused
+  entirely by demo mode's fetch interceptor: its number redactor faked any
+  integer >= 1000 inside raw replay JSON at *view* time, corrupting Meta /
+  ViewportResize widths, pointer x/y coordinates, and numeric values inside
+  `_cssText` and SVG attributes before rrweb ever saw the payload (heights
+  below 1000 stayed real, which is why the symptom looked like a viewport
+  problem rather than a redaction bug — two different sessions that both
+  stored a 1,152px width read back as the same 4,491px, a deterministic
+  salted-hash fingerprint of the redactor, not two coincidentally identical
+  malformed recordings). This is fixed in
+  `packages/core/src/demo/fetch-interceptor.ts`: raw replay payload and
+  manifest URLs are skipped from demo number redaction entirely, and must
+  never be routed through it again. Do not reintroduce viewport clamping or
+  pointer-coordinate projection in the player — they can now only corrupt
+  genuine future recordings (for example, a real 3440x900 ultrawide browser
+  window, or a short vertical window under 1,000px tall).
 - Keep rrweb's stock cursor stylesheet and its hotspot transform. During
   playback, hide the viewer's native pointer over Analytics' transparent
   click-to-pause overlay so it cannot masquerade as a frozen recorded cursor.
@@ -152,10 +158,13 @@ agent answers about browser recordings in the Analytics template.
   hide generic framework primitives such as
   `[data-radix-popper-content-wrapper]`: Radix dropdowns, selects, tooltips,
   and other real recorded product UI all share that wrapper.
-- Keep the realistic fidelity and malformed-viewport tests in
-  `SessionDetailPage.spec.ts`. Do not change their expectations merely to bless
-  a new sanitizer or raw ultra-wide sizing; validate the affected replay in a
-  browser first.
+- Keep the realistic-fidelity purity/pass-through tests in
+  `SessionDetailPage.spec.ts` — raw event identity, raw viewport dimensions,
+  and raw resize-state derivation (including the 3,189x885 tripwire against
+  reintroducing a clamp) — as regression guards against reintroducing any
+  viewport "recovery" or pointer-projection heuristic. Do not change their
+  expectations merely to bless a new sanitizer or clamp; validate the affected
+  replay in a browser first.
 - The event timeline soft-highlights the active marker, auto-scrolls it into
   view (pausing briefly after manual scroll), and supports search. It appears
   beside the player from ~880px content width upward.