@mark1russell7/rigor-statistics 0.1.6 → 0.1.8

package/build/index.js

@@ -436,6 +436,1442 @@ function factor(a, k) {
 	}
 	return true;
 }
+// src/response.ts
+/**
+* The format `response-records/1`: the measured points of a function of many dimensions, with a fitted model and the
+* held-out error of each measure. A record is plain JSON. A browser reads it with `parseResponseRecord`, and it
+* evaluates the models with `predictResponse`. A view shows one dimension with `sliceResponse`, or two dimensions
+* with `surfaceResponse`, and it holds the other dimensions.
+*
+* This file has the types and the pure functions that read a record. `response-parse.ts` has the validator, and
+* `response-fit.ts` has the fit. The three files use no Node import, no clock and no `Math.random`.
+*
+* A model calculates integer powers with multiplication, so its terms are equal in each JavaScript engine. A log
+* scale uses `Math.log10` and `10 ** x`. An engine can give a different last bit for these two operations.
+*/
+/** The value of the field `schema` of a record. */
+const RESPONSE_RECORDS_SCHEMA = "response-records/1";
+/** This function gives the key of the group of a point. A point without a group is a group of its own. */
+function groupKey(point) {
+	return point.group === void 0 ? `point ${JSON.stringify(point.id)}` : `group ${JSON.stringify(point.group)}`;
+}
+/** This function gives true for a dimension whose value is a number. */
+function isNumberDimension(dimension) {
+	return dimension.kind === "continuous" || dimension.kind === "ordinal" && typeof dimension.levels[0] === "number";
+}
+/** This function gives the low and the high end of a dimension on the numeric axis of a model. */
+function axisEnds(dimension) {
+	if (!isNumberDimension(dimension)) return [0, dimension.levels.length - 1];
+	const values = dimension.kind === "continuous" ? dimension.range : dimension.levels;
+	const low = values[0];
+	const high = values[values.length - 1];
+	return dimension.log === true ? [Math.log10(low), Math.log10(high)] : [low, high];
+}
+/** This function gives true when a place has the condition of a dimension. A dimension with no condition is present. */
+function whenHolds(dimension, values) {
+	return dimension.when === void 0 || dimension.when.levels.includes(values[dimension.when.dimension]);
+}
+/** This function gives the reason that `value` is not a value of `dimension`. It gives `undefined` for a good value. */
+function valueFault(dimension, value) {
+	if (dimension.kind === "continuous") {
+		if (typeof value !== "number" || !Number.isFinite(value)) return `the value ${JSON.stringify(value)} is not a finite number`;
+		const [low, high] = dimension.range;
+		return value < low || value > high ? `the value ${value} is outside the range ${low} to ${high}` : void 0;
+	}
+	return dimension.levels.includes(value) ? void 0 : `the value ${JSON.stringify(value)} is not a level of the dimension`;
+}
+/**
+* This function gives the input of a dimension, for each kind of model. It reads only a field of the object, not of
+* its prototype. It refuses `null` at a dimension with no condition, so a mistake of a caller cannot give a quiet value.
+*/
+function inputValue(inputs, dimension, conditional) {
+	if (!Object.hasOwn(inputs, dimension)) throw new RangeError(`predictResponse: the inputs have no value of the dimension "${dimension}".`);
+	const value = inputs[dimension];
+	if (value === null && !conditional) throw new RangeError(`predictResponse: the dimension "${dimension}" has no condition, so it needs a value, not null.`);
+	return value;
+}
+/** This function gives the coordinate of one input of a ridge model. An absent input has `null`, and a level has 0. */
+function coordinate(input, value) {
+	if (value === null) return null;
+	const bad = (reason) => /* @__PURE__ */ new RangeError(`predictResponse: the value ${JSON.stringify(value)} of the dimension "${input.dimension}" ${reason}.`);
+	if (input.kind === "number") {
+		if (typeof value !== "number" || !Number.isFinite(value)) throw bad("is not a finite number");
+		if (input.log === true && value <= 0) throw bad("is not above 0, and the dimension has a log scale");
+		return ((input.log === true ? Math.log10(value) : value) - input.center) / input.spread;
+	}
+	const position = input.levels.indexOf(value);
+	if (position < 0) throw bad("is not a level of the model");
+	return input.kind === "rank" ? (position - input.center) / input.spread : 0;
+}
+/** This function gives the coordinate of each input of a ridge model. */
+function coordinates(inputs, values) {
+	return new Map(inputs.map((input) => [input.dimension, coordinate(input, inputValue(values, input.dimension, input.conditional === true))]));
+}
+/**
+* This function gives the product of the factors of a term at a place. A power is a loop of multiplications. A term
+* with an absent dimension is 0, so the columns of the levels of the parent carry the mean of that place.
+*/
+function product(factors, at, values) {
+	let value = 1;
+	for (const factor of factors) {
+		const c = at.get(factor.dimension);
+		if (c === null) return 0;
+		if ("level" in factor) {
+			if (values[factor.dimension] !== factor.level) return 0;
+		} else for (let i = 0; i < factor.power; i++) value *= c;
+	}
+	return value;
+}
+/** This function gives the prediction on the scale of the model. The sum with 0 removes a negative zero. */
+function predictScaled(model, inputs) {
+	if (model.kind === "table") {
+		const at = model.dimensions.map((d) => inputValue(inputs, d, model.conditional?.includes(d) === true));
+		return model.cells.find((cell) => cell.at.every((v, i) => v === at[i]))?.value ?? model.fallback;
+	}
+	const at = coordinates(model.inputs, inputs);
+	let sum = model.intercept;
+	for (const term of model.terms) sum += term.weight * product(term.factors, at, inputs);
+	return sum + 0;
+}
+/** This function changes a measured value to the scale of a model. A log scale with a floor lifts each smaller value. */
+function toModelScale(value, log, floor) {
+	return log ? Math.log10(Math.max(value, floor ?? value)) : value;
+}
+/** This function changes a value from the scale of the model to the scale of the measure. */
+function unscale(model, value) {
+	return model.scale === "log" ? 10 ** value : value;
+}
+/**
+* This function gives the value of a model at `inputs`, on the scale of the measure. The inputs have a value for each
+* dimension that the model reads. An absent conditional dimension has `null`. A table model gives its `fallback` for a
+* combination with no cell.
+*
+* The function throws a RangeError for a missing input and for a value that is not a number or a level of the model.
+* It throws for `null` at a dimension with no condition, for each kind of model. It also throws for a value at or below
+* 0 on a log scale. A number outside the range of the record is good, so the
+* function extrapolates.
+*/
+function predictResponse(model, inputs) {
+	return unscale(model, predictScaled(model, inputs));
+}
+/**
+* This function gives the held-out error of a measure over all the folds. Each point has the same weight, so a small
+* fold has a small effect. The function throws a RangeError when no fold has the measure.
+*/
+function heldOutError(record, measure) {
+	let n = 0;
+	let folds = 0;
+	let absolute = 0;
+	let square = 0;
+	let baseline = 0;
+	for (const fold of record.folds) {
+		if (!Object.hasOwn(fold.errors, measure)) continue;
+		const error = fold.errors[measure];
+		n += error.n;
+		folds += 1;
+		absolute += error.n * error.mae;
+		square += error.n * error.rmse * error.rmse;
+		baseline += error.n * error.baselineMae;
+	}
+	if (n === 0) throw new RangeError(`heldOutError: no fold has an error of the measure "${measure}".`);
+	const mae = absolute / n;
+	const baselineMae = baseline / n;
+	return {
+		n,
+		folds,
+		mae,
+		rmse: Math.sqrt(square / n),
+		baselineMae,
+		skill: baselineMae > 0 ? 1 - mae / baselineMae : null
+	};
+}
+/** This function gives the stored predictions of a measure in a fold. A fold with no predictions gives `undefined`. */
+function predictionsOf(fold, measure) {
+	return fold.predictions !== void 0 && Object.hasOwn(fold.predictions, measure) ? fold.predictions[measure] : void 0;
+}
+/**
+* This function gives the held-out error of a chosen set of points, on the scale of the model. It uses the stored
+* predictions of the option `outOfFold`. Thus a reader can get the error of one cell. The result has the fields of
+* `heldOutError`, and the set of all the points gives the same values to the rounding of the sums.
+*
+* Each point counts at most once. A point with no value of the measure, or with no prediction, adds nothing to `n`.
+* The baseline of a point is the mean of the training points of its fold.
+*
+* The function throws a RangeError for an unknown measure and for a record with no predictions of the measure. It
+* also throws for an unknown id, for a repeated id, and for a set with no point to score.
+*/
+function heldOutErrorAt(record, measure, ids) {
+	const model = record.models.find((m) => m.measure === measure);
+	if (model === void 0) throw new RangeError(`heldOutErrorAt: the record has no model of the measure "${measure}".`);
+	if (!record.folds.some((fold) => predictionsOf(fold, measure) !== void 0)) throw new RangeError(`heldOutErrorAt: the record has no predictions of the measure "${measure}". Fit it with the option outOfFold.`);
+	const chosen = new Set(ids);
+	if (chosen.size !== ids.length) throw new RangeError("heldOutErrorAt: the list of ids has a repeated id.");
+	const points = new Map(record.points.map((p) => [p.id, p]));
+	for (const id of ids) if (!points.has(id)) throw new RangeError(`heldOutErrorAt: the record has no point "${id}".`);
+	const scaled = (point) => {
+		const value = point.measures[measure];
+		return typeof value === "number" ? toModelScale(value, model.scale === "log", model.floor) : void 0;
+	};
+	let n = 0;
+	let folds = 0;
+	let absolute = 0;
+	let square = 0;
+	let baselineSum = 0;
+	for (const fold of record.folds) {
+		const predicted = predictionsOf(fold, measure);
+		if (predicted === void 0) continue;
+		const scored = fold.heldOut.filter((id) => chosen.has(id) && Object.hasOwn(predicted, id));
+		if (scored.length === 0) continue;
+		const held = new Set(fold.heldOut);
+		const baseline = mean(record.points.flatMap((p) => held.has(p.id) || scaled(p) === void 0 ? [] : [scaled(p)]));
+		folds += 1;
+		for (const id of scored) {
+			const y = scaled(points.get(id));
+			const error = y - predicted[id];
+			n += 1;
+			absolute += Math.abs(error);
+			square += error * error;
+			baselineSum += Math.abs(y - baseline);
+		}
+	}
+	if (n === 0) throw new RangeError(`heldOutErrorAt: no chosen point has a prediction of the measure "${measure}".`);
+	const mae = absolute / n;
+	const baselineMae = baselineSum / n;
+	return {
+		n,
+		folds,
+		mae,
+		rmse: Math.sqrt(square / n),
+		baselineMae,
+		skill: baselineMae > 0 ? 1 - mae / baselineMae : null
+	};
+}
+/**
+* This function gives the usual value of a dimension: a measured median, or the most common level among `among`. A
+* tie gives the first level. A dimension with no measured value gives its low end or its first level.
+*/
+function usualValue(dimension, points, among) {
+	const values = points.flatMap((p) => p.values[dimension.id] === null ? [] : [p.values[dimension.id]]);
+	if (dimension.kind === "continuous") return values.length === 0 ? dimension.range[0] : quantile(values, .5, "nearest-rank");
+	const levels = dimension.levels.filter((level) => among === void 0 || among.includes(level));
+	let best = levels[0];
+	let most = 0;
+	for (const level of levels) {
+		const count = values.filter((v) => v === level).length;
+		if (count > most) [best, most] = [level, count];
+	}
+	return best;
+}
+/** This function gives the place of a value on its axis. A number or a rank is a share of the axis, from 0 to 1. */
+function axisPlace(dimension, value) {
+	if (value === null || dimension.kind === "categorical") return value;
+	const [low, high] = axisEnds(dimension);
+	if (high === low) return 0;
+	if (!isNumberDimension(dimension)) return dimension.levels.indexOf(value) / high;
+	return ((dimension.log === true ? Math.log10(value) : value) - low) / (high - low);
+}
+/** This function gives the count of one dimension between two places: their distance, or 1 when they do not compare. */
+const axisGap = (a, b) => a === b ? 0 : typeof a === "number" && typeof b === "number" ? Math.abs(a - b) : 1;
+/**
+* This function gives a function of the field `nearest` of a band. A place compares with each point that has a value
+* of the measure. A point stops at the first count that is not less than the best distance so far.
+*/
+function nearestOf(dimensions, points, measure) {
+	const rows = points.filter((p) => typeof p.measures[measure] === "number").map((p) => dimensions.map((d) => axisPlace(d, p.values[d.id])));
+	return (place) => {
+		const here = dimensions.map((d) => axisPlace(d, place[d.id]));
+		let best = 1;
+		for (const row of rows) {
+			let far = 0;
+			for (let i = 0; i < here.length && far < best; i++) far = Math.max(far, axisGap(row[i], here[i]));
+			if (far < best) best = far;
+		}
+		return best;
+	};
+}
+/** This function gives the levels that the parent of each varied conditional dimension needs. */
+function neededLevels(name, varied, vary) {
+	const needed = /* @__PURE__ */ new Map();
+	for (const { id, when } of varied) {
+		if (when === void 0) continue;
+		if (vary.includes(when.dimension)) throw new RangeError(`${name}: the dimension "${id}" has a value only at some levels of "${when.dimension}", so hold "${when.dimension}".`);
+		const earlier = needed.get(when.dimension);
+		needed.set(when.dimension, earlier === void 0 ? when.levels : earlier.filter((level) => when.levels.includes(level)));
+	}
+	return needed;
+}
+/** This function gives the value of each dimension that does not vary. `sliceResponse` tells the rules. */
+function heldValues(name, record, vary, hold, needed) {
+	const others = record.dimensions.filter((d) => !vary.includes(d.id));
+	const plain = new Map(others.filter((d) => d.when === void 0).map((d) => [d.id, Object.hasOwn(hold, d.id) ? hold[d.id] : usualValue(d, record.points, needed.get(d.id))]));
+	for (const [parent, levels] of needed) {
+		const value = plain.get(parent);
+		if (!levels.includes(value)) throw new RangeError(`${name}: a varied dimension needs "${parent}" at one of ${JSON.stringify(levels)}, not ${JSON.stringify(value)}.`);
+	}
+	const valueOf = ({ id, when }) => {
+		if (when === void 0) return plain.get(id);
+		if (!vary.includes(when.dimension) && !when.levels.includes(plain.get(when.dimension))) return null;
+		const value = Object.hasOwn(hold, id) ? hold[id] : usualValue(record.dimensions.find((d) => d.id === id), record.points);
+		if (value === null) throw new RangeError(`${name}: the held dimension "${id}" is null, and a level of "${when.dimension}" in this view needs a value.`);
+		return value;
+	};
+	return Object.fromEntries(others.map((d) => [d.id, valueOf(d)]));
+}
+/** This function gives the values of an axis: each level, or `steps` equal distances on the scale of the dimension. */
+function axisValues(dimension, steps) {
+	if (dimension.kind !== "continuous") return dimension.levels;
+	const [low, high] = dimension.range;
+	const [a, b] = axisEnds(dimension);
+	return Array.from({ length: steps }, (_, i) => {
+		if (i === 0) return low;
+		if (i === steps - 1) return high;
+		const x = a + (b - a) * i / (steps - 1);
+		return dimension.log === true ? 10 ** x : x;
+	});
+}
+/** This function gives true when the value of a point matches a held value of a dimension. */
+function matches(dimension, value, held, tolerance) {
+	if (typeof value !== "number" || typeof held !== "number") return value === held;
+	const [low, high] = axisEnds(dimension);
+	const log = dimension.kind !== "categorical" && dimension.log === true;
+	return Math.abs(log ? Math.log10(value) - Math.log10(held) : value - held) <= tolerance * (high - low);
+}
+/** This function examines the request of a view, and it gives the parts that the two views share. */
+function frameOf(name, record, measure, vary, options) {
+	const { hold = {}, steps = 33, tolerance = 0, width = 1 } = options;
+	if (!Number.isSafeInteger(steps) || steps < 2) throw new RangeError(`${name}: steps is a whole number of 2 or more, not ${steps}.`);
+	if (!(Number.isFinite(tolerance) && tolerance >= 0)) throw new RangeError(`${name}: tolerance is a finite number of 0 or more, not ${tolerance}.`);
+	if (!(Number.isFinite(width) && width >= 0)) throw new RangeError(`${name}: width is a finite number of 0 or more, not ${width}.`);
+	const model = record.models.find((m) => m.measure === measure);
+	if (model === void 0) throw new RangeError(`${name}: the record has no model of the measure "${measure}".`);
+	const known = (id) => {
+		const dimension = record.dimensions.find((d) => d.id === id);
+		if (dimension === void 0) throw new RangeError(`${name}: the record has no dimension "${id}".`);
+		return dimension;
+	};
+	const varied = vary.map(known);
+	if (new Set(vary).size !== vary.length) throw new RangeError(`${name}: the two varied dimensions are one dimension, "${vary[0]}".`);
+	for (const id of Object.keys(hold)) {
+		if (vary.includes(id)) throw new RangeError(`${name}: the dimension "${id}" is both varied and held.`);
+		const dimension = known(id);
+		if (hold[id] === null && dimension.when !== void 0) continue;
+		const fault = valueFault(dimension, hold[id]);
+		if (fault !== void 0) throw new RangeError(`${name}: the held dimension "${id}": ${fault}.`);
+	}
+	const others = record.dimensions.filter((d) => !vary.includes(d.id));
+	const held = heldValues(name, record, vary, hold, neededLevels(name, varied, vary));
+	const placed = record.points.filter((p) => vary.every((id) => p.values[id] !== null) && others.every((d) => matches(d, p.values[d.id], whenHolds(d, p.values) ? held[d.id] : null, tolerance)));
+	const matched = placed.filter((p) => typeof p.measures[measure] === "number");
+	const missing = placed.filter((p) => typeof p.measures[measure] !== "number");
+	const error = heldOutError(record, measure);
+	const nearest = nearestOf(record.dimensions, record.points, measure);
+	const band = (inputs) => {
+		const place = Object.fromEntries(record.dimensions.map((d) => [d.id, whenHolds(d, inputs) ? inputs[d.id] : null]));
+		const value = predictScaled(model, place);
+		return {
+			value: unscale(model, value),
+			low: unscale(model, value - width * error.rmse),
+			high: unscale(model, value + width * error.rmse),
+			nearest: nearest(place)
+		};
+	};
+	return {
+		held,
+		axes: varied.map((d) => axisValues(d, steps)),
+		matched,
+		missing,
+		error,
+		band
+	};
+}
+/** This function gives the group field of a measured point of a view. */
+const groupOf = (point) => point.group === void 0 ? {} : { group: point.group };
+/** This function gives the declared reason of a point with no value of a measure, or `null` for no stated reason. */
+const reasonOf = (point, measure) => point.absent !== void 0 && Object.hasOwn(point.absent, measure) ? point.absent[measure] : null;
+/**
+* This function gives a view of a measure over one dimension of a parsed record:
+* - `curve`: the fitted value at each level, or at `steps` values of a continuous dimension, with its band.
+* - `points`: the measured points that match the held values. This list is empty when no point matches them.
+* - `absent`: the points that match the held values and have no value of the measure, each with its reason. A chart
+*   can draw each reason apart.
+* - `held`: the value of each other dimension.
+* - `error`: the held-out error.
+*
+* Each dimension with no value in `hold` takes its usual value. For a continuous dimension, this value is the median
+* of its measured values. For the other kinds, it is the most common level, and a tie gives the first level.
+*
+* A conditional dimension follows its parent:
+* - To vary a conditional dimension, the parent needs a level inside `when`. With no held value, the parent takes the
+*   most common level inside `when`. A held level outside `when` is a RangeError.
+* - A held conditional dimension reads `null` in `held` when its parent is outside `when`, also with a value in `hold`.
+*   The points that match have `null` at this dimension.
+* - When the parent varies, a held conditional dimension keeps its value in `held`. Each place outside `when` reads
+*   `null` for the fit, and for the matching points.
+*
+* The band is the fitted value, plus and less `width` times the held-out root mean square error. On a log scale, this
+* distance is on the log scale of the model, so the band is a ratio. The band has one width along all the curve. The
+* band is the mean error of the model, and `nearest` tells how far the place is from a measurement.
+*
+* The function throws a RangeError for an unknown measure or dimension, and for a held value that is not good for its
+* dimension. It also throws for a dimension that is both varied and held, and for a bad option.
+*/
+function sliceResponse(record, measure, options) {
+	const { vary } = options;
+	const { held, axes, matched, missing, error, band } = frameOf("sliceResponse", record, measure, [vary], options);
+	return {
+		measure,
+		vary,
+		held,
+		curve: axes[0].map((at) => ({
+			at,
+			...band({
+				...held,
+				[vary]: at
+			})
+		})),
+		points: matched.map((p) => ({
+			id: p.id,
+			at: p.values[vary],
+			value: p.measures[measure],
+			...groupOf(p)
+		})),
+		absent: missing.map((p) => ({
+			id: p.id,
+			at: p.values[vary],
+			reason: reasonOf(p, measure),
+			...groupOf(p)
+		})),
+		error
+	};
+}
+/**
+* This function gives the view of `sliceResponse` over two dimensions. The fields `x` and `y` are the two axes, and
+* `cells` has one row for each value of `y`. The rules of the held values, of the matching points and of the band are
+* the rules of `sliceResponse`. The function also throws a RangeError when the two varied dimensions are one dimension.
+* It throws when a conditional dimension varies with its parent, and when two varied dimensions need no common level.
+*/
+function surfaceResponse(record, measure, options) {
+	const { vary } = options;
+	const [xId, yId] = vary;
+	const { held, axes, matched, missing, error, band } = frameOf("surfaceResponse", record, measure, vary, options);
+	const x = axes[0];
+	const y = axes[1];
+	return {
+		measure,
+		vary,
+		held,
+		x,
+		y,
+		cells: y.map((b) => x.map((a) => band({
+			...held,
+			[xId]: a,
+			[yId]: b
+		}))),
+		points: matched.map((p) => ({
+			id: p.id,
+			at: [p.values[xId], p.values[yId]],
+			value: p.measures[measure],
+			...groupOf(p)
+		})),
+		absent: missing.map((p) => ({
+			id: p.id,
+			at: [p.values[xId], p.values[yId]],
+			reason: reasonOf(p, measure),
+			...groupOf(p)
+		})),
+		error
+	};
+}
+// src/response-parse.ts
+/**
+* The validator of the format `response-records/1`. The functions here read unknown data and write faults. Thus a page
+* can show the reason that a file is bad.
+*/
+/** The largest power of a factor. A larger power of a coordinate from -1 to 1 adds almost nothing to a model. */
+const RESPONSE_MAX_POWER = 8;
+/** This function gives an unknown value as short text for a message. */
+function shown(value) {
+	if (value === void 0) return "nothing";
+	const text = JSON.stringify(value) ?? String(value);
+	return text.length > 60 ? `${text.slice(0, 60)}...` : text;
+}
+/** This function gives a path with one more key. */
+const at = (path, key) => path === "" ? key : `${path}.${key}`;
+const isNumber = (v) => typeof v === "number" && Number.isFinite(v);
+/** This function gives the field `key` of an unknown value, or `undefined` for a value that is not an object. */
+const peek = (value, key) => typeof value === "object" && value !== null ? value[key] : void 0;
+/** This function writes a fault when a test fails. */
+function need(ok, path, message, faults) {
+	if (!ok) faults.push({
+		path,
+		message
+	});
+}
+/** This function gives the fields of a plain object. It writes a fault for another value, and for each wrong key. */
+function fields(value, path, keys, optional, faults) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		faults.push({
+			path,
+			message: `this is an object, not ${shown(value)}.`
+		});
+		return;
+	}
+	const object = value;
+	for (const key of keys) need(Object.hasOwn(object, key), at(path, key), "this field is missing.", faults);
+	for (const key of Object.keys(object)) need(keys.includes(key) || optional.includes(key), at(path, key), `${RESPONSE_RECORDS_SCHEMA} has no such field.`, faults);
+	return object;
+}
+/** This function gives the items of a list. It writes a fault for another value, and for a short list. */
+function list(value, path, least, faults) {
+	if (!Array.isArray(value)) {
+		faults.push({
+			path,
+			message: `this is a list, not ${shown(value)}.`
+		});
+		return [];
+	}
+	need(value.length >= least, path, `this list has ${value.length} items, and it needs ${least} or more.`, faults);
+	return value;
+}
+/** This function examines a field when it is present. A missing field already has a fault, or it is optional. */
+function check(object, key, path, test, wanted, faults) {
+	if (Object.hasOwn(object, key)) need(test(object[key]), at(path, key), `this is ${wanted}, not ${shown(object[key])}.`, faults);
+}
+const isId = (v) => typeof v === "string" && v !== "";
+const isString = (v) => typeof v === "string";
+const isPositive = (v) => isNumber(v) && v > 0;
+const isNotNegative = (v) => isNumber(v) && v >= 0;
+/** This function writes a fault for each id that is a duplicate, and it gives the set of the ids. */
+function uniqueIds(items, path, faults) {
+	const ids = /* @__PURE__ */ new Set();
+	items.forEach((item, i) => {
+		const id = peek(item, "id");
+		if (typeof id !== "string") return;
+		need(!ids.has(id), `${path}[${i}].id`, `an earlier item has the id ${shown(id)}.`, faults);
+		ids.add(id);
+	});
+	return ids;
+}
+/** This function examines the levels of a categorical or ordinal dimension. */
+function checkLevels(value, path, numbersToo, log, faults) {
+	const levels = list(value, path, 1, faults);
+	const numbers = numbersToo && levels.every(isNumber);
+	need(numbers || levels.every(isString), path, numbersToo ? "these levels are all text or all finite numbers." : "these levels are all text.", faults);
+	need(new Set(levels).size === levels.length, path, "these levels have a duplicate.", faults);
+	if (numbers) need(levels.every((v, i) => i === 0 || levels[i - 1] < v), path, "these number levels are not in ascending order.", faults);
+	if (log) need(levels.every(isPositive), path, "a log dimension has number levels above 0.", faults);
+}
+/** This function examines one dimension. */
+function checkDimension(value, path, faults) {
+	const kind = peek(value, "kind");
+	const object = fields(value, path, [
+		"id",
+		"label",
+		"kind",
+		"unit"
+	], [
+		"range",
+		"levels",
+		"log",
+		"when"
+	], faults);
+	if (object === void 0) return;
+	check(object, "id", path, isId, "text with one character or more", faults);
+	check(object, "label", path, isString, "text", faults);
+	check(object, "unit", path, isString, "text", faults);
+	check(object, "log", path, (v) => typeof v === "boolean", "true or false", faults);
+	const log = object["log"] === true;
+	if (kind === "continuous") {
+		need(!Object.hasOwn(object, "levels"), at(path, "levels"), "a continuous dimension has a range, not levels.", faults);
+		need(!Object.hasOwn(object, "range") || !log || !isNumber(peek(object["range"], "0")) || peek(object["range"], "0") > 0, at(path, "range"), "a log dimension has a range above 0.", faults);
+		need(Object.hasOwn(object, "range"), at(path, "range"), "this field is missing.", faults);
+		const range = object["range"];
+		const good = Array.isArray(range) && range.length === 2 && isNumber(range[0]) && isNumber(range[1]) && range[0] < range[1];
+		if (Object.hasOwn(object, "range")) need(good, at(path, "range"), `this is a low and a high finite number, with low less than high, not ${shown(range)}.`, faults);
+	} else if (kind === "ordinal" || kind === "categorical") {
+		need(!Object.hasOwn(object, "range"), at(path, "range"), `a dimension of the kind ${kind} has levels, not a range.`, faults);
+		need(kind === "ordinal" || !Object.hasOwn(object, "log"), at(path, "log"), "a categorical dimension has no log scale.", faults);
+		need(Object.hasOwn(object, "levels"), at(path, "levels"), "this field is missing.", faults);
+		if (Object.hasOwn(object, "levels")) checkLevels(object["levels"], at(path, "levels"), kind === "ordinal", log, faults);
+	} else if (Object.hasOwn(object, "kind")) faults.push({
+		path: at(path, "kind"),
+		message: `this is "continuous", "ordinal" or "categorical", not ${shown(kind)}.`
+	});
+}
+/** This function examines the condition of one dimension against all the dimensions. */
+function checkWhen(value, path, dimensions, faults) {
+	const object = fields(value, path, ["dimension", "levels"], [], faults);
+	if (object === void 0) return;
+	const levels = Object.hasOwn(object, "levels") ? list(object["levels"], at(path, "levels"), 1, faults) : [];
+	need(new Set(levels).size === levels.length, at(path, "levels"), "these levels have a duplicate.", faults);
+	if (!Object.hasOwn(object, "dimension")) return;
+	const id = object["dimension"];
+	const parent = dimensions.find((d) => peek(d, "id") === id);
+	if (parent === void 0) {
+		faults.push({
+			path: at(path, "dimension"),
+			message: `the record has no dimension ${shown(id)}.`
+		});
+		return;
+	}
+	const kind = peek(parent, "kind");
+	need(kind === "categorical" || kind === "ordinal", at(path, "dimension"), `the parent ${shown(id)} is ${shown(kind)}, and a parent is categorical or ordinal.`, faults);
+	need(peek(parent, "when") === void 0, at(path, "dimension"), `the parent ${shown(id)} is itself conditional.`, faults);
+	const known = peek(parent, "levels");
+	if (!Array.isArray(known)) return;
+	levels.forEach((level, i) => need(known.includes(level), `${at(path, "levels")}[${i}]`, `the dimension ${shown(id)} has no level ${shown(level)}.`, faults));
+}
+/** This function examines one measure. */
+function checkMeasure(value, path, faults) {
+	const object = fields(value, path, [
+		"id",
+		"label",
+		"unit",
+		"direction"
+	], [], faults);
+	if (object === void 0) return;
+	check(object, "id", path, isId, "text with one character or more", faults);
+	check(object, "label", path, isString, "text", faults);
+	check(object, "unit", path, isString, "text", faults);
+	check(object, "direction", path, (v) => v === "higher" || v === "lower" || v === "none", `"higher", "lower" or "none"`, faults);
+}
+/** This function examines one declared reason. */
+function checkReason(value, path, faults) {
+	const object = fields(value, path, ["id", "label"], [], faults);
+	if (object === void 0) return;
+	check(object, "id", path, isId, "text with one character or more", faults);
+	check(object, "label", path, isString, "text", faults);
+}
+/** This function examines the reasons of a point: each has a declaration, and each is on a measure with no number. */
+function checkAbsent(value, path, measuresOfPoint, measures, reasons, faults) {
+	const absent = fields(value, path, [], [...measures], faults);
+	if (absent === void 0) return;
+	for (const measure of measures) {
+		if (!Object.hasOwn(absent, measure)) continue;
+		need(reasons.has(absent[measure]), at(path, measure), `the record declares no reason ${shown(absent[measure])}.`, faults);
+		need(typeof peek(measuresOfPoint, measure) !== "number", at(path, measure), "this measure has a number, so it has no reason.", faults);
+	}
+}
+/** This function examines one point, with the dimensions, the measures and the reasons of the record. */
+function checkPoint(value, path, dimensions, measures, reasons, faults) {
+	const object = fields(value, path, [
+		"id",
+		"values",
+		"measures"
+	], ["group", "absent"], faults);
+	if (object === void 0) return;
+	check(object, "id", path, isId, "text with one character or more", faults);
+	check(object, "group", path, isId, "text with one character or more", faults);
+	if (Object.hasOwn(object, "values")) {
+		const inside = at(path, "values");
+		const ids = dimensions.map((d) => d.id);
+		const values = fields(object["values"], inside, ids, [], faults);
+		for (const dimension of dimensions) {
+			if (values === void 0 || !Object.hasOwn(values, dimension.id)) continue;
+			const value = values[dimension.id];
+			const present = whenHolds(dimension, values);
+			const parent = dimension.when?.dimension;
+			if (value === null && dimension.when !== void 0) {
+				need(!present, at(inside, dimension.id), `this needs a value when the dimension "${parent}" is ${shown(values[parent])}.`, faults);
+				continue;
+			}
+			const fault = valueFault(dimension, value);
+			if (fault !== void 0) faults.push({
+				path: at(inside, dimension.id),
+				message: `${fault}.`
+			});
+			else need(present, at(inside, dimension.id), `this is null when the dimension "${parent}" is ${shown(values[parent])}.`, faults);
+		}
+	}
+	if (Object.hasOwn(object, "absent")) checkAbsent(object["absent"], at(path, "absent"), object["measures"], measures, reasons, faults);
+	if (Object.hasOwn(object, "measures")) {
+		const inside = at(path, "measures");
+		const values = fields(object["measures"], inside, [...measures], [], faults);
+		if (values === void 0) return;
+		for (const measure of measures) check(values, measure, inside, (v) => v === null || isNumber(v), "a finite number or null", faults);
+	}
+}
+/**
+* This function examines the data of a record: all but its models and its folds. It gives each fault that it finds.
+* It examines the points only when the dimensions and the measures have no fault, because the points refer to them.
+* `required` and `optional` name the other top-level fields.
+*/
+function responseDataFaults(value, required, optional) {
+	const faults = [];
+	const object = fields(value, "", [
+		"schema",
+		"name",
+		"dimensions",
+		"measures",
+		"points",
+		...required
+	], ["reasons", ...optional], faults);
+	if (object === void 0) return faults;
+	check(object, "schema", "", (v) => v === RESPONSE_RECORDS_SCHEMA, `"${RESPONSE_RECORDS_SCHEMA}"`, faults);
+	check(object, "name", "", isId, "text with one character or more", faults);
+	const dimensions = Object.hasOwn(object, "dimensions") ? list(object["dimensions"], "dimensions", 1, faults) : [];
+	dimensions.forEach((d, i) => checkDimension(d, `dimensions[${i}]`, faults));
+	uniqueIds(dimensions, "dimensions", faults);
+	dimensions.forEach((d, i) => {
+		if (peek(d, "when") !== void 0) checkWhen(peek(d, "when"), `dimensions[${i}].when`, dimensions, faults);
+	});
+	const measures = Object.hasOwn(object, "measures") ? list(object["measures"], "measures", 1, faults) : [];
+	measures.forEach((m, i) => checkMeasure(m, `measures[${i}]`, faults));
+	const measureIds = uniqueIds(measures, "measures", faults);
+	const reasons = Object.hasOwn(object, "reasons") ? list(object["reasons"], "reasons", 0, faults) : [];
+	reasons.forEach((r, i) => checkReason(r, `reasons[${i}]`, faults));
+	const reasonIds = uniqueIds(reasons, "reasons", faults);
+	if (faults.length > 0) return faults;
+	const points = list(object["points"], "points", 1, faults);
+	points.forEach((p, i) => checkPoint(p, `points[${i}]`, dimensions, measureIds, reasonIds, faults));
+	uniqueIds(points, "points", faults);
+	return faults;
+}
+/** This function examines one input of a ridge model against the dimensions of the record. */
+function checkInput(value, path, dimensions, faults) {
+	const kind = peek(value, "kind");
+	if (kind !== "number" && kind !== "rank" && kind !== "level") {
+		faults.push({
+			path: at(path, "kind"),
+			message: `this is "number", "rank" or "level", not ${shown(kind)}.`
+		});
+		return;
+	}
+	const keys = {
+		number: ["center", "spread"],
+		rank: [
+			"levels",
+			"center",
+			"spread"
+		],
+		level: ["levels"]
+	}[kind];
+	const object = fields(value, path, [
+		"kind",
+		"dimension",
+		...keys
+	], kind === "number" ? ["log", "conditional"] : ["conditional"], faults);
+	if (object === void 0) return;
+	check(object, "center", path, isNumber, "a finite number", faults);
+	check(object, "spread", path, isPositive, "a finite number above 0", faults);
+	check(object, "log", path, (v) => typeof v === "boolean", "true or false", faults);
+	check(object, "conditional", path, (v) => typeof v === "boolean", "true or false", faults);
+	const dimension = dimensions.get(object["dimension"]);
+	if (dimension === void 0) {
+		faults.push({
+			path: at(path, "dimension"),
+			message: `the record has no dimension ${shown(object["dimension"])}.`
+		});
+		return;
+	}
+	const want = isNumberDimension(dimension) ? "number" : dimension.kind === "categorical" ? "level" : "rank";
+	need(kind === want, at(path, "kind"), `the dimension "${dimension.id}" needs an input of the kind "${want}".`, faults);
+	need((object["conditional"] ?? false) === (dimension.when !== void 0), at(path, "conditional"), `this does not agree with the condition of the dimension "${dimension.id}".`, faults);
+	if (kind === "number" && dimension.kind !== "categorical") need((object["log"] ?? false) === (dimension.log ?? false), at(path, "log"), `this does not agree with the log scale of the dimension "${dimension.id}".`, faults);
+	if (kind !== "number" && dimension.kind !== "continuous") need(JSON.stringify(object["levels"]) === JSON.stringify(dimension.levels), at(path, "levels"), `these are not the levels of the dimension "${dimension.id}".`, faults);
+}
+/** This function examines the factors of one term against the inputs of a model. `fitResponse` also uses it. */
+function factorFaults(value, path, inputs, dimensions) {
+	const faults = [];
+	list(value, path, 1, faults).forEach((item, i) => {
+		const inside = `${path}[${i}]`;
+		const isLevel = peek(item, "level") !== void 0;
+		const factor = fields(item, inside, ["dimension", isLevel ? "level" : "power"], [], faults);
+		if (factor === void 0) return;
+		const input = inputs.get(factor["dimension"]);
+		if (input === void 0) faults.push({
+			path: at(inside, "dimension"),
+			message: `the model has no input ${shown(factor["dimension"])}.`
+		});
+		else if (isLevel) {
+			const dimension = dimensions.get(input.dimension);
+			need((dimension === void 0 || dimension.kind === "continuous" ? [] : dimension.levels).includes(factor["level"]), at(inside, "level"), `the input "${input.dimension}" has no level ${shown(factor["level"])}.`, faults);
+		} else {
+			need(input.kind !== "level", inside, `the categorical input "${input.dimension}" takes a level, not a power.`, faults);
+			const good = (v) => Number.isSafeInteger(v) && v >= 1 && v <= 8;
+			check(factor, "power", inside, good, `a whole number from 1 to 8`, faults);
+		}
+	});
+	return faults;
+}
+/** This function examines the fields of a ridge model after its common fields. */
+function checkRidge(object, path, dimensions, faults) {
+	check(object, "lambda", path, isNotNegative, "a finite number of 0 or more", faults);
+	check(object, "intercept", path, isNumber, "a finite number", faults);
+	const inputs = Object.hasOwn(object, "inputs") ? list(object["inputs"], at(path, "inputs"), 0, faults) : [];
+	const known = /* @__PURE__ */ new Map();
+	inputs.forEach((input, i) => {
+		const inside = `${at(path, "inputs")}[${i}]`;
+		checkInput(input, inside, dimensions, faults);
+		const dimension = peek(input, "dimension");
+		if (typeof dimension !== "string") return;
+		need(!known.has(dimension), at(inside, "dimension"), `an earlier input has the dimension "${dimension}".`, faults);
+		known.set(dimension, input);
+	});
+	(Object.hasOwn(object, "terms") ? list(object["terms"], at(path, "terms"), 0, faults) : []).forEach((term, i) => {
+		const inside = `${at(path, "terms")}[${i}]`;
+		const fieldsOfTerm = fields(term, inside, ["factors", "weight"], [], faults);
+		if (fieldsOfTerm === void 0) return;
+		check(fieldsOfTerm, "weight", inside, isNumber, "a finite number", faults);
+		if (Object.hasOwn(fieldsOfTerm, "factors")) faults.push(...factorFaults(fieldsOfTerm["factors"], at(inside, "factors"), known, dimensions));
+	});
+}
+/** This function examines the dimensions of a table model, and it gives the good ones. */
+function tableDimensions(object, path, dimensions, faults) {
+	const table = [];
+	(Object.hasOwn(object, "dimensions") ? list(object["dimensions"], at(path, "dimensions"), 1, faults) : []).forEach((id, i) => {
+		const dimension = dimensions.get(id);
+		const inside = `${at(path, "dimensions")}[${i}]`;
+		if (dimension === void 0) faults.push({
+			path: inside,
+			message: `the record has no dimension ${shown(id)}.`
+		});
+		else if (dimension.kind === "continuous") faults.push({
+			path: inside,
+			message: `a table cannot read the continuous dimension "${dimension.id}".`
+		});
+		else {
+			need(!table.includes(dimension), inside, `an earlier item is the dimension "${dimension.id}".`, faults);
+			table.push(dimension);
+		}
+	});
+	return table;
+}
+/** This function examines the fields of a table model after its common fields. */
+function checkTable(object, path, dimensions, faults) {
+	check(object, "fallback", path, isNumber, "a finite number", faults);
+	const table = tableDimensions(object, path, dimensions, faults);
+	const conditional = table.filter((d) => d.when !== void 0).map((d) => d.id);
+	need(JSON.stringify(object["conditional"] ?? []) === JSON.stringify(conditional), at(path, "conditional"), `this does not agree with the conditions of the dimensions of the table: ${shown(conditional)}.`, faults);
+	const cells = Object.hasOwn(object, "cells") ? list(object["cells"], at(path, "cells"), 1, faults) : [];
+	const seen = /* @__PURE__ */ new Set();
+	cells.forEach((cell, i) => {
+		const inside = `${at(path, "cells")}[${i}]`;
+		const fieldsOfCell = fields(cell, inside, [
+			"at",
+			"value",
+			"n"
+		], [], faults);
+		if (fieldsOfCell === void 0) return;
+		check(fieldsOfCell, "value", inside, isNumber, "a finite number", faults);
+		check(fieldsOfCell, "n", inside, (v) => Number.isSafeInteger(v) && v >= 1, "a whole number of 1 or more", faults);
+		if (!Object.hasOwn(fieldsOfCell, "at")) return;
+		const values = list(fieldsOfCell["at"], at(inside, "at"), 0, faults);
+		need(values.length === table.length, at(inside, "at"), `this list has ${values.length} values, and the table has ${table.length} dimensions.`, faults);
+		table.forEach((dimension, j) => {
+			const absent = values[j] === null && dimension.when !== void 0;
+			const fault = j < values.length && !absent ? valueFault(dimension, values[j]) : void 0;
+			if (fault !== void 0) faults.push({
+				path: `${at(inside, "at")}[${j}]`,
+				message: `${fault}.`
+			});
+		});
+		const key = JSON.stringify(values);
+		need(!seen.has(key), at(inside, "at"), `an earlier cell has the values ${shown(values)}.`, faults);
+		seen.add(key);
+	});
+}
+/** This function examines the list of models: one model for each measure. */
+function checkModels(value, data, faults) {
+	const dimensions = new Map(data.dimensions.map((d) => [d.id, d]));
+	const measures = new Set(data.measures.map((m) => m.id));
+	const covered = /* @__PURE__ */ new Set();
+	list(value, "models", 0, faults).forEach((item, i) => {
+		const path = `models[${i}]`;
+		const kind = peek(item, "kind");
+		if (kind !== "ridge" && kind !== "table") {
+			faults.push({
+				path: at(path, "kind"),
+				message: `this is "ridge" or "table", not ${shown(kind)}.`
+			});
+			return;
+		}
+		const object = fields(item, path, [
+			"kind",
+			"measure",
+			"scale",
+			...kind === "ridge" ? [
+				"lambda",
+				"inputs",
+				"intercept",
+				"terms"
+			] : [
+				"dimensions",
+				"cells",
+				"fallback"
+			]
+		], kind === "ridge" ? ["floor"] : ["floor", "conditional"], faults);
+		if (object === void 0) return;
+		const measure = object["measure"];
+		if (typeof measure !== "string" || !measures.has(measure)) faults.push({
+			path: at(path, "measure"),
+			message: `the record has no measure ${shown(measure)}.`
+		});
+		else {
+			need(!covered.has(measure), at(path, "measure"), `an earlier model has the measure "${measure}".`, faults);
+			covered.add(measure);
+		}
+		check(object, "scale", path, (v) => v === "linear" || v === "log", `"linear" or "log"`, faults);
+		check(object, "floor", path, isPositive, "a finite number above 0", faults);
+		need(!Object.hasOwn(object, "floor") || object["scale"] === "log", at(path, "floor"), "only a model with the scale log has a floor.", faults);
+		if (kind === "ridge") checkRidge(object, path, dimensions, faults);
+		else checkTable(object, path, dimensions, faults);
+	});
+	for (const measure of measures) need(covered.has(measure), "models", `no model has the measure "${measure}".`, faults);
+}
+/** This function examines the error of one measure in one fold. */
+function checkFoldError(value, path, count, faults) {
+	const object = fields(value, path, [
+		"n",
+		"mae",
+		"rmse",
+		"baselineMae"
+	], [], faults);
+	if (object === void 0) return;
+	check(object, "n", path, (v) => v === count, `${count}, the held-out points of the fold with a value of this measure`, faults);
+	for (const key of [
+		"mae",
+		"rmse",
+		"baselineMae"
+	]) check(object, key, path, isNotNegative, "a finite number of 0 or more", faults);
+}
+/** This function examines the stored predictions of a fold against its held-out points and its errors. */
+function checkPredictions(value, path, held, errors, measures, faults) {
+	const predictions = fields(value, path, [], measures, faults);
+	if (predictions === void 0) return;
+	for (const measure of measures) {
+		if (!Object.hasOwn(predictions, measure)) continue;
+		const inside = at(path, measure);
+		const stored = fields(predictions[measure], inside, [], Object.keys(peek(predictions, measure) ?? {}), faults);
+		if (stored === void 0) continue;
+		need(peek(errors, measure) !== void 0, inside, "this fold has no error of this measure.", faults);
+		const scored = new Set(held.filter((p) => typeof p.measures[measure] === "number").map((p) => p.id));
+		for (const id of Object.keys(stored)) {
+			need(scored.has(id), at(inside, id), `this fold has no held-out point ${shown(id)} with a value of the measure.`, faults);
+			check(stored, id, inside, isNumber, "a finite number", faults);
+		}
+		for (const id of scored) need(Object.hasOwn(stored, id), at(inside, id), "this held-out point has no prediction.", faults);
+	}
+}
+/** This function adds the points of a fold to `foldOfPoint`, and it gives them. Each bad id gives a fault. */
+function heldPoints(value, path, f, points, foldOfPoint, faults) {
+	const held = [];
+	list(value, path, 1, faults).forEach((id, i) => {
+		const inside = `${path}[${i}]`;
+		const point = points.get(id);
+		const earlier = foldOfPoint.get(id);
+		if (point === void 0) faults.push({
+			path: inside,
+			message: `the record has no point ${shown(id)}.`
+		});
+		else if (earlier !== void 0) faults.push({
+			path: inside,
+			message: `the point "${point.id}" is also in fold ${earlier}.`
+		});
+		else {
+			foldOfPoint.set(point.id, f);
+			held.push(point);
+		}
+	});
+	return held;
+}
+/** This function gives the number of points of each group in a list. */
+function groupSizes(points) {
+	const sizes = /* @__PURE__ */ new Map();
+	for (const p of points) sizes.set(groupKey(p), (sizes.get(groupKey(p)) ?? 0) + 1);
+	return sizes;
+}
+/** This function examines the list of folds. `parseResponseRecord` tells the rules. */
+function checkFolds(value, data, faults) {
+	const points = new Map(data.points.map((p) => [p.id, p]));
+	const measures = data.measures.map((m) => m.id);
+	const sizes = groupSizes(data.points);
+	const foldOfPoint = /* @__PURE__ */ new Map();
+	const covered = /* @__PURE__ */ new Set();
+	const folds = list(value, "folds", 1, faults);
+	const predicted = measures.filter((m) => folds.some((fold) => peek(peek(fold, "predictions"), m) !== void 0));
+	folds.forEach((item, f) => {
+		const path = `folds[${f}]`;
+		const object = fields(item, path, ["heldOut", "errors"], ["predictions"], faults);
+		if (object === void 0) return;
+		const held = Object.hasOwn(object, "heldOut") ? heldPoints(object["heldOut"], at(path, "heldOut"), f, points, foldOfPoint, faults) : [];
+		for (const [group, count] of groupSizes(held)) {
+			const size = sizes.get(group);
+			need(count === size, at(path, "heldOut"), `the ${group} has ${count} of its ${size} points in this fold, so it is on both sides of the split.`, faults);
+		}
+		if (Object.hasOwn(object, "predictions")) checkPredictions(object["predictions"], at(path, "predictions"), held, object["errors"], measures, faults);
+		if (!Object.hasOwn(object, "errors")) return;
+		const errors = fields(object["errors"], at(path, "errors"), [], measures, faults);
+		if (errors === void 0) return;
+		for (const measure of measures) {
+			if (!Object.hasOwn(errors, measure)) continue;
+			const count = held.filter((p) => p.measures[measure] !== null).length;
+			checkFoldError(errors[measure], at(at(path, "errors"), measure), count, faults);
+			if (count > 0) covered.add(measure);
+			need(!predicted.includes(measure) || peek(object["predictions"], measure) !== void 0, at(path, "predictions"), `another fold has predictions of the measure "${measure}", so this fold needs them too.`, faults);
+		}
+	});
+	for (const measure of measures) need(covered.has(measure), "folds", `no fold has a held-out error of the measure "${measure}".`, faults);
+}
+/**
+* This function examines unknown data, for example the result of `JSON.parse`, against `response-records/1`. It gives
+* `{ ok: true, record }`, with the same object as the record, or `{ ok: false, faults }`. Each fault has the path of
+* the bad field and a message. The function does not throw. Data that the checks cannot read, for example an object
+* with a loop, gives one fault.
+*
+* A field that the format does not have is a fault. Thus a wrong spelling of an optional field cannot go unseen.
+*
+* The function examines the models and the folds only when the data has no fault, because they refer to the data.
+* Thus a correction of the data can show more faults. These rules apply to the folds:
+* - A point is in one fold or in no fold.
+* - All the points of a group are in one fold, or all are in no fold. Thus no group is on both sides of a split.
+* - The count `n` of an error is the number of held-out points with a value of the measure.
+* - Each measure has an error in one fold or more.
+*
+* These rules apply to the predictions of a fold:
+* - Each prediction is a finite number of a held-out point of the fold with a value of the measure.
+* - The fold has a prediction of each such point, and an error of the measure.
+* - When one fold has predictions of a measure, each fold with an error of the measure has them.
+*
+* These rules apply to the reasons of a point:
+* - Each reason is on a known measure with no number. A measure with `null` and no reason is good.
+* - Each reason has a declaration in the field `reasons` of the record.
+*/
+function parseResponseRecord(value) {
+	try {
+		const faults = [...responseDataFaults(value, ["models", "folds"], [])];
+		if (faults.length === 0) {
+			const record = value;
+			checkModels(record.models, record, faults);
+			checkFolds(record.folds, record, faults);
+			if (faults.length === 0) return {
+				ok: true,
+				record
+			};
+		}
+		return {
+			ok: false,
+			faults
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			faults: [{
+				path: "",
+				message: `the validator cannot read this data: ${String(error)}.`
+			}]
+		};
+	}
+}
+// src/response-fit.ts
+/**
+* The fit of `response-records/1`. The function `fitResponse` splits the groups into folds. For each fold, it fits a
+* model on the other folds and scores the model on the fold. Then it fits the model of the record on all the points.
+*
+* The coordinates of a ridge model come from the declared ranges, not from the points. Thus each fold has the same
+* design, and no fact of a held-out point goes into a fit. The penalty of a fold comes from the other folds only.
+*/
+/** The default penalties of a ridge fit. The coordinates are from -1 to 1, so one list suits each record. */
+const RESPONSE_LAMBDAS = [
+	1e-6,
+	1e-4,
+	.001,
+	.01,
+	.1,
+	1,
+	10,
+	100
+];
+/** The largest number of coefficients of a ridge fit. The memory of each fold grows as the square of this number. */
+const RESPONSE_MAX_TERMS = 1024;
+/** This function compares two texts by their code units, so the order does not depend on a locale. */
+const byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** This function gives the input of a ridge model for a dimension. The coordinates run from -1 to 1 over the dimension. */
+function inputOf(dimension) {
+	const conditional = dimension.when === void 0 ? {} : { conditional: true };
+	if (dimension.kind === "categorical") return {
+		kind: "level",
+		dimension: dimension.id,
+		levels: dimension.levels,
+		...conditional
+	};
+	const [low, high] = axisEnds(dimension);
+	const center = (low + high) / 2;
+	const spread = high > low ? (high - low) / 2 : 1;
+	if (!isNumberDimension(dimension)) return {
+		kind: "rank",
+		dimension: dimension.id,
+		levels: dimension.levels,
+		center,
+		spread,
+		...conditional
+	};
+	return {
+		kind: "number",
+		dimension: dimension.id,
+		center,
+		spread,
+		...dimension.log === true ? { log: true } : {},
+		...conditional
+	};
+}
+/** This function gives the factors of one dimension, each with its power. */
+function factorsOf(dimension, degree) {
+	if (dimension.kind === "categorical") return dimension.levels.map((level) => [{
+		dimension: dimension.id,
+		level
+	}, 1]);
+	return Array.from({ length: degree }, (_, i) => [{
+		dimension: dimension.id,
+		power: i + 1
+	}, i + 1]);
+}
+/**
+* This function gives one column for each level of an ordinal parent inside a condition. An ordinal parent has no
+* one-hot columns of its own, so these columns carry the mean of each level with an absent child.
+*/
+function parentColumns(dimensions) {
+	return dimensions.flatMap((parent) => {
+		if (parent.kind !== "ordinal") return [];
+		const conditions = dimensions.flatMap((d) => d.when?.dimension === parent.id ? [d.when.levels] : []);
+		return parent.levels.filter((level) => conditions.some((c) => c.includes(level))).map((level) => [{
+			dimension: parent.id,
+			level
+		}]);
+	});
+}
+/** This function gives true when the general product of two dimensions adds nothing: a child with its parent, or two children with no common level. */
+function separate(a, b) {
+	if (a.when?.dimension === b.id || b.when?.dimension === a.id) return true;
+	return a.when !== void 0 && a.when.dimension === b.when?.dimension && !a.when.levels.some((level) => b.when?.levels.includes(level));
+}
+/**
+* This function gives the terms of the expansion: each factor, and each product of two dimensions up to `degree`. A
+* conditional dimension with two parent levels or more also has each power times each of these levels. Thus each
+* level has its own curve. With one parent level, the terms of the dimension are already the curve of this level.
+*/
+function expansion(dimensions, degree, interactions) {
+	const each = dimensions.map((d) => factorsOf(d, degree));
+	const terms = [...each.flatMap((factors) => factors.map(([factor]) => [factor])), ...parentColumns(dimensions)];
+	if (!interactions) return terms;
+	each.forEach((first, a) => {
+		each.slice(a + 1).forEach((second, offset) => {
+			if (separate(dimensions[a], dimensions[a + 1 + offset])) return;
+			for (const [f, p] of first) for (const [g, q] of second) if (p + q <= degree) terms.push([f, g]);
+		});
+	});
+	dimensions.forEach(({ when }, a) => {
+		if (when === void 0 || when.levels.length < 2) return;
+		for (const [factor] of each[a]) for (const level of when.levels) terms.push([factor, {
+			dimension: when.dimension,
+			level
+		}]);
+	});
+	return terms;
+}
+/** This function gives the terms that are not 0 at one point or more. A fold gives a term with no point the weight 0. */
+function seenTerms(terms, dimensions, points) {
+	const inputs = checkedInputs(dimensions, terms);
+	const places = points.map((point) => ({
+		at: coordinates(inputs, point.values),
+		values: point.values
+	}));
+	return terms.filter((term) => places.some(({ at, values }) => product(term, at, values) !== 0));
+}
+/** This function gives the inputs of a ridge fit: one for each dimension of a term. It throws for a bad term. */
+function checkedInputs(dimensions, terms) {
+	const used = new Set(terms.flatMap((t) => t.map((f) => f.dimension)));
+	const inputs = dimensions.filter((d) => used.has(d.id)).map(inputOf);
+	const known = new Map(inputs.map((input) => [input.dimension, input]));
+	const byId = new Map(dimensions.map((d) => [d.id, d]));
+	terms.forEach((term, i) => {
+		const [fault] = factorFaults(term, `terms[${i}]`, known, byId);
+		if (fault !== void 0) throw new RangeError(`fitResponse: ${fault.path}: ${fault.message}`);
+	});
+	return inputs;
+}
+/**
+* This function gives the ridge fits of the rows of one measure. It keeps `X'X` and `X'y` of each fold, so a fit adds
+* the sums of its training folds. The first coefficient is the intercept, and it has no penalty.
+*/
+function ridgeLearner(rows, plan) {
+	const { terms, inputs, folds, lambdas } = plan;
+	const k = terms.length + 1;
+	const design = new Float64Array(rows.length * k);
+	const grams = Array.from({ length: folds }, () => new Float64Array(k * k));
+	const moments = Array.from({ length: folds }, () => new Float64Array(k));
+	rows.forEach((row, r) => {
+		const at = coordinates(inputs, row.point.values);
+		const offset = r * k;
+		design[offset] = 1;
+		terms.forEach((term, j) => {
+			design[offset + j + 1] = product(term, at, row.point.values);
+		});
+		const gram = grams[row.fold];
+		const moment = moments[row.fold];
+		for (let a = 0; a < k; a++) {
+			const value = design[offset + a];
+			moment[a] = moment[a] + value * row.y;
+			for (let b = 0; b <= a; b++) gram[a * k + b] = gram[a * k + b] + value * design[offset + b];
+		}
+	});
+	const predict = (beta, r) => {
+		let sum = 0;
+		for (let j = 0; j < k; j++) sum += beta[j] * design[r * k + j];
+		return sum;
+	};
+	const solve = (left, lambda) => {
+		const gram = new Float64Array(k * k);
+		const moment = new Float64Array(k);
+		for (let f = 0; f < folds; f++) {
+			if (left.includes(f)) continue;
+			const g = grams[f];
+			const m = moments[f];
+			for (let i = 0; i < k * k; i++) gram[i] = gram[i] + g[i];
+			for (let i = 0; i < k; i++) moment[i] = moment[i] + m[i];
+		}
+		return ridgeSolve(gram, moment, lambda, { free: [0] });
+	};
+	const choose = (outer) => {
+		const descending = [...lambdas].sort((a, b) => b - a);
+		let best = descending[0];
+		let bestError = Number.POSITIVE_INFINITY;
+		for (const lambda of descending) {
+			let error = 0;
+			for (let f = 0; f < folds; f++) {
+				if (f === outer) continue;
+				const beta = solve([outer, f], lambda);
+				rows.forEach((row, r) => {
+					if (row.fold === f) error += (row.y - predict(beta, r)) ** 2;
+				});
+			}
+			if (error < bestError) [best, bestError] = [lambda, error];
+		}
+		return best;
+	};
+	return {
+		learner: (fold) => {
+			const beta = solve([fold], choose(fold));
+			return (r) => predict(beta, r);
+		},
+		final: () => {
+			const lambda = choose(void 0);
+			return {
+				lambda,
+				beta: solve([], lambda)
+			};
+		}
+	};
+}
+/** This function gives the mean of the rows of each combination of levels, as cells in the order of their text. */
+function tableCells(rows, dimensions) {
+	const cells = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const at = dimensions.map((d) => row.point.values[d]);
+		const key = JSON.stringify(at);
+		const cell = cells.get(key);
+		if (cell === void 0) cells.set(key, {
+			at,
+			ys: [row.y]
+		});
+		else cell.ys.push(row.y);
+	}
+	return [...cells.keys()].sort(byText).map((key) => {
+		const { at, ys } = cells.get(key);
+		return {
+			at,
+			value: mean(ys),
+			n: ys.length
+		};
+	});
+}
+/** This function gives the fits of a table: the mean of each cell, or the mean of the rows for a cell with no row. */
+function tableLearner(rows, dimensions) {
+	const keys = rows.map((row) => JSON.stringify(dimensions.map((d) => row.point.values[d])));
+	return (fold) => {
+		const train = rows.filter((row) => row.fold !== fold);
+		const cells = new Map(tableCells(train, dimensions).map((c) => [JSON.stringify(c.at), c.value]));
+		const fallback = mean(train.map((row) => row.y));
+		return (r) => cells.get(keys[r]) ?? fallback;
+	};
+}
+/** This function gives the score of a fold. A fold with no held-out row or no training row has no score. */
+function foldScore(rows, fold, learner) {
+	const train = rows.filter((row) => row.fold !== fold).map((row) => row.y);
+	const held = rows.flatMap((row, r) => row.fold === fold ? [r] : []);
+	if (held.length === 0 || train.length === 0) return void 0;
+	const predict = learner(fold);
+	const baseline = mean(train);
+	const predicted = held.map((r) => predict(r));
+	const errors = held.map((r, i) => rows[r].y - predicted[i]);
+	return {
+		error: {
+			n: held.length,
+			mae: mean(errors.map(Math.abs)),
+			rmse: Math.sqrt(mean(errors.map((e) => e * e))),
+			baselineMae: mean(held.map((r) => Math.abs(rows[r].y - baseline)))
+		},
+		predictions: Object.fromEntries(held.map((r, i) => [rows[r].point.id, predicted[i]]))
+	};
+}
+/** This function gives the rows of a measure. It throws a RangeError for a value that a log scale cannot read. */
+function rowsOf(points, measure, log, floor, foldOf) {
+	return points.flatMap((point) => {
+		const value = point.measures[measure];
+		if (typeof value !== "number") return [];
+		if (log && floor === void 0 && value <= 0) throw new RangeError(`fitResponse: the point "${point.id}" has the value ${value} of the log measure "${measure}". Give logFloor.`);
+		return [{
+			point,
+			y: toModelScale(value, log, floor),
+			fold: foldOf.get(groupKey(point))
+		}];
+	});
+}
+/** This function gives the model of one measure on all its rows, and the score of each fold. */
+function fitMeasure(rows, measure, log, floor, plan) {
+	if (rows.length === 0) throw new RangeError(`fitResponse: no point has a value of the measure "${measure.id}".`);
+	const base = {
+		measure: measure.id,
+		scale: log ? "log" : "linear",
+		...log && floor !== void 0 ? { floor } : {}
+	};
+	const ridge = plan.kind === "ridge" ? ridgeLearner(rows, plan) : void 0;
+	const learner = ridge?.learner ?? tableLearner(rows, plan.ids);
+	const scores = Array.from({ length: plan.folds }, (_, f) => foldScore(rows, f, learner));
+	if (scores.every((s) => s === void 0)) throw new RangeError(`fitResponse: all the values of the measure "${measure.id}" are in one fold. Give more groups.`);
+	const conditional = plan.conditional.length === 0 ? {} : { conditional: plan.conditional };
+	if (ridge === void 0) return {
+		model: {
+			kind: "table",
+			...base,
+			dimensions: plan.ids,
+			...conditional,
+			cells: tableCells(rows, plan.ids),
+			fallback: mean(rows.map((r) => r.y))
+		},
+		scores
+	};
+	const { lambda, beta } = ridge.final();
+	if (!beta.every(Number.isFinite)) throw new RangeError(`fitResponse: the fit of the measure "${measure.id}" with lambda ${lambda} is singular. Give a larger lambda.`);
+	const terms = plan.terms.map((factors, j) => ({
+		factors,
+		weight: beta[j + 1]
+	}));
+	return {
+		model: {
+			kind: "ridge",
+			...base,
+			lambda,
+			inputs: plan.inputs,
+			intercept: beta[0],
+			terms
+		},
+		scores
+	};
+}
+/** This function examines the options that do not depend on the data, and it gives the number of folds and the penalties. */
+function checkedOptions(options) {
+	const { folds = 5, degree = 2, lambdas = RESPONSE_LAMBDAS, logFloor } = options;
+	if (!Number.isSafeInteger(folds) || folds < 3) throw new RangeError(`fitResponse: folds is a whole number of 3 or more, not ${folds}.`);
+	if (!Number.isSafeInteger(degree) || degree < 1 || degree > 8) throw new RangeError(`fitResponse: degree is a whole number from 1 to 8, not ${degree}.`);
+	if (lambdas.length === 0 || !lambdas.every((l) => Number.isFinite(l) && l > 0)) throw new RangeError("fitResponse: lambdas is a list of finite numbers above 0, with one item or more.");
+	if (logFloor !== void 0 && !(Number.isFinite(logFloor) && logFloor > 0)) throw new RangeError(`fitResponse: logFloor is a finite number above 0, not ${logFloor}.`);
+	return {
+		folds,
+		degree,
+		lambdas
+	};
+}
+/** This function gives the kind of model. It throws a RangeError when a table cannot read a dimension. */
+function kindOf(dimensions, model) {
+	const continuous = dimensions.find((d) => d.kind === "continuous");
+	if (model === "table" && continuous !== void 0) throw new RangeError(`fitResponse: a table cannot read the continuous dimension "${continuous.id}".`);
+	if (model !== "auto") return model;
+	return dimensions.every((d) => d.kind === "categorical") ? "table" : "ridge";
+}
+/**
+* This function fits each measure of `data`, and it gives a record with the models and the folds.
+*
+* The split: the groups, sorted and then shuffled with `seed`, go to the folds in turn. A point with no group is a
+* group of its own. Thus the repeats of one group are not on both sides of a split. The same split applies to each
+* measure. A record needs 3 groups or more.
+*
+* The model: a ridge fit over a stated expansion, or the mean of each cell of a table. The default expansion has
+* each power of each number dimension up to `degree`. It has one column for each level of a categorical dimension.
+* It also has the products of two dimensions up to `degree`. Each coordinate goes from -1 to 1 over the declared
+* range. The intercept has no penalty.
+*
+* A conditional dimension: a term with an absent dimension is 0. Thus the columns of the parent carry the mean of each
+* level with no value. A dimension with two parent levels or more also has each power times each of these levels, if
+* `interactions` is true. A table keeps `null` as a level of its cells.
+*
+* The penalty: each fold of a ridge fit chooses from `lambdas` with the other folds. Thus the held-out error of a
+* fold is not optimistic. The model of the record chooses with all the folds.
+*
+* The errors: a fold scores the model of the other folds on its held-out points, on the scale of the model. With the
+* option `outOfFold`, the fold also stores the prediction of each of these points.
+*
+* The reasons: a measure with a stated reason is `null` for the fit. The field `reasons` of the data stays in the record.
+*
+* The result does not depend on the order of the points, except for the field `points`, which keeps the order of
+* the data. The same data and options give the same bytes in one JavaScript engine.
+*
+* The function throws a RangeError for data with a fault, for a bad option, and for fewer than 3 groups. It also
+* throws for a measure with no value, and for a measure with all its values in one fold. It throws for a value of 0
+* or less on a log scale with no `logFloor`. It throws for more than `RESPONSE_MAX_TERMS` terms.
+*/
+function fitResponse(data, options = {}) {
+	const [fault] = responseDataFaults(data, [], ["models", "folds"]);
+	if (fault !== void 0) throw new RangeError(`fitResponse: ${fault.path === "" ? "the data" : fault.path}: ${fault.message}`);
+	const { degree, lambdas, folds: wanted } = checkedOptions(options);
+	const { dimensions, measures } = data;
+	const log = new Set(options.log ?? []);
+	for (const id of log) if (!measures.some((m) => m.id === id)) throw new RangeError(`fitResponse: the option log names the unknown measure "${id}".`);
+	const kind = kindOf(dimensions, options.model ?? "auto");
+	const interactions = options.interactions ?? true;
+	const expanded = kind === "table" ? [] : options.terms ?? expansion(dimensions, degree, interactions !== false);
+	const terms = interactions === "seen" && options.terms === void 0 ? seenTerms(expanded, dimensions, data.points) : expanded;
+	if (terms.length + 1 > 1024) throw new RangeError(`fitResponse: the expansion has ${terms.length} terms, and the limit is 1023. Set interactions to false or "seen", or give terms.`);
+	const inputs = checkedInputs(dimensions, terms);
+	const points = [...data.points].sort((a, b) => byText(a.id, b.id));
+	const groups = [...new Set(points.map(groupKey))].sort(byText);
+	if (groups.length < 3) throw new RangeError(`fitResponse: the points have ${groups.length} groups, and a held-out split needs 3 or more.`);
+	const folds = Math.min(wanted, groups.length);
+	const shuffled = random(options.seed ?? 1).shuffle(groups);
+	const foldOf = new Map(shuffled.map((group, i) => [group, i % folds]));
+	const plan = {
+		ids: dimensions.map((d) => d.id),
+		conditional: dimensions.flatMap((d) => d.when === void 0 ? [] : [d.id]),
+		kind,
+		folds,
+		lambdas,
+		terms,
+		inputs
+	};
+	const fits = measures.map((m) => fitMeasure(rowsOf(points, m.id, log.has(m.id), options.logFloor, foldOf), m, log.has(m.id), options.logFloor, plan));
+	const foldRecords = Array.from({ length: folds }, (_, f) => {
+		const scored = measures.flatMap((m, i) => {
+			const score = fits[i]?.scores[f];
+			return score === void 0 ? [] : [[m.id, score]];
+		});
+		return {
+			heldOut: points.filter((p) => foldOf.get(groupKey(p)) === f).map((p) => p.id),
+			errors: Object.fromEntries(scored.map(([id, score]) => [id, score.error])),
+			...options.outOfFold === true ? { predictions: Object.fromEntries(scored.map(([id, score]) => [id, score.predictions])) } : {}
+		};
+	});
+	const reasons = data.reasons === void 0 ? {} : { reasons: data.reasons };
+	return {
+		schema: RESPONSE_RECORDS_SCHEMA,
+		name: data.name,
+		dimensions,
+		measures,
+		...reasons,
+		points: data.points,
+		models: fits.map((fit) => fit.model),
+		folds: foldRecords
+	};
+}
 // src/tests.ts
 /**
 * The tests of a difference: the sign test, the paired permutation test, the Wilson interval of a proportion and
@@ -891,6 +2327,6 @@ function calibration(forecasts) {
 		interval: wilson(hits, n)
 	}));
 }
-export { KENDALL_EXACT, Z95, binomialInterval, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapTwo, brier, calibration, compareRatios, holm, kendallTau, leastSquares, mean, median, medianInterval, negativeBinomialInterval, noiseFloor, noiseVerdict, pairedPermutation, quantile, quantileSorted, ranks, ridgeSolve, sd, signTest, signTestPower, sorted, spearman, summarize, wilson };
+export { KENDALL_EXACT, RESPONSE_LAMBDAS, RESPONSE_MAX_POWER, RESPONSE_MAX_TERMS, RESPONSE_RECORDS_SCHEMA, Z95, binomialInterval, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapTwo, brier, calibration, compareRatios, fitResponse, heldOutError, heldOutErrorAt, holm, kendallTau, leastSquares, mean, median, medianInterval, negativeBinomialInterval, noiseFloor, noiseVerdict, pairedPermutation, parseResponseRecord, predictResponse, quantile, quantileSorted, ranks, ridgeSolve, sd, signTest, signTestPower, sliceResponse, sorted, spearman, summarize, surfaceResponse, wilson };
 
 //# sourceMappingURL=index.js.map