prographs 0.12.0 → 0.13.0

package/dist/charts/softwarediagrams/index.js

@@ -1,4 +1,4 @@
-import { ActivityNodeKind, BpmnFlowKind, BpmnNodeKind, BpmnPartition, CallGraphLayering, DataFlowKind, DataFlowNotation, DifferentialFlameBasis, DifferentialFlameSort, MemoryMapOrigin, MemoryMapUsage, NassiBranchWidth, NassiKind, NassiRowHeight, ParseTreeEdge, ParseTreeLeaves, ParseTreeLevels, PetriNodeKind, PetriTokenMark, PetriTransitionForm, SignalFlowArc, SignalFlowArrow, SignalFlowNode, SoftwareRouting, TrieCompression, TrieLabel, UseCaseActorForm, UseCaseActorSide, UseCaseLinkKind, UseCaseNodeKind } from "./softwareEnums.js";
+import { ActivityNodeKind, BpmnFlowKind, BpmnNodeKind, BpmnPartition, CallGraphLayering, ComponentGrouping, ComponentInterfaceForm, ComponentLinkKind, ComponentNodeKind, DataFlowKind, DataFlowNotation, DeploymentArtifactForm, DeploymentKind, DeploymentNodeForm, DifferentialFlameBasis, DifferentialFlameSort, MemoryMapOrigin, MemoryMapUsage, NassiBranchWidth, NassiKind, NassiRowHeight, ParseTreeEdge, ParseTreeLeaves, ParseTreeLevels, PetriNodeKind, PetriTokenMark, PetriTransitionForm, SignalFlowArc, SignalFlowArrow, SignalFlowNode, SoftwareRouting, TrieCompression, TrieLabel, UseCaseActorForm, UseCaseActorSide, UseCaseLinkKind, UseCaseNodeKind } from "./softwareEnums.js";
 import { SoftwareText } from "./SoftwareText.js";
 import { SoftwarePlacer } from "./SoftwarePlacer.js";
 import { SoftwareLayers } from "./SoftwareLayers.js";
@@ -10,7 +10,9 @@ import { SoftwareSamples } from "./SoftwareSamples.js";
 import { ActivityDiagram } from "./ActivityDiagram.js";
 import { BpmnDiagram } from "./BpmnDiagram.js";
 import { CallGraph } from "./CallGraph.js";
+import { ComponentDiagram } from "./ComponentDiagram.js";
 import { DataFlowDiagram } from "./DataFlowDiagram.js";
+import { DeploymentDiagram } from "./DeploymentDiagram.js";
 import { DifferentialFlameGraph } from "./DifferentialFlameGraph.js";
 import { MemoryMap } from "./MemoryMap.js";
 import { NassiLayout } from "./NassiLayout.js";
@@ -34,6 +36,8 @@ var softwarediagramsCatalog = [
 	CallGraph,
 	SignalFlowGraph,
 	ParseTree,
-	TrieDiagram
+	TrieDiagram,
+	ComponentDiagram,
+	DeploymentDiagram
 ];
