@agent-native/core 0.98.16 → 0.99.0

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

@@ -3,6 +3,7 @@ import { runWithRequestContext } from "@agent-native/core/server/request-context
 import { sendDashboardReportSubscription } from "../lib/dashboard-report";
 import {
   claimDueDashboardReportSubscriptions,
+  dashboardReportRetryAt,
   markDashboardReportResult,
 } from "../lib/dashboard-report-subscriptions";
 
@@ -41,22 +42,40 @@ export async function runDashboardReportsOnce(): Promise<{
     for (const sub of batch) {
       processed++;
       try {
+        const retryAt = dashboardReportRetryAt(sub);
         const result = await runWithRequestContext(
           {
             userEmail: sub.ownerEmail,
             orgId: sub.orgId ?? undefined,
           },
-          () => sendDashboardReportSubscription(sub),
+          () =>
+            sendDashboardReportSubscription(sub, {
+              skipEmailWithoutScreenshot: retryAt !== null,
+            }),
         );
         if (!result.screenshotAttached) {
           const message = result.screenshotError
             ? `Dashboard screenshot unavailable: ${result.screenshotError}`
             : "Dashboard screenshot unavailable";
+          if (retryAt && !result.emailsSent) {
+            console.error(
+              `[dashboard-report] Subscription ${sub.id} skipped sending without a screenshot, will retry:`,
+              message,
+            );
+            await markDashboardReportResult(
+              sub,
+              "error",
+              `${message} (retry scheduled)`,
+              { nextRunAt: retryAt },
+            );
+            continue;
+          }
+          failed++;
           console.error(
             `[dashboard-report] Subscription ${sub.id} sent without a screenshot:`,
             message,
           );
-          await markDashboardReportResult(sub, "success", message);
+          await markDashboardReportResult(sub, "error", message);
           continue;
         }
         await markDashboardReportResult(sub, "success");

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

@@ -158,6 +158,19 @@ function calendarDayAfter(parts: { year: number; month: number; day: number }) {
   };
 }
 
+function calendarDayBefore(parts: {
+  year: number;
+  month: number;
+  day: number;
+}) {
+  const prev = new Date(Date.UTC(parts.year, parts.month - 1, parts.day - 1));
+  return {
+    year: prev.getUTCFullYear(),
+    month: prev.getUTCMonth() + 1,
+    day: prev.getUTCDate(),
+  };
+}
+
 function zonedTimeToUtc(
   parts: { year: number; month: number; day: number },
   hour: number,
@@ -205,6 +218,47 @@ export function nextDailyRunAt(
   return candidate.toISOString();
 }
 
+export function lastDailyRunAt(
+  timeOfDay: string,
+  timeZone: string,
+  from: Date = new Date(),
+): string {
+  const [hour, minute] = assertTimeOfDay(timeOfDay).split(":").map(Number);
+  const timezone = assertTimezone(timeZone);
+  const today = getZonedParts(from, timezone);
+  let candidate = zonedTimeToUtc(today, hour, minute, timezone);
+  if (candidate.getTime() > from.getTime()) {
+    candidate = zonedTimeToUtc(
+      calendarDayBefore(today),
+      hour,
+      minute,
+      timezone,
+    );
+  }
+  return candidate.toISOString();
+}
+
+const DASHBOARD_REPORT_RETRY_WINDOW_MS = 60 * 60 * 1000;
+const DASHBOARD_REPORT_RETRY_DELAY_MS = 10 * 60 * 1000;
+
+export function dashboardReportRetryAt(
+  sub: DashboardReportSubscription,
+  now: Date = new Date(),
+): string | null {
+  if (!sub.enabled) return null;
+  try {
+    const anchor = Date.parse(lastDailyRunAt(sub.timeOfDay, sub.timezone, now));
+    if (now.getTime() - anchor < DASHBOARD_REPORT_RETRY_WINDOW_MS) {
+      return new Date(
+        now.getTime() + DASHBOARD_REPORT_RETRY_DELAY_MS,
+      ).toISOString();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 function rowToSubscription(row: any): DashboardReportSubscription {
   return {
     id: row.id,
@@ -477,6 +531,7 @@ export async function markDashboardReportResult(
   sub: DashboardReportSubscription,
   status: "success" | "error",
   error?: string,
+  options?: { nextRunAt?: string },
 ): Promise<void> {
   const now = nowIso();
   const db = getDb() as any;
@@ -486,7 +541,8 @@ export async function markDashboardReportResult(
       lastStatus: status,
       lastError: error ? error.slice(0, 500) : null,
       nextRunAt: sub.enabled
-        ? nextDailyRunAt(sub.timeOfDay, sub.timezone, new Date())
+        ? (options?.nextRunAt ??
+          nextDailyRunAt(sub.timeOfDay, sub.timezone, new Date()))
         : null,
       updatedAt: now,
     })

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

@@ -1,4 +1,8 @@
+import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { readdir, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   getAppProductionUrl,
@@ -44,11 +48,24 @@ const DASHBOARD_REPORT_CID = "dashboard-report-snapshot";
 const LOCAL_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SECOND_READY_TIMEOUT_MS = 45_000;
+const SERVERLESS_FULL_ATTEMPT_TIMEOUT_MS = 125_000;
+const SERVERLESS_LIGHTWEIGHT_ATTEMPT_TIMEOUT_MS = 85_000;
+const BROWSER_CLEANUP_TIMEOUT_MS = 10_000;
 const SCREENSHOT_VIEWPORT_PADDING = 64;
 
 type DashboardScreenshotAttempt = {
   label: "full" | "full-lightweight";
   viewport: { width: number; height: number };
+  captureScale?: number;
+  readyTimeout?: number;
+  secondReadyTimeout?: number;
+  totalTimeout?: number;
+};
+
+type LaunchedScreenshotBrowser = {
+  browser: any;
+  cleanup: () => Promise<void>;
+  newPage: () => Promise<any>;
 };
 
 function daysAgo(n: number): string {
@@ -216,14 +233,44 @@ function localChromiumExecutablePath(): string | null {
   return candidates.find((candidate) => existsSync(candidate)) ?? null;
 }
 
-async function launchScreenshotBrowser() {
+async function sweepStaleScreenshotProfiles(): Promise<void> {
+  let entries: string[];
+  try {
+    entries = await readdir(tmpdir());
+  } catch {
+    return;
+  }
+  const stale = entries
+    .filter((entry) => entry.startsWith("dashboard-report-playwright-"))
+    .slice(0, 8);
+  for (const entry of stale) {
+    const full = join(tmpdir(), entry);
+    const info = await stat(full).catch(() => null);
+    if (info && Date.now() - info.mtimeMs > 30 * 60_000) {
+      await rm(full, { recursive: true, force: true }).catch(() => {});
+    }
+  }
+}
+
+async function launchScreenshotBrowser(
+  viewport: DashboardScreenshotAttempt["viewport"],
+): Promise<LaunchedScreenshotBrowser> {
   const { chromium: playwright } = await import("playwright-core");
   const localExecutablePath = localChromiumExecutablePath();
   if (localExecutablePath) {
-    return playwright.launch({
+    const browser = await playwright.launch({
       executablePath: localExecutablePath,
       headless: true,
     });
+    return {
+      browser,
+      cleanup: async () => {},
+      newPage: () =>
+        browser.newPage({
+          viewport,
+          deviceScaleFactor: 1,
+        }),
+    };
   }
 
   if (isServerlessBrowserRuntime()) {
@@ -232,19 +279,54 @@ async function launchScreenshotBrowser() {
     const packUrl =
       process.env.DASHBOARD_REPORT_CHROMIUM_PACK_URL?.trim() ||
       DEFAULT_SERVERLESS_CHROMIUM_PACK_URL;
-    return playwright.launch({
-      args: [
-        ...chromium.args,
-        "--disable-dev-shm-usage",
-        "--disable-gpu",
-        "--hide-scrollbars",
-      ],
-      executablePath: await chromium.executablePath(packUrl),
-      headless: true,
-    });
+    await sweepStaleScreenshotProfiles();
+    const userDataDir = join(
+      tmpdir(),
+      `dashboard-report-playwright-${randomUUID()}`,
+    );
+    const cleanup = async () => {
+      await rm(userDataDir, { recursive: true, force: true }).catch((err) => {
+        console.error(
+          "[dashboard-report] Failed to clean Chromium profile:",
+          errorMessage(err),
+        );
+      });
+    };
+
+    try {
+      const browser = await playwright.launchPersistentContext(userDataDir, {
+        args: [
+          ...chromium.args,
+          "--disable-dev-shm-usage",
+          "--disable-gpu",
+          "--hide-scrollbars",
+        ],
+        deviceScaleFactor: 1,
+        executablePath: await chromium.executablePath(packUrl),
+        headless: true,
+        viewport,
+      });
+      return {
+        browser,
+        cleanup,
+        newPage: () => browser.newPage(),
+      };
+    } catch (err) {
+      await cleanup();
+      throw err;
+    }
   }
 
-  return playwright.launch({ headless: true });
+  const browser = await playwright.launch({ headless: true });
+  return {
+    browser,
+    cleanup: async () => {},
+    newPage: () =>
+      browser.newPage({
+        viewport,
+        deviceScaleFactor: 1,
+      }),
+  };
 }
 
 function screenshotTimeoutMs(): number {
@@ -350,6 +432,40 @@ async function fitViewportWidthToDashboardCapture(
   await page.waitForTimeout(250);
 }
 
+async function scaleDashboardCapture(
+  page: any,
+  scale: number | undefined,
+): Promise<void> {
+  if (!scale || scale >= 1) return;
+  await page.evaluate(`(() => {
+    const root = document.querySelector("[data-dashboard-report-capture]");
+    if (root instanceof HTMLElement) root.style.zoom = "${scale}";
+  })()`);
+  await page.waitForTimeout(250);
+}
+
+async function runBoundedBrowserCleanup(
+  label: string,
+  operation: () => Promise<void>,
+): Promise<void> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      operation(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`${label} exceeded cleanup timeout`)),
+          BROWSER_CLEANUP_TIMEOUT_MS,
+        );
+      }),
+    ]);
+  } catch (err) {
+    console.error(`[dashboard-report] ${label}:`, errorMessage(err));
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 async function captureDashboardPng(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
@@ -373,13 +489,47 @@ async function captureDashboardPng(
   screenshotUrl.searchParams.set(EMBED_MODE_QUERY_PARAM, "1");
   screenshotUrl.searchParams.set(EMBED_TOKEN_QUERY_PARAM, token);
 
-  const browser = await launchScreenshotBrowser();
+  let browser: any;
+  let cleanup = async () => {};
+  let newPage = async (): Promise<any> => {
+    throw new Error("Screenshot browser did not provide a page factory");
+  };
+  let launchPromise: Promise<LaunchedScreenshotBrowser> | undefined;
+  let launchTimeout: ReturnType<typeof setTimeout> | undefined;
+  let captureStage = "launching the screenshot browser";
+  let attemptTimedOut = false;
+  const attemptTimeout = attempt.totalTimeout
+    ? setTimeout(() => {
+        attemptTimedOut = true;
+        if (browser) void browser.close().catch(() => {});
+      }, attempt.totalTimeout)
+    : null;
   try {
+    launchPromise = launchScreenshotBrowser(attempt.viewport);
+    const launched = attempt.totalTimeout
+      ? await Promise.race([
+          launchPromise,
+          new Promise<never>((_, reject) => {
+            launchTimeout = setTimeout(() => {
+              attemptTimedOut = true;
+              reject(
+                new Error(
+                  `${attempt.label} browser launch exceeded ${attempt.totalTimeout}ms`,
+                ),
+              );
+            }, attempt.totalTimeout);
+          }),
+        ])
+      : await launchPromise;
+    browser = launched.browser;
+    cleanup = launched.cleanup;
+    newPage = launched.newPage;
+    if (attemptTimedOut) {
+      throw new Error("Screenshot browser launch exceeded attempt timeout");
+    }
+
     const timeout = screenshotTimeoutMs();
-    const page = await browser.newPage({
-      viewport: attempt.viewport,
-      deviceScaleFactor: 1,
-    });
+    const page = await newPage();
     page.setDefaultTimeout(timeout);
     await page.emulateMedia({ media: "screen", colorScheme: "light" });
     await page.addInitScript(() => {
@@ -390,14 +540,24 @@ async function captureDashboardPng(
       timeout,
     });
 
+    captureStage = "waiting for the report surface";
     const capture = page.locator("[data-dashboard-report-capture]");
     await capture.waitFor({ state: "visible", timeout });
-    await waitForDashboardReportReady(page, timeout);
+    captureStage = "waiting for dashboard queries";
+    await waitForDashboardReportReady(page, attempt.readyTimeout ?? timeout);
+    captureStage = "rendering lazy dashboard panels";
     await scrollDashboardForLazyRendering(page);
-    await waitForDashboardReportReady(page, secondReadyTimeoutMs());
+    captureStage = "waiting for lazy dashboard panels";
+    await waitForDashboardReportReady(
+      page,
+      attempt.secondReadyTimeout ?? secondReadyTimeoutMs(),
+    );
 
+    captureStage = "sizing the dashboard capture";
     await fitViewportWidthToDashboardCapture(page, capture, attempt.viewport);
+    await scaleDashboardCapture(page, attempt.captureScale);
     await capture.scrollIntoViewIfNeeded();
+    captureStage = "rasterizing the dashboard PNG";
     const image = await capture.screenshot({
       type: "png",
       animations: "disabled",
@@ -406,8 +566,39 @@ async function captureDashboardPng(
       throw new Error("Dashboard screenshot was empty");
     }
     return Buffer.from(image);
+  } catch (err) {
+    if (attemptTimedOut) {
+      throw new Error(
+        `${attempt.label} capture exceeded ${attempt.totalTimeout}ms while ${captureStage}`,
+      );
+    }
+    throw new Error(`${captureStage}: ${errorMessage(err)}`);
   } finally {
-    await browser.close();
+    if (attemptTimeout) clearTimeout(attemptTimeout);
+    if (launchTimeout) clearTimeout(launchTimeout);
+    if (!browser && launchPromise) {
+      void launchPromise.then(
+        async (lateBrowser) => {
+          await runBoundedBrowserCleanup(
+            "Failed to close late screenshot browser",
+            () => lateBrowser.browser.close(),
+          );
+          await runBoundedBrowserCleanup(
+            "Failed to clean late Chromium profile",
+            lateBrowser.cleanup,
+          );
+        },
+        () => {
+          // The launch rejection was already handled by the race above.
+        },
+      );
+    }
+    if (browser) {
+      await runBoundedBrowserCleanup("Failed to close screenshot browser", () =>
+        browser.close(),
+      );
+    }
+    await runBoundedBrowserCleanup("Failed to clean Chromium profile", cleanup);
   }
 }
 
@@ -419,6 +610,11 @@ function errorMessage(err: unknown): string {
   );
 }
 
+function storedAttemptError(message: string): string {
+  const normalized = message.replace(/\s+/g, " ").trim();
+  return normalized.length > 220 ? `${normalized.slice(0, 219)}…` : normalized;
+}
+
 async function captureDashboardPngWithFallback(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
@@ -427,11 +623,33 @@ async function captureDashboardPngWithFallback(
   mode: "full" | "full-lightweight" | "none";
   error?: string;
 }> {
+  const serverless = isServerlessBrowserRuntime();
   const attempts: DashboardScreenshotAttempt[] = [
-    { label: "full", viewport: { width: 1440, height: 1800 } },
-    { label: "full-lightweight", viewport: { width: 1200, height: 1400 } },
+    {
+      label: "full",
+      viewport: { width: 1440, height: 1800 },
+      captureScale: 0.85,
+      ...(serverless
+        ? {
+            secondReadyTimeout: 25_000,
+            totalTimeout: SERVERLESS_FULL_ATTEMPT_TIMEOUT_MS,
+          }
+        : {}),
+    },
+    {
+      label: "full-lightweight",
+      viewport: { width: 1200, height: 1400 },
+      captureScale: 0.7,
+      ...(serverless
+        ? {
+            readyTimeout: 55_000,
+            secondReadyTimeout: 15_000,
+            totalTimeout: SERVERLESS_LIGHTWEIGHT_ATTEMPT_TIMEOUT_MS,
+          }
+        : {}),
+    },
   ];
-  let lastError: string | undefined;
+  const errors: string[] = [];
 
   for (const attempt of attempts) {
     try {
@@ -440,15 +658,20 @@ async function captureDashboardPngWithFallback(
         mode: attempt.label,
       };
     } catch (err) {
-      lastError = errorMessage(err);
+      const attemptError = errorMessage(err);
+      errors.push(`${attempt.label}: ${storedAttemptError(attemptError)}`);
       console.error(
         `[dashboard-report] ${attempt.label} screenshot failed for subscription ${sub.id}:`,
-        lastError,
+        attemptError,
       );
     }
   }
 
-  return { png: null, mode: "none", error: lastError };
+  return {
+    png: null,
+    mode: "none",
+    ...(errors.length ? { error: errors.join(" | ") } : {}),
+  };
 }
 
 function reportDate(snapshot: ReportSnapshot): string {
@@ -518,13 +741,17 @@ function reportFilename(title: string): string {
 
 export async function sendDashboardReportSubscription(
   sub: DashboardReportSubscription,
-  options: { requireScreenshot?: boolean } = {},
+  options: {
+    requireScreenshot?: boolean;
+    skipEmailWithoutScreenshot?: boolean;
+  } = {},
 ): Promise<{
   dashboardUrl: string;
   recipientCount: number;
   screenshotAttached: boolean;
   screenshotMode: "full" | "full-lightweight" | "none";
   screenshotError?: string;
+  emailsSent: boolean;
 }> {
   const snapshot = await collectReportSnapshot(sub);
   const capture = await captureDashboardPngWithFallback(sub, snapshot);
@@ -535,6 +762,16 @@ export async function sendDashboardReportSubscription(
         : "Dashboard screenshot unavailable",
     );
   }
+  if (!capture.png && options.skipEmailWithoutScreenshot) {
+    return {
+      dashboardUrl: snapshot.dashboardUrl,
+      recipientCount: sub.recipients.length,
+      screenshotAttached: false,
+      screenshotMode: capture.mode,
+      emailsSent: false,
+      ...(capture.error ? { screenshotError: capture.error } : {}),
+    };
+  }
   const screenshotAttached = Boolean(capture.png);
   const html = renderReportEmailHtml(snapshot, { screenshotAttached });
   const text = renderReportText(snapshot, { screenshotAttached });
@@ -565,6 +802,7 @@ export async function sendDashboardReportSubscription(
     recipientCount: sub.recipients.length,
     screenshotAttached,
     screenshotMode: capture.mode,
+    emailsSent: true,
     ...(capture.error ? { screenshotError: capture.error } : {}),
   };
 }

package/corpus/templates/analytics/server/routes/[...page].get.ts

@@ -161,9 +161,7 @@ export default defineEventHandler(async (event) => {
   const headers = new Headers(response.headers);
   headers.delete("content-length");
   if (discovery.privateResponse) {
-    headers.set("Cache-Control", "private, max-age=0, no-store");
     headers.set("Referrer-Policy", "no-referrer");
-    setResponseHeader(event, "Cache-Control", "private, max-age=0, no-store");
     setResponseHeader(event, "Referrer-Policy", "no-referrer");
   }
 

package/corpus/templates/assets/.agents/skills/security/SKILL.md

@@ -147,6 +147,16 @@ export default defineEventHandler(async (event) => {
 
 - Never create unprotected routes that modify data.
 
+**Exception — the SSR HTML/`.data` catch-all is deliberately session-blind.**
+The rule above is for routes that read or mutate user data. The SSR page
+render and React Router `.data` route are different: they serve one
+impersonal, public-cacheable shell to every visitor by design, and loaders on
+that path render no user data. Do not "fix" this by adding `getSession`,
+`private`, or `no-store` to it — that regresses the CDN cache contract for the
+whole site. Data scoping lives in actions and API routes; the client gates
+private UI after the shell loads. See the `authentication` skill and
+`guard:ssr-cache-shell` / `ssr-handler.spec.ts`.
+
 ## Human-in-the-Loop Approval for High-Consequence Actions
 
 For a small set of outward-facing, hard-to-undo operations — sending an email, charging a card, deleting an account, posting publicly — auth and access control are necessary but not sufficient: you also do not want the **agent** to perform them autonomously. Set `needsApproval` on the `defineAction` so the agent cannot run the action without a human approving the specific call.

package/corpus/templates/assets/agent-native.app-skill.json

@@ -5,7 +5,7 @@
   "description": "Create, search, select, and export brand image and video assets from the Assets app.",
   "hosted": {
     "url": "https://assets.agent-native.com",
-    "mcpUrl": "https://assets.agent-native.com/_agent-native/mcp"
+    "mcpUrl": "https://assets.agent-native.com/mcp"
   },
   "mcp": {
     "serverName": "agent-native-assets"

package/corpus/templates/brain/.agents/skills/security/SKILL.md

@@ -147,6 +147,16 @@ export default defineEventHandler(async (event) => {
 
 - Never create unprotected routes that modify data.
 
+**Exception — the SSR HTML/`.data` catch-all is deliberately session-blind.**
+The rule above is for routes that read or mutate user data. The SSR page
+render and React Router `.data` route are different: they serve one
+impersonal, public-cacheable shell to every visitor by design, and loaders on
+that path render no user data. Do not "fix" this by adding `getSession`,
+`private`, or `no-store` to it — that regresses the CDN cache contract for the
+whole site. Data scoping lives in actions and API routes; the client gates
+private UI after the shell loads. See the `authentication` skill and
+`guard:ssr-cache-shell` / `ssr-handler.spec.ts`.
+
 ## Human-in-the-Loop Approval for High-Consequence Actions
 
 For a small set of outward-facing, hard-to-undo operations — sending an email, charging a card, deleting an account, posting publicly — auth and access control are necessary but not sufficient: you also do not want the **agent** to perform them autonomously. Set `needsApproval` on the `defineAction` so the agent cannot run the action without a human approving the specific call.

package/corpus/templates/calendar/.agents/skills/security/SKILL.md

@@ -147,6 +147,16 @@ export default defineEventHandler(async (event) => {
 
 - Never create unprotected routes that modify data.
 
+**Exception — the SSR HTML/`.data` catch-all is deliberately session-blind.**
+The rule above is for routes that read or mutate user data. The SSR page
+render and React Router `.data` route are different: they serve one
+impersonal, public-cacheable shell to every visitor by design, and loaders on
+that path render no user data. Do not "fix" this by adding `getSession`,
+`private`, or `no-store` to it — that regresses the CDN cache contract for the
+whole site. Data scoping lives in actions and API routes; the client gates
+private UI after the shell loads. See the `authentication` skill and
+`guard:ssr-cache-shell` / `ssr-handler.spec.ts`.
+
 ## Human-in-the-Loop Approval for High-Consequence Actions
 
 For a small set of outward-facing, hard-to-undo operations — sending an email, charging a card, deleting an account, posting publicly — auth and access control are necessary but not sufficient: you also do not want the **agent** to perform them autonomously. Set `needsApproval` on the `defineAction` so the agent cannot run the action without a human approving the specific call.

package/corpus/templates/calendar/AGENTS.md

@@ -67,7 +67,8 @@ Detailed event, availability, booking, storage, and UI rules live in
 - Use `get-attendee-timezones` / `set-attendee-timezone` to read or save
   per-guest IANA timezone overrides (`attendee-timezones` user setting). The UI
   shows each guest's local event-start time when a timezone is known (self from
-  the event/browser zone; others from `attendee.timeZone` or the override map).
+  the browser zone; others from `attendee.timeZone` or the override map, with
+  the event zone as a fallback for the organizer).
 - Use `rsvp-event` for invitation responses. Pass `note` when the user wants a
   visible RSVP comment on a declined or tentative response; pass an empty note to
   clear an existing RSVP comment.

package/corpus/templates/calendar/app/components/calendar/EventDetailPopover.tsx

@@ -11,7 +11,6 @@ import {
   IconMapPin,
   IconUser,
   IconVideo,
-  IconGlobe,
   IconRefresh,
   IconBell,
   IconChevronRight,
@@ -86,7 +85,6 @@ import {
   dateTimeInTimezoneToIso,
   formatRecurrenceText,
   formatReminderText,
-  formatTimezoneLabel,
   getEventEndValidationMessage,
   getLocalTimezone,
   getRecurrencePreset,
@@ -1274,17 +1272,6 @@ export function EventDetailPopover({
     ? t("eventForm.loadingRepeat")
     : formatRecurrenceText(recurrenceRules) ||
       (isRecurringEvent ? t("eventForm.repeats") : null);
-  // Show the browser's local timezone offset (this is what the user sees times in)
-  const localOffsetMinutes = -new Date().getTimezoneOffset();
-  const localOffsetSign = localOffsetMinutes >= 0 ? "+" : "-";
-  const localOffsetH = Math.floor(Math.abs(localOffsetMinutes) / 60);
-  const localOffsetM = Math.abs(localOffsetMinutes) % 60;
-  const tzLabel = event.startTimeZone
-    ? formatTimezoneLabel(event.startTimeZone)
-    : localOffsetM
-      ? `GMT${localOffsetSign}${localOffsetH}:${String(localOffsetM).padStart(2, "0")}`
-      : `GMT${localOffsetSign}${localOffsetH}`;
-
   const handleOpenChange = useCallback(
     (newOpen: boolean) => {
       if (!newOpen && open) {
@@ -1726,12 +1713,6 @@ export function EventDetailPopover({
                 />
               )}
 
-              {/* Timezone */}
-              <div className="flex items-center gap-3 py-1.5">
-                <IconGlobe className="h-4 w-4 shrink-0 text-muted-foreground" />
-                <span className="text-sm text-muted-foreground">{tzLabel}</span>
-              </div>
-
               {/* Recurrence */}
               {editingField === "recurrence" ? (
                 <div className="flex items-start gap-3 py-1.5">