// circuits.jsx — circuit/grouping data + new Main Sets screen // Three naming conventions per exercise + smart columns auto-detect // Helper: build N identical sets from a template const setsOf = (n, template) => Array.from({ length: n }, () => ({ done: false, rpe: null, ...template })); const CIRCUITS = [ { id: 'c1', kind: 'couplet', label: 'Squats & Step and Punch', rounds: 2, rest: '60s', exercises: [ { id: 'e1', systemName: 'SquatShoulderWidthWHF', shortName: 'Squats', fullName: 'Squats with feet shoulder width with hands free', flagged: false, sets: [ // Multi-weight demo: every set carries the same three loads. // Real workouts rarely change weight rig mid-circuit, so the // labelled list should persist into round 2. { reps: 15, weight: [ { kind: 'ankle weight', value: 10 }, { kind: 'chest dumbbell', value: 4 }, { kind: 'weight vest', value: 3 }, ], weight2: null, equip: null, done: false }, { reps: 15, weight: [ { kind: 'ankle weight', value: 10 }, { kind: 'chest dumbbell', value: 4 }, { kind: 'weight vest', value: 3 }, ], weight2: null, equip: null, done: false }, ], }, { id: 'e2', systemName: 'StepMediumAndOppCablePunch', shortName: 'Step and Opposite Punch', fullName: 'Step medium with opp arm cable press', flagged: false, // Tempo is the whole point of this movement — always surface it, // even when global tempo is off or the user is in Basic view. focusColumns: ['tempo'], sets: [ { reps: 10, weight: 10, equip: '8', tempo: '2-0-1', rpe: 7, done: false }, { reps: 10, weight: 10, equip: '8', tempo: '2-0-1', rpe: 7, done: false }, ], }, ], }, { id: 'c2', kind: 'single', label: 'Wall Sit', rounds: 5, rest: '45s', exercises: [ { id: 'e3', systemName: 'WallSitNeutralFeetWShoulderPressNeutralElbowNeutralGrip', shortName: 'Wall sit with shoulder press', fullName: 'Wall sit with feet hip width with double arm shoulder press with elbows neutral width and neutral grip', flagged: false, // Equipment hub setting drives the whole press — promote it always. focusColumns: ['equip'], // Labeled pad settings are part of the rig for THIS exercise, so // every set carries the same three settings (trainer sets them // once, all rounds use them). sets: [ { reps: '30s', weight: 5, weight2: null, equip: [ { name: 'Seat Pad', value: 2 }, { name: 'Thigh Pad', value: 4 }, { name: 'Back Pad', value: 1 }, ], done: false }, { reps: '30s', weight: 5, weight2: null, equip: [ { name: 'Seat Pad', value: 2 }, { name: 'Thigh Pad', value: 4 }, { name: 'Back Pad', value: 1 }, ], done: false }, { reps: '30s', weight: 5, weight2: null, equip: [ { name: 'Seat Pad', value: 2 }, { name: 'Thigh Pad', value: 4 }, { name: 'Back Pad', value: 1 }, ], done: false }, { reps: '30s', weight: 5, weight2: null, equip: [ { name: 'Seat Pad', value: 2 }, { name: 'Thigh Pad', value: 4 }, { name: 'Back Pad', value: 1 }, ], done: false }, { reps: '30s', weight: 5, weight2: null, equip: [ { name: 'Seat Pad', value: 2 }, { name: 'Thigh Pad', value: 4 }, { name: 'Back Pad', value: 1 }, ], done: false }, ], }, ], }, { id: 'c3', kind: 'triplet', label: 'Jump Rope & Curls & Chest Press', rounds: 4, rest: '60s', exercises: [ { id: 'e4', systemName: 'JumpRope', shortName: 'Jump Rope', fullName: 'Jump Rope', flagged: false, // Cardio intensity — RPE matters more than weight or tempo. focusColumns: ['rpe'], sets: setsOf(4, { reps: '30s', weight: null, weight2: null, equip: null, rpe: 7 }), }, { id: 'e5', systemName: 'StanceSingleLegWBicepsCurlsSupinated', shortName: 'Single leg stance with biceps curls', fullName: 'Single leg stance with supinated biceps curls', flagged: false, sets: setsOf(4, { reps: 10, weight: 8, weight2: null, equip: null }), }, { id: 'e6', systemName: 'ChestPressWideAltCableSeatedChair', shortName: 'Seated Alternating Chest Press', fullName: 'Seated on chair alternating Cable chest press with wide elbows', flagged: false, // Controlled tempo under load + RPE for progressive overload tracking. focusColumns: ['tempo', 'rpe'], sets: [ // Demo of the vertical-expansion pattern: tempo 2-0-6-0 occupies // four rows; weight (20) and RPE (7) live on row 1 only. { reps: 15, weight: 20, equip: '12', tempo: '2-0-6-0', rpe: 7, done: false }, { reps: 15, weight: 10, equip: '12', tempo: '2-1-2', rpe: 7, done: false }, { reps: 15, weight: 10, equip: '12', tempo: '2-1-2', rpe: 7, done: false }, { reps: 15, weight: 10, equip: '12', tempo: '2-1-2', rpe: 8, done: false }, ], }, ], }, // Bonus core circuit for variety in demo { id: 'c4', kind: 'single', label: 'Crunches', rounds: 2, rest: '30s', exercises: [ { id: 'e7', systemName: 'CrunchesHeadCradledWFeetFlatKneesBent', shortName: 'Crunches', fullName: 'Crunches with head cradled with feet flat with knees bent', flagged: false, sets: setsOf(2, { reps: 10, weight: null, weight2: null, equip: null }), }, ], }, ]; const KIND_LABEL = { single: 'Single', couplet: 'Couplet', triplet: 'Triplet', giant: 'Giant Set' }; // Detect which optional columns this circuit needs function smartColumns(circuit) { const cols = { equip: false, tempo: false, rpe: false }; circuit.exercises.forEach(ex => { ex.sets.forEach(s => { if (hasAnyValue(s.equip)) cols.equip = true; if (hasAnyValue(s.tempo)) cols.tempo = true; if (s.rpe != null && s.rpe !== '') cols.rpe = true; }); }); return cols; } // A cell value counts as "present" if any element of the multi-value list // is non-empty. Lets a set with weight=[10,12,null] still light up the col. function hasAnyValue(v) { if (Array.isArray(v)) return v.some(x => x != null && x !== ''); if (v == null || v === '') return false; if (typeof v === 'string' && v.includes('-')) return v.split('-').some(p => p.trim() !== ''); return true; } // ── Vertical-expansion + labeled-list helpers ──────────────────────────── // Tempo expands VERTICALLY (one row per number). Weight + equipment behave // differently: weight is summarised inline as "10, 4, 3" in the main row // and broken out in a labelled box below; equipment never appears in the // main row at all — it lives only in the breakdown box (the trainer sets // it once before the workout starts, so per-set lookup is rare). function expandSet(s) { const tempoParts = s.tempo != null && s.tempo !== '' ? String(s.tempo).split('-').map(p => p.trim()) : []; const weights = normalizeWeights(s.weight); const equips = normalizeEquip(s.equip); // Only tempo drives the vertical row span now — weight/equip live in the // expanded box, so they don't grow the main row stack. const rowSpan = Math.max(1, tempoParts.length); return { tempoParts, weights, equips, rowSpan }; } // Normalize a `weight` field into [{label, value}]. Accepts a scalar // ("10" / 10), a bare array ([10, 4, 3]), or an array of labeled entries // ([{kind, value}]). Empty values are filtered out so the breakdown box // doesn't render orphan rows. function normalizeWeights(w) { if (w == null || w === '') return []; const list = Array.isArray(w) ? w : [w]; return list .map(item => { if (item == null || item === '') return null; if (typeof item === 'object') { return { label: item.kind || item.label || '', value: item.value }; } return { label: '', value: item }; }) .filter(x => x !== null && x.value !== '' && x.value != null); } // Same shape for equipment. Equipment entries usually carry a name (e.g. // "Seat Pad") and a small numeric setting, so the {label, value} pair fits // naturally. Bare string entries ("Hub 4") render with no label. function normalizeEquip(e) { if (e == null || e === '') return []; const list = Array.isArray(e) ? e : [e]; return list .map(item => { if (item == null || item === '') return null; if (typeof item === 'object') { return { label: item.name || item.label || '', value: item.value }; } return { label: '', value: item }; }) .filter(x => x !== null && x.value !== '' && x.value != null); } // Display helpers — what goes in the compact main-row weight cell. function weightRowText(weights) { if (!weights.length) return ''; return weights.map(w => String(w.value)).join(', '); } // Write helpers — update the Nth slot of a multi-value field. They return // the *new value for that field* so the caller can pass a normal patch to // onUpdateSet({ tempo: … }) and the rest of the app sees one mutation. function tempoWithPart(s, idx, val) { const parts = s.tempo != null && s.tempo !== '' ? String(s.tempo).split('-') : []; while (parts.length <= idx) parts.push(''); parts[idx] = val; // Trim trailing empties so a deletion at the end shrinks the row span. while (parts.length > 1 && parts[parts.length - 1] === '') parts.pop(); return parts.join('-'); } function listWithSlot(current, idx, val) { const list = Array.isArray(current) ? [...current] : (current != null && current !== '' ? [current] : []); while (list.length <= idx) list.push(''); list[idx] = val; while (list.length > 1 && (list[list.length - 1] === '' || list[list.length - 1] == null)) list.pop(); // Collapse single-item array back to a scalar so simple sets stay simple. return list.length <= 1 ? (list[0] ?? '') : list; } function MainSetsCircuitsScreen({ theme, cardStyle, onBack, onNav, viewMode, setViewMode, circuits, onUpdateSet, onOpenFeedback, notes, onEditNote, tableStyle, setOrder, setSetOrder, columnPrefs }) { const [openId, setOpenId] = React.useState('c1'); const meta = FLOW_SECTIONS.find(s => s.id === 'main'); const hasMultiExercise = circuits.some(c => c.exercises.length > 1); const order = setOrder || 'interleaved'; return ( <> {/* Sticky header — TopBar + view/order banner travel together while scrolling */}
onNav('main-sets-print')} title="Print view — read-only, see all sets at a glance" style={{ display: 'inline-flex', alignItems: 'center', gap: 5, padding: '5px 11px 5px 9px', borderRadius: 9999, cursor: 'pointer', userSelect: 'none', background: theme.isDark ? 'rgba(255,255,255,0.06)' : 'rgba(0,0,0,0.05)', border: `1px solid ${theme.border}`, color: theme.text, fontFamily: theme.uiFamily, fontSize: 10, fontWeight: 700, textTransform: 'uppercase', letterSpacing: 0.5, }}> Print view
}/> {/* Banner: meta line + view/order toggles. ONE source of truth for both. */}
{circuits.length} circuits · {meta.est}
onNav('settings')} title="Settings — toggle which optional columns appear globally" style={{ marginLeft: 'auto', display: 'inline-flex', alignItems: 'center', gap: 4, padding: '4px 9px', borderRadius: 9999, cursor: 'pointer', userSelect: 'none', background: 'transparent', border: `1px solid ${theme.border}`, color: theme.muted, fontFamily: theme.uiFamily, fontSize: 10, fontWeight: 700, textTransform: 'uppercase', letterSpacing: 0.5, }}> Columns
{hasMultiExercise && ( )}
{/* Session-level note row */} onEditNote('session', null, 'Session note')}/> {circuits.map((c, i) => { const isOpen = openId === c.id; return ( setOpenId(isOpen ? null : c.id)} onUpdateSet={onUpdateSet} onOpenFeedback={onOpenFeedback} onNav={onNav} circuitNote={notes.circuit[c.id]} exerciseNotes={notes.exercise} onEditNote={onEditNote} /> ); })}
); } // Helper: gracefully no-op if setSetOrder wasn't passed. function setSetSetOrderOrDefault(fn) { return fn || (() => {}); } // Reusable segmented control for the sticky banner. function Segmented({ theme, label, value, options, onChange }) { return (
{label}
{options.map(o => (
onChange(o.v)} style={{ padding: '4px 11px', borderRadius: 9999, cursor: 'pointer', background: value === o.v ? theme.primary : 'transparent', color: value === o.v ? theme.primaryInk : theme.muted, fontFamily: theme.uiFamily, fontSize: 10, fontWeight: 700, textTransform: 'uppercase', letterSpacing: 0.4, whiteSpace: 'nowrap', }}>{o.label}
))}
); } function CircuitCard({ theme, cardStyle, circuit, index, isOpen, mode, tableStyle, order, onToggle, onUpdateSet, onOpenFeedback, onNav, circuitNote, exerciseNotes, onEditNote, columnPrefs }) { // Single-exercise circuits are inherently linear — interleaving is a no-op, // so we fall back to by-exercise to avoid the legend/badge overhead. const effectiveOrder = circuit.exercises.length < 2 ? 'by-exercise' : order; const cols = smartColumns(circuit); const completed = circuit.exercises.reduce((n, ex) => n + ex.sets.filter(s => s.done).length, 0); const total = circuit.exercises.reduce((n, ex) => n + ex.sets.length, 0); const pct = completed / total; return ( {/* Header — always tappable */}
{String(index + 1).padStart(2, '0')}
{KIND_LABEL[circuit.kind]} ×{circuit.rounds} · rest {circuit.rest}
{circuit.label}
{circuit.exercises.map(e => e.shortName).join(' + ')}
{completed}/{total}
{/* Progress bar */}
{isOpen && (
{effectiveOrder === 'interleaved' ? ( onNav(`exercise-${ex.id}`, { ex })} exerciseNotes={exerciseNotes} onEditNote={onEditNote}/> ) : ( circuit.exercises.map((ex, exIdx) => ( onEditNote('exercise', ex.id, ex.shortName)} onUpdateSet={(setIdx, patch) => onUpdateSet(ex.id, setIdx, patch)} onOpenFeedback={() => onOpenFeedback({ exerciseId: ex.id, exerciseName: ex.shortName })} onOpenDetail={() => onNav(`exercise-${ex.id}`, { ex })} /> )) )} {/* Circuit-level note */} onEditNote('circuit', circuit.id, circuit.label)}/>
)} ); } // ─── Session note (top of Main Sets) ───────────────────────────────────── function SessionNoteRow({ theme, cardStyle, note, onEdit }) { const has = note && note.trim(); return (
Session note
{has ? note : 'Add a note about today\'s session…'}
); } // ─── Circuit-level note (bottom of expanded circuit) ───────────────────── function CircuitNoteRow({ theme, note, onEdit }) { const has = note && note.trim(); return (
Circuit note
{has ? note : 'Add a note for this circuit…'}
); } function ExerciseInlineBlock({ theme, exercise, exIdx, mode, cols, tableStyle, isLast, onUpdateSet, onOpenFeedback, onOpenDetail, note, onEditNote, columnPrefs }) { const ex = exercise; const detailed = mode === 'detailed'; const accent = exerciseColor(theme, exIdx); const weightUnit = (columnPrefs && columnPrefs.weightUnit) || 'lb'; // Detect which optional columns THIS exercise has data for… const exDataCols = { equip: cols.equip && ex.sets.some(s => s.equip != null && s.equip !== ''), tempo: cols.tempo && ex.sets.some(s => s.tempo != null && s.tempo !== ''), rpe: cols.rpe && ex.sets.some(s => s.rpe != null && s.rpe !== ''), }; // Per-exercise focus override (e.g. focusColumns: ['tempo'] on a tempo- // critical movement) — promotes the column above global prefs and Basic. const focusCols = exerciseFocusCols(ex); // …gate them through global column prefs AND the basic/detailed mask AND // any focus overrides. const exCols = effectiveColumns(exDataCols, columnPrefs, mode, focusCols); // ⋯ chip: row has data AND that column is not currently visible (basic // OR settings-hidden — same affordance, both cases). const hiddenLabels = []; if (exDataCols.equip && !exCols.equip) hiddenLabels.push('Equip'); if (exDataCols.tempo && !exCols.tempo) hiddenLabels.push('Tempo'); if (exDataCols.rpe && !exCols.rpe) hiddenLabels.push('RPE'); const hasHidden = hiddenLabels.length > 0; // Focus labels — promoted columns that override Basic / Settings. const focusLabels = []; if (focusCols.equip && exDataCols.equip) focusLabels.push('Equip'); if (focusCols.tempo && exDataCols.tempo) focusLabels.push('Tempo'); if (focusCols.rpe && exDataCols.rpe) focusLabels.push('RPE'); const hasFocus = focusLabels.length > 0; return (
{/* Exercise header */}
{detailed ? ex.fullName : ex.shortName}
{ex.flagged &&
} {hasFocus && (
★ Focus · {focusLabels.join(' · ')}
)} {hasHidden && (
⋯
)}
{detailed && (
{ex.systemName}
)} {detailed && ex.flagged && ex.flagNote && (
⚐ {ex.flagNote}
)}
{/* Exercise-level note preview */} {note && (
{note}
)} {/* Set table — non-negotiable cols + smart cols */}
); } // Router — picks the table style function SetTable({ theme, ex, exIdx, cols, tableStyle, weightUnit, onUpdateSet }) { if (tableStyle === 'swipe') return ; if (tableStyle === 'flip') return ; if (tableStyle === 'expand') return ; return ; } function ClassicTable({ theme, ex, exIdx, cols, weightUnit, onUpdateSet }) { const wtLabel = `Wt (${weightUnit || 'lb'})`; const accent = exerciseColor(theme, exIdx); // Equipment never appears as a row column anymore — it lives only in the // per-set expanded breakdown. Same for individual weight entries when a // set carries more than one load (those collapse to a comma list in row). const colsList = ['Set', 'Reps', wtLabel]; if (cols.tempo) colsList.push('Tempo'); if (cols.rpe) colsList.push('RPE'); colsList.push('✓'); colsList.push(''); // chevron slot // Build grid template based on present cols. Weight gets more width now // that it may carry a comma list like "10, 4, 3". const parts = ['24px', '0.8fr', '1.4fr']; if (cols.tempo) parts.push('46px'); if (cols.rpe) parts.push('34px'); parts.push('26px'); parts.push('20px'); // chevron const grid = parts.join(' '); return (
{colsList.map((c, i) =>
{c}
)}
{ex.sets.map((s, setIdx) => ( ))}
); } // Renders one set as a *vertical group* of rows. The colored accent bar + // background tint span the full group so multi-value sets read as one unit. // When the set has multi-value weight OR any equipment data, a tappable // chevron toggles a labelled breakdown box at the bottom of the group. function SetGroup({ theme, accent, grid, cols, set, setIdx, exIdx, onUpdateSet, showSetCol }) { const { tempoParts, weights, equips, rowSpan } = expandSet(set); const hasBreakdown = weights.length > 1 || equips.length > 0 || weights.some(w => w.label); const [open, setOpen] = React.useState(false); const groupBg = set.done ? (theme.isDark ? 'rgba(52,211,153,0.10)' : 'rgba(46,125,50,0.07)') : exerciseSetTint(theme, exIdx, setIdx); // Row weight cell content: single value editable; multi values render as // a static comma list (edits happen in the expanded breakdown). const weightRow = weightRowText(weights); return (
{Array.from({ length: rowSpan }).map((_, rowIdx) => { const primary = rowIdx === 0; return (
{showSetCol && ( )} onUpdateSet(setIdx, { reps: v })}/> {primary ? ( weights.length > 1 ? ( ) : ( onUpdateSet(setIdx, { weight: listWithSlot(set.weight, 0, v) })}/> ) ) : } {cols.tempo && ( onUpdateSet(setIdx, { tempo: tempoWithPart(set, rowIdx, v) })}/> )} {cols.rpe && ( onUpdateSet(setIdx, { rpe: v })}/> )}
{primary ? onUpdateSet(setIdx, { done: !set.done })}/> : }
{primary && hasBreakdown ? ( setOpen(v => !v)}/> ) : }
); })} {hasBreakdown && open && ( onUpdateSet(setIdx, { weight: replaceLabeled(set.weight, idx, v, 'kind') })} onChangeEquip={(idx, v) => onUpdateSet(setIdx, { equip: replaceLabeled(set.equip, idx, v, 'name') })} /> )}
); } // Static read-only cell for the comma-separated weight list. Kept separate // from because we don't want trainers editing a synthesised string // — the source of truth is the labelled list in the breakdown box. function WeightListCell({ theme, text }) { return (
{text}
); } function ExpandChevron({ theme, open, accent, onClick }) { // Matches the chevron pattern used on circuit-card headers: a small // gray right-facing chevron when collapsed, rotated down when open. return (
); } // Replace the Nth entry in a labelled list, preserving its label. Used by // the breakdown editors so a tweak to "Weight 2 → 5" updates only that // slot, not the whole array. function replaceLabeled(current, idx, val, labelKey) { const list = Array.isArray(current) ? [...current] : (current != null && current !== '' ? [current] : []); const prev = list[idx]; const existingLabel = (prev && typeof prev === 'object') ? (prev[labelKey] || prev.label || '') : ''; list[idx] = existingLabel ? { [labelKey]: existingLabel, value: val } : val; return list; } // The labelled detail box that appears below a set's main rows when the // trainer taps the chevron. Two columns: weight entries on the left, // equipment entries on the right (or stacked if either side is empty). function ExpandedBreakdown({ theme, accent, weights, equips, onChangeWeight, onChangeEquip }) { // A lone unlabeled weight is already shown in the main row, so we don't // duplicate it here — only surface the weight column when there are // multiple loads OR at least one carries a label worth reading. const showWeights = weights.length > 1 || weights.some(w => w.label); const showEquips = equips.length > 0; if (!showWeights && !showEquips) return null; const showBoth = showWeights && showEquips; return (
{showWeights && ( `Weight ${i + 1}`} onChange={onChangeWeight}/> )} {showEquips && ( e.label || `Setting ${i + 1}`} hideSlotPrefix onChange={onChangeEquip}/> )}
); } function BreakdownColumn({ theme, accent, title, entries, slotLabel, hideSlotPrefix, onChange }) { return (
{title}
{entries.map((entry, i) => { const slot = slotLabel(i, entry); return (
{!hideSlotPrefix && ( {slot} )} {hideSlotPrefix ? entry.label : entry.label} onChange && onChange(i, v)}/>
); })}
); } function BreakdownInput({ theme, value, onChange }) { return (
onChange && onChange(e.target.value)} style={{ width: '3.4ch', minWidth: 0, background: 'transparent', border: 'none', outline: 'none', fontFamily: theme.monoFamily, fontSize: 12, fontWeight: 600, color: theme.text, textAlign: 'left', }}/>
); } function DoneCheck({ theme, done, onClick }) { return (
{done && }
); } // Universal table cell. value=null → renders a dash; editable=true wraps in // an input. Left-aligned everywhere — anchored numerals stay still as the // user types instead of jumping around in a centered cell. function Cell({ theme, value, editable, emphasis, accent, onChange }) { if (value === null || value === undefined) return ; if (editable) { // The hit-target is intentionally TIGHT — just wide enough for 2–3 digits. // Trainers scroll the table constantly mid-workout, and a full-width tap // target invites the keyboard at the wrong moment. Left-anchored in the // cell so the visible value stays put as the user types. return (
onChange && onChange(e.target.value)} style={{ width: '3.2ch', minWidth: 0, background: 'transparent', border: 'none', outline: 'none', fontFamily: theme.monoFamily, fontSize: 12, fontWeight: 600, color: theme.text, textAlign: 'left', }}/>
); } // Read-only value (e.g. Set # column on row 0). return (
{value}
); } function Dash({ theme }) { return (
—
); } function CellInput({ theme, value, suffix, onChange }) { return (
onChange(e.target.value)} style={{ width: '3.2ch', minWidth: 0, background: 'transparent', border: 'none', outline: 'none', fontFamily: theme.monoFamily, fontSize: 12, fontWeight: 600, color: theme.text, textAlign: 'left' }}/> {suffix && {suffix}}
); } // ─── Note editor — bottom sheet for session/circuit/exercise notes ─────── function NoteEditor({ theme, editor, notes, onSave, onClose }) { const initial = editor.scope === 'session' ? notes.session : (notes[editor.scope]?.[editor.id] || ''); const [val, setVal] = React.useState(initial); const inputRef = React.useRef(null); React.useEffect(() => { setTimeout(() => inputRef.current?.focus(), 80); }, []); const scopeLabel = editor.scope === 'session' ? 'Session' : editor.scope === 'circuit' ? 'Circuit' : 'Exercise'; const placeholder = { session: 'How is the overall session going? Energy, focus, anything to remember…', circuit: 'Notes about this circuit — pacing, rest changes, observations…', exercise: 'Form cues, modifications, how it felt…', }[editor.scope]; return (
e.stopPropagation()} style={{ width: '100%', background: theme.bg, borderTopLeftRadius: 18, borderTopRightRadius: 18, padding: '16px 18px 22px', borderTop: `1px solid ${theme.border}`, maxHeight: '85%', display: 'flex', flexDirection: 'column', }}>
{scopeLabel} Note
{editor.label || (editor.scope === 'session' ? 'Today\'s session' : '')}