Harden log rendering and storage against edge cases

LogStore.get() now returns a shallow copy so callers cannot mutate the
internal array.  The trace detail page uses a safeISOString helper that
falls back to "(invalid)" for NaN or otherwise unparseable timestamps
instead of throwing a RangeError.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: dahlia

packages/debugger/src/mod.test.ts

@@ -1148,6 +1148,65 @@ test("trace detail page shows log records", async () => {
   ok(html.includes("log record"));
 });
 
+test("log API returns a snapshot: mutating the array does not affect store", async () => {
+  const { federation } = createMockFederation();
+  const exporter = createMockExporter();
+  const dbg = createFederationDebugger(federation, { exporter });
+
+  const traceId = "aaaa1111bbbb2222cccc3333dddd4444";
+  dbg.sink({
+    category: ["fedify"],
+    level: "info",
+    message: ["original"],
+    rawMessage: "original",
+    timestamp: Date.now(),
+    properties: { traceId, spanId: "1234567890abcdef" },
+  });
+
+  // First fetch: get logs
+  const r1 = await dbg.fetch(
+    new Request(`https://example.com/__debug__/api/logs/${traceId}`),
+    { contextData: undefined },
+  );
+  const logs1 = (await r1.json()) as SerializedLogRecord[];
+  strictEqual(logs1.length, 1);
+
+  // Second fetch: logs should still have 1 entry (not affected by prior read)
+  const r2 = await dbg.fetch(
+    new Request(`https://example.com/__debug__/api/logs/${traceId}`),
+    { contextData: undefined },
+  );
+  const logs2 = (await r2.json()) as SerializedLogRecord[];
+  strictEqual(logs2.length, 1);
+  strictEqual(logs2[0].message, "original");
+});
+
+test("trace detail page handles invalid log timestamp gracefully", async () => {
+  const { federation } = createMockFederation();
+  const exporter = createMockExporter();
+  const dbg = createFederationDebugger(federation, { exporter });
+
+  const traceId = "aaaa1111bbbb2222cccc3333dddd4444";
+  // Push a log with NaN timestamp (simulates corrupted data)
+  dbg.sink({
+    category: ["fedify"],
+    level: "info",
+    message: ["test message"],
+    rawMessage: "test message",
+    timestamp: NaN,
+    properties: { traceId, spanId: "1234567890abcdef" },
+  });
+
+  const request = new Request(
+    `https://example.com/__debug__/traces/${traceId}`,
+  );
+  // Should not throw — the page must render without crashing
+  const response = await dbg.fetch(request, { contextData: undefined });
+  strictEqual(response.status, 200);
+  const html = await response.text();
+  ok(html.includes("test message"));
+});
+
 test("trace detail page shows empty log message", async () => {
   const { federation } = createMockFederation();
   const exporter = createMockExporter();

packages/debugger/src/mod.tsx

@@ -112,8 +112,9 @@ class LogStore {
     }
   }
 
-  get(traceId: string): SerializedLogRecord[] {
-    return this.#logs.get(traceId) ?? [];
+  get(traceId: string): readonly SerializedLogRecord[] {
+    const logs = this.#logs.get(traceId);
+    return logs != null ? [...logs] : [];
   }
 }
 

packages/debugger/src/views/trace-detail.tsx

@@ -5,6 +5,20 @@ import type { TraceActivityRecord } from "@fedify/fedify/otel";
 import type { SerializedLogRecord } from "../mod.tsx";
 import { Layout } from "./layout.tsx";
 
+/**
+ * Safely formats a timestamp (milliseconds since epoch) as an ISO string.
+ * Returns `"(invalid)"` if the timestamp is not a finite number or produces
+ * an invalid `Date`.
+ */
+function safeISOString(timestamp: number): string {
+  if (!Number.isFinite(timestamp)) return "(invalid)";
+  try {
+    return new Date(timestamp).toISOString();
+  } catch {
+    return "(invalid)";
+  }
+}
+
 /**
  * Props for the {@link TraceDetailPage} component.
  */
@@ -22,7 +36,7 @@ export interface TraceDetailPageProps {
   /**
    * The list of log records for this trace.
    */
-  logs: SerializedLogRecord[];
+  logs: readonly SerializedLogRecord[];
 
   /**
    * The path prefix for the debug dashboard.
@@ -179,8 +193,11 @@ export const TraceDetailPage: FC<TraceDetailPageProps> = (
               {logs.map((log, i) => (
                 <tr key={i} class={`log-${log.level}`}>
                   <td>
-                    <time datetime={new Date(log.timestamp).toISOString()}>
-                      {new Date(log.timestamp).toISOString().slice(11, 23)}
+                    <time datetime={safeISOString(log.timestamp)}>
+                      {(() => {
+                        const iso = safeISOString(log.timestamp);
+                        return iso === "(invalid)" ? iso : iso.slice(11, 23);
+                      })()}
                     </time>
                   </td>
                   <td>