@agent-native/core 0.79.20 → 0.79.22

package/corpus/templates/analytics/server/lib/dashboard-report.ts

@@ -38,7 +38,17 @@ const DATE_FILTER_TYPES: ReadonlySet<FilterType> = new Set([
 const DEFAULT_SERVERLESS_CHROMIUM_PACK_URL =
   "https://github.com/Sparticuz/chromium/releases/download/v149.0.0/chromium-v149.0.0-pack.x64.tar";
 const DASHBOARD_REPORT_SCREENSHOT_PARAM = "reportScreenshot";
+const DASHBOARD_REPORT_PANEL_LIMIT_PARAM = "reportPanelLimit";
 const DASHBOARD_REPORT_CID = "dashboard-report-snapshot";
+const COMPACT_REPORT_PANEL_LIMIT = 12;
+const LOCAL_SCREENSHOT_TIMEOUT_MS = 90_000;
+const SERVERLESS_SCREENSHOT_TIMEOUT_MS = 25_000;
+const SERVERLESS_SECOND_READY_TIMEOUT_MS = 10_000;
+
+type DashboardScreenshotAttempt = {
+  label: "full" | "compact";
+  panelLimit?: number;
+};
 
 function daysAgo(n: number): string {
   const d = new Date();
@@ -104,7 +114,7 @@ function dashboardBaseUrl(): string {
 function buildDashboardPath(
   dashboardId: string,
   filters: Record<string, string>,
-  options?: { reportScreenshot?: boolean },
+  options?: { reportScreenshot?: boolean; panelLimit?: number },
 ): string {
   const url = new URL(
     `/dashboards/${encodeURIComponent(dashboardId)}`,
@@ -116,13 +126,19 @@ function buildDashboardPath(
   if (options?.reportScreenshot) {
     url.searchParams.set(DASHBOARD_REPORT_SCREENSHOT_PARAM, "1");
   }
+  if (options?.panelLimit && options.panelLimit > 0) {
+    url.searchParams.set(
+      DASHBOARD_REPORT_PANEL_LIMIT_PARAM,
+      String(Math.floor(options.panelLimit)),
+    );
+  }
   return `${url.pathname}${url.search}`;
 }
 
 function buildDashboardUrl(
   dashboardId: string,
   filters: Record<string, string>,
-  options?: { reportScreenshot?: boolean },
+  options?: { reportScreenshot?: boolean; panelLimit?: number },
 ): string {
   const path = buildDashboardPath(dashboardId, filters, options);
   const url = new URL(path, `${dashboardBaseUrl()}/`);
@@ -224,7 +240,16 @@ async function launchScreenshotBrowser() {
   return playwright.launch({ headless: true });
 }
 
-async function waitForDashboardReportReady(page: any): Promise<void> {
+function screenshotTimeoutMs(): number {
+  return isServerlessBrowserRuntime()
+    ? SERVERLESS_SCREENSHOT_TIMEOUT_MS
+    : LOCAL_SCREENSHOT_TIMEOUT_MS;
+}
+
+async function waitForDashboardReportReady(
+  page: any,
+  timeout: number,
+): Promise<void> {
   try {
     await page.waitForFunction(
       `(() => {
@@ -236,7 +261,7 @@ async function waitForDashboardReportReady(page: any): Promise<void> {
         return !root.querySelector("[data-dashboard-report-loading='true']");
       })()`,
       undefined,
-      { timeout: 90_000 },
+      { timeout },
     );
     await page.evaluate(`(async () => {
       await document.fonts?.ready;
@@ -281,12 +306,14 @@ async function scrollDashboardForLazyRendering(page: any): Promise<void> {
 async function captureDashboardPng(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
+  attempt: DashboardScreenshotAttempt,
 ): Promise<Buffer> {
   const targetPath = buildDashboardPath(
     snapshot.dashboardId,
     snapshot.filters,
     {
       reportScreenshot: true,
+      panelLimit: attempt.panelLimit,
     },
   );
   const token = signEmbedSessionToken({
@@ -302,22 +329,28 @@ async function captureDashboardPng(
 
   const browser = await launchScreenshotBrowser();
   try {
+    const timeout = screenshotTimeoutMs();
     const page = await browser.newPage({
       viewport: { width: 1440, height: 1800 },
       deviceScaleFactor: 1,
     });
-    page.setDefaultTimeout(90_000);
+    page.setDefaultTimeout(timeout);
     await page.emulateMedia({ media: "screen" });
     await page.goto(screenshotUrl.toString(), {
       waitUntil: "domcontentloaded",
-      timeout: 90_000,
+      timeout,
     });
 
     const capture = page.locator("[data-dashboard-report-capture]");
-    await capture.waitFor({ state: "visible", timeout: 90_000 });
-    await waitForDashboardReportReady(page);
+    await capture.waitFor({ state: "visible", timeout });
+    await waitForDashboardReportReady(page, timeout);
     await scrollDashboardForLazyRendering(page);
-    await waitForDashboardReportReady(page);
+    await waitForDashboardReportReady(
+      page,
+      isServerlessBrowserRuntime()
+        ? SERVERLESS_SECOND_READY_TIMEOUT_MS
+        : timeout,
+    );
 
     const box = await capture.boundingBox();
     if (box) {
@@ -340,6 +373,42 @@ async function captureDashboardPng(
   }
 }
 
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+async function captureDashboardPngWithFallback(
+  sub: DashboardReportSubscription,
+  snapshot: ReportSnapshot,
+): Promise<{
+  png: Buffer | null;
+  mode: "full" | "compact" | "none";
+  error?: string;
+}> {
+  const attempts: DashboardScreenshotAttempt[] = [
+    { label: "full" },
+    { label: "compact", panelLimit: COMPACT_REPORT_PANEL_LIMIT },
+  ];
+  let lastError: string | undefined;
+
+  for (const attempt of attempts) {
+    try {
+      return {
+        png: await captureDashboardPng(sub, snapshot, attempt),
+        mode: attempt.label,
+      };
+    } catch (err) {
+      lastError = errorMessage(err);
+      console.error(
+        `[dashboard-report] ${attempt.label} screenshot failed for subscription ${sub.id}:`,
+        lastError,
+      );
+    }
+  }
+
+  return { png: null, mode: "none", error: lastError };
+}
+
 function reportDate(snapshot: ReportSnapshot): string {
   return new Date(snapshot.generatedAt).toLocaleDateString("en-US", {
     year: "numeric",
@@ -348,13 +417,23 @@ function reportDate(snapshot: ReportSnapshot): string {
   });
 }
 
-function renderReportEmailHtml(snapshot: ReportSnapshot): string {
+function renderReportEmailHtml(
+  snapshot: ReportSnapshot,
+  options: { screenshotAttached: boolean },
+): string {
   const title = escapeHtml(snapshot.title);
   const dashboardUrl = escapeHtml(snapshot.dashboardUrl);
   const date = escapeHtml(reportDate(snapshot));
   const description = snapshot.description
     ? `<p style="margin:8px 0 18px;color:#525866;font-size:14px;line-height:1.5;">${escapeHtml(snapshot.description)}</p>`
     : "";
+  const screenshotBlock = options.screenshotAttached
+    ? `<a href="${dashboardUrl}" style="display:block;text-decoration:none;">
+      <img src="cid:${DASHBOARD_REPORT_CID}" alt="${title}" width="100%" style="display:block;width:100%;max-width:1280px;height:auto;border:1px solid #e5e7eb;border-radius:8px;" />
+    </a>`
+    : `<div style="margin:18px 0;padding:14px 16px;border:1px solid #e5e7eb;border-radius:8px;background:#f9fafb;color:#374151;font-size:14px;line-height:1.5;">
+      The dashboard image was unavailable for this run. Open the live dashboard to view the latest report.
+    </div>`;
 
   return `<!doctype html>
 <html>
@@ -363,9 +442,7 @@ function renderReportEmailHtml(snapshot: ReportSnapshot): string {
       Here's the report of <a href="${dashboardUrl}" style="color:#2563eb;text-decoration:none;">${title}</a> for ${date}.
     </h3>
     ${description}
-    <a href="${dashboardUrl}" style="display:block;text-decoration:none;">
-      <img src="cid:${DASHBOARD_REPORT_CID}" alt="${title}" width="100%" style="display:block;width:100%;max-width:1280px;height:auto;border:1px solid #e5e7eb;border-radius:8px;" />
-    </a>
+    ${screenshotBlock}
     <p style="margin:18px 0 0;color:#525866;font-size:13px;line-height:1.45;">
       <a href="${dashboardUrl}" style="color:#2563eb;text-decoration:none;">Open dashboard</a>
     </p>
@@ -373,12 +450,19 @@ function renderReportEmailHtml(snapshot: ReportSnapshot): string {
 </html>`;
 }
 
-function renderReportText(snapshot: ReportSnapshot): string {
-  return [
+function renderReportText(
+  snapshot: ReportSnapshot,
+  options: { screenshotAttached: boolean },
+): string {
+  const lines = [
     `Daily dashboard report: ${snapshot.title}`,
     `Date: ${reportDate(snapshot)}`,
     `Open dashboard: ${snapshot.dashboardUrl}`,
-  ].join("\n");
+  ];
+  if (!options.screenshotAttached) {
+    lines.push("Dashboard image unavailable for this run.");
+  }
+  return lines.join("\n");
 }
 
 function reportFilename(title: string): string {
@@ -396,11 +480,14 @@ export async function sendDashboardReportSubscription(
   dashboardUrl: string;
   recipientCount: number;
   screenshotAttached: boolean;
+  screenshotMode: "full" | "compact" | "none";
+  screenshotError?: string;
 }> {
   const snapshot = await collectReportSnapshot(sub);
-  const png = await captureDashboardPng(sub, snapshot);
-  const html = renderReportEmailHtml(snapshot);
-  const text = renderReportText(snapshot);
+  const capture = await captureDashboardPngWithFallback(sub, snapshot);
+  const screenshotAttached = Boolean(capture.png);
+  const html = renderReportEmailHtml(snapshot, { screenshotAttached });
+  const text = renderReportText(snapshot, { screenshotAttached });
   const subject = `Daily dashboard: ${snapshot.title}`;
 
   for (const to of sub.recipients) {
@@ -409,21 +496,25 @@ export async function sendDashboardReportSubscription(
       subject,
       html,
       text,
-      attachments: [
-        {
-          filename: reportFilename(snapshot.title),
-          content: png,
-          contentType: "image/png",
-          contentId: DASHBOARD_REPORT_CID,
-          disposition: "inline",
-        },
-      ],
+      attachments: capture.png
+        ? [
+            {
+              filename: reportFilename(snapshot.title),
+              content: capture.png,
+              contentType: "image/png",
+              contentId: DASHBOARD_REPORT_CID,
+              disposition: "inline",
+            },
+          ]
+        : undefined,
     });
   }
 
   return {
     dashboardUrl: snapshot.dashboardUrl,
     recipientCount: sub.recipients.length,
-    screenshotAttached: true,
+    screenshotAttached,
+    screenshotMode: capture.mode,
+    ...(capture.error ? { screenshotError: capture.error } : {}),
   };
 }

package/corpus/templates/analytics/server/lib/first-party-metric-catalog.ts

@@ -166,7 +166,7 @@ const REPLAY_RECORDING_DATE_SQL = "substr(started_at, 1, 10)";
 const REPLAY_TIME_RANGE_FILTER = dashboardTimeRangeFilter(
   REPLAY_RECORDING_DATE_SQL,
 );
-const REPLAY_RECORDING_FILTER = `chunk_count > 0 AND ${REPLAY_TIME_RANGE_FILTER} AND ${DASHBOARD_EMAIL_FILTER}`;
+const REPLAY_RECORDING_FILTER = `chunk_count > 0 AND event_count > 0 AND user_id LIKE '%@%' AND ${REPLAY_TIME_RANGE_FILTER} AND ${DASHBOARD_EMAIL_FILTER}`;
 const REPLAY_SESSIONS_SQL = `SELECT COUNT(*) AS count FROM session_recordings WHERE ${REPLAY_RECORDING_FILTER}`;
 const REPLAY_CHUNKS_OVER_TIME_SQL = `SELECT ${REPLAY_RECORDING_DATE_SQL} AS date, SUM(chunk_count) AS count FROM session_recordings WHERE ${REPLAY_RECORDING_FILTER} GROUP BY ${REPLAY_RECORDING_DATE_SQL} ORDER BY date`;
 const RECENT_REPLAY_SESSIONS_SQL = `SELECT id AS recording_id, session_id, COALESCE(NULLIF(app, ''), NULLIF(template, ''), 'unknown') AS app, COALESCE(NULLIF(user_id, ''), NULLIF(user_key, ''), NULLIF(anonymous_id, ''), 'anonymous') AS visitor, chunk_count AS chunks, event_count AS events, started_at, COALESCE(ended_at, last_ingested_at, started_at) AS last_seen, '/sessions/' || id AS href FROM session_recordings WHERE ${REPLAY_RECORDING_FILTER} ORDER BY last_seen DESC LIMIT 25`;

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

@@ -194,6 +194,11 @@ function replayString(value: unknown): string | null {
   return null;
 }
 
+function replayEmail(value: unknown): string | null {
+  const raw = replayString(value);
+  return raw && raw.includes("@") ? raw : null;
+}
+
 function replayInteger(value: unknown): number | null {
   if (typeof value === "number" && Number.isInteger(value)) return value;
   if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
@@ -341,6 +346,30 @@ function inferReplayEventCount(inlineData: string | null): number | null {
   return null;
 }
 
+function inferReplayEventTimes(inlineData: string | null): {
+  startedAt: string | null;
+  endedAt: string | null;
+} {
+  if (!inlineData) return { startedAt: null, endedAt: null };
+  try {
+    const parsed = JSON.parse(inlineData);
+    const events = Array.isArray(parsed)
+      ? parsed
+      : Array.isArray(parsed?.events)
+        ? parsed.events
+        : [];
+    const timestamps = events
+      .map((event: unknown) => replayTimestamp(replayRecord(event).timestamp))
+      .filter((value: string | null): value is string => Boolean(value));
+    return {
+      startedAt: replayMinIso(timestamps),
+      endedAt: replayMaxIso(timestamps),
+    };
+  } catch {
+    return { startedAt: null, endedAt: null };
+  }
+}
+
 function normalizeReplayBlobRef(value: unknown): string | null {
   const ref = replayString(value);
   if (!ref) return null;
@@ -393,6 +422,16 @@ function decodeReplayBlobRef(value: string | null): StoredReplayBlobRef | null {
   }
 }
 
+async function deleteReplayBlobHandleQuietly(
+  handle: PrivateBlobHandle,
+): Promise<void> {
+  try {
+    await deletePrivateBlob(handle);
+  } catch {
+    // Best-effort rollback cleanup; the original ingest error is more useful.
+  }
+}
+
 function parsePositiveIntegerEnv(name: string, fallback: number): number {
   const raw = process.env[name];
   if (!raw) return fallback;
@@ -533,14 +572,19 @@ function normalizeReplayChunk(rawValue: unknown): NormalizedSessionReplayChunk {
   if (!checksum || checksum.length > 128) {
     throw replayError("Each replay chunk requires a valid checksum", 400);
   }
+  const inferredTimes = inferReplayEventTimes(inlineData);
 
   return {
     seq,
     checksum,
     byteLength,
     eventCount,
-    startedAt: replayTimestamp(raw.startedAt ?? raw.startTime ?? raw.start),
-    endedAt: replayTimestamp(raw.endedAt ?? raw.endTime ?? raw.end),
+    startedAt:
+      replayTimestamp(raw.startedAt ?? raw.startTime ?? raw.start) ??
+      inferredTimes.startedAt,
+    endedAt:
+      replayTimestamp(raw.endedAt ?? raw.endTime ?? raw.end) ??
+      inferredTimes.endedAt,
     storageKind,
     storageRef,
     inlineData,
@@ -721,7 +765,17 @@ export function parseSessionReplayIngestPayload(
     body.status === "completed" || body.completed === true || endedAt
       ? "completed"
       : "active";
-  const userId = replayString(body.userId ?? body.user_id);
+  const userEmail =
+    replayEmail(body.userEmail ?? body.user_email) ||
+    replayEmail(properties.userEmail ?? properties.user_email) ||
+    replayEmail(properties.email) ||
+    replayEmail(context.userEmail ?? context.user_email) ||
+    replayEmail(body.userId ?? body.user_id);
+  const userId =
+    userEmail ||
+    replayString(body.userId ?? body.user_id) ||
+    replayString(properties.userId ?? properties.user_id) ||
+    replayString(context.userId ?? context.user_id);
   const anonymousId = replayString(body.anonymousId ?? body.anonymous_id);
 
   return {
@@ -730,7 +784,7 @@ export function parseSessionReplayIngestPayload(
     sessionId,
     userId,
     anonymousId,
-    userKey: userId || anonymousId,
+    userKey: userEmail || userId || anonymousId,
     startedAt,
     endedAt,
     durationMs:
@@ -933,6 +987,14 @@ function rowToSessionRecordingSummary(
   };
 }
 
+function isVisibleSessionRecording(row: any): boolean {
+  return (
+    Boolean(replayEmail(row.userId)) &&
+    Number(row.chunkCount ?? 0) > 0 &&
+    Number(row.eventCount ?? 0) > 0
+  );
+}
+
 function mergeReplayMetadata(
   existing: Record<string, unknown>,
   incoming: Record<string, unknown>,
@@ -951,6 +1013,27 @@ function replayRecordingChangeScope(row: {
   return { owner: row.ownerEmail };
 }
 
+async function deleteEmptyReplayRecordingPlaceholder(
+  db: any,
+  recording: { id: string; ownerEmail: string; orgId: string | null },
+): Promise<void> {
+  await db.delete(schema.sessionRecordings).where(
+    and(
+      eq(schema.sessionRecordings.id, recording.id),
+      eq(schema.sessionRecordings.ownerEmail, recording.ownerEmail),
+      recording.orgId
+        ? eq(schema.sessionRecordings.orgId, recording.orgId)
+        : isNull(schema.sessionRecordings.orgId),
+      eq(schema.sessionRecordings.chunkCount, 0),
+      eq(schema.sessionRecordings.eventCount, 0),
+      sql`not exists (
+          select 1 from ${schema.sessionReplayChunks}
+          where ${schema.sessionReplayChunks.recordingId} = ${schema.sessionRecordings.id}
+        )`,
+    ),
+  );
+}
+
 function escapeSqlLike(value: string): string {
   return value.replace(/[\\%_]/g, (match) => `\\${match}`);
 }
@@ -1006,10 +1089,11 @@ export async function recordSessionReplayChunks(
     .limit(1);
 
   if (!recording) {
+    const newRecordingId = replayId("sr");
     await db
       .insert(schema.sessionRecordings)
       .values({
-        id: replayId("sr"),
+        id: newRecordingId,
         publicKeyId: key.id,
         clientRecordingId: input.clientRecordingId,
         sessionId: input.sessionId,
@@ -1070,54 +1154,76 @@ export async function recordSessionReplayChunks(
     existingChunks.map((chunk: any) => [chunk.seq, chunk]),
   );
   const rowsToInsert: any[] = [];
+  const uploadedBlobHandles: PrivateBlobHandle[] = [];
   let duplicateChunks = 0;
+  const wasEmptyRecording =
+    Number(recording.chunkCount ?? 0) === 0 &&
+    Number(recording.eventCount ?? 0) === 0 &&
+    existingChunks.length === 0;
 
-  for (const rawChunk of input.chunks) {
-    const chunk = await storeReplayChunkBlob(rawChunk, {
-      publicKeyId: key.id,
-      recordingId: recording.id,
-      ownerEmail: key.ownerEmail,
-      orgId: key.orgId,
-    });
-    const existing = existingBySeq.get(chunk.seq);
-    if (existing) {
-      if (existing.checksum !== chunk.checksum) {
+  try {
+    for (const rawChunk of input.chunks) {
+      const existing = existingBySeq.get(rawChunk.seq);
+      if (existing) {
+        if (existing.checksum !== rawChunk.checksum) {
+          throw replayError(
+            `Replay chunk ${rawChunk.seq} was already recorded with a different checksum`,
+            409,
+          );
+        }
+        duplicateChunks += 1;
+        continue;
+      }
+      if (
+        existingChunks.length + rowsToInsert.length >=
+        MAX_REPLAY_CHUNKS_PER_RECORDING
+      ) {
         throw replayError(
-          `Replay chunk ${chunk.seq} was already recorded with a different checksum`,
-          409,
+          `Session recordings may contain at most ${MAX_REPLAY_CHUNKS_PER_RECORDING} chunks`,
+          413,
         );
       }
-      duplicateChunks += 1;
-      continue;
-    }
-    if (
-      existingChunks.length + rowsToInsert.length >=
-      MAX_REPLAY_CHUNKS_PER_RECORDING
-    ) {
-      throw replayError(
-        `Session recordings may contain at most ${MAX_REPLAY_CHUNKS_PER_RECORDING} chunks`,
-        413,
-      );
+      const chunk = await storeReplayChunkBlob(rawChunk, {
+        publicKeyId: key.id,
+        recordingId: recording.id,
+        ownerEmail: key.ownerEmail,
+        orgId: key.orgId,
+      });
+      if (rawChunk.storageKind !== "blob" && chunk.storageKind === "blob") {
+        const ref = decodeReplayBlobRef(chunk.storageRef);
+        if (ref) uploadedBlobHandles.push(ref.handle);
+      }
+      rowsToInsert.push({
+        id: replayId("src"),
+        recordingId: recording.id,
+        seq: chunk.seq,
+        checksum: chunk.checksum,
+        byteLength: chunk.byteLength,
+        eventCount: chunk.eventCount,
+        startedAt: chunk.startedAt,
+        endedAt: chunk.endedAt,
+        storageKind: chunk.storageKind,
+        storageRef: chunk.storageRef,
+        inlineData: chunk.inlineData,
+        ownerEmail: key.ownerEmail,
+        orgId: key.orgId,
+      });
     }
-    rowsToInsert.push({
-      id: replayId("src"),
-      recordingId: recording.id,
-      seq: chunk.seq,
-      checksum: chunk.checksum,
-      byteLength: chunk.byteLength,
-      eventCount: chunk.eventCount,
-      startedAt: chunk.startedAt,
-      endedAt: chunk.endedAt,
-      storageKind: chunk.storageKind,
-      storageRef: chunk.storageRef,
-      inlineData: chunk.inlineData,
-      ownerEmail: key.ownerEmail,
-      orgId: key.orgId,
-    });
-  }
 
-  if (rowsToInsert.length) {
-    await db.insert(schema.sessionReplayChunks).values(rowsToInsert);
+    if (rowsToInsert.length) {
+      await db.insert(schema.sessionReplayChunks).values(rowsToInsert);
+    }
+    uploadedBlobHandles.length = 0;
+  } catch (error) {
+    await Promise.all(uploadedBlobHandles.map(deleteReplayBlobHandleQuietly));
+    if (wasEmptyRecording) {
+      await deleteEmptyReplayRecordingPlaceholder(db, {
+        id: recording.id,
+        ownerEmail: key.ownerEmail,
+        orgId: key.orgId,
+      });
+    }
+    throw error;
   }
 
   await db.insert(schema.sessionReplayIngests).values({
@@ -1239,6 +1345,9 @@ export async function listSessionRecordings(
       userEmail: scope.userEmail,
       orgId: scope.orgId ?? undefined,
     }),
+    replayTextContains(schema.sessionRecordings.userId, "@"),
+    gte(schema.sessionRecordings.chunkCount, 1),
+    gte(schema.sessionRecordings.eventCount, 1),
   ];
   if (filters.app)
     conditions.push(eq(schema.sessionRecordings.app, filters.app));
@@ -1300,6 +1409,9 @@ export async function getSessionReplaySummary(
     orgId: scope.orgId ?? undefined,
   });
   if (!access) throw replayError("Session recording not found", 404);
+  if (!isVisibleSessionRecording(access.resource)) {
+    throw replayError("Session recording not found", 404);
+  }
   return rowToSessionRecordingSummary(access.resource, access.role);
 }
 

package/corpus/templates/assets/app/components/layout/Layout.tsx

@@ -87,7 +87,7 @@ export function Layout({ children }: LayoutProps) {
       )}
       <div
         className={cn(
-          "agent-layout-left-drawer fixed inset-y-0 start-0 z-50 md:static md:z-auto",
+          "agent-layout-left-drawer fixed inset-y-0 start-0 z-50 transition-transform duration-200 ease-out md:static md:z-auto md:transition-none",
           mobileSidebarOpen
             ? "translate-x-0"
             : "-translate-x-full md:translate-x-0",

package/corpus/templates/assets/changelog/2026-06-27-mobile-navigation-chrome-and-motion.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-06-27
+---
+
+Improved mobile navigation chrome and sidebar drawer motion.

package/corpus/templates/clips/app/components/capture-install-options.tsx

@@ -59,15 +59,6 @@ function InstallOptionsContent({ desktopHref = "/download" }) {
 
   return (
     <div className="grid gap-2">
-      <div className="px-1 pb-1">
-        <div className="text-sm font-medium text-popover-foreground">
-          {t("captureInstall.title")}
-        </div>
-        <p className="mt-1 text-xs leading-relaxed text-muted-foreground">
-          {t("captureInstall.description")}
-        </p>
-      </div>
-
       {chromeAvailable ? (
         <a
           href={clipsChromeExtensionUrl ?? undefined}