@jarenjs/core 0.46.5 → 0.56.0

package/dist/types/series/normalize.d.ts

@@ -0,0 +1,190 @@
+export type Sample = {
+    /**
+     * - Unix epoch milliseconds
+     */
+    at: number;
+    /**
+     * - the reading, or `null` for a
+     * measured gap
+     */
+    value: number | null;
+};
+export type Interval = {
+    /**
+     * - inclusive lower bound, epoch milliseconds
+     */
+    start: number;
+    /**
+     * - exclusive upper bound, epoch milliseconds
+     */
+    end: number;
+};
+/**
+ * @typedef {Object} Sample
+ * @property {number} at - Unix epoch milliseconds
+ * @property {number | null} value - the reading, or `null` for a
+ *   measured gap
+ */
+/**
+ * @typedef {Object} Interval
+ * @property {number} start - inclusive lower bound, epoch milliseconds
+ * @property {number} end - exclusive upper bound, epoch milliseconds
+ */
+/**
+ * The instant `value` names, in Unix epoch milliseconds.
+ *
+ * Accepts the two forms a date has in this suite: a finite **number**
+ * (already epoch milliseconds, returned unchanged) and a valid **RFC
+ * 3339 string**. A full-date reads as UTC midnight, an offset shifts to
+ * the instant it names, and `Z` is UTC.
+ *
+ * Refused, all as `TypeError`: a full-time (`'09:30:00Z'` names no day,
+ * and inventing one would be a hidden clock), a date-time without an
+ * offset (`'2026-01-01T09:30:00'` names no instant without a zone),
+ * `NaN`/`Infinity`, a `Date` object (dates are strings or numbers here,
+ * never a wrapper), and anything else.
+ *
+ * @param {number | string} value
+ * @returns {number} epoch milliseconds
+ * @throws {TypeError} when `value` names no instant
+ * @example
+ * toEpoch(0);                      // 0
+ * toEpoch('1970-01-01');           // 0
+ * toEpoch('1970-01-01T01:00:00+01:00'); // 0
+ */
+export declare function toEpoch(value: number | string): number;
+/**
+ * One instant read out of a row, with the row named when it is not one.
+ * "not an RFC 3339 instant" is a puzzle when ten thousand rows were
+ * handed in; "row 4172, at: …" is a defect someone can go and look at.
+ *
+ * @param {any} value - the raw member
+ * @param {string} role - the member's name, for the message
+ * @param {number} index - the row's position
+ * @returns {number} epoch milliseconds
+ * @throws {TypeError} when `value` names no instant
+ */
+export declare function epochAt(value: any, role: string, index: number): number;
+/**
+ * Sorted canonical samples: every row's instant converted once, its
+ * value checked, its other members kept, and the whole ascending by
+ * instant.
+ *
+ * The sort is **stable**, so rows sharing an instant come out in input
+ * order — and both are present, because a duplicate instant is two
+ * readings, not one row written twice.
+ *
+ * Each result is a shallow copy of its source row with canonical `at`
+ * and `value` members written over it, so a source that spelled its
+ * instant `on` keeps `on` too and nothing a caller attached is lost.
+ *
+ * @param {any[]} rows - the source rows
+ * @param {Object} [options]
+ * @param {string | ((item: any, index: number) => any)} [options.at]
+ *   where the instant lives (default `'at'`)
+ * @param {string | ((item: any, index: number) => any)} [options.value]
+ *   where the reading lives (default `'value'`)
+ * @returns {(Sample & Record<string, any>)[]} a new array of new records
+ * @throws {TypeError} for a non-array, a row that is not an object, an
+ *   instant that names none, or a value that is neither a finite number
+ *   nor `null`
+ * @example
+ * normalizeSeries([{ on: '2026-01-01T00:00:01Z', v: 2 },
+ *                  { on: '2026-01-01T00:00:00Z', v: 1 }],
+ *                 { at: 'on', value: 'v' });
+ * // [{ on: '…:00Z', v: 1, at: 1767225600000, value: 1 },
+ * //  { on: '…:01Z', v: 2, at: 1767225601000, value: 2 }]
+ */
+export declare function normalizeSeries(rows: any[], options?: {
+    at?: string | ((item: any, index: number) => any);
+    value?: string | ((item: any, index: number) => any);
+}): (Sample & Record<string, any>)[];
+/**
+ * The same canonical samples, without the copy when there is nothing to
+ * convert.
+ *
+ * {@link normalizeSeries} always builds a new array of new records,
+ * which is the right answer at the door and the wrong one three kernels
+ * later: bucketing, rolling and joining all take a series that a caller
+ * usually normalized once already, and re-copying a hundred thousand
+ * rows per operation costs more than the operation. So this checks
+ * instead of converting — one pass, no allocation — and hands the
+ * caller's own array straight back when every row is already
+ * `{ at: <finite number>, value: <number | null> }` and ascending.
+ *
+ * Nothing is trusted: a row that fails the check sends the whole array
+ * through {@link normalizeSeries}, which refuses it there with the row
+ * named. The fast path is a measurement, not a promise.
+ *
+ * @param {any[]} rows
+ * @param {Object} [options]
+ * @param {string | ((item: any, index: number) => any)} [options.at]
+ * @param {string | ((item: any, index: number) => any)} [options.value]
+ * @returns {(Sample & Record<string, any>)[]} `rows` itself, or a new
+ *   normalized array
+ * @throws {TypeError} exactly where {@link normalizeSeries} does
+ */
+export declare function canonicalSeries(rows: any[], options?: {
+    at?: string | ((item: any, index: number) => any);
+    value?: string | ((item: any, index: number) => any);
+}): (Sample & Record<string, any>)[];
+/**
+ * Sorted canonical intervals: every bound converted once, the direction
+ * checked, other members kept, and the whole ascending by start.
+ *
+ * Half-open `[start, end)` with `start < end` is the contract the whole
+ * algebra rests on, so an empty (`start === end`), reversed or
+ * non-finite interval is refused here rather than producing an answer
+ * later that no reader could predict. Duplicates survive — two bookings
+ * of the same slot are two bookings — and rows sharing a start keep
+ * their input order.
+ *
+ * @param {any[]} rows - the source rows
+ * @param {Object} [options]
+ * @param {string | ((item: any, index: number) => any)} [options.start]
+ *   where the lower bound lives (default `'start'`)
+ * @param {string | ((item: any, index: number) => any)} [options.end]
+ *   where the upper bound lives (default `'end'`)
+ * @returns {(Interval & Record<string, any>)[]} a new array of new records
+ * @throws {TypeError} for a non-array, a row that is not an object, a
+ *   bound that names no instant, or `end <= start`
+ * @example
+ * normalizeIntervals([{ start: '2026-01-01', end: '2026-01-02' }]);
+ * // [{ start: 1767225600000, end: 1767312000000 }]
+ */
+export declare function normalizeIntervals(rows: any[], options?: {
+    start?: string | ((item: any, index: number) => any);
+    end?: string | ((item: any, index: number) => any);
+}): (Interval & Record<string, any>)[];
+/**
+ * The index of the first row at or after `at` — the lower end of a
+ * half-open cut. `rows` must already be ascending on `key`.
+ *
+ * This is the whole reason a series is normalized once: a range over a
+ * sorted array is two binary searches and a slice, not a pass over
+ * everything.
+ *
+ * @param {any[]} rows - ascending on `key`
+ * @param {number} at - epoch milliseconds
+ * @param {string} [key] - the member holding the instant (default `'at'`)
+ * @returns {number} an index in `[0, rows.length]`
+ * @example
+ * const lo = lowerBoundTime(samples, start);
+ * const hi = lowerBoundTime(samples, end);
+ * samples.slice(lo, hi); // every sample in [start, end)
+ */
+export declare function lowerBoundTime(rows: any[], at: number, key?: string): number;
+/**
+ * The index of the first row strictly after `at`. `rows` must already
+ * be ascending on `key`.
+ *
+ * The twin of {@link lowerBoundTime}: together they bracket the rows AT
+ * an instant (`[lowerBoundTime(rows, t), upperBoundTime(rows, t))`),
+ * which is what a duplicate-tolerant as-of has to read.
+ *
+ * @param {any[]} rows - ascending on `key`
+ * @param {number} at - epoch milliseconds
+ * @param {string} [key] - the member holding the instant (default `'at'`)
+ * @returns {number} an index in `[0, rows.length]`
+ */
+export declare function upperBoundTime(rows: any[], at: number, key?: string): number;