-export { ActivityDiagram, ActivityNodeKind, BpmnDiagram, BpmnFlowKind, BpmnNodeKind, BpmnPartition, CallGraph, CallGraphLayering, DataFlowDiagram, DataFlowKind, DataFlowNotation, DifferentialFlameBasis, DifferentialFlameGraph, DifferentialFlameSort, MemoryMap, MemoryMapOrigin, MemoryMapUsage, NassiBranchWidth, NassiKind, NassiLayout, NassiRowHeight, NassiShneidermanDiagram, ParseTree, ParseTreeEdge, ParseTreeLeaves, ParseTreeLevels, PetriNet, PetriNodeKind, PetriTokenMark, PetriTransitionForm, SignalFlowArc, SignalFlowArrow, SignalFlowGraph, SignalFlowNode, SoftwareDiagram, SoftwareGraph, SoftwareLayers, SoftwarePlacer, SoftwareRouting, SoftwareSamples, SoftwareShapes, SoftwareText, SoftwareTree, SoftwareWiring, TrieCompression, TrieDiagram, TrieLabel, UseCaseActorForm, UseCaseActorSide, UseCaseDiagram, UseCaseLinkKind, UseCaseNodeKind, softwarediagramsCatalog };
+export { ActivityDiagram, ActivityNodeKind, BpmnDiagram, BpmnFlowKind, BpmnNodeKind, BpmnPartition, CallGraph, CallGraphLayering, ComponentDiagram, ComponentGrouping, ComponentInterfaceForm, ComponentLinkKind, ComponentNodeKind, DataFlowDiagram, DataFlowKind, DataFlowNotation, DeploymentArtifactForm, DeploymentDiagram, DeploymentKind, DeploymentNodeForm, DifferentialFlameBasis, DifferentialFlameGraph, DifferentialFlameSort, MemoryMap, MemoryMapOrigin, MemoryMapUsage, NassiBranchWidth, NassiKind, NassiLayout, NassiRowHeight, NassiShneidermanDiagram, ParseTree, ParseTreeEdge, ParseTreeLeaves, ParseTreeLevels, PetriNet, PetriNodeKind, PetriTokenMark, PetriTransitionForm, SignalFlowArc, SignalFlowArrow, SignalFlowGraph, SignalFlowNode, SoftwareDiagram, SoftwareGraph, SoftwareLayers, SoftwarePlacer, SoftwareRouting, SoftwareSamples, SoftwareShapes, SoftwareText, SoftwareTree, SoftwareWiring, TrieCompression, TrieDiagram, TrieLabel, UseCaseActorForm, UseCaseActorSide, UseCaseDiagram, UseCaseLinkKind, UseCaseNodeKind, softwarediagramsCatalog };

package/dist/charts/softwarediagrams/softwareEnums.js

@@ -189,4 +189,48 @@ var TrieLabel = /* @__PURE__ */ function(TrieLabel) {
 	TrieLabel["Node"] = "node";
 	return TrieLabel;
 }({});
-export { ActivityNodeKind, BpmnFlowKind, BpmnNodeKind, BpmnPartition, CallGraphLayering, DataFlowKind, DataFlowNotation, DifferentialFlameBasis, DifferentialFlameSort, MemoryMapOrigin, MemoryMapUsage, NassiBranchWidth, NassiKind, NassiRowHeight, ParseTreeEdge, ParseTreeLeaves, ParseTreeLevels, PetriNodeKind, PetriTokenMark, PetriTransitionForm, SignalFlowArc, SignalFlowArrow, SignalFlowNode, SoftwareRouting, TrieCompression, TrieLabel, UseCaseActorForm, UseCaseActorSide, UseCaseLinkKind, UseCaseNodeKind };
+var ComponentNodeKind = /* @__PURE__ */ function(ComponentNodeKind) {
+	ComponentNodeKind["Component"] = "component";
+	ComponentNodeKind["Interface"] = "interface";
+	return ComponentNodeKind;
+}({});
+/** `Provides` and `Requires` join a component to an interface; `Dependency` joins two components. */
+var ComponentLinkKind = /* @__PURE__ */ function(ComponentLinkKind) {
+	ComponentLinkKind["Provides"] = "provides";
+	ComponentLinkKind["Requires"] = "requires";
+	ComponentLinkKind["Dependency"] = "dependency";
+	return ComponentLinkKind;
+}({});
+/** How a component reaches an interface it requires: a socket cupped around the ball, or a dashed dependency arrow to it. */
+var ComponentInterfaceForm = /* @__PURE__ */ function(ComponentInterfaceForm) {
+	ComponentInterfaceForm["BallSocket"] = "ball-socket";
+	ComponentInterfaceForm["Dependency"] = "dependency";
+	return ComponentInterfaceForm;
+}({});
+/** `Frames` encloses the components of each package in a package frame; `Flat` tells packages apart by colour alone. */
+var ComponentGrouping = /* @__PURE__ */ function(ComponentGrouping) {
+	ComponentGrouping["Frames"] = "frames";
+	ComponentGrouping["Flat"] = "flat";
+	return ComponentGrouping;
+}({});
+/** A deployment target or what is deployed on it. `Environment` is UML's execution environment. */
+var DeploymentKind = /* @__PURE__ */ function(DeploymentKind) {
+	DeploymentKind["Node"] = "node";
+	DeploymentKind["Device"] = "device";
+	DeploymentKind["Environment"] = "environment";
+	DeploymentKind["Artifact"] = "artifact";
+	return DeploymentKind;
+}({});
+/** `Cube` draws UML's node box with a top and a side face; `Flat` keeps the front face only. */
+var DeploymentNodeForm = /* @__PURE__ */ function(DeploymentNodeForm) {
+	DeploymentNodeForm["Cube"] = "cube";
+	DeploymentNodeForm["Flat"] = "flat";
+	return DeploymentNodeForm;
+}({});
+/** Artifacts as symbols inside their node, or as a list of names under the node's own. */
+var DeploymentArtifactForm = /* @__PURE__ */ function(DeploymentArtifactForm) {
+	DeploymentArtifactForm["Symbol"] = "symbol";
+	DeploymentArtifactForm["Listed"] = "listed";
+	return DeploymentArtifactForm;
+}({});
+export { ActivityNodeKind, BpmnFlowKind, BpmnNodeKind, BpmnPartition, CallGraphLayering, ComponentGrouping, ComponentInterfaceForm, ComponentLinkKind, ComponentNodeKind, DataFlowKind, DataFlowNotation, DeploymentArtifactForm, DeploymentKind, DeploymentNodeForm, DifferentialFlameBasis, DifferentialFlameSort, MemoryMapOrigin, MemoryMapUsage, NassiBranchWidth, NassiKind, NassiRowHeight, ParseTreeEdge, ParseTreeLeaves, ParseTreeLevels, PetriNodeKind, PetriTokenMark, PetriTransitionForm, SignalFlowArc, SignalFlowArrow, SignalFlowNode, SoftwareRouting, TrieCompression, TrieLabel, UseCaseActorForm, UseCaseActorSide, UseCaseLinkKind, UseCaseNodeKind };

