@agent-native/core 0.161.2 → 0.161.6

package/corpus/templates/analytics/actions/update-dashboard.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { interpolate } from "../app/pages/adhoc/sql-dashboard/interpolate";
 import { dryRunQuery } from "../server/lib/bigquery";
 import { queueDashboardCollabSync } from "../server/lib/dashboard-collab-sync";
+import { serializeProgramDescriptorInput } from "../server/lib/dashboard-panel-query";
 import { validateFirstPartyDashboardTimeScope } from "../server/lib/dashboard-time-scope";
 import {
   upsertDashboard,
@@ -362,6 +363,13 @@ export function validateDashboardConfig(
     if (!isSection && !isExtension && !validSources.has(p.source as string)) {
       return `panel[${i}].source must be 'bigquery', 'ga4', 'amplitude', 'first-party', 'demo', 'prometheus', or 'program' (got '${p.source}'). source selects the backend — put the PromQL/SQL/table name or program descriptor in sql, not here.`;
     }
+    if (p.source === "program") {
+      try {
+        serializeProgramDescriptorInput(p.sql);
+      } catch (e: any) {
+        return `panel[${i}] "${p.title || p.id}" program descriptor is invalid: ${e?.message ?? e}`;
+      }
+    }
     if (isExtension) {
       const cfg = p.config as Record<string, unknown> | undefined;
       const extensionId =

package/corpus/templates/clips/actions/save-browser-transcript.ts

@@ -26,8 +26,19 @@ import { buildCaptionSegmentsFromText } from "../shared/transcript-segments.js";
 import { booleanParam } from "./lib/cli-params.js";
 import { isAutoTitleReplaceable } from "./lib/title-source.js";
 
-function nativeSegmentsJson(fullText: string): string {
-  return JSON.stringify(buildCaptionSegmentsFromText(fullText));
+// web-speech and macos-native are both mic-only engines — see
+// transcription-engine.ts's file header. When a caller sends fullText with
+// no segments (word-level timings were never captured), there's no
+// per-line source to preserve, but for these two engines there's also no
+// ambiguity: every word came from the mic. Leaving source undefined here
+// falls through to resolveSpeaker's default and renders the whole thing as
+// "Them". Whisper mixes mic + system, so it has no safe single-speaker guess.
+function nativeSegmentsJson(
+  fullText: string,
+  engineSource?: "web-speech" | "macos-native" | "whisper",
+): string {
+  const source = engineSource && engineSource !== "whisper" ? "mic" : undefined;
+  return JSON.stringify(buildCaptionSegmentsFromText(fullText, null, source));
 }
 
 // Real transcript segments supplied by a caller that already has accurate
@@ -45,6 +56,11 @@ const segmentSchema = z
     text: z.string(),
     // Stream the segment came from; the transcript UI maps mic→"Me", system→"Them".
     source: z.enum(["mic", "system"]).optional(),
+    // Diarized speaker for this segment, when the provider identifies one.
+    // Declared so zod keeps it: an undeclared key is stripped before the array
+    // is serialized, which would drop a provider's speaker labels on save and
+    // leave the transcript unable to tell its speakers apart on reload.
+    speaker: z.string().nullable().optional(),
   })
   .transform((s) => {
     if (s.endMs < s.startMs) {
@@ -74,7 +90,7 @@ export default defineAction({
       .array(segmentSchema)
       .optional()
       .describe(
-        "Real transcript segments with accurate timestamps (ms). When provided, stored verbatim instead of synthesizing timings from fullText.",
+        "Transcript segments with per-segment timings (ms) and the `mic`/`system` stream each came from. Stored verbatim when provided, instead of synthesizing timings from fullText. Timings are the engine's own where it reported them; the mic-only engines report none, so callers may send estimates to keep each segment's speaker.",
       ),
     overwriteReady: booleanParam
       .default(false)
@@ -97,7 +113,7 @@ export default defineAction({
     const segmentsJson =
       args.segments && args.segments.length > 0
         ? JSON.stringify(args.segments)
-        : nativeSegmentsJson(fullText);
+        : nativeSegmentsJson(fullText, args.source);
 
     const [current] = await db
       .select({

package/corpus/templates/clips/app/components/meetings/transcript-bubbles.tsx

@@ -61,8 +61,99 @@ export interface SpeakerIdentity {
   initialsSource: AttendeeStackParticipant | string;
   isOwner: boolean;
   accentClass: string;
+  /** The capture could not tell speakers apart, so this transcript names
+   *  nobody — the row renders without an avatar or label rather than claiming
+   *  a speaker we cannot know. */
+  unattributed?: boolean;
 }
 
+/**
+ * Whether a transcript carries enough signal to name who said what.
+ *
+ * A capture that only ever produced one speaker signal cannot distinguish two
+ * people: the mic-only fallback engines tag every segment `mic` (the remote
+ * side reaches the transcript only as bleed into the same microphone), and
+ * cloud transcription of a single mixed track tags nothing at all. Attributing
+ * those to the recording owner reads as fact and is wrong for every line the
+ * other person spoke — including in the AI summary and action items derived
+ * from it. A per-segment `speaker` label from a diarizing provider counts as
+ * signal even when `source` is absent.
+ *
+ * Only meaningful when two people could have spoken; a solo recording that is
+ * all mic genuinely is all one person.
+ */
+export function transcriptDistinguishesSpeakers(
+  segments: TranscriptSegment[],
+  participants: AttendeeStackParticipant[],
+  ownerEmail?: string | null,
+): boolean {
+  if (countPossibleSpeakers(participants, ownerEmail) < 2) return true;
+  const signals = new Set<string>();
+  for (const segment of segments) {
+    const signal = speakerSignal(segment);
+    if (signal) signals.add(signal);
+    if (signals.size > 1) return true;
+  }
+  return false;
+}
+
+/**
+ * What one segment claims about who was speaking, as a comparable key.
+ *
+ * A generic placeholder is not an identity — it names a side of the
+ * conversation, which is what `source` already says. Counting `speaker: "Me"`
+ * and a plain `source: "mic"` as two different speakers would mark a mic-only
+ * transcript distinguishable and hand the remote side's bleed back to the
+ * owner's name, so placeholders resolve to the side they mean instead. A real
+ * name wins over `source`, since a diarizing provider knows more than the
+ * stream split does; a placeholder yields to it.
+ */
+function speakerSignal(segment: TranscriptSegment): string | null {
+  const speaker = segment.speaker?.trim();
+  const side = placeholderSide(speaker);
+  if (speaker && !side) return `speaker:${normalizeSpeaker(speaker)}`;
+  if (segment.source) return `source:${segment.source}`;
+  // No placeholder and no source is an absence of information, not a side.
+  // Defaulting it to "system" here would make a transcript that mixes tagged
+  // and untagged segments look like two speakers.
+  return side ? `source:${side}` : null;
+}
+
+/**
+ * How many people could have spoken in this meeting.
+ *
+ * The participant roster is the calendar attendee list, which routinely omits
+ * the recording owner — `create-meeting` deliberately does not synthesize a row
+ * for a non-attendee owner, because that table feeds the public share payload.
+ * So counting rows alone reads an owner-plus-one-attendee meeting as solo and
+ * hands a mic-only transcript back to attribution, which is what labels the
+ * remote side's bleed as the owner.
+ *
+ * A withheld owner (`null`, from the public share page) still counts: it means
+ * an owner exists and is not among the participants. An owner we were never
+ * told about (`undefined`) also counts, because "we cannot name them" is not
+ * the same as "they are not there" — the cost of over-counting is a lost label,
+ * and the cost of under-counting is a false one.
+ */
+function countPossibleSpeakers(
+  participants: AttendeeStackParticipant[],
+  ownerEmail?: string | null,
+): number {
+  const ownerInRoster = ownerEmail
+    ? Boolean(findParticipant(ownerEmail, participants))
+    : false;
+  return participants.length + (ownerInRoster ? 0 : 1);
+}
+
+const UNATTRIBUTED_SPEAKER: SpeakerIdentity = {
+  key: "unattributed",
+  label: null,
+  initialsSource: "",
+  isOwner: false,
+  accentClass: "",
+  unattributed: true,
+};
+
 const SPEAKER_ACCENTS = [
   "bg-accent text-accent-foreground",
   "bg-secondary text-secondary-foreground",
@@ -75,6 +166,37 @@ function normalizeSpeaker(value: string): string {
   return value.trim().toLowerCase().replace(/\s+/g, " ");
 }
 
+// Some providers (and our own seed fixture) tag unresolved segments with a
+// literal placeholder word instead of leaving `speaker` blank. These name a
+// side of the conversation rather than a person, so neither the label nor the
+// attribution check may treat one as an identity.
+const GENERIC_MIC_SPEAKER = /^(me|self|you)$/i;
+const GENERIC_SYSTEM_SPEAKER = /^them$/i;
+
+/** The side a generic placeholder names, or null when it names a person. */
+function placeholderSide(
+  label: string | null | undefined,
+): "mic" | "system" | null {
+  const speaker = label?.trim();
+  if (!speaker) return null;
+  if (GENERIC_MIC_SPEAKER.test(speaker)) return "mic";
+  if (GENERIC_SYSTEM_SPEAKER.test(speaker)) return "system";
+  return null;
+}
+
+/**
+ * Which side of the conversation a segment belongs to.
+ *
+ * `source` is the real signal, but a segment can arrive with only a
+ * placeholder speaker on it. Falling straight through to "system" then drops
+ * every "Me" into the remote group, which is how a transcript labelled purely
+ * with placeholders renders entirely as "Them" — the original bug. Read the
+ * side the placeholder names before defaulting.
+ */
+function segmentSide(segment: TranscriptSegment): "mic" | "system" {
+  return segment.source ?? placeholderSide(segment.speaker) ?? "system";
+}
+
 // Exported for regression testing — see transcript-bubbles.test.ts. These
 // are pure functions with no dependency on the component itself.
 export function findParticipant(
@@ -139,22 +261,23 @@ export function resolveSpeaker(
   participants: AttendeeStackParticipant[],
   ownerEmail?: string | null,
 ): SpeakerIdentity {
-  const source = segment.source === "mic" ? "mic" : "system";
+  const source = segmentSide(segment);
   const rawSpeaker = segment.speaker?.trim();
   const participant =
     findParticipant(segment.speaker, participants) ||
     resolveParticipantForSpeaker(source, participants, ownerEmail);
   const participantName = participant?.name?.trim();
   const resolvedLabel = participantName || rawSpeaker;
-  // Some providers (and our own seed fixture) tag unresolved segments with a
-  // literal placeholder word instead of leaving speaker blank. Treat those the
-  // same as "no label" on both sides so the UI falls back to the translated
-  // Me/Them string instead of rendering the raw English placeholder verbatim.
+  // Treat a placeholder as "no label" so the UI falls back to the translated
+  // Me/Them string instead of rendering the raw English word verbatim. Only
+  // the placeholder matching this segment's own side counts: "Them" on a mic
+  // segment is a contradiction, not a placeholder, and keeping it visible is
+  // better than silently dropping it.
   const isGenericPlaceholderLabel =
     !!resolvedLabel &&
     (source === "mic"
-      ? /^(me|self|you)$/i.test(resolvedLabel)
-      : /^them$/i.test(resolvedLabel));
+      ? GENERIC_MIC_SPEAKER.test(resolvedLabel)
+      : GENERIC_SYSTEM_SPEAKER.test(resolvedLabel));
   const label = isGenericPlaceholderLabel
     ? null
     : participantName || rawSpeaker || null;
@@ -203,9 +326,16 @@ function groupConsecutive(
   participants: AttendeeStackParticipant[],
   ownerEmail?: string | null,
 ): BubbleGroup[] {
+  const attributable = transcriptDistinguishesSpeakers(
+    segments,
+    participants,
+    ownerEmail,
+  );
   const groups: BubbleGroup[] = [];
   segments.forEach((seg, index) => {
-    const speaker = resolveSpeaker(seg, participants, ownerEmail);
+    const speaker = attributable
+      ? resolveSpeaker(seg, participants, ownerEmail)
+      : UNATTRIBUTED_SPEAKER;
     const last = groups[groups.length - 1];
     if (last && last.speaker.key === speaker.key) {
       last.segments.push({ seg, index });
@@ -509,38 +639,40 @@ export function TranscriptBubbles({
                   key={`${group.speaker.key}:${gi}`}
                   className="space-y-0.5"
                 >
-                  <div className="flex h-6 items-center gap-2">
-                    <Avatar
-                      className={cn(
-                        "size-6 shrink-0",
-                        group.speaker.accentClass,
-                      )}
-                    >
-                      <AvatarFallback
+                  {!group.speaker.unattributed && (
+                    <div className="flex h-6 items-center gap-2">
+                      <Avatar
                         className={cn(
-                          "text-[9px] font-semibold",
+                          "size-6 shrink-0",
                           group.speaker.accentClass,
                         )}
                       >
-                        {attendeeInitials(group.speaker.initialsSource)}
-                      </AvatarFallback>
-                    </Avatar>
-                    <div className="flex min-h-6 items-center">
-                      <span
-                        className={cn(
-                          "text-xs font-semibold leading-6",
-                          group.speaker.isOwner
-                            ? "text-primary"
-                            : "text-foreground",
-                        )}
-                      >
-                        {group.speaker.label ||
-                          (group.speaker.isOwner
-                            ? t("transcriptBubbles.me")
-                            : t("transcriptBubbles.them"))}
-                      </span>
+                        <AvatarFallback
+                          className={cn(
+                            "text-[9px] font-semibold",
+                            group.speaker.accentClass,
+                          )}
+                        >
+                          {attendeeInitials(group.speaker.initialsSource)}
+                        </AvatarFallback>
+                      </Avatar>
+                      <div className="flex min-h-6 items-center">
+                        <span
+                          className={cn(
+                            "text-xs font-semibold leading-6",
+                            group.speaker.isOwner
+                              ? "text-primary"
+                              : "text-foreground",
+                          )}
+                        >
+                          {group.speaker.label ||
+                            (group.speaker.isOwner
+                              ? t("transcriptBubbles.me")
+                              : t("transcriptBubbles.them"))}
+                        </span>
+                      </div>
                     </div>
-                  </div>
+                  )}
                   <div className="space-y-1">
                     {group.segments.map(({ seg, index }) => {
                       return (

package/corpus/templates/clips/desktop/src/lib/transcription-capture.ts

@@ -36,7 +36,9 @@ function wait(ms: number): Promise<void> {
 export interface CapturedTranscript {
   /** Speaker-labelled text, lines joined by blank lines. */
   text: string;
-  /** Real whisper segments with verbatim timestamps. */
+  /** Whisper's verbatim timestamps where the engine reported them, else one
+   *  synthesized segment per line — the mic-only engines report no timings,
+   *  and a dropped line would lose its speaker along with its text. */
   segments: SourcedTranscriptSegment[];
   /** Source stored with `save-browser-transcript`. */
   source?: "web-speech" | "macos-native" | "whisper";
@@ -332,9 +334,14 @@ export async function startTranscriptionCapture(
     });
   };
 
+  // `source` reports the engine that actually produced this transcript, not
+  // the one we asked for: `startTranscriptionEngine` may have fallen back to
+  // mic-only macos-native. Omitting it made the server default to "whisper"
+  // and treat a mic-only capture as mixed mic + system audio.
   const captured = (): CapturedTranscript => ({
     text: transcriptFullText(lines),
     segments: transcriptSegments(lines),
+    source: engine,
   });
 
   let engine: TranscriptionEngine;

package/corpus/templates/clips/desktop/src/lib/transcription-engine.ts

@@ -245,11 +245,48 @@ export function transcriptFullText(lines: TranscriptLine[]): string {
     .trim();
 }
 
-/** Flattened verbatim segments, as persisted alongside the text. */
+/** Rough duration estimate for a line with no verbatim timing, matching the
+ *  pacing `buildCaptionSegmentsFromText` uses server-side. */
+function estimatedLineDurationMs(text: string): number {
+  const words = text.split(/\s+/).filter(Boolean).length || 1;
+  return Math.max(900, words * 420);
+}
+
+/** Flattened verbatim segments, as persisted alongside the text.
+ *
+ *  A line with no verbatim timings still contributes one synthesized segment
+ *  rather than being dropped: the mic-only fallback engines report no
+ *  timestamps at all, and dropping the line loses its text and its `source`
+ *  — and a `source`-less stored segment silently renders as "Them". Those
+ *  engines report `startMs: null` on *every* line, so a synthesized segment
+ *  continues from the previous line's end; anchoring each at its own
+ *  null-coalesced 0 would stack the whole transcript on one instant and break
+ *  ordering and timestamp seeking. */
 export function transcriptSegments(
   lines: TranscriptLine[],
 ): SourcedTranscriptSegment[] {
-  return lines.flatMap((line) => line.segments);
+  const segments: SourcedTranscriptSegment[] = [];
+  let cursorMs = 0;
+  for (const line of lines) {
+    if (line.segments.length) {
+      segments.push(...line.segments);
+      cursorMs = line.segments.reduce(
+        (latest, segment) => Math.max(latest, segment.endMs),
+        cursorMs,
+      );
+      continue;
+    }
+    // `appendFinalTranscript` is the only path that yields an untimed line and
+    // it always pairs `segments: []` with `startMs: null`, so today this reads
+    // as `cursorMs`. Honouring a line's own stamp is for the shape the type
+    // still permits (see `historyLine` in overlays/live-transcript.tsx), and
+    // clamping to the cursor keeps a stale stamp from reordering the transcript.
+    const startMs = Math.max(line.startMs ?? cursorMs, cursorMs);
+    const endMs = startMs + estimatedLineDurationMs(line.text);
+    segments.push({ startMs, endMs, text: line.text, source: line.source });
+    cursorMs = endMs;
+  }
+  return segments;
 }
 
 /**

package/corpus/templates/forms/server/lib/public-form-ssr.ts

@@ -601,6 +601,9 @@ function renderFormPage(
         if (v) data[f.id] = parseInt(v);
       } else if (f.type === "scale") {
         data[f.id] = parseInt(el.querySelector(".slider").value);
+      } else if (f.type === "radio") {
+        var checked = el.querySelector('input[type="radio"]:checked');
+        if (checked && checked.value) data[f.id] = checked.value;
       } else {
         var input = el.querySelector("input, textarea, select");
         if (input && input.value) data[f.id] = input.value;

package/corpus/templates/slides/actions/list-decks.ts

@@ -22,7 +22,9 @@ export default defineAction({
     includeSlides: z
       .enum(["true", "false"])
       .optional()
-      .describe("Set to 'true' for full frontend deck payloads"),
+      .describe(
+        "Set to 'true' for full frontend deck payloads; omitted returns metadata only",
+      ),
     light: z
       .enum(["true", "false"])
       .optional()
@@ -84,6 +86,39 @@ export default defineAction({
       return { count: rows.length, decks: rows };
     }
 
+    if (args.includeSlides !== "true") {
+      // The deck body is an opaque JSON blob containing every slide's HTML.
+      // Metadata callers must opt into it explicitly; the frontend opens one
+      // deck at a time through get-deck instead of downloading every body.
+      const rows = await db
+        .select({
+          id: schema.decks.id,
+          title: schema.decks.title,
+          ownerEmail: schema.decks.ownerEmail,
+          designSystemId: schema.decks.designSystemId,
+          createdAt: schema.decks.createdAt,
+          updatedAt: schema.decks.updatedAt,
+          visibility: schema.decks.visibility,
+        })
+        .from(schema.decks)
+        .where(where)
+        .orderBy(desc(schema.decks.updatedAt));
+
+      return {
+        count: rows.length,
+        decks: rows.map((row) => ({
+          id: row.id,
+          title: row.title,
+          url: getDeckUrl(row.id),
+          visibility: row.visibility,
+          designSystemId: row.designSystemId ?? null,
+          createdByMe: ownerEmail ? row.ownerEmail === ownerEmail : false,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt,
+        })),
+      };
+    }
+
     const rows = await db
       .select()
       .from(schema.decks)

package/corpus/templates/slides/app/components/editor/SlideEditor.tsx

@@ -965,11 +965,13 @@ function MultiSelectOutline({
 }
 
 /** Translucent rectangle drawn while marquee-dragging */
+type MarqueeSelectionRect = { x: number; y: number; w: number; h: number };
+
 function MarqueeRect({
   rect,
   viewportRect,
 }: {
-  rect: { x: number; y: number; w: number; h: number };
+  rect: MarqueeSelectionRect;
   viewportRect: DOMRect | null;
 }) {
   return (
@@ -1204,12 +1206,7 @@ export default function SlideEditor({
   /** Anchor rect for the floating chip (the slide canvas) */
   const [chipAnchorRect, setChipAnchorRect] = useState<DOMRect | null>(null);
   /** Active marquee rectangle (viewport coords). null = not dragging. */
-  const [marquee, setMarquee] = useState<{
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-  } | null>(null);
+  const [marquee, setMarquee] = useState<MarqueeSelectionRect | null>(null);
   const [activeAlignmentGuides, setActiveAlignmentGuides] = useState<{
     guides: SlideAlignmentGuide[];
     viewport: AlignmentGuideViewport;
@@ -1502,6 +1499,8 @@ export default function SlideEditor({
   }, [overflowInfo, slide.id, dims.width, dims.height]);
   /** Marquee origin (viewport coords). Set on pointerdown. */
   const marqueeOriginRef = useRef<{ x: number; y: number } | null>(null);
+  /** Latest marquee geometry, readable by the stable window pointer handlers. */
+  const marqueeRef = useRef<MarqueeSelectionRect | null>(null);
   /** Set right before placing a text box so the click event that follows the
    *  placing pointerdown doesn't fall through to click-to-select/deselect
    *  logic and steal focus back off the freshly created box. */
@@ -4432,7 +4431,12 @@ export default function SlideEditor({
       marqueeOriginRef.current = { x: e.clientX, y: e.clientY };
       marqueeAdditiveRef.current = e.shiftKey || e.metaKey || e.ctrlKey;
       marqueePrevSelectionRef.current = new Set(multiSelection);
-      setMarquee({ x: e.clientX, y: e.clientY, w: 0, h: 0 });
+      const initialMarquee = { x: e.clientX, y: e.clientY, w: 0, h: 0 };
+      marqueeRef.current = initialMarquee;
+      setMarquee(initialMarquee);
+      if (e.pointerId >= 0) {
+        e.currentTarget.setPointerCapture(e.pointerId);
+      }
 
       // Clear single-select feedback when starting a marquee on whitespace
       // (non-additive). Additive marquee preserves the existing selection.
@@ -4462,25 +4466,28 @@ export default function SlideEditor({
     ],
   );
 
-  // Window-level pointermove / pointerup so the drag still tracks if the
-  // pointer leaves the slide.
+  // Keep these listeners stable while React re-renders the marquee overlay.
+  // Re-attaching them whenever marquee state changes can lose a fast
+  // pointermove/pointerup between the effect cleanup and re-install.
   useEffect(() => {
-    if (!marquee) return;
     const onMove = (e: PointerEvent) => {
       const origin = marqueeOriginRef.current;
-      if (!origin) return;
+      if (!origin || !marqueeRef.current) return;
       const x = Math.min(origin.x, e.clientX);
       const y = Math.min(origin.y, e.clientY);
       const w = Math.abs(e.clientX - origin.x);
       const h = Math.abs(e.clientY - origin.y);
-      setMarquee({ x, y, w, h });
+      const nextMarquee = { x, y, w, h };
+      marqueeRef.current = nextMarquee;
+      setMarquee(nextMarquee);
     };
-    const onUp = () => {
+    const finish = (cancelled: boolean) => {
       const origin = marqueeOriginRef.current;
-      const current = marquee;
+      const current = marqueeRef.current;
       marqueeOriginRef.current = null;
+      marqueeRef.current = null;
       setMarquee(null);
-      if (!origin || !current) return;
+      if (cancelled || !origin || !current) return;
 
       const slideContent = getSlideContent();
       if (!slideContent) return;
@@ -4518,13 +4525,18 @@ export default function SlideEditor({
 
       applyMultiSelection(hits);
     };
+
+    const onUp = () => finish(false);
+    const onCancel = () => finish(true);
     window.addEventListener("pointermove", onMove);
     window.addEventListener("pointerup", onUp);
+    window.addEventListener("pointercancel", onCancel);
     return () => {
       window.removeEventListener("pointermove", onMove);
       window.removeEventListener("pointerup", onUp);
+      window.removeEventListener("pointercancel", onCancel);
     };
-  }, [marquee, getSlideContent, applyMultiSelection]);
+  }, [getSlideContent, applyMultiSelection]);
 
   /** Send the current selection to the agent chat composer */
   const sendSelectionToAgent = useCallback(() => {

package/corpus/templates/slides/app/context/DeckContext.tsx

@@ -940,7 +940,7 @@ export function deriveInverseOp(
 }
 
 /**
- * Fetch the deck list. Returns `null` on any failure (network error, non-2xx
+ * Fetch the deck metadata list. Returns `null` on any failure (network error, non-2xx
  * response) so callers can distinguish "authoritative empty list" from
  * "couldn't reach the server" — wiping local state on a transient failure
  * kicks the user out of the editor and shows the "Create your first deck"
@@ -951,7 +951,7 @@ async function fetchDecksFromAPI(): Promise<Deck[] | null> {
   try {
     const result = await callAction<DeckListActionResult>(
       "list-decks",
-      { includeSlides: "true" },
+      { light: "true" },
       { method: "GET" },
     );
     if (!Array.isArray(result?.decks)) {
@@ -1076,12 +1076,23 @@ export async function includeOpenDeckIfMissing(
 async function fetchDecksForCurrentRoute(): Promise<Deck[] | null> {
   const currentOpenDeckId = currentOpenDeckIdFromWindow();
   const loaded = await fetchDecksFromAPI();
-  if (loaded !== null) {
-    return includeOpenDeckIfMissing(loaded, currentOpenDeckId);
+  if (loaded === null) {
+    if (!currentOpenDeckId) return null;
+    const directDeck = await fetchDeckFromAPI(currentOpenDeckId);
+    return directDeck ? [directDeck] : null;
   }
-  if (!currentOpenDeckId) return null;
+  if (!currentOpenDeckId) return loaded;
+
+  // The list is intentionally metadata-only. Hydrate just the deck the user
+  // opened so the editor gets full slide content without making the home page
+  // download every deck body.
   const directDeck = await fetchDeckFromAPI(currentOpenDeckId);
-  return directDeck ? [directDeck] : null;
+  if (!directDeck) return loaded;
+  const index = loaded.findIndex((deck) => deck.id === currentOpenDeckId);
+  if (index < 0) return [...loaded, directDeck];
+  const next = [...loaded];
+  next[index] = directDeck;
+  return next;
 }
 
 async function deleteDeckFromAPI(id: string): Promise<void> {