@rydr/game-sdk 8.21.0 → 9.0.0

package/dist/training/compile.js

@@ -0,0 +1,367 @@
+/**
+ * Compiling a workout: authored segments → a flat, time-addressable timeline.
+ *
+ * This is where percentages of FTP finally become watts, and it happens **once**,
+ * at the start of a ride (and again if the rider edits their FTP
+ * mid-session). Everything downstream — the engine's clock, the chart, the ERG
+ * target — then addresses the timeline by *time* rather than re-walking the
+ * segment tree, which is what keeps a 3x13x30/15 workout (78 efforts, 157
+ * timeline entries) cheap to run at 60 fps.
+ *
+ * Ported from the legacy RYDR app, where this expansion had been duplicated in
+ * four places — the HUD, the game entry point, the image generator and the
+ * standalone HUD page — and they disagreed. One compiler, one answer.
+ */
+import { zoneForPercent } from "./zones.js";
+// ============================================================================
+// Watts
+// ============================================================================
+/**
+ * A smart trainer's real control resolution is 1 W on paper but ~5 W in practice,
+ * and a target of "213 W" invites a precision the hardware doesn't have. Rounding
+ * here rather than at display time also means the number the rider reads is
+ * exactly the number sent to the trainer.
+ */
+export function resolvePower(percentOfFtp, ftp) {
+    return Math.round(((percentOfFtp / 100) * ftp) / 5) * 5;
+}
+// ============================================================================
+// Fast start
+// ============================================================================
+/**
+ * "Fast start" opens an effort above its target and settles back, so the rider
+ * reaches VO2max sooner in each rep — the Rønnestad protocol's key detail. The
+ * boost is paid back over the remainder, so the effort's *average* is unchanged
+ * and the workout's overall load is identical either way.
+ */
+const FAST_START_MULTIPLIER = 1.2;
+const FAST_START_MAX_S = 60;
+/** The boost covers at most this fraction of the effort. */
+const FAST_START_FRACTION = 1 / 3;
+/**
+ * Open an effort above its target and pay the boost back over the remainder.
+ *
+ * Mutates the entry, and applies to **any** `work` entry — one fanned out of an
+ * interval set, or one placed by hand on the timeline editor. It used to live
+ * inside the interval-set branch, which meant flattening a Rønnestad session
+ * silently dropped the one detail the protocol is *for*.
+ *
+ * Deliberately not applied to a ramp: a ramp already declares the power shape
+ * its author wanted, and boosting its opening would fight that curve rather
+ * than serve it.
+ */
+function applyFastStart(entry, target) {
+    if (entry.duration <= 0)
+        return;
+    const boostDuration = Math.min(entry.duration * FAST_START_FRACTION, FAST_START_MAX_S);
+    const boostPower = Math.round(target * FAST_START_MULTIPLIER);
+    const remainder = entry.duration - boostDuration;
+    if (remainder <= 0)
+        return;
+    entry.fastStartPower = boostPower;
+    entry.fastStartDuration = boostDuration;
+    // Pay the boost back so the effort still averages `target`.
+    entry.power = Math.round((target * entry.duration - boostPower * boostDuration) / remainder);
+}
+/** At or above this fraction of FTP, a non-rep segment counts as hard work. */
+export const HARD_WORK_THRESHOLD = 0.75;
+/**
+ * Expand authored segments into the timeline.
+ *
+ * A fixed zone becomes one `steady` entry and a ramp becomes one `steady` entry
+ * carrying its endpoints; an interval set fans out into a `work` and a `recovery`
+ * entry per rep, with a `rest` entry between sets.
+ */
+export function compileWorkout(segments, ftp, options) {
+    const flat = [];
+    let t = 0;
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+        const seg = segments[segmentIndex];
+        if (seg.type === "fixed") {
+            const power = resolvePower(seg.power, ftp);
+            const entry = {
+                // A block placed by hand says what it is; one authored as a plain steady
+                // block, and every workout written before the timeline editor existed,
+                // says nothing and is steady.
+                type: seg.phase ?? "steady",
+                duration: seg.duration,
+                power,
+                startTime: t,
+                endTime: t + seg.duration,
+                segmentIndex,
+                powerPercent: seg.power,
+                hardWork: power >= ftp * HARD_WORK_THRESHOLD,
+            };
+            if (entry.type === "work") {
+                entry.hardWork = true;
+                if (options?.fastStart)
+                    applyFastStart(entry, power);
+            }
+            flat.push(entry);
+            t += seg.duration;
+            continue;
+        }
+        if (seg.type === "ramp") {
+            const rampStartPower = resolvePower(seg.startPower, ftp);
+            const rampEndPower = resolvePower(seg.endPower, ftp);
+            // `power` is the ramp's mean, so anything reading the field without
+            // understanding ramps (a summary, a coarse chart) still gets a fair number.
+            const power = Math.round((rampStartPower + rampEndPower) / 2);
+            flat.push({
+                type: seg.phase ?? "steady",
+                duration: seg.duration,
+                power,
+                startTime: t,
+                endTime: t + seg.duration,
+                segmentIndex,
+                rampStartPower,
+                rampEndPower,
+                powerPercent: (seg.startPower + seg.endPower) / 2,
+                hardWork: seg.phase === "work" || power >= ftp * HARD_WORK_THRESHOLD,
+            });
+            t += seg.duration;
+            continue;
+        }
+        const workPower = resolvePower(seg.workPower, ftp);
+        const recoveryPower = resolvePower(seg.recoveryPower, ftp);
+        const restPower = resolvePower(seg.restPower, ftp);
+        for (let set = 1; set <= seg.sets; set++) {
+            for (let rep = 1; rep <= seg.reps; rep++) {
+                const work = {
+                    type: "work",
+                    duration: seg.workDuration,
+                    power: workPower,
+                    startTime: t,
+                    endTime: t + seg.workDuration,
+                    segmentIndex,
+                    set,
+                    rep,
+                    powerPercent: seg.workPower,
+                    hardWork: true,
+                };
+                if (options?.fastStart)
+                    applyFastStart(work, workPower);
+                flat.push(work);
+                t += seg.workDuration;
+                // A rep can have no recovery (a set of one long effort), and a zero-length
+                // entry would be an un-addressable hole in the timeline.
+                if (seg.recoveryDuration > 0) {
+                    flat.push({
+                        type: "recovery",
+                        duration: seg.recoveryDuration,
+                        power: recoveryPower,
+                        startTime: t,
+                        endTime: t + seg.recoveryDuration,
+                        segmentIndex,
+                        set,
+                        rep,
+                        powerPercent: seg.recoveryPower,
+                        hardWork: recoveryPower >= ftp * HARD_WORK_THRESHOLD,
+                    });
+                    t += seg.recoveryDuration;
+                }
+            }
+            // Rest goes BETWEEN sets — never after the last one, which is the workout ending.
+            if (set < seg.sets && seg.restBetweenSets > 0) {
+                flat.push({
+                    type: "rest",
+                    duration: seg.restBetweenSets,
+                    power: restPower,
+                    startTime: t,
+                    endTime: t + seg.restBetweenSets,
+                    segmentIndex,
+                    set,
+                    powerPercent: seg.restPower,
+                    hardWork: restPower >= ftp * HARD_WORK_THRESHOLD,
+                });
+                t += seg.restBetweenSets;
+            }
+        }
+    }
+    numberReps(flat);
+    return flat;
+}
+/**
+ * Give hand-placed efforts their set and rep numbers.
+ *
+ * An interval set numbers its own on the way out — it knows it is set 2 of 3.
+ * A block dragged onto the timeline knows only that it is an effort, so the
+ * numbering has to be read back off the sequence: each `work` entry is the next
+ * rep, and a `rest` entry closes the set it followed.
+ *
+ * That derivation is what keeps the rep wall and the interval countdown working
+ * on a flattened workout. It runs over the whole timeline in one pass and only
+ * ever *fills in* — an entry that already carries a number keeps it, and its
+ * numbers seed the counters, so a workout mixing an authored interval set with
+ * hand-placed blocks after it goes on counting from where the set left off
+ * rather than restarting at rep 1.
+ */
+function numberReps(flat) {
+    let set = 1;
+    let rep = 0;
+    for (const entry of flat) {
+        if (entry.set !== undefined) {
+            // Authored by an interval set: adopt its numbering rather than imposing one.
+            set = entry.set;
+            rep = entry.rep ?? rep;
+            // A rest emitted by a set closes it, exactly as it does below.
+            if (entry.type === "rest") {
+                set += 1;
+                rep = 0;
+            }
+            continue;
+        }
+        if (entry.type === "work") {
+            rep += 1;
+            entry.set = set;
+            entry.rep = rep;
+        }
+        else if (entry.type === "recovery") {
+            // The recovery belongs to the effort it follows, so it takes that rep's
+            // number — and a recovery with no effort before it takes rep 1, which is
+            // the only honest answer for a workout that opens with one.
+            entry.set = set;
+            entry.rep = Math.max(1, rep);
+        }
+        else if (entry.type === "rest") {
+            entry.set = set;
+            set += 1;
+            rep = 0;
+        }
+    }
+}
+/** Total seconds of a compiled timeline. */
+export function timelineDuration(timeline) {
+    return timeline.length === 0 ? 0 : timeline[timeline.length - 1].endTime;
+}
+/**
+ * The entry containing `timeSec`, or null past the end.
+ *
+ * Binary search rather than the legacy linear scan: this is called every frame,
+ * and a Rønnestad set alone compiles to 78 efforts.
+ */
+export function segmentAtTime(timeline, timeSec) {
+    let lo = 0;
+    let hi = timeline.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const seg = timeline[mid];
+        if (timeSec < seg.startTime)
+            hi = mid - 1;
+        else if (timeSec >= seg.endTime)
+            lo = mid + 1;
+        else
+            return seg;
+    }
+    return null;
+}
+/**
+ * The instantaneous target in watts at `timeSec` — the number that goes to the
+ * trainer and onto the screen.
+ *
+ * Unlike `FlatSegment.power` this resolves the two cases where a segment's target
+ * moves *within* it: a ramp interpolates between its endpoints, and a fast-start
+ * effort holds its boost before settling. Returns 0 past the end of the workout.
+ */
+export function targetPowerAt(timeline, timeSec) {
+    const seg = segmentAtTime(timeline, timeSec);
+    if (!seg)
+        return 0;
+    return targetPowerIn(seg, timeSec);
+}
+/** The target within a known segment — the hot path, when the caller already has it. */
+export function targetPowerIn(seg, timeSec) {
+    if (seg.rampStartPower !== undefined && seg.rampEndPower !== undefined) {
+        const progress = seg.duration > 0 ? (timeSec - seg.startTime) / seg.duration : 0;
+        const clamped = Math.min(1, Math.max(0, progress));
+        return Math.round(seg.rampStartPower + (seg.rampEndPower - seg.rampStartPower) * clamped);
+    }
+    if (seg.fastStartPower !== undefined &&
+        seg.fastStartDuration !== undefined &&
+        timeSec < seg.startTime + seg.fastStartDuration) {
+        return seg.fastStartPower;
+    }
+    return seg.power;
+}
+/**
+ * What the planned session will cost, computed from the target trace.
+ *
+ * Normalized power follows the real definition — sample at 1 Hz, take a 30-second
+ * rolling mean, then the fourth root of the mean fourth power — rather than the
+ * shortcut of averaging the targets. The distinction matters exactly where this
+ * app is aimed: a 3x13x30/15 at 130% FTP and a steady block at the same *average*
+ * are wildly different sessions, and only the rolling mean says so.
+ *
+ * These are of course the numbers for riding the workout *perfectly*. What the
+ * rider actually did is measured by the engine and reported on the results screen.
+ */
+export function workoutMetrics(workout, ftp) {
+    const timeline = compileWorkout(workout.segments, ftp);
+    const duration = Math.round(timelineDuration(timeline));
+    const intervals = timeline.filter((seg) => seg.type === "work").length;
+    const empty = {
+        duration: 0,
+        intervals: 0,
+        averageIntensity: 0,
+        peakIntensity: 0,
+        normalizedPower: 0,
+        intensityFactor: 0,
+        tss: 0,
+        kilojoules: 0,
+        timeInZone: {},
+    };
+    if (duration <= 0 || ftp <= 0)
+        return { ...empty, intervals };
+    // 1 Hz target trace. A workout is minutes-to-hours long, so this is at most a
+    // few thousand numbers — cheaper than being clever about it.
+    const trace = new Float64Array(duration);
+    for (let t = 0; t < duration; t++)
+        trace[t] = targetPowerAt(timeline, t + 0.5);
+    let sum = 0;
+    let peak = 0;
+    for (let t = 0; t < duration; t++) {
+        sum += trace[t];
+        if (trace[t] > peak)
+            peak = trace[t];
+    }
+    // 30-second rolling mean, then the fourth-power mean of that.
+    const window = 30;
+    let rollingSum = 0;
+    let fourthSum = 0;
+    let counted = 0;
+    for (let t = 0; t < duration; t++) {
+        rollingSum += trace[t];
+        if (t >= window)
+            rollingSum -= trace[t - window];
+        // Skip the first partial window: it would divide a short sum by a full window
+        // and understate the opening. A workout shorter than the window has nothing
+        // to roll, so it falls back to its own mean.
+        if (t >= window - 1) {
+            const rolled = rollingSum / window;
+            fourthSum += rolled ** 4;
+            counted++;
+        }
+    }
+    const normalizedPower = counted > 0 ? Math.round((fourthSum / counted) ** 0.25) : Math.round(sum / duration);
+    const intensityFactor = normalizedPower / ftp;
+    // The canonical TSS formula: an hour at FTP is exactly 100.
+    const tss = (duration * normalizedPower * intensityFactor) / (ftp * 3600) * 100;
+    const timeInZone = {};
+    for (const seg of timeline) {
+        // Zone from the authored percentage, so a segment can't change zone as FTP moves.
+        const zone = zoneForPercent(seg.powerPercent).zone;
+        timeInZone[zone] = (timeInZone[zone] ?? 0) + seg.duration;
+    }
+    return {
+        duration,
+        intervals,
+        averageIntensity: sum / duration / ftp,
+        peakIntensity: peak / ftp,
+        normalizedPower,
+        intensityFactor,
+        tss: Math.round(tss),
+        kilojoules: Math.round(sum / 1000),
+        timeInZone,
+    };
+}
+//# sourceMappingURL=compile.js.map

package/dist/training/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../../src/training/compile.ts"],"names":[],"mappings":"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"}

package/dist/training/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./model.js";
+export * from "./compile.js";
+export * from "./zones.js";
+export * from "./state.js";
+export * from "./protocol.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/training/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/training/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC"}

package/dist/training/index.js

@@ -0,0 +1,6 @@
+export * from "./model.js";
+export * from "./compile.js";
+export * from "./zones.js";
+export * from "./state.js";
+export * from "./protocol.js";
+//# sourceMappingURL=index.js.map

package/dist/training/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/training/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC"}

package/dist/training/model.d.ts

@@ -0,0 +1,252 @@
+/**
+ * The workout data model.
+ *
+ * A workout is an ordered list of **segments**, and every power in it is a
+ * percentage of FTP — never watts. That is the whole reason a workout written by
+ * one rider is rideable by another: 88% FTP is sweet spot for a 180 W rider and
+ * for a 340 W rider, where "160 W" is a different session for each of them.
+ * Watts appear exactly once, at the last moment, in `compile.ts`.
+ *
+ * Three segment kinds cover the structured-training vocabulary:
+ * a steady block, a repeating interval set, and a linear ramp. Ported from the
+ * legacy RYDR app (`src/types/workout.ts`), which had earned this shape.
+ */
+/**
+ * What the session is *for*. Purely descriptive — it drives grouping and filtering
+ * in the library, never the execution. (The legacy app also used categories to
+ * decide which workouts could validate an FTP estimate; that belonged to its
+ * progression system and has no counterpart here.)
+ */
+export type WorkoutCategory = "recovery" | "endurance" | "tempo" | "sweetSpot" | "threshold" | "aerobicPower" | "shortBursts" | "sprint";
+export declare const CATEGORY_LABELS: Record<WorkoutCategory, string>;
+/**
+ * Which power zone each category *reads* as, for tinting a pill or a badge.
+ *
+ * Purely presentational — a category is descriptive (see above) and never drives
+ * execution, so this is only ever asked for a colour. It exists so a category
+ * pill and the chart underneath it agree about what "Threshold" looks like; the
+ * colour itself still comes from `zoneByNumber` in `./zones`, which stays the
+ * one place a zone colour is written down.
+ *
+ * Two of the eight straddle a boundary and are pinned to the lower zone, which
+ * is the legacy app's choice and worth keeping: sweet spot lives between Z3 and
+ * Z4, short bursts between Z5 and Z6, and picking the higher zone in each case
+ * made them read as harder than the sessions actually are.
+ */
+export declare const CATEGORY_ZONE: Record<WorkoutCategory, number>;
+/** Display order for pickers and filters — easiest to hardest. */
+export declare const CATEGORY_ORDER: readonly WorkoutCategory[];
+/**
+ * What a segment *is* to the rider, which is not the same as which authored
+ * segment it came from: a steady 20-minute block and the work half of a 40/20
+ * are both "hold this", but only one of them is a rep being counted.
+ *
+ * Lives here rather than in `compile.ts` (which re-exports it) because a
+ * hand-placed block now declares its own — see {@link SegmentBase.phase}.
+ */
+export type PhaseType = "work" | "recovery" | "rest" | "steady";
+interface SegmentBase {
+    /** Unique within its workout. */
+    id: string;
+    /**
+     * What this block IS, for a block placed by hand on the timeline editor.
+     *
+     * An {@link IntervalSetSegment} says `3 sets of 13 efforts` and the compiler
+     * derives the phases; a block dragged onto the timeline has no set to belong
+     * to, so it has to say for itself whether it is an effort, a recovery, a rest
+     * between sets, or just a stretch of riding.
+     *
+     * That matters because everything downstream — the efforts count, the rep
+     * wall, the interval countdown, fast start, the mashup's effort matching —
+     * reads the *compiled* entry's phase, never the authored segment. Without
+     * this, flattening `3x13x30/15` into 78 blocks would silently turn a
+     * Rønnestad session into 39 minutes of undifferentiated "steady".
+     *
+     * Optional, and absent means `"steady"`, so every workout authored before the
+     * timeline editor existed compiles exactly as it did. Ignored on an
+     * {@link IntervalSetSegment}, which numbers its own phases.
+     */
+    phase?: PhaseType;
+}
+/** A steady block: one power held for one duration. Maps to ZWO `<SteadyState>`. */
+export interface FixedZoneSegment extends SegmentBase {
+    type: "fixed";
+    /** Seconds. */
+    duration: number;
+    /** % of FTP — 75 means 75% FTP. */
+    power: number;
+}
+/**
+ * A repeating interval set, the workhorse of structured training.
+ *
+ * Reads as `sets × reps × work/recovery`, with an optional rest between sets:
+ * `3x13x30/15 + 3' rest` is three sets of thirteen 30-second efforts with 15
+ * seconds easy between them, resting three minutes between sets. Maps to ZWO
+ * `<IntervalsT>` plus a `<SteadyState>` per rest.
+ */
+export interface IntervalSetSegment extends SegmentBase {
+    type: "intervals";
+    sets: number;
+    /** Efforts per set. */
+    reps: number;
+    /** Seconds of work per rep. */
+    workDuration: number;
+    /** % of FTP during the effort. */
+    workPower: number;
+    /** Seconds of recovery between reps. */
+    recoveryDuration: number;
+    /** % of FTP during the recovery. */
+    recoveryPower: number;
+    /** Seconds of rest between sets; 0 for none. */
+    restBetweenSets: number;
+    /** % of FTP during the rest. */
+    restPower: number;
+}
+/** A linear power ramp. Maps to ZWO `<Warmup>` / `<Cooldown>` / `<Ramp>`. */
+export interface RampSegment extends SegmentBase {
+    type: "ramp";
+    /** Seconds. */
+    duration: number;
+    /** % of FTP at the start. */
+    startPower: number;
+    /** % of FTP at the end. */
+    endPower: number;
+}
+export type WorkoutSegment = FixedZoneSegment | IntervalSetSegment | RampSegment;
+export type SegmentKind = WorkoutSegment["type"];
+/**
+ * A coach's cue attached to a point in time, e.g. from a ZWO `<textevent>`.
+ * Preserved on import and shown during the ride.
+ */
+export interface TextEvent {
+    /** Seconds from the start of the workout. */
+    timeOffset: number;
+    message: string;
+}
+/**
+ * One song placed on a workout's timeline.
+ *
+ * The workout's own clock, in seconds — the same axis the segments sit on, which
+ * is the entire point: a song placed at 12:00 is heard at 12:00 of the ride, so
+ * an author can put a drop on rep 1 and have it land there.
+ *
+ * Referenced by {@link MusicTrack.id} rather than by URL. The library is curated
+ * and mutable — a track can be re-trimmed, re-uploaded, retitled — and a lane
+ * that stored the URL would go on pointing at bytes that had been replaced.
+ * The cost is that a deleted track leaves a hole, which `normalizeLane` drops.
+ */
+export interface PlacedTrack {
+    /** Unique within the lane. The same song may be placed more than once. */
+    id: string;
+    /** → {@link MusicTrack.id}. */
+    trackId: string;
+    /** Seconds from the start of the workout. */
+    startTime: number;
+    /**
+     * Where in the file to start, in seconds. Defaults to 0.
+     *
+     * Rarely needed: songs are cropped destructively in the music editor (see
+     * `src/music/trim.ts`), so a track in the library is usually already exactly
+     * the part that was wanted. This is for the last-mile nudge — dropping four
+     * bars of intro so the first beat lands on the block boundary — without
+     * re-cutting the file for every workout that uses it.
+     */
+    clipStartSec?: number;
+    /** Seconds to play. Defaults to the rest of the file after `clipStartSec`. */
+    duration?: number;
+}
+/**
+ * The songs a workout plays, and when.
+ *
+ * An object rather than a bare array so the lane can grow a property later (a
+ * per-workout crossfade, a ducking rule) without every stored document needing
+ * a migration.
+ *
+ * A workout with no `music` is not silent — it falls back to the rider's chosen
+ * style, shuffled on the wall clock (`src/music/playlist.ts`, WORK-10). This
+ * field is what "somebody scored this session by hand" looks like.
+ */
+export interface WorkoutMusic {
+    tracks: PlacedTrack[];
+}
+/** Who can see a workout — mirrors the SDK data-store scope it's saved in. */
+export type WorkoutVisibility = "preset" | "private" | "shared";
+export interface Workout {
+    id: string;
+    name: string;
+    description: string;
+    segments: WorkoutSegment[];
+    category: WorkoutCategory;
+    /** Unix ms. */
+    createdAt: number;
+    /** Unix ms. */
+    updatedAt: number;
+    /** Cues carried over from an imported file. */
+    textEvents?: TextEvent[];
+    /**
+     * The songs this session was scored with, placed on its own clock.
+     *
+     * Absent for every workout that wasn't authored in the timeline editor, and
+     * absent is a perfectly good answer — see {@link WorkoutMusic}.
+     */
+    music?: WorkoutMusic;
+}
+/** A workout as it comes back from the store, with where it came from attached. */
+export interface StoredWorkout extends Workout {
+    visibility: WorkoutVisibility;
+    /** Display name of the rider who wrote it — only meaningful for `shared`. */
+    authorName?: string;
+    /** True when the signed-in rider owns it, and so may edit or delete it. */
+    isMine: boolean;
+}
+export declare function generateSegmentId(): string;
+export declare function generatePlacedTrackId(): string;
+export declare function generateWorkoutId(): string;
+export declare function createFixedZoneSegment(overrides?: Partial<Omit<FixedZoneSegment, "type" | "id">>): FixedZoneSegment;
+export declare function createIntervalSetSegment(overrides?: Partial<Omit<IntervalSetSegment, "type" | "id">>): IntervalSetSegment;
+export declare function createRampSegment(overrides?: Partial<Omit<RampSegment, "type" | "id">>): RampSegment;
+export declare function createWorkout(overrides?: Partial<Omit<Workout, "id" | "createdAt" | "updatedAt">>): Workout;
+/** A deep copy under a fresh id — for "duplicate", and for editing a preset. */
+export declare function cloneWorkout(workout: Workout, name?: string): Workout;
+/** Seconds a segment occupies on the timeline. */
+export declare function segmentDuration(segment: WorkoutSegment): number;
+/** Total seconds of a whole workout. */
+export declare function workoutDuration(workout: Pick<Workout, "segments">): number;
+/** How many work efforts the rider will actually do. */
+export declare function workoutIntervalCount(workout: Pick<Workout, "segments">): number;
+/**
+ * Explode an interval set into the individual blocks it stands for.
+ *
+ * The timeline editor places blocks one at a time, so a workout imported from
+ * ZWO — or authored in the card editor — has to be flattened before it can be
+ * dragged around. `3x13x30/15` becomes 78 blocks plus 2 rests.
+ *
+ * **This is deliberately lossy in exactly one way and lossless in every other.**
+ * Gone is the shorthand: nothing afterwards knows those 78 blocks were once
+ * three sets, so `describeSegment` stops saying `"3x13x30/15"` and ZWO export
+ * writes a run of `<SteadyState>` rather than an `<IntervalsT>`. Kept is
+ * everything the *ride* reads — each block carries its {@link PhaseType}, so the
+ * compiled timeline has the same phases, the same efforts count, the same
+ * `set`/`rep` numbering and the same fast start it had before. `compileWorkout`
+ * of a flattened workout equals `compileWorkout` of the original, which is
+ * asserted in `test/flatten.test.ts` and is the whole licence for doing this.
+ *
+ * Mirrors `compileWorkout`'s expansion step for step, including its two edge
+ * rules: a rep with no recovery emits no recovery block, and the rest goes
+ * BETWEEN sets and never after the last one.
+ */
+export declare function flattenSegment(segment: WorkoutSegment): WorkoutSegment[];
+/** Every segment flattened, in order. What the timeline editor opens a workout as. */
+export declare function flattenSegments(segments: readonly WorkoutSegment[]): WorkoutSegment[];
+/** Whether anything here would change shape under {@link flattenSegments}. */
+export declare function hasCompositeSegments(workout: Pick<Workout, "segments">): boolean;
+/** Whether somebody scored this session by hand — see {@link WorkoutMusic}. */
+export declare function hasAuthoredMusic(workout: Pick<Workout, "music">): boolean;
+/** `90` → `"1:30"`, `3725` → `"1:02:05"`. For clocks and countdowns. */
+export declare function formatClock(totalSeconds: number): string;
+/** `2700` → `"45min"`, `90` → `"1min 30s"`, `45` → `"45s"`. For labels, not clocks. */
+export declare function formatDuration(totalSeconds: number): string;
+/** The one-line shorthand a cyclist would actually say out loud. */
+export declare function describeSegment(segment: WorkoutSegment): string;
+export {};
+//# sourceMappingURL=model.d.ts.map

package/dist/training/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/training/model.ts"],"names":[],"mappings":"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"}