fix(editor): live preview shows the whole recurring series, not just one event

Recurrence rows ("+ Add recurrence") were only ever expanded into real
occurrences at Review & submit time (proposeOrGenerate), so the live
preview added earlier never reflected them — it kept showing exactly one
card (the shared template) no matter how many dates the series would
actually generate.

refresh() now reuses the same expansion (buildRecurringEvents +
expandRecurrenceDates) used by Review & submit, via getRecurrenceSeries(),
and previews every occurrence once at least one recurrence row exists.
Falls back to the single-event preview when there are no rows, including
in bulk-edit mode, where renderForm never wires recurrence rows at all.

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

Author: claude

apps/editor/CHANGELOG.md

@@ -6,6 +6,13 @@ tied to semver releases.
 
 ## 2026-08-13
 
+- **Live preview now shows the whole series, not just the template**: once
+  one or more "+ Add recurrence" rows exist, the preview expands them the
+  same way Review & submit would (`buildRecurringEvents`/
+  `expandRecurrenceDates`) and shows every generated occurrence, instead of
+  a single card for the shared template. Previously the preview always
+  showed exactly one event regardless of any recurrence rows, since they
+  were only ever expanded at Review & submit time.
 - **Live preview**: the form now renders the event being edited with the
   same `<ote-events>` widget (`apps/embed`) used elsewhere in the app, fed
   purely in-memory from the current draft (`layout="cards"`, debounced ~200ms

apps/editor/CLAUDE.md

@@ -172,14 +172,27 @@ already self-hosted via `dist/embed` — see `build.mjs`) as the events list
 view, but driven from the in-memory draft rather than a fetched feed:
 `main.ts`'s `refresh()` computes `toEventJson(state)` and calls
 `schedulePreviewUpdate()`, which debounces ~200ms then sets
-`previewWidget.events = [event]`. This works because
+`previewWidget.events = events`. This works because
 `oteJsonToPreviewFeed` (`packages/preview-feed`) treats every event field as
 optional and only ever throws if its input isn't shaped like `{ events:
 [...] }` — never true here — so the preview renders fine even for a blank
 new-event draft or mid-edit bulk-edit template. There is deliberately no
 "wait until the draft is schema-valid" gate; if you're tempted to add one,
 it isn't needed and would just make the preview lag behind typing.
 
+`events` is `[toEventJson(state)]` (one card) only when `getRecurrenceSeries()`
+is empty. Once one or more "+ Add recurrence" rows exist, `refresh()` expands
+them the same way `proposeOrGenerate()` does at Review & submit time
+(`buildRecurringEvents(s, expandRecurrenceDates(s.rule))` per row, flattened)
+and previews every occurrence instead — otherwise the preview would keep
+showing just the shared template while the organizer builds a series, which
+is exactly the state that's about to disappear once Review & submit expands
+it for real. `getRecurrenceSeries` reads `renderForm`'s live recurrence-row
+state (via its own `getSeries` closure) and only exists in the normal
+single-event render path — `renderForm` never wires it up in bulk-edit mode
+(`bulkEditChecklist` set), so it stays `() => []` there and bulk edit keeps
+previewing the shared template alone, same as before.
+
 ## OTE has no recurrence-rule concept
 
 The spec is explicit: one document per occurrence, always ("un documento

apps/editor/src/main.ts

@@ -889,22 +889,35 @@ async function startEditor(repo: string | null): Promise<void> {
   let draftValid = false;
 
   // Debounced so a fast typist doesn't force a full shadow-DOM re-render on
-  // every keystroke; the preview always reflects `state` as of the most
-  // recent refresh() call, including mid-edit while bulk-editing a series
-  // template — toEventJson() never throws on a partial/blank event (see
-  // packages/preview-feed's tolerant field handling), so no separate
-  // "wait until valid" gate is needed here.
+  // every keystroke; the preview always reflects `state` (and, once one or
+  // more recurrence rows exist, every occurrence they'd generate) as of the
+  // most recent refresh() call — toEventJson() never throws on a
+  // partial/blank event (see packages/preview-feed's tolerant field
+  // handling), so no separate "wait until valid" gate is needed here.
   let previewTimer: ReturnType<typeof setTimeout> | undefined;
-  function schedulePreviewUpdate(event: OteEvent): void {
+  function schedulePreviewUpdate(events: OteEvent[]): void {
     clearTimeout(previewTimer);
     previewTimer = setTimeout(() => {
-      previewWidget.events = [event] as unknown as OriginalOteEvent[];
+      previewWidget.events = events as unknown as OriginalOteEvent[];
     }, 200);
   }
 
   function refresh(): boolean {
     const event = toEventJson(state);
-    schedulePreviewUpdate(event);
+    // "+ Add recurrence" rows (getRecurrenceSeries, wired from renderForm)
+    // aren't reflected in `state` itself — they only get expanded into real
+    // occurrences at Review & submit time (proposeOrGenerate, below). The
+    // preview reuses that same expansion (buildRecurringEvents/
+    // expandRecurrenceDates) so it shows the whole series being built
+    // instead of just the shared template with one date. Empty in bulk-edit
+    // mode too (renderForm never wires recurrence rows there), so this
+    // falls through to the single-event preview as before.
+    const series = getRecurrenceSeries();
+    schedulePreviewUpdate(
+      series.length > 0
+        ? series.flatMap((s) => buildRecurringEvents(s, expandRecurrenceDates(s.rule)) as unknown as OteEvent[])
+        : [event],
+    );
 
     // Bulk-edit template: id/slug/startDate are deliberately blank (see
     // buildBulkEditTemplate) — the normal required-field validation would