package/dist/charts/sportscharts/PowerDurationCurve.js

@@ -0,0 +1,301 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SportsSamples } from "./SportsSamples.js";
+import { SportsTimelineChart } from "./SportsTimelineChart.js";
+import { line, scaleLinear, scaleLog } from "d3";
+// src/charts/sportscharts/PowerDurationCurve.ts
+var PowerDurationUnit = /* @__PURE__ */ function(PowerDurationUnit) {
+	PowerDurationUnit["Watts"] = "watts";
+	PowerDurationUnit["PerKilogram"] = "watts-per-kg";
+	return PowerDurationUnit;
+}({});
+var STANDARD = [
+	5,
+	60,
+	300,
+	1200,
+	3600
+];
+var ROUND = [
+	1,
+	18e3,
+	10,
+	30,
+	600,
+	1800,
+	7200,
+	36e3,
+	86400,
+	2,
+	15,
+	120,
+	10800
+];
+var TICK_GAP = 40;
+var DOT = 4.5;
+var CHAR = 6.2;
+/**
+* What an athlete can hold for how long: best mean power against the length of the effort, on a log time axis from seconds to hours.
+* Use it to compare seasons, read the standard test durations, and find critical power and W' from the fitted model.
+*/
+var PowerDurationCurve = class PowerDurationCurve extends SportsTimelineChart {
+	static meta = {
+		id: "power-duration-curve",
+		name: "Power-duration curve",
+		family: ChartFamily.Trend,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots an athlete's best mean power against effort duration on a log axis, with the fitted critical power model, earlier periods for reference and the standard durations marked, in watts or watts per kilogram. The sample rider is invented.",
+		tags: [
+			"sports",
+			"cycling",
+			"critical power",
+			"mean maximal power",
+			"W prime",
+			"power profile"
+		],
+		sample: (seed) => SportsSamples.powerCurve(seed),
+		variants: {
+			unit: ["watts", "watts-per-kg"],
+			model: [true, false],
+			references: [true, false],
+			markers: [true, false]
+		}
+	};
+	#periods = [];
+	#fit = null;
+	#who = "";
+	#timeAxis = null;
+	#powerAxis = null;
+	defaults() {
+		return {
+			x: "duration",
+			y: "power",
+			period: "period",
+			weight: "weight",
+			athlete: "athlete",
+			unit: "watts",
+			model: true,
+			fitWindow: [120, 1800],
+			references: true,
+			markers: true
+		};
+	}
+	get #perKilo() {
+		return this.options.unit === "watts-per-kg";
+	}
+	get #unit() {
+		return this.#perKilo ? "W/kg" : "W";
+	}
+	#value(power) {
+		return this.#perKilo ? power.toFixed(power < 10 ? 2 : 1) : Math.round(power).toLocaleString("en");
+	}
+	/** A duration in the largest units that keep it whole: `5 s`, `20 min`, `1 h 30 min`. */
+	static span(seconds) {
+		if (seconds < 60) return `${+seconds.toFixed(1)} s`;
+		const whole = Math.round(seconds), minutes = Math.round(whole / 60);
+		if (whole < 3600) return whole % 60 ? `${Math.floor(whole / 60)} min ${whole % 60} s` : `${whole / 60} min`;
+		return minutes % 60 ? `${Math.floor(minutes / 60)} h ${minutes % 60} min` : `${minutes / 60} h`;
+	}
+	/**
+	* Least squares fit of P = CP + W'/t to the readings inside `window`, as a straight line of power against 1/t.
+	* `null` with fewer than two durations there, or when the line gives a critical power or W' at or below zero.
+	*/
+	static fit(points, [from, to]) {
+		const used = points.filter((point) => point.t >= from && point.t <= to), n = used.length;
+		let sx = 0, sy = 0, sxx = 0, sxy = 0;
+		for (const { t, p } of used) {
+			sx += 1 / t;
+			sy += p;
+			sxx += 1 / (t * t);
+			sxy += p / t;
+		}
+		const spread = n * sxx - sx * sx;
+		if (n < 2 || spread <= 1e-15) return null;
+		const wPrime = (n * sxy - sx * sy) / spread, cp = (sy - wPrime * sx) / n;
+		return cp > 0 && wPrime > 0 ? {
+			cp,
+			wPrime
+		} : null;
+	}
+	/** Power at `t` seconds, read between the two nearest durations along log time. `null` outside the curve. */
+	static at(points, t) {
+		const after = points.findIndex((point) => point.t >= t), b = points[after];
+		if (!b) return null;
+		if (b.t === t) return b.p;
+		const a = points[after - 1];
+		return a ? a.p + (b.p - a.p) * Math.log(t / a.t) / Math.log(b.t / a.t) : null;
+	}
+	/** Axis ticks at round durations at least `gap` px apart, the standard test durations first. */
+	static ticks(scale, gap = TICK_GAP) {
+		const [low, high] = scale.domain(), kept = [];
+		for (const tick of [...STANDARD, ...ROUND]) if (tick >= low && tick <= high && kept.every((other) => Math.abs(scale(other) - scale(tick)) >= gap)) kept.push(tick);
+		return kept.sort((a, b) => a - b);
+	}
+	/** The first athlete's curves, the current period first, each with one reading per duration in rising order. */
+	get curves() {
+		const { x, y, period, weight, athlete, current } = this.options, rows = this.rows(), perKilo = this.#perKilo;
+		const who = this.#who = rows.map((row) => this.word(row[athlete])).find(Boolean) ?? "";
+		const best = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const t = this.number(row[x]), watts = this.number(row[y]), mass = this.number(row[weight]);
+			if (this.word(row[athlete], who) !== who || t === null || t <= 0 || watts === null || perKilo && !(mass !== null && mass > 0)) continue;
+			const name = this.word(row[period], "Power"), held = best.get(name) ?? best.set(name, /* @__PURE__ */ new Map()).get(name);
+			held.set(t, Math.max(held.get(t) ?? -Infinity, perKilo ? watts / mass : watts));
+		}
+		const curves = [...best].map(([name, held]) => ({
+			period: name,
+			points: [...held].sort((a, b) => a[0] - b[0]).map(([t, p]) => ({
+				t,
+				p
+			}))
+		}));
+		const lead = curves.findIndex((curve) => curve.period === current);
+		return lead > 0 ? [curves[lead], ...curves.filter((_, i) => i !== lead)] : curves;
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, { references, model, fitWindow } = this.options;
+		const periods = this.#periods = references ? this.curves : this.curves.slice(0, 1);
+		this.#fit = model && periods[0] ? PowerDurationCurve.fit(periods[0].points, fitWindow) : null;
+		const points = periods.flatMap((curve) => curve.points), times = points.map((point) => point.t), powers = points.map((point) => point.p);
+		let [low, high] = points.length ? [Math.min(...times), Math.max(...times)] : [1, 3600];
+		if (low === high) [low, high] = [low / 2, high * 2];
+		const top = Math.max(0, ...powers), bottom = Math.min(0, ...powers);
+		const x = scaleLog([low, high], [0, width]), y = this.#powerAxis = scaleLinear([bottom, top > bottom ? top * 1.04 : bottom + 1], [height, 0]).nice();
+		this.#timeAxis = Object.assign(x, { ticks: () => PowerDurationCurve.ticks(x) });
+		return {
+			x,
+			y
+		};
+	}
+	/** Time ticks name their duration, and the top power tick carries the unit. */
+	tickFormat(scale) {
+		if (scale === this.#timeAxis) return (value) => PowerDurationCurve.span(+value);
+		const plain = super.tickFormat(scale);
+		if (scale !== this.#powerAxis || !plain) return plain;
+		const top = Math.max(...this.#powerAxis.ticks(this.yTicks()));
+		return (value) => +value === top ? `${plain(value)} ${this.#unit}` : plain(value);
+	}
+	plotMarks(ctx, { x, y }) {
+		const { markers, fitWindow } = this.options, periods = this.#periods, fit = this.#fit, lead = periods[0], unit = this.#unit;
+		const color = (name) => ctx.palette.color(name);
+		for (const curve of periods) color(curve.period);
+		const [low, high] = x.domain(), top = y.domain()[1], { width, height } = ctx.plot;
+		const reading = (power) => `${this.#value(power)} ${unit}`;
+		const asymptote = ctx.marks("axis-critical", "line", fit ? [fit] : []).attr("stroke", ctx.theme.axis).attr("stroke-width", 1).attr("stroke-dasharray", "2 3");
+		ctx.set(asymptote, {
+			x1: 0,
+			x2: width,
+			y1: (d) => y(d.cp),
+			y2: (d) => y(d.cp)
+		});
+		const marked = markers && lead ? STANDARD.flatMap((t) => {
+			const p = PowerDurationCurve.at(lead.points, t);
+			return p === null || t < low || t > high ? [] : [{
+				t,
+				p
+			}];
+		}) : [];
+		const drops = ctx.marks("axis-standard", "line", marked, (d) => d.t).attr("stroke", ctx.theme.axis).attr("stroke-width", 1).attr("stroke-dasharray", "1 3");
+		ctx.set(drops, {
+			x1: (d) => x(d.t),
+			x2: (d) => x(d.t),
+			y1: (d) => y(d.p),
+			y2: height
+		});
+		const trace = line().curve(Scales.curve()).x((d) => x(d.t)).y((d) => y(d.p));
+		const drawn = [...periods].reverse();
+		const paths = ctx.marks("curves", "path", drawn.filter((curve) => curve.points.length > 1), (d) => d.period).attr("fill", "none").attr("stroke", (d) => color(d.period)).attr("stroke-width", (d) => d === lead ? 2 : 1.5).attr("stroke-opacity", (d) => d === lead ? 1 : .7).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+		ctx.set(paths, { d: (d) => trace(d.points) ?? "" });
+		ctx.drawOn(paths);
+		ctx.hover(paths, (d) => ({
+			title: d.period,
+			color: color(d.period),
+			rows: STANDARD.flatMap((t) => {
+				const p = PowerDurationCurve.at(d.points, t);
+				return p === null ? [] : [[PowerDurationCurve.span(t), reading(p)]];
+			})
+		}));
+		const lone = ctx.marks("single", "circle", drawn.filter((curve) => curve.points.length === 1), (d) => d.period).attr("fill", (d) => color(d.period)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(lone, {
+			cx: (d) => x(d.points[0].t),
+			cy: (d) => y(d.points[0].p),
+			r: DOT
+		}, { r: 0 });
+		ctx.hover(lone, (d) => ({
+			title: d.period,
+			color: color(d.period),
+			rows: [[PowerDurationCurve.span(d.points[0].t), reading(d.points[0].p)]]
+		}));
+		const start = fit ? Math.max(low, fit.wPrime / Math.max(1e-9, top - fit.cp)) : high;
+		const steps = start < high ? Array.from({ length: 64 }, (_, i) => start * (high / start) ** (i / 63)) : [];
+		const fitted = ctx.marks("model", "path", fit && steps.length ? [fit] : []).attr("fill", "none").attr("stroke", ctx.theme.ink).attr("stroke-width", 1.5).attr("stroke-dasharray", "5 4");
+		ctx.set(fitted, { d: (d) => line().x((t) => x(t)).y((t) => y(d.cp + d.wPrime / t))(steps) ?? "" });
+		ctx.hover(fitted, (d) => ({
+			title: "Critical power model",
+			rows: [
+				["Critical power", reading(d.cp)],
+				["W'", this.#work(d.wPrime)],
+				["Fitted over", `${PowerDurationCurve.span(fitWindow[0])} to ${PowerDurationCurve.span(fitWindow[1])}`]
+			]
+		}));
+		const dots = ctx.marks("standard", "circle", marked, (d) => d.t).attr("fill", lead ? color(lead.period) : null).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: (d) => x(d.t),
+			cy: (d) => y(d.p),
+			r: DOT
+		}, { r: 0 }, 30);
+		ctx.hover(dots, (d) => ({
+			title: `Best ${PowerDurationCurve.span(d.t)}`,
+			color: lead ? color(lead.period) : void 0,
+			rows: [[lead?.period ?? "", reading(d.p)], ...fit ? [["Model", reading(fit.cp + fit.wPrime / d.t)]] : []]
+		}));
+		let edge = -Infinity;
+		const values = marked.flatMap((d) => {
+			const text = this.#value(d.p), wide = text.length * CHAR, flip = x(d.t) + 7 + wide > width, left = flip ? x(d.t) - 7 - wide : x(d.t) + 7;
+			if (left < edge + 4 || y(d.p) < 18) return [];
+			edge = left + wide;
+			return [{
+				key: `value-${d.t}`,
+				text,
+				x: flip ? x(d.t) - 7 : x(d.t) + 7,
+				y: y(d.p) - 7,
+				anchor: flip ? "end" : "start",
+				tone: "ink"
+			}];
+		});
+		const summary = !lead ? [{
+			key: "empty",
+			text: this.#perKilo && this.rows().length ? "No body weight to divide by" : "No power readings",
+			x: 4,
+			y: 12,
+			tone: "muted"
+		}] : [...this.#who ? [{
+			key: "who",
+			text: this.#who,
+			x: width - 4,
+			y: 12,
+			anchor: "end",
+			tone: "ink"
+		}] : [], ...fit ? [{
+			key: "fit",
+			text: `CP ${reading(fit.cp)}, W' ${this.#work(fit.wPrime)}`,
+			x: width - 4,
+			y: this.#who ? 26 : 12,
+			anchor: "end"
+		}, {
+			key: "critical",
+			text: "CP",
+			x: 4,
+			y: y(fit.cp) - 5,
+			tone: "muted",
+			size: 10
+		}] : []];
+		this.notes(ctx, "notes", [...values, ...summary]);
+	}
+	/** W' in kilojoules, or in joules per kilogram when power is per kilogram. */
+	#work(wPrime) {
+		return this.#perKilo ? `${Math.round(wPrime)} J/kg` : `${(wPrime / 1e3).toFixed(1)} kJ`;
+	}
+};
+export { PowerDurationCurve, PowerDurationUnit };

package/dist/charts/sportscharts/SportsSamples.js

@@ -314,6 +314,64 @@ var GOLF_BAG = [
 		bias: 0
 	}
 ];
+var RIDERS = [
+	"Ines Halvard",
+	"Tomas Rehn",
+	"Mirela Stanek",
+	"Jonah Averill"
+];
+var POWER_PERIODS = [
+	"This season",
+	"Last season",
+	"Two seasons ago"
+];
+var POWER_DURATIONS = [
+	1,
+	2,
+	3,
+	5,
+	8,
+	10,
+	15,
+	20,
+	30,
+	45,
+	60,
+	90,
+	120,
+	180,
+	240,
+	300,
+	420,
+	600,
+	900,
+	1200,
+	1800,
+	2700,
+	3600,
+	5400,
+	7200,
+	10800,
+	14400,
+	18e3
+];
+/** Stress score of each weekday's session, Monday first. 0 is a rest day. */
+var TRAINING_WEEK = [
+	0,
+	85,
+	60,
+	95,
+	0,
+	150,
+	110
+];
+/** Share of the planned load in each week of a block: three weeks building, one easy. */
+var TRAINING_BLOCK = [
+	.85,
+	1,
+	1.2,
+	.55
+];
 /** Picks from weighted items with one uniform draw. */
 var weighted = (items, roll) => {
 	let pick = roll * items.reduce((sum, item) => sum + (item.weight ?? item.share ?? 1), 0);
@@ -674,5 +732,49 @@ var SportsSamples = class SportsSamples {
 			};
 		}));
 	}
+	/**
+	* `{ athlete, period, duration, power, weight }`: one rider's best mean power in watts for efforts of a second to five hours,
+	* this season and the two before, with body weight in kilograms. Power follows a three-parameter critical power curve that fades past half an hour.
+	*/
+	static powerCurve(seed) {
+		const { u, n } = SampleData.rng(seed);
+		const athlete = RIDERS[Math.floor(u() * RIDERS.length)], cp = 250 + u() * 55, reserve = 17e3 + u() * 8e3, sprint = 950 + u() * 350, mass = 62 + u() * 14;
+		return POWER_PERIODS.flatMap((period, back) => {
+			const steady = cp * (1 - back * (.03 + u() * .02)), burst = reserve * (1 - back * .06), top = sprint * [
+				1,
+				1.04,
+				.97
+			][back];
+			const weight = round(mass + back * .9 + n() * .3, 1);
+			let best = Infinity;
+			return POWER_DURATIONS.map((duration) => {
+				const fade = duration > 1800 ? 1 - .06 * Math.log(duration / 1800) : 1;
+				best = Math.min(best, Math.round((steady + burst / (duration + burst / (top - steady))) * fade * (1 + n() * .008)));
+				return {
+					athlete,
+					period,
+					duration,
+					power: best,
+					weight
+				};
+			});
+		});
+	}
+	/** `{ date, athlete, load }`: a training stress score for each session of 20 weeks in four week blocks, ending in a taper and a race. Rest days and missed sessions have no row. */
+	static trainingLoad(seed, weeks = 20) {
+		const { u, n } = SampleData.rng(seed);
+		const athlete = RIDERS[Math.floor(u() * RIDERS.length)], start = Date.UTC(2025, 1, 3 + 7 * (seed % 4)), last = weeks * 7 - 1;
+		return Array.from({ length: weeks * 7 }, (_, day) => {
+			const week = Math.floor(day / 7), left = weeks - 1 - week;
+			const share = left === 0 ? .45 : left === 1 ? .7 : TRAINING_BLOCK[week % 4] * (.7 + week * .035);
+			const planned = day === last ? 240 : TRAINING_WEEK[day % 7] * share;
+			if (!planned || day !== last && u() < .06) return [];
+			return [{
+				date: new Date(start + day * 864e5).toISOString().slice(0, 10),
+				athlete,
+				load: Math.max(10, Math.round(planned * (1 + n() * .12)))
+			}];
+		}).flat();
+	}
 };
 export { SportsSamples };