package/dist/types/series/rolling.d.ts

@@ -0,0 +1,67 @@
+export type Sample = import('./normalize.js').Sample;
+/**
+ * `rollingSeries`' closed specification: a window measured in time,
+ * how much of one counts, the clock a calendar width walks, and where
+ * a row keeps its instant and its reading.
+ */
+export declare const ROLLING_MEMBERS: readonly string[];
+/**
+ * A rolling aggregate over a time-width window.
+ *
+ * Returns one `{ at, value, count }` per input sample, labelled at that
+ * sample's own instant, where the window is the half-open span
+ * `(at − width, at]`. Two samples at one instant share that window, and
+ * so report the same value and count.
+ *
+ * `count` is the number of **source rows** in the window — duplicates
+ * and measured gaps included — and the six value aggregates skip `null`
+ * readings, so `value` is `null` exactly when the window had nothing to
+ * measure. `aggregate: 'count'` returns that row count as the value.
+ *
+ * `minPeriods` is the number of source rows the window must hold before
+ * a value is reported at all; below it the row is `null` with its real
+ * `count`. It counts rows rather than readings, so a window full of
+ * measured gaps satisfies it and still reports `null` — which is the
+ * honest answer: readings were due, and none of them carried a number.
+ *
+ * `width` is a fixed duration (`'PT1H'`, `86400000`) or, with a clock,
+ * a calendar one (`'P1M'`, and `'P1D'` on a named zone where a day may
+ * be 23 or 25 hours long). A calendar window's start is computed by the
+ * calendar kernel per output, which is O(1) each — it is never a scan
+ * back through the window.
+ *
+ * @param {any[]} rows - the samples, in any order
+ * @param {Object} spec
+ * @param {number | string} spec.width - the window's width
+ * @param {'sum'|'mean'|'min'|'max'|'first'|'last'|'count'} [spec.aggregate]
+ *   default `'mean'`
+ * @param {number} [spec.minPeriods] - default 1
+ * @param {string} [spec.zone] - a named zone, needing `provider`
+ * @param {number} [spec.offset] - minutes east of UTC
+ * @param {import('./zone.js').ZoneProvider} [spec.provider]
+ * @param {'reject'|'earlier'|'later'} [spec.disambiguation]
+ * @param {string | ((item: any, index: number) => any)} [spec.at]
+ * @param {string | ((item: any, index: number) => any)} [spec.value]
+ * @returns {{ at: number, value: number | null, count: number }[]}
+ * @throws {TypeError} for a width that is not one positive whole span,
+ *   an unknown aggregate, a `minPeriods` that is not a positive whole
+ *   number, or a row that is not a canonical sample
+ * @example
+ * rollingSeries(readings, { width: 'PT5M', aggregate: 'mean' });
+ * rollingSeries(readings, { width: 'PT1M', minPeriods: 60 });
+ */
+export declare function rollingSeries(rows: any[], spec: {
+    width: number | string;
+    aggregate?: 'sum' | 'mean' | 'min' | 'max' | 'first' | 'last' | 'count';
+    minPeriods?: number;
+    zone?: string;
+    offset?: number;
+    provider?: import('./zone.js').ZoneProvider;
+    disambiguation?: 'reject' | 'earlier' | 'later';
+    at?: string | ((item: any, index: number) => any);
+    value?: string | ((item: any, index: number) => any);
+}): {
+    at: number;
+    value: number | null;
+    count: number;
+}[];

