How workout data is created, stored, and read after V21, and what changed from the old dual-store model.

Engine execution (IOutputStatement[])
        │
        ▼
EventRecord rows in `events`            ← THE single statement/metric store
        │
        ├── projectEventToFacts(record) → AnalyticsDataPoint  (WQL filters/aggregates)
        └── eventsToStoredLogs(events)  → StoredOutputStatement[]  (display, replay)

Session rows in `sessions`              ← execution metadata only (no statements)

Session carries identity and totals (id, noteId, block content, start/end, duration, completed). EventRecord carries every statement and metric. Nothing stores the statement stream twice.

Workout execution runs in the CodeMirror editor or fullscreen timer:

• apps/playground/src/components/organisms/editor/NoteEditor.tsx and .../review/FullscreenTimer.tsx drive the run.
• The Whiteboard runtime (@bitcobblers/wod-wiki-engine) emits IOutputStatements (reps, loads, elapsed time, HR).
• On completion, resultRecorder.record(...) hands the payload to the persistence seam.

The editor and fullscreen timer await the recorder before showing saved results or dismissing a reported run. Next-driven completion counts even without starting the playback loop. Stop preserves a partial run; stopping after the stack drains preserves completion. Live output counts mean captured, not saved.

A rejected write keeps the overlay open with its payload and result ID. Retry save reuses that ID and the existing session-results query. Badges and mounted Sessions listings refresh after commit.

Session metadata, event rows, and summaries share the note mutation's IndexedDB transaction in IndexedDBNotePersistence.mutateNote / IndexedDBContentProvider.updateEntry. A rejected write aborts the transaction:

1. Session row — saveSession writes the flattened metadata record (scalars only).
2. Event rows — toEventRows(logs, identity) converts each statement to an EventRecord (grain: 'event', id ${resultId}:${seq}) and toSummaryEventRows folds Tier-2 outputs into grain: 'summary' rows; appendEvents + finalizeSummaries persist them.

The event rows are the archival record. If a later re-derivation runs (rederiveResultAnalytics), it purges the result's event rows and re-appends the replayed set, so the store converges to exactly one row set.

QueryService fetches EventRecord[] by time range, result, note, or block content, then flattens each row with projectEventToFacts(record) into one AnalyticsDataPoint per numeric metric. Filters, buckets, rollups, and cross-workout joins run on those facts. Joins are relational: resultId → session, noteId → note (and through page_notes to pages), blockContentId → same workout across notes and days.

eventsToStoredLogs(events) is the inverse of toEventRows: it rebuilds an ordered StoredOutputStatement[] from a session's event rows. Consumers:

• sessionToPayload(session, events) reconstructs the results payload a HistoryEntry exposes, so review grids and analytics views keep working.
• replayResultAnalytics(block, events) feeds the headless engine to recompute Tier-1/Tier-2 outputs after edits or RPE capture.

The live runtime still hands getAnalyticsFromLogs its in-memory statement stream directly; nothing round-trips through IndexedDB mid-run.

The V21 upgrade copies each session's scalar fields onto the row, projects any unprojected legacy logs into event rows (idempotent, deterministic ids), then drops data.