@agent-native/core 0.97.0 → 0.98.1

package/corpus/templates/analytics/server/lib/dashboards-store.ts

@@ -1,3 +1,18 @@
+/**
+ * Dashboards + analyses store — SQL first, legacy settings-KV as
+ * read-only fallback. Writes always go to SQL.
+ *
+ * Lazy migration: when a record is fetched by id and exists only in the
+ * legacy settings store, it is copied into SQL on the fly using the
+ * settings key as the source of truth for `ownerEmail` / `orgId` /
+ * `visibility`, then returned. Subsequent reads hit SQL directly.
+ *
+ * - `u:<email>:dashboard-{id}`     → kind='explorer', owner=email,  visibility='private'
+ * - `u:<email>:sql-dashboard-{id}` → kind='sql',      owner=email,  visibility='private'
+ * - `o:<orgId>:sql-dashboard-{id}` → kind='sql',      owner=caller, visibility='org'
+ * - `adhoc-analysis-{id}`          → owner=caller,   legacy visibility from its source key
+ */
+import { isPostgres } from "@agent-native/core/db";
 import { recordChange } from "@agent-native/core/server";
 import {
   getAllSettings,
@@ -13,21 +28,7 @@ import {
   resolveAccess,
   type ShareRole,
 } from "@agent-native/core/sharing";
-/**
- * Dashboards + analyses store — SQL first, legacy settings-KV as
- * read-only fallback. Writes always go to SQL.
- *
- * Lazy migration: when a record is fetched by id and exists only in the
- * legacy settings store, it is copied into SQL on the fly using the
- * settings key as the source of truth for `ownerEmail` / `orgId` /
- * `visibility`, then returned. Subsequent reads hit SQL directly.
- *
- * - `u:<email>:dashboard-{id}`     → kind='explorer', owner=email,  visibility='private'
- * - `u:<email>:sql-dashboard-{id}` → kind='sql',      owner=email,  visibility='private'
- * - `o:<orgId>:sql-dashboard-{id}` → kind='sql',      owner=caller, visibility='org'
- * - `adhoc-analysis-{id}`          → owner=caller,   legacy visibility from its source key
- */
-import { and, desc, eq, isNotNull, isNull } from "drizzle-orm";
+import { and, desc, eq, isNotNull, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../db/index.js";
 
@@ -56,6 +57,22 @@ export interface DashboardRecord {
   canManage?: boolean;
 }
 
+/** Metadata-only dashboard row for navigation and picker surfaces. */
+export interface DashboardSummaryRecord {
+  id: string;
+  kind: DashboardKind;
+  name: string;
+  parentId: string | null;
+  ownerEmail: string;
+  orgId: string | null;
+  visibility: "private" | "org" | "public";
+  createdAt: string;
+  updatedAt: string;
+  archivedAt: string | null;
+  hiddenAt: string | null;
+  hiddenBy: string | null;
+}
+
 export interface DashboardRevisionRecord {
   id: string;
   dashboardId: string;
@@ -168,6 +185,19 @@ export class DashboardConflictError extends Error {
   }
 }
 
+/**
+ * Thrown when a fenced `upsertAnalysis` write (an `expectedUpdatedAt` was
+ * supplied) loses its compare-and-swap because another writer changed the
+ * row first. Callers should re-read the analysis and re-apply their mutation
+ * against the fresh record — see `upsertAnalysisWithRetry`.
+ */
+export class AnalysisConflictError extends Error {
+  constructor(id: string) {
+    super(`Analysis "${id}" changed between read and write.`);
+    this.name = "AnalysisConflictError";
+  }
+}
+
 function changeScope(
   ownerEmail: string,
   orgId: string | null,
@@ -465,6 +495,125 @@ export async function listDashboards(
   return out;
 }
 
+/**
+ * List dashboard metadata without transferring or parsing each dashboard's
+ * potentially very large panel config. This is the list-path counterpart to
+ * `getDashboard`, which remains the full-config detail read.
+ *
+ * Legacy settings rows are surfaced directly instead of being migrated during
+ * the read. Opening one by id still performs the existing lazy migration, but
+ * navigation no longer turns an ordinary list into N sequential writes.
+ */
+export async function listDashboardSummaries(
+  ctx: AccessCtx,
+  filter?: {
+    kind?: DashboardKind;
+    archived?: DashboardArchiveFilter;
+    hidden?: DashboardHiddenFilter;
+  },
+): Promise<DashboardSummaryRecord[]> {
+  const db = getDb() as any;
+  const archived = filter?.archived ?? "active";
+  const hidden = filter?.hidden ?? "visible";
+  const conditions: any[] = [
+    accessFilter(schema.dashboards, schema.dashboardShares, {
+      userEmail: ctx.email,
+      orgId: ctx.orgId ?? undefined,
+    }),
+  ];
+  if (filter?.kind) conditions.push(eq(schema.dashboards.kind, filter.kind));
+  if (archived === "active")
+    conditions.push(isNull(schema.dashboards.archivedAt));
+  else if (archived === "archived")
+    conditions.push(isNotNull(schema.dashboards.archivedAt));
+  if (hidden === "visible") conditions.push(isNull(schema.dashboards.hiddenAt));
+  else if (hidden === "hidden")
+    conditions.push(isNotNull(schema.dashboards.hiddenAt));
+  const where = conditions.length === 1 ? conditions[0] : and(...conditions);
+  const parentId = isPostgres()
+    ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'parentId')`
+    : sql<
+        string | null
+      >`json_extract(${schema.dashboards.config}, '$.parentId')`;
+  const rows = await db
+    .select({
+      id: schema.dashboards.id,
+      kind: schema.dashboards.kind,
+      name: schema.dashboards.title,
+      parentId,
+      ownerEmail: schema.dashboards.ownerEmail,
+      orgId: schema.dashboards.orgId,
+      visibility: schema.dashboards.visibility,
+      createdAt: schema.dashboards.createdAt,
+      updatedAt: schema.dashboards.updatedAt,
+      archivedAt: schema.dashboards.archivedAt,
+      hiddenAt: schema.dashboards.hiddenAt,
+      hiddenBy: schema.dashboards.hiddenBy,
+    })
+    .from(schema.dashboards)
+    .where(where);
+  const out: DashboardSummaryRecord[] = rows.map((row: any) => ({
+    ...row,
+    parentId: typeof row.parentId === "string" ? row.parentId : null,
+    orgId: row.orgId ?? null,
+    archivedAt: row.archivedAt ?? null,
+    hiddenAt: row.hiddenAt ?? null,
+    hiddenBy: row.hiddenBy ?? null,
+  }));
+  const seen = new Set(out.map((row) => row.id));
+
+  if (archived === "archived" || hidden === "hidden") return out;
+  try {
+    const all = await getAllSettings();
+    for (const [key, value] of Object.entries(all)) {
+      let id: string | null = null;
+      let kind: DashboardKind | null = null;
+      let orgId: string | null = null;
+      let visibility: DashboardSummaryRecord["visibility"] = "private";
+      if (ctx.orgId && key.startsWith(`o:${ctx.orgId}:${SQL_PREFIX}`)) {
+        id = key.slice(`o:${ctx.orgId}:${SQL_PREFIX}`.length);
+        kind = "sql";
+        orgId = ctx.orgId;
+        visibility = "org";
+      } else if (ctx.email && key.startsWith(`u:${ctx.email}:${SQL_PREFIX}`)) {
+        id = key.slice(`u:${ctx.email}:${SQL_PREFIX}`.length);
+        kind = "sql";
+      } else if (
+        ctx.email &&
+        key.startsWith(`u:${ctx.email}:${EXPLORER_PREFIX}`)
+      ) {
+        id = key.slice(`u:${ctx.email}:${EXPLORER_PREFIX}`.length);
+        kind = "explorer";
+      }
+      if (!id || !kind || seen.has(id)) continue;
+      if (filter?.kind && filter.kind !== kind) continue;
+      seen.add(id);
+      const config = value as Record<string, unknown>;
+      const { title } = configFromSettings(config);
+      const createdAt =
+        typeof config.createdAt === "string" ? config.createdAt : nowIso();
+      out.push({
+        id,
+        kind,
+        name: title,
+        parentId: typeof config.parentId === "string" ? config.parentId : null,
+        ownerEmail: ctx.email,
+        orgId,
+        visibility,
+        createdAt,
+        updatedAt:
+          typeof config.updatedAt === "string" ? config.updatedAt : createdAt,
+        archivedAt: null,
+        hiddenAt: null,
+        hiddenBy: null,
+      });
+    }
+  } catch {
+    // Legacy scan is best-effort.
+  }
+  return out;
+}
+
 async function pruneDashboardRevisions(
   db: any,
   dashboardId: string,
@@ -1247,6 +1396,21 @@ async function snapshotAnalysisRevision(
   await pruneAnalysisRevisions(db, analysis.id);
 }
 
+/**
+ * Upsert an analysis. On create, caller becomes owner and visibility defaults
+ * to `private`. On update, `assertAccess` requires `editor`.
+ *
+ * `expectedUpdatedAt` fences the update against concurrent writers: pass the
+ * `updatedAt` observed by an earlier `getAnalysis` call and the UPDATE only
+ * applies `WHERE id = ? AND updated_at = ?`. If another writer already saved
+ * in between, the fenced UPDATE affects zero rows and this throws
+ * `AnalysisConflictError` instead of silently clobbering their write. Omit it
+ * (the default) to keep the prior unconditional last-write-wins behavior,
+ * which existing callers (legacy migration, revision restore, and
+ * `save-analysis`'s create/re-run path) still rely on. See
+ * `upsertAnalysisWithRetry` for the read-modify-write pattern that recomputes
+ * the patch from fresh state on a lost race.
+ */
 export async function upsertAnalysis(
   id: string,
   body: {
@@ -1259,8 +1423,17 @@ export async function upsertAnalysis(
     resultData?: Record<string, unknown> | null;
   },
   ctx: AccessCtx,
+  expectedUpdatedAt?: string,
 ): Promise<AnalysisRecord> {
   const existing = await getAnalysis(id, ctx);
+  if (!existing && expectedUpdatedAt !== undefined) {
+    // A fence was supplied against a specific prior version, but the row is
+    // gone (deleted, or a legacy key that failed to migrate) by the time we
+    // looked. Treat this as a conflict rather than silently creating a fresh
+    // row — the caller's mutation was computed against state that no longer
+    // exists.
+    throw new AnalysisConflictError(id);
+  }
   const db = getDb() as any;
   if (existing) {
     await assertAccess("analysis", id, "editor", {
@@ -1305,11 +1478,36 @@ export async function upsertAnalysis(
         JSON.stringify(existing.dataSources) ||
       next.resultMarkdown !== existing.resultMarkdown ||
       JSON.stringify(next.resultData) !== JSON.stringify(existing.resultData);
-    if (changed) await snapshotAnalysisRevision(db, existing, ctx);
-    await db
-      .update(schema.analyses)
-      .set(patch)
-      .where(eq(schema.analyses.id, id));
+    if (expectedUpdatedAt !== undefined) {
+      // Fenced write. Snapshot the revision only after we know this exact
+      // write actually landed — otherwise a lost race would record a
+      // revision for a save that never happened.
+      const updateResult = await db
+        .update(schema.analyses)
+        .set(patch)
+        .where(
+          and(
+            eq(schema.analyses.id, id),
+            eq(schema.analyses.updatedAt, expectedUpdatedAt),
+          ),
+        );
+      const affected = affectedRowCount(updateResult);
+      if (affected === undefined) {
+        throw new Error(
+          "The database driver did not report an affected-row count for the fenced analysis update.",
+        );
+      }
+      if (affected === 0) {
+        throw new AnalysisConflictError(id);
+      }
+      if (changed) await snapshotAnalysisRevision(db, existing, ctx);
+    } else {
+      if (changed) await snapshotAnalysisRevision(db, existing, ctx);
+      await db
+        .update(schema.analyses)
+        .set(patch)
+        .where(eq(schema.analyses.id, id));
+    }
   } else {
     await db.insert(schema.analyses).values({
       id,
@@ -1337,6 +1535,77 @@ export async function upsertAnalysis(
   return rowToAnalysis(row);
 }
 
+/** Max attempts (first try + retries) for `upsertAnalysisWithRetry`. */
+export const ANALYSIS_SAVE_MAX_ATTEMPTS = 3;
+
+/**
+ * Read-modify-write helper for action call sites that fetch an analysis,
+ * mutate its fields in memory, then save it back. Fences every save with the
+ * `updatedAt` of the record `mutate` was given, so a concurrent writer (e.g.
+ * `save-analysis` re-running with fresh results while someone renames it)
+ * never gets silently clobbered.
+ *
+ * `mutate` is invoked with the freshest `AnalysisRecord` on every attempt —
+ * re-fetched from `getAnalysis` each time — and must recompute the body patch
+ * to save FROM THAT RECORD, not from a closure over an earlier read; only
+ * then does a retry actually merge both writers' changes instead of
+ * re-deriving the same stale result. `mutate` may throw a non-conflict error
+ * (e.g. validation) to abort immediately without retrying.
+ *
+ * On a lost race, this re-reads and re-invokes `mutate` up to `maxAttempts`
+ * times before failing loud with a clear error so callers never silently
+ * drop a write or loop forever.
+ */
+export async function upsertAnalysisWithRetry(
+  id: string,
+  ctx: AccessCtx,
+  mutate: (existing: AnalysisRecord) =>
+    | {
+        name?: string;
+        description?: string;
+        question?: string;
+        instructions?: string;
+        dataSources?: string[];
+        resultMarkdown?: string;
+        resultData?: Record<string, unknown> | null;
+      }
+    | Promise<{
+        name?: string;
+        description?: string;
+        question?: string;
+        instructions?: string;
+        dataSources?: string[];
+        resultMarkdown?: string;
+        resultData?: Record<string, unknown> | null;
+      }>,
+  maxAttempts: number = ANALYSIS_SAVE_MAX_ATTEMPTS,
+): Promise<AnalysisRecord> {
+  let lastConflict: unknown;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const existing = await getAnalysis(id, ctx);
+    if (!existing) {
+      throw new Error(`analysis "${id}" not found (or you don't have access).`);
+    }
+    const body = await mutate(existing);
+    try {
+      return await upsertAnalysis(id, body, ctx, existing.updatedAt);
+    } catch (err) {
+      if (err instanceof AnalysisConflictError) {
+        lastConflict = err;
+        continue;
+      }
+      throw err;
+    }
+  }
+  const finalError = new Error(
+    `Could not save analysis "${id}" after ${maxAttempts} attempt(s); it kept changing concurrently. Re-read the analysis and try again.`,
+  );
+  if (lastConflict !== undefined) {
+    (finalError as Error & { cause?: unknown }).cause = lastConflict;
+  }
+  throw finalError;
+}
+
 export async function listAnalysisRevisions(
   analysisId: string,
   ctx: AccessCtx,

package/corpus/templates/analytics/server/lib/data-dictionary-context.ts

@@ -1,6 +1,11 @@
 type DictionaryEntry = Record<string, unknown>;
 
 const MAX_INJECTED_ENTRIES = 40;
+// Per-field caps above bound a single entry to ~3-3.5K chars, so 40 entries
+// could still swell to ~130K chars riding every chat request even though the
+// entry count is capped. Bound the whole rendered block too, and truncate at
+// entry boundaries (never mid-entry) once it's hit.
+const MAX_DICTIONARY_CONTEXT_CHARS = 10_000;
 
 function compact(value: unknown, max = 240): string {
   const text = String(value ?? "")
@@ -97,6 +102,76 @@ function renderOmittedDictionaryEntries(omitted: number): string[] {
   ];
 }
 
+function renderedTextLength(lines: string[]): number {
+  // +1 per line approximates the join("\n") separators without materializing
+  // the joined string on every entry (entry counts are small, so this stays
+  // cheap even though it's O(n) per call).
+  return lines.reduce((total, line) => total + line.length + 1, 0);
+}
+
+type TrustLabel = "approved/canonical" | "unreviewed/human" | "ai-suggestion";
+
+/**
+ * Render one trust-tier group into `lines`, respecting both the per-tier
+ * count budget already applied by `takeWithinBudget` and the shared total
+ * character budget tracked in `state`. Entries are never split mid-render:
+ * once adding the next whole entry would exceed the char budget, rendering
+ * stops at that entry boundary and everything remaining (in this group and
+ * any group processed after it) is counted as omitted.
+ */
+function renderGroupWithinBudget(
+  lines: string[],
+  title: string,
+  groupEntries: DictionaryEntry[],
+  trustLabel: TrustLabel,
+  renderedCount: number,
+  state: { charBudgetExceeded: boolean; anyEntryRendered: boolean },
+): { renderedCount: number; omitted: number } {
+  if (!groupEntries.length) return { renderedCount, omitted: 0 };
+
+  const budgeted = takeWithinBudget(groupEntries, renderedCount);
+  let omitted = budgeted.omitted;
+  const bodyLines: string[] = [];
+  let includedFromGroup = 0;
+
+  for (const entry of budgeted.entries) {
+    if (state.charBudgetExceeded) {
+      omitted += 1;
+      continue;
+    }
+
+    const entryLines = renderEntry(entry, trustLabel);
+    const headerAddition = includedFromGroup === 0 ? title.length + 1 : 0;
+    const prospectiveTotal =
+      renderedTextLength(lines) +
+      headerAddition +
+      renderedTextLength(bodyLines) +
+      renderedTextLength(entryLines);
+
+    // Always keep at least one entry across the whole dictionary render so a
+    // single oversized entry can't produce an empty block; every entry after
+    // that respects the char budget at its boundary.
+    if (
+      prospectiveTotal > MAX_DICTIONARY_CONTEXT_CHARS &&
+      state.anyEntryRendered
+    ) {
+      state.charBudgetExceeded = true;
+      omitted += 1;
+      continue;
+    }
+
+    bodyLines.push(...entryLines);
+    includedFromGroup += 1;
+    state.anyEntryRendered = true;
+  }
+
+  if (includedFromGroup > 0) {
+    lines.push(title, ...bodyLines, "");
+  }
+
+  return { renderedCount: budgeted.renderedCount, omitted };
+}
+
 /**
  * Render data-dictionary entries as compact prompt context.
  *
@@ -127,6 +202,7 @@ export function renderDataDictionary(entries: DictionaryEntry[]): string {
   const includeAiSuggestions = approved.length + humanUnreviewed.length === 0;
   let renderedCount = 0;
   let omittedEntries = 0;
+  const budgetState = { charBudgetExceeded: false, anyEntryRendered: false };
 
   const lines: string[] = [
     "<data-dictionary>",
@@ -136,43 +212,39 @@ export function renderDataDictionary(entries: DictionaryEntry[]): string {
     "",
   ];
 
-  if (approved.length) {
-    const budgeted = takeWithinBudget(approved, renderedCount);
-    renderedCount = budgeted.renderedCount;
-    omittedEntries += budgeted.omitted;
-    if (budgeted.entries.length) {
-      lines.push("## Approved canonical entries");
-      for (const entry of budgeted.entries) {
-        lines.push(...renderEntry(entry, "approved/canonical"));
-      }
-      lines.push("");
-    }
-  }
+  const approvedResult = renderGroupWithinBudget(
+    lines,
+    "## Approved canonical entries",
+    approved,
+    "approved/canonical",
+    renderedCount,
+    budgetState,
+  );
+  renderedCount = approvedResult.renderedCount;
+  omittedEntries += approvedResult.omitted;
 
-  if (humanUnreviewed.length) {
-    const budgeted = takeWithinBudget(humanUnreviewed, renderedCount);
-    renderedCount = budgeted.renderedCount;
-    omittedEntries += budgeted.omitted;
-    if (budgeted.entries.length) {
-      lines.push("## Unreviewed human-authored entries");
-      for (const entry of budgeted.entries) {
-        lines.push(...renderEntry(entry, "unreviewed/human"));
-      }
-      lines.push("");
-    }
-  }
+  const humanResult = renderGroupWithinBudget(
+    lines,
+    "## Unreviewed human-authored entries",
+    humanUnreviewed,
+    "unreviewed/human",
+    renderedCount,
+    budgetState,
+  );
+  renderedCount = humanResult.renderedCount;
+  omittedEntries += humanResult.omitted;
 
   if (includeAiSuggestions && aiSuggestions.length) {
-    const budgeted = takeWithinBudget(aiSuggestions, renderedCount);
-    renderedCount = budgeted.renderedCount;
-    omittedEntries += budgeted.omitted;
-    if (budgeted.entries.length) {
-      lines.push("## AI-generated suggestions");
-      for (const entry of budgeted.entries) {
-        lines.push(...renderEntry(entry, "ai-suggestion"));
-      }
-      lines.push("");
-    }
+    const aiResult = renderGroupWithinBudget(
+      lines,
+      "## AI-generated suggestions",
+      aiSuggestions,
+      "ai-suggestion",
+      renderedCount,
+      budgetState,
+    );
+    renderedCount = aiResult.renderedCount;
+    omittedEntries += aiResult.omitted;
   } else if (aiSuggestions.length) {
     lines.push(
       `${aiSuggestions.length} AI-generated unapproved suggestion${

package/corpus/templates/analytics/server/lib/demo-dashboards.ts

@@ -104,6 +104,15 @@ function publicState(state: DemoDashboardState): Record<string, unknown> {
   };
 }
 
+function stateContent(state: DemoDashboardState): string {
+  return JSON.stringify({
+    version: state.version,
+    initializedAt: state.initializedAt,
+    dashboards: state.dashboards ?? {},
+    deleted: state.deleted ?? {},
+  });
+}
+
 export function demoDashboardIdForUser(
   email: string,
   demoId: DemoDashboardId,
@@ -265,7 +274,10 @@ export async function ensureDemoDashboardsForUser(
         throw new Error(`Demo dashboard seed not found: ${demo.seedId}`);
       const config = applyDemoMetadata(seed, demo.id);
       const row = await upsertDashboard(dashboardId, "sql", config, privateCtx);
-      await syncToCollab(dashboardId, config);
+      // SQL is the source of truth and collab state can seed lazily. Do not
+      // hold first-open installation (and the whole app shell) behind a remote
+      // collab read/write that may be slow or temporarily unavailable.
+      void syncToCollab(dashboardId, config);
       archivedAt = row.archivedAt;
       created = !existing;
     }
@@ -288,14 +300,18 @@ export async function ensureDemoDashboardsForUser(
     });
   }
 
-  const updatedState: DemoDashboardState = {
+  const updatedStateContent: DemoDashboardState = {
     version: DEMO_DASHBOARD_VERSION,
     initializedAt: state.initializedAt ?? nowIso(),
-    updatedAt: nowIso(),
     dashboards,
     deleted,
   };
-  await writeDemoState(ctx.email, updatedState);
+  if (reset || stateContent(state) !== stateContent(updatedStateContent)) {
+    await writeDemoState(ctx.email, {
+      ...updatedStateContent,
+      updatedAt: nowIso(),
+    });
+  }
 
   const firstActive = results.find((row) => row.installed && !row.archivedAt);
   return {

package/corpus/templates/analytics/server/lib/session-replay-agent-context.ts

@@ -50,6 +50,7 @@ const MOUSE_INTERACTION = {
   DblClick: 4,
   Focus: 5,
 } as const;
+const SCROLL_MARKER_BURST_MS = 1_000;
 
 function appBasePath(): string {
   const raw = process.env.VITE_APP_BASE_PATH || process.env.APP_BASE_PATH || "";
@@ -499,6 +500,7 @@ function capReplayTimelineMarkers(
 function buildReplayTimeline(events: AgentReplayEvent[]) {
   const startedAt = replayStartedAt(events);
   const markers: ReplayTimelineMarker[] = [];
+  const lastScrollByTarget = new Map<string, number>();
 
   for (const event of events) {
     const timestamp = Number(event.timestamp ?? 0);
@@ -568,6 +570,15 @@ function buildReplayTimeline(events: AgentReplayEvent[]) {
       event.type === RRWEB_EVENT_TYPE.IncrementalSnapshot &&
       event.data?.source === INCREMENTAL_SOURCE.Scroll
     ) {
+      const target = String(event.data?.id ?? "viewport");
+      const previousTimestamp = lastScrollByTarget.get(target);
+      if (
+        previousTimestamp !== undefined &&
+        timestamp - previousTimestamp <= SCROLL_MARKER_BURST_MS
+      ) {
+        lastScrollByTarget.set(target, timestamp);
+        continue;
+      }
       markers.push({
         timestamp,
         offsetMs: Math.max(0, timestamp - startedAt),
@@ -575,6 +586,7 @@ function buildReplayTimeline(events: AgentReplayEvent[]) {
         label: "Scroll",
         detail: null,
       });
+      lastScrollByTarget.set(target, timestamp);
     } else if (
       event.type === RRWEB_EVENT_TYPE.IncrementalSnapshot &&
       event.data?.source === INCREMENTAL_SOURCE.MouseInteraction &&