package/dist/types/series/selector.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A reader for one member of a source row.
+ * @param {string | ((item: any, index: number) => any)} spec - a
+ *   property name, or a function of the row and its position
+ * @param {string} role - the member's name, for the message
+ * @returns {(item: any, index: number) => any}
+ * @throws {TypeError} when `spec` is neither
+ */
+export declare function selectorOf(spec: string | ((item: any, index: number) => any), role: string): (item: any, index: number) => any;
+/**
+ * The row at `index`, confirmed to be something with members to read.
+ * @param {any} item
+ * @param {number} index
+ * @returns {any}
+ * @throws {TypeError} when it is not an object
+ */
+export declare function requireRow(item: any, index: number): any;
+/**
+ * One specification, confirmed to name only admitted members.
+ * @param {any} spec - the caller's specification object
+ * @param {readonly string[]} allowed - the closed member list
+ * @param {string} kernel - the function's name, for the message
+ * @param {string} shape - what the specification is, for the message
+ *   when it is not an object at all
+ * @returns {any} the same object
+ * @throws {TypeError} when it is not an object, or names a member the
+ *   kernel does not admit
+ */
+export declare function requireSpecMembers(spec: any, allowed: readonly string[], kernel: string, shape: string): any;

package/dist/types/series/zone.d.ts

@@ -0,0 +1,59 @@
+export type ZoneProvider = {
+    /**
+     * - the wall
+     * clock at an instant, as a parts record (`year`, `month` 1-12, `day`,
+     * `hours`, `minutes`, `seconds`, and `offset` in minutes east if known)
+     */
+    toParts: (epoch: number, zone: string) => any;
+    /**
+     * - the instant a wall clock names, in epoch milliseconds;
+     * non-finite (or a throw) when the local time is ambiguous or does not
+     * exist and `disambiguation` does not resolve it
+     */
+    toEpoch: (parts: any, zone: string, disambiguation: string) => number;
+};
+export type Clock = {
+    /**
+     * - what the clock is called, for messages
+     */
+    zone: string;
+    partsAt: (epoch: number) => any;
+    epochOf: (parts: any) => number;
+};
+/**
+ * The four members every calendar-aware specification carries, so
+ * a bucket ladder, a rolling window and a query document all spell
+ * the clock the same way.
+ */
+export declare const CLOCK_MEMBERS: readonly string[];
+/**
+ * The clock an operation reads its calendar boundaries on.
+ *
+ * Defaults to UTC, which needs nothing: no provider, no zone name, no
+ * ambiguity. `{ offset }` is a constant number of minutes east and is
+ * exact integer arithmetic. `{ zone }` is a name, and a name means
+ * nothing without a `provider` — asking for `'Europe/Amsterdam'` with no
+ * tzdb is a refusal, never a silent fall back to UTC that is right for
+ * eight months of the year.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.zone] - an IANA name; `'UTC'` needs no provider
+ * @param {number} [options.offset] - minutes east of UTC, for a fixed offset
+ * @param {ZoneProvider} [options.provider] - the tzdb, for a named zone
+ * @param {'reject' | 'earlier' | 'later'} [options.disambiguation]
+ *   what a local time that happens twice, or never, resolves to
+ *   (default `'reject'`)
+ * @returns {Clock}
+ * @throws {TypeError} for a named zone with no provider, a non-finite
+ *   offset, an unknown disambiguation, or both a zone and an offset
+ * @example
+ * resolveClock();                        // UTC
+ * resolveClock({ offset: 330 });         // +05:30, constant
+ * resolveClock({ zone: 'Europe/Amsterdam', provider, disambiguation: 'later' });
+ */
+export declare function resolveClock(options?: {
+    zone?: string;
+    offset?: number;
+    provider?: ZoneProvider;
+    disambiguation?: 'reject' | 'earlier' | 'later';
+}): Clock;

package/dist/types/stats.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @file Descriptive statistics over a sample of numbers: the mean, the
+ * sample variance and its root, the median, and a quantile that will
+ * not answer until told which quantile it is being asked for.
+ *
+ * Before this file the suite computed these in two places with two
+ * quantile rules — linear interpolation in the query layer's statistics
+ * pack, nearest rank in the benchmark harness — and each was the right
+ * rule for its consumer: an interpolated percentile is what an analyst
+ * expects of `$percentile`, while a benchmark row of eleven readings
+ * should not publish a latency nobody measured. Both rules stay; the
+ * definitions move here so that there is one of each, and `quantile`
+ * makes the caller name its method, because "the 95th percentile" of a
+ * small sample is a different number under every one of the seven
+ * common definitions and a default would decide silently.
+ *
+ * Every function answers `undefined` for a sample it cannot summarize —
+ * an empty one, or fewer than two values for a variance — rather than
+ * `NaN` or `0`: a number that was not measured must not format as one.
+ * The caller's array is never reordered; a quantile sorts a copy.
+ * Values are numbers by contract and are not checked one by one.
+ */
+/**
+ * The arithmetic mean.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` for an empty sample
+ */
+export declare function mean(values: readonly number[]): number | undefined;
+/**
+ * The SAMPLE variance, with Bessel's correction (`n − 1`): the sample is
+ * taken as drawn from a population it did not enumerate, which is what a
+ * benchmark's rounds and a query's rows both are.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` for fewer than two values
+ */
+export declare function variance(values: readonly number[]): number | undefined;
+/**
+ * The sample standard deviation — the root of {@link variance}.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` where the variance is
+ */
+export declare function stddev(values: readonly number[]): number | undefined;
+/**
+ * The median: the middle value, or the mean of the two middle values
+ * when the sample has an even count.
+ *
+ * This is NOT `quantile(values, 0.5, …)` under either method, and on an
+ * even count the three disagree: for `[1, 2, 3, 4]` the median is `2.5`,
+ * the nearest-rank p50 is `2`, and the linear p50 is `2.5` only because
+ * that sample happens to be evenly spaced. A consumer publishing a "p50"
+ * beside a "p95" wants `quantile` with its method named; a consumer
+ * asking for the median wants this.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` for an empty sample
+ */
+export declare function median(values: readonly number[]): number | undefined;
+export type QuantileMethod = 'nearest-rank' | 'linear';
+/**
+ * The `p`-quantile of a sample, `p` on `[0, 1]`, under a NAMED method.
+ *
+ * The method is required, not defaulted: on a small sample the common
+ * definitions disagree by whole values, and a caller who did not say
+ * which one it wanted has published a number it cannot explain.
+ * @param {readonly number[]} values
+ * @param {number} p - the probability, `0` (the minimum) to `1` (the maximum)
+ * @param {{ method: QuantileMethod }} options
+ * @returns {number | undefined} `undefined` for an empty sample
+ * @throws {TypeError} when `method` is absent or not one of {@link QuantileMethod}
+ * @throws {RangeError} when `p` is not a number in `[0, 1]`
+ */
+export declare function quantile(values: readonly number[], p: number, options: {
+    method: QuantileMethod;
+}): number | undefined;

package/docs/DATES.md

@@ -42,6 +42,43 @@ start Monday, per ISO). **Month math clamps**: 31 Jan + 1 month =
 28 Feb, which is what makes add and diff behave as inverses in the
 query operators built on this.
 
+Two refusals keep those answers honest, both `TypeError`:
+
+- **A unit reads a half, and a value may not carry it.** `year` through
+  `day` read the calendar; `hour` through `millisecond` read the clock.
+  Adding hours to a full-date, adding a day to a full-time, or
+  truncating either to the unit it has not got has no answer to give.
+  `day` and coarser truncations are the boundary both forms have, so
+  `startOfParts` / `endOfParts` of a `day` on a full-time is midnight and
+  `23:59:59.999`.
+- **A fraction is a quantity only where it converts exactly.** A
+  fractional fixed-width amount becomes whole milliseconds — `1.5 day` is
+  thirty-six hours, and needs a value with a clock to land on. A
+  fractional calendar unit is refused unless it lands on a whole month:
+  half a year is six months, half a month is nothing.
+
+## Time-axis ticks — `ticks.js`
+
+`niceTimeStep(span, count)` picks the `[unit, amount]` a domain should be
+read in — from 1/5/15/30 seconds and minutes through 1/3/6/12 hours, 1/2
+days, 1/2 weeks and 1/3/6 months, then whole years on the 1/2/5 × 10^k
+ladder, so a millennial domain steps by centuries rather than running out
+of axis. `axisTicksTime(min, max, count)` lays the boundaries down: each
+tick is a multiple of the step's own amount, so an axis reads
+`1850 1900 1950 2000` rather than offsets from wherever the data began.
+Below a second the calendar has nothing to say and the numeric ladder
+answers instead. The chart component re-exports both rather than
+carrying its own copy.
+
+`timeTicksEvery(min, max, unit, amount?, options?)` is the same boundary
+rule with the step supplied instead of chosen — what a document that
+declares its own interval needs (Mermaid's Gantt `tickInterval 1week` is
+the one in this repo). `options.weekStart` is an ISO weekday, so a
+document whose weeks begin on Sunday gets Sundays; `options.limit` caps
+the count. `axisTicksTime` is now this function with the ladder in
+front of it, so a chart axis and a timeline cannot disagree about where
+a tick falls.
+
 ## Durations — `duration.js`
 
 `parseDuration('P3DT4H')` — ISO 8601 duration decomposition into
@@ -65,6 +102,43 @@ ISO tokens work bare; name tokens (`MMMM`, `EEE`, `a`) require a
 `names` provider, which is where `@jarenjs/locales` plugs in — the
 kernel ships no month names, so server-rendered output stays
 byte-stable across Node/ICU versions.
+`compileDateLocale(pack).names` is that provider: five arrays (12 months
+wide and short, 7 weekdays wide and short from Sunday, the two day-period
+markers), read once out of a locale pack's own msgids and frozen, so a
+pattern compiled against them costs no lookup per date.
+
+## Parsing — `parse.js`
+
+`compileDateParser(pattern, names?)` is the formatter's strict inverse
+over the same LDML vocabulary, compiled the same way: the pattern is
+scanned once into a chain of readers, and no regular expression is built
+per compile or per parse. It returns a function from text to the parts
+record `parseRFC3339Parts` produces, so `epochOfRFC3339Parts`,
+`addToParts` and `formatRFC3339Parts` all take its output unchanged, and
+the lexical family follows the pattern — date tokens only give a
+full-date, time tokens only a full-time.
+
+Strict means three things, and each of them is the difference between an
+answer and a plausible wrong answer:
+
+1. **Full consumption.** `yyyy-MM-dd` does not read `2026-01-02T03:04`.
+2. **Impossible civil dates fail.** `31-02-2014` is `null`, not 3 March.
+3. **Fixed-width tokens are fixed width.** `MM` reads exactly two digits.
+
+Malformed *text* is data and comes back `null`; a malformed *pattern* is
+the programmer's error and throws at compile time. The tokens that only
+ever format — `EEEE`, `DDD`, `ww`, `Q` are derived *from* a date rather
+than fields *of* one — throw with a message naming the token and the
+reason, rather than reading nothing in silence. Two tokens are
+documented rather than refused: `yy` reads 00–68 as 2000–2068 and 69–99
+as 1969–1999 (the POSIX pivot), and `h`/`hh` with no `a` in the same
+pattern read as the morning.
+
+A consumer whose patterns are **not** LDML adapts its own tokens onto
+this vocabulary rather than handing its spelling over. `@jarenjs/mermaid`
+does exactly that for a Gantt's `dateFormat` (moment's grammar) and
+`axisFormat` (strftime): LDML's `YYYY` is the *week-numbering* year, so
+reading `YYYY-MM-DD` as LDML answers 2019 for 2018-12-31.
 
 ## Not here
 
@@ -72,7 +146,9 @@ byte-stable across Node/ICU versions.
 Node ≥ 24 baseline); the string/number representation is exactly what
 `Temporal.Instant.from()` consumes, so the kernel can delegate
 internally later without a surface change. Relative-time phrasing and
-month-name catalogs are `@jarenjs/locales`' job; `formatMinimum`/
+month-name catalogs are `@jarenjs/locales`' job — including the decision
+that a relative phrase is handed its signed amount rather than working
+one out, which is the same "no `now`" rule this kernel keeps; `formatMinimum`/
 `formatMaximum` bound comparison lives in `@jarenjs/formats`; time
 *axes* (charts) and date *controls* (forms) consume this kernel from
 their own packages.

package/docs/GEO.md

@@ -22,10 +22,10 @@ the *wrong sign* on near-collinear input, which makes containment
 contradict itself. `orient2dFast` is the naive form, exported for
 callers that provably do not care. Every winding and containment answer
 in this module rests on this sign; its cost is the deliberate
-point-in-polygon loss on the benchmark page (<!--bm:geo.pip2000-->0.5×<!--/bm--> against
+point-in-polygon loss on the benchmark page (<!--fact:geo.pip2000-->0.5×<!--/fact--> against
 Turf at 2000 vertices, kept on purpose). Every loss the kernel carries is
 published in [ARCHITECTURE](../ARCHITECTURE.md), derived from the committed
-measurement: <!--bm:geo.losses-->three rows lose to a rival: point in polygon (2000-vertex) at 0.5× (turf), bounding box (2000-vertex) at 0.9× (turf), index build (100k boxes) at 0.8× (flatbush)<!--/bm-->.
+measurement: <!--fact:geo.losses-->three rows lose to a rival: point in polygon (2000-vertex) at 0.5× (turf), bounding box (2000-vertex) at 0.9× (turf), index build (100k boxes) at 0.8× (flatbush)<!--/fact-->.
 
 ## Distance — `distance.js`