@howells/hairline 0.0.0-stage → 0.1.0

package/lib/types/charts/glance/jitter-strip.d.ts

@@ -0,0 +1,24 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { JitterGroup } from "./jitter-strip.data.js";
+interface JitterStripProps extends NoteProps {
+    data?: JitterGroup[];
+    height?: number;
+    format?: (v: number) => string;
+    /** Axis caption, e.g. "days after 21 March". */
+    axisLabel?: string;
+    /** Formats the labels on the scale; defaults to `format`. */
+    tickFormat?: (v: number) => string;
+    /** Unit for the tooltip noun when a record has no name, e.g. "year". */
+    unit?: string;
+    /** Index of the hero group (default the first: median and name in ink); a given one also inks its rings. */
+    highlight?: number;
+}
+/**
+ * G15 Easter dates. One hollow ring per record, set on a lattice: values
+ * snap to equal-pitch columns and stack outward from each band's centre
+ * line, so pile-ups read as taller columns, evenly spaced, with no random
+ * jitter. The hero row's median (the first group, or the highlight) is a
+ * 2px ink tick; every other median is a quiet 2px rule.
+ */
+export declare const JitterStrip: (props: JitterStripProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/jitter-strip.data.d.ts

@@ -0,0 +1,27 @@
+export interface JitterGroup {
+    label: string;
+    /** One value per record. */
+    values: number[];
+    /** One name per record, in the same order as `values`, for the tooltip. */
+    names?: string[];
+}
+/**
+ * Easter dates: the date of Easter Sunday in every year of the 1800s, 1900s,
+ * 2000s and 2100s (100 years each), as days after 21 March (0 is 21 March, 35
+ * is 25 April), which are the earliest and latest it can fall. The days are
+ * in jitter-strip.easter.json, one list a century in year order.
+ *
+ * Source: computed with the Gregorian rule, the Meeus/Jones/Butcher
+ * algorithm (Jean Meeus, Astronomical Algorithms, 1991), as set out at
+ * https://en.wikipedia.org/wiki/Date_of_Easter#Anonymous_Gregorian_algorithm
+ * and checked against the Good Friday dates (2019 to 2028, ten of them) in
+ * gov.uk's bank holidays file for England and Wales (Open Government
+ * Licence v3.0), https://www.gov.uk/bank-holidays.json, fetched 2026-10-15.
+ *
+ * Transform: for each year, Easter Sunday minus 21 March of that year in
+ * days. The 2100s are a prediction.
+ * Sanity: the earliest Easter in the four centuries is 22 March (1818) and
+ * the latest 25 April (1886, 1943, 2038 and 2190); the median in the 2000s is
+ * 20 days after 21 March, 10 April.
+ */
+export declare const jitterStripDemo: JitterGroup[];

package/lib/types/charts/glance/link-bundle.d.ts

@@ -0,0 +1,22 @@
+import type { CSSProperties } from "react";
+interface Point {
+    x: number;
+    y: number;
+}
+interface LinkBundleProps {
+    /** Tone, motion and hover classes for the strands, e.g. "stroke-l4 draw". */
+    className: string;
+    /** Number of hairlines, 1–4: the link's weight. */
+    lines: number;
+    /** Control point of a bowed link; omit for a straight one. */
+    q?: Point;
+    s: Point;
+    style?: CSSProperties;
+    t: Point;
+}
+/**
+ * A link engraved as a bundle of 1px hairlines at a 2px pitch, centred on
+ * the link's path; the number of strands carries its weight.
+ */
+export declare const LinkBundle: (props: LinkBundleProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/matrix-heat-glance.d.ts

@@ -0,0 +1,22 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { MatrixGlanceData } from "./matrix-heat-glance.data.js";
+interface MatrixHeatGlanceProps extends NoteProps {
+    data?: MatrixGlanceData;
+    /** Overrides the natural height (which follows the cell size). */
+    height?: number;
+    /** Value domain for the five screens; defaults to 0 – 100. */
+    domain?: [number, number];
+    format?: (v: number) => string;
+    /** Suffix for the tooltip value, e.g. "% of households". */
+    unit?: string;
+    /** [row, column] of the hero cell; defaults to the highest value. */
+    highlight?: [number, number];
+}
+/**
+ * G20 Kit by income. One tile per row and column, each a halftone screen
+ * on paper whose dot grows a step per bin (five bins, pitch 4), the number
+ * centred on a paper plate. The one hero tile (the highest value) is solid
+ * ink, its number in paper.
+ */
+export declare const MatrixHeatGlance: (props: MatrixHeatGlanceProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/matrix-heat-glance.data.d.ts

@@ -0,0 +1,35 @@
+export interface MatrixGlanceData {
+    columns: string[];
+    rows: string[];
+    /** values[row][column]. */
+    values: number[][];
+}
+/**
+ * Kit by income: the percentage of UK households that own a car or van, a
+ * tumble dryer, a dishwasher, a home computer, an internet connection and a
+ * mobile phone, by tenth of gross household income, financial year ending 2019
+ * (April 2018 to March 2019). It is the last year the survey asked about
+ * dishwashers and tumble dryers.
+ *
+ * Source: Office for National Statistics, Family spending workbook 4:
+ * expenditure by household characteristic, financial years ending 2001 to
+ * 2019 (Living Costs and Food Survey; Open Government Licence v3.0), sheets
+ * A46 "Percentage of households with durable goods by income group and
+ * household composition" and A47 "Percentage of households with cars by income
+ * group":
+ * https://www.ons.gov.uk/peoplepopulationandcommunity/personalandhouseholdfinances/expenditure/datasets/familyspendingworkbook4expenditurebyhouseholdcharacteristic
+ * file https://www.ons.gov.uk/file?uri=/peoplepopulationandcommunity/personalandhouseholdfinances/expenditure/datasets/familyspendingworkbook4expenditurebyhouseholdcharacteristic/fye2001tofye2019/familyspendingworkbook4expenditurebyhouseholdcharacteristics.xlsx
+ * Fetched 2026-10-15.
+ *
+ * Transform: the ten rows "Lowest ten per cent" to "Highest ten per cent"
+ * under "Gross income decile group". Tumble dryer, Dishwasher, Computer
+ * (home computer), Internet (internet connection) and Mobile (mobile phone)
+ * are the A46 columns of those names; Car is the A47 column "All with
+ * cars/vans". Whole per cents, as published. Rows are labelled by tenth
+ * ("2nd" is the second decile group). The workbook for the year ending 2021
+ * (note 3 to its table A46) says the dishwasher and tumble dryer questions
+ * were removed from the questionnaire that year.
+ * Sanity: 20% of households in the lowest tenth have a dishwasher against 83%
+ * in the highest; the mobile phone is the flattest, 88% to 99%.
+ */
+export declare const matrixHeatGlanceDemo: MatrixGlanceData;

package/lib/types/charts/glance/pictorial-bar.d.ts

@@ -0,0 +1,20 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { PictorialDatum } from "./pictorial-bar.data.js";
+interface PictorialBarProps extends NoteProps {
+    data?: PictorialDatum[];
+    /** Amount one icon stands for (same units as `value`). */
+    unit?: number;
+    height?: number;
+    format?: (v: number) => string;
+    /** Footnote. */
+    /** Index of the row to draw in the hero colour. */
+    highlight?: number;
+}
+/**
+ * G5 Long novels. Each row is a track of page glyphs; one page =
+ * `unit`. Every page is a 1px outline; the counted pages are filled with
+ * the row's hatch and the last is cut to the remainder. Only the biggest
+ * row is inked; the others are engraved in one grey.
+ */
+export declare const PictorialBar: (props: PictorialBarProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/pictorial-bar.data.d.ts

@@ -0,0 +1,27 @@
+/**
+ * G5 Long novels: the length of four long novels in English, in thousands of
+ * words. One page glyph is 50 thousand words.
+ *
+ * Source: Project Gutenberg plain-text editions (public domain; the Project
+ * Gutenberg licence lets the texts be used for any purpose, and these counts
+ * are derived facts), fetched 2026-10-15 from https://www.gutenberg.org/cache/epub/<id>/pg<id>.txt :
+ *   2600 War and Peace, translated by Aylmer Maude
+ *   135  Les Misérables, translated by Isabel Florence Hapgood
+ *   996  Don Quixote, translated by John Ormsby
+ *   145  Middlemarch, by George Eliot (written in English)
+ *
+ * Transform: every whitespace-separated token containing a letter or digit,
+ * between the "*** START OF" and "*** END OF" marker lines, so the Gutenberg
+ * licence text is left out but any translator's preface or notes inside the
+ * book are counted. Raw counts: 563,001, 564,986, 427,245 and 316,339 words,
+ * rounded to the nearest thousand. These are English translations, so the
+ * counts belong to a particular translation, not to the original. Les
+ * Misérables (Hapgood) edges War and Peace (Maude) by about two thousand words.
+ */
+export interface PictorialDatum {
+    label: string;
+    /** Thousands of words. */
+    value: number;
+}
+/** Words in four long novels, in thousands. */
+export declare const pictorialBarDemo: PictorialDatum[];

package/lib/types/charts/glance/rainfall-dual-area.d.ts

@@ -0,0 +1,19 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { RainfallDatum } from "./rainfall-dual-area.data.js";
+interface RainfallDualAreaProps extends NoteProps {
+    data?: RainfallDatum[];
+    height?: number;
+    formatInput?: (v: number) => string;
+    formatOutput?: (v: number) => string;
+    /** Names for the two series, used in the tooltip. */
+    inputName?: string;
+    outputName?: string;
+}
+/**
+ * G8 Rain and river. Hatched input bars hang from a hairline top rule like
+ * rain (millimetres a day); the output rises below as an area engraved in fine
+ * horizontal rules (river flow) under a 2px ink line. Two scales, stacked, one
+ * shared time axis. Scrub to read a day.
+ */
+export declare const RainfallDualArea: (props: RainfallDualAreaProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/rainfall-dual-area.data.d.ts

@@ -0,0 +1,32 @@
+/**
+ * G8 Rain and river: the Ure in Wensleydale, 28 November to 21 December 2015.
+ * Rain hangs from the top; the river rises from the floor.
+ *
+ * Sources: Environment Agency Hydrology API (Open Government Licence v3.0),
+ * https://environment.data.gov.uk/hydrology/ , fetched 2026-10-15.
+ *  - Flow: daily mean flow, m3/s, River Ure at Kilgram Bridge (station
+ *    F2206, guid 41d13879-a145-4975-83bc-1aa9878d2fb5), measure
+ *    41d13879-a145-4975-83bc-1aa9878d2fb5-flow-m-86400-m3s-qualified:
+ *    https://environment.data.gov.uk/hydrology/id/measures/41d13879-a145-4975-83bc-1aa9878d2fb5-flow-m-86400-m3s-qualified/readings.json?mineq-date=2015-11-28&maxeq-date=2015-12-21
+ *  - Rain: daily total, mm, the Sedbusk rain gauge in Upper Wensleydale
+ *    (guid 74d6a909-ad5a-4e66-8f2a-9ad42ec1dbb5), measure
+ *    74d6a909-ad5a-4e66-8f2a-9ad42ec1dbb5-rainfall-t-86400-mm-qualified:
+ *    https://environment.data.gov.uk/hydrology/id/measures/74d6a909-ad5a-4e66-8f2a-9ad42ec1dbb5-rainfall-t-86400-mm-qualified/readings.json?mineq-date=2015-11-28&maxeq-date=2015-12-21
+ *
+ * Transform: the 24 days from 2015-11-28 to 2015-12-21, each date's rain
+ * total and mean flow side by side, flow rounded to 0.1 m3/s. All 48 readings
+ * are marked Complete. The rain gauge is one point, not a catchment average.
+ * The wettest day is 5 December (76.8
+ * mm); the river's daily mean peaks the same day (315.1 m3/s), so the two
+ * shapes line up bar for bar rather than lagging by days.
+ */
+export interface RainfallDatum {
+    /** The day. */
+    date: Date;
+    /** Hangs from the top: rain, mm. */
+    input: number;
+    /** Rises from the floor: mean river flow, m3/s. */
+    output: number;
+}
+/** Rain at Sedbusk and flow of the Ure at Kilgram Bridge, a day at a time. */
+export declare const rainfallDemo: RainfallDatum[];

package/lib/types/charts/glance/rank-strip.d.ts

@@ -0,0 +1,19 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { RankStripData } from "./rank-strip.data.js";
+interface RankStripProps extends NoteProps {
+    data?: RankStripData;
+    /** Overrides the natural height (which follows the cell size). */
+    height?: number;
+    /** Label of the hero entity; defaults to the biggest climber. */
+    highlight?: string;
+}
+/**
+ * G21 Nobel countries. One row per entity, one tile per period, the tile
+ * carrying the rank small in its lower-left corner. Each tile is engraved:
+ * the higher the rank, the denser and darker its hatch, so a
+ * climb reads as a row darkening left to right. The hero entity's row has
+ * a 2px concentric outline and the net move is printed at the end of every
+ * row.
+ */
+export declare const RankStrip: (props: RankStripProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/rank-strip.data.d.ts

@@ -0,0 +1,36 @@
+export interface RankSeries {
+    label: string;
+    /** Rank in each period, 1 = top. */
+    ranks: number[];
+}
+export interface RankStripData {
+    periods: string[];
+    series: RankSeries[];
+    /** Size of the field the ranks are among, for the tooltip ("#3 of 6"); defaults to the number of series. */
+    outOf?: number;
+}
+/**
+ * Nobel countries: where six countries rank among themselves by Nobel Prizes
+ * won in five 15-year periods, 1951 to 2025.
+ *
+ * Source: Nobel Prize Outreach, Nobel Prize API v2.1, all laureates (CC0, per
+ * the API terms of use, https://www.nobelprize.org/about/terms-of-use-for-api-nobelprize-org-and-data-nobelprize-org/):
+ * https://api.nobelprize.org/2.1/laureates?limit=1200&format=json
+ * Fetched 2026-10-15.
+ *
+ * Transform, one rule throughout: a laureate's country is their country of
+ * birth in today's borders (birth.place.countryNow), not the country of their
+ * institution. Every laureate and prize pair counts 1, so a shared prize is
+ * counted whole for each laureate, and someone with two prizes counts twice.
+ * Organisations have no birthplace and are skipped (34 prizes, with a few
+ * laureates without a recorded birth country). A prize belongs to the period
+ * of its award year, and 2026 is not in the table. Counts, in period order:
+ * USA 30, 48, 52, 70, 61; United Kingdom 12, 17, 7, 14, 18; Germany 9, 11, 14,
+ * 7, 7; France 8, 8, 4, 4, 12; Japan 1, 3, 3, 9, 13; Sweden 3, 6, 5, 1, 3.
+ * Rank is among these six only (1 is most prizes). The six and the periods were
+ * chosen so that no two countries tie in any period, so no tie-break is
+ * needed (the script checks it).
+ * Sanity: Japan climbs from 6th to 3rd with 13 prizes in 2011 to 2025; Germany
+ * slips from 3rd to 5th.
+ */
+export declare const rankStripDemo: RankStripData;

package/lib/types/charts/glance/scatter-labels.d.ts

@@ -0,0 +1,23 @@
+/** A name set beside one mark. */
+export interface PlacedName {
+    id: string;
+    x: number;
+    y: number;
+    text: string;
+    anchor: "end" | "middle" | "start";
+    kind: "name";
+}
+/**
+ * Names for the circles of a scatter, largest first. Each goes right of its
+ * circle, else left, above or below, taking the first spot that is clear of
+ * every circle and every name already set; failing that, the first spot clear
+ * of the other names (over a smaller circle); failing that, it is left out
+ * (the tooltip still names it). `at` gives a datum's centre and radius.
+ */
+export declare const placeNames: <T extends {
+    label: string;
+    value: number;
+}>(data: T[], bounds: {
+    left: number;
+    right: number;
+}, at: (d: T) => [number, number, number]) => PlacedName[];

package/lib/types/charts/glance/scatter-morph.d.ts

@@ -0,0 +1,22 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { MorphDatum } from "./scatter-morph.data.js";
+interface ScatterMorphProps extends NoteProps {
+    data?: MorphDatum[];
+    height?: number;
+    format?: (v: number) => string;
+    /** Axis names for the scatter view. */
+    xLabel?: string;
+    yLabel?: string;
+    formatX?: (v: number) => string;
+    formatY?: (v: number) => string;
+}
+/**
+ * G9 Largest asteroids. One set of entities that cycles through three views,
+ * scatter → bars → ring, every few seconds; each mark flies smoothly into its
+ * new shape. Hover pauses the cycle; the view controls jump straight to a
+ * view. The biggest item is solid ink; the rest are hatched on paper inside
+ * a 1px rim, the pattern fixed to the page so marks glide across one
+ * continuous engraved screen.
+ */
+export declare const ScatterMorph: (props: ScatterMorphProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/scatter-morph.data.d.ts

@@ -0,0 +1,30 @@
+/**
+ * G9 Largest asteroids: the twelve largest asteroids of the main belt. Size is
+ * diameter in kilometres, x the tilt of the orbit (inclination, degrees), y how
+ * stretched it is (eccentricity, 0 a circle).
+ *
+ * Source: NASA/JPL Small-Body Database (SBDB) Query API,
+ * https://ssd-api.jpl.nasa.gov/doc/sbdb_query.html , fetched 2026-10-15:
+ * https://ssd-api.jpl.nasa.gov/sbdb_query.api?fields=full_name,name,diameter,a,i,e&sb-kind=a&sb-class=IMB,MBA,OMB&sort=-diameter&limit=12
+ * The API pages state no licence; NASA/JPL products are US government works,
+ * which is public domain in the US (an assumption, not a statement read there).
+ *
+ * Transform: sb-kind=a is asteroids; sb-class=IMB,MBA,OMB (inner, middle and
+ * outer main belt) leaves out the trans-Neptunian bodies and centaurs that
+ * the plain list puts among the largest, and the twelve largest by diameter
+ * are kept in the order the API gives. Value is the diameter rounded to whole
+ * kilometres; x is the inclination in degrees and y the eccentricity, as
+ * given. Ceres, 939 km, is the largest and is also classed a dwarf planet;
+ * Pallas, the third largest, has the most tilted orbit (34.93 degrees).
+ */
+export interface MorphDatum {
+    label: string;
+    /** Size: area in the scatter, height in the bars, angle in the ring. */
+    value: number;
+    /** Scatter x: orbital inclination, degrees. */
+    x: number;
+    /** Scatter y: orbital eccentricity. */
+    y: number;
+}
+/** The twelve largest main-belt asteroids: diameter (km), inclination, eccentricity. */
+export declare const scatterMorphDemo: MorphDatum[];

package/lib/types/charts/glance/single-axis.d.ts

@@ -0,0 +1,27 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { SingleAxisRow } from "./single-axis.data.js";
+interface SingleAxisProps extends NoteProps {
+    data?: SingleAxisRow[];
+    height?: number;
+    /** Labels for the columns; defaults to hours 00:00–23:00. */
+    columns?: string[];
+    /** Column indices that get an axis label. */
+    ticks?: number[];
+    format?: (v: number) => string;
+    /** Unit shown in the tooltip, e.g. "m". */
+    unit?: string;
+    /** Clock the hours are read on, shown after the axis and in the tooltip. */
+    zone?: string;
+    /** Index of the row to draw in the hero colour. */
+    highlight?: number;
+}
+/**
+ * G14 Up the Hudson (punch card). One row per station, each on its own
+ * hairline hour axis (local standard time); circle area = predicted tide
+ * height, rows in order up a river. The row with
+ * the highest tides (or the highlight) is solid ink; every other station's
+ * circles are hatched over a paper ground inside a 1px outline, so neighbours
+ * overlap cleanly.
+ */
+export declare const SingleAxis: (props: SingleAxisProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/single-axis.data.d.ts

@@ -0,0 +1,6 @@
+export interface SingleAxisRow {
+    label: string;
+    /** One value per column (hour). */
+    values: number[];
+}
+export declare const singleAxisDemo: SingleAxisRow[];

package/lib/types/charts/glance/stagger-wave.d.ts

@@ -0,0 +1,18 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { WaveDatum } from "./stagger-wave.data.js";
+interface StaggerWaveProps extends NoteProps {
+    data?: WaveDatum[];
+    height?: number;
+    format?: (v: number) => string;
+    /** Index of the bar to draw in the hero colour. */
+    highlight?: number;
+}
+/**
+ * G12 Cold December. Thirty to sixty narrow bars, one a day, squared off with
+ * a 2px corner, that enter as a wave, left to right. Bars stand on a zero
+ * line: up for a positive value, down for a negative one. The peak (or the
+ * highlight) is solid ink; every other bar is hatched inside a crisp 1px
+ * outline. The card's Replay re-runs it.
+ */
+export declare const StaggerWave: (props: StaggerWaveProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/stagger-wave.data.d.ts

@@ -0,0 +1,26 @@
+/**
+ * G12 Cold December: the daily mean temperature of central England, 2 November
+ * to 27 December 2010, one bar a day.
+ *
+ * Source: Met Office Hadley Centre Central England Temperature (HadCET),
+ * daily mean, v2.1.1.0 + provisional,
+ * https://www.metoffice.gov.uk/hadobs/hadcet/data/download.html
+ * File: https://www.metoffice.gov.uk/hadobs/hadcet/data/meantemp_daily_totals.txt
+ * Fetched 2026-10-15. Licence: Open Government Licence v3.0, with the Met
+ * Office's attribution.
+ *
+ * Transform: the 56 values from 2010-11-02 to 2010-12-27, in degrees Celsius
+ * to one decimal place, exactly as they stand (none is missing). The coldest
+ * is 20 December, -7.0; 23 of the 56 days are below zero. December 2010 had
+ * a mean of -0.67 (the mean of its 31 daily values), the coldest December in
+ * the series since 1890 (-0.80).
+ */
+export interface WaveDatum {
+    date: Date;
+    /** Daily mean temperature, degrees Celsius. */
+    value: number;
+}
+/** Daily mean central England temperature, 2 November to 27 December 2010. */
+export declare const staggerWaveDemo: WaveDatum[];
+/** Index of the coldest day, the bar drawn in ink. */
+export declare const staggerWaveColdest: number;

package/lib/types/charts/glance/tree-lr.d.ts

@@ -0,0 +1,16 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { TreeDatum } from "./tree-lr.data.js";
+interface TreeLRProps extends NoteProps {
+    data?: TreeDatum;
+    height?: number;
+    /** Name of a top-level branch to draw in the hero colour. */
+    highlight?: string;
+}
+/**
+ * G7 Indo-European. A two- or three-level hierarchy laid out left to right
+ * with smooth 1px hairline links; leaves are bare ends, named where the
+ * link stops. One branch (the highlight, else the first) is inked; the
+ * others share one grey. Hover any node to trace its path back to the root.
+ */
+export declare const TreeLR: (props: TreeLRProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/tree-lr.data.d.ts

@@ -0,0 +1,27 @@
+/**
+ * G7 Indo-European: four branches of the Indo-European family and three
+ * languages under each.
+ *
+ * Source: Glottolog 5.3 (Hammarström, Forkel, Haspelmath and Bank, Max Planck
+ * Institute for Evolutionary Anthropology, Leipzig, 2026), CC BY 4.0,
+ * https://doi.org/10.5281/zenodo.15525265 . File glottolog_languoid.csv.zip,
+ * https://glottolog.org/meta/downloads , fetched 2026-10-15.
+ *
+ * Transform: Glottolog's tree is much deeper than this one. Indo-European
+ * (indo1319) has Classical Indo-European (clas1257) below it; Germanic
+ * (germ1287), Italic then Romance (roma1334) and Celtic (celt1248) sit under
+ * that, and Slavic (slav1255) sits under Balto-Slavic. This chart prunes the
+ * intermediate families and keeps the four branches directly under the root.
+ * The twelve languages were chosen by hand, spread across each branch's
+ * sub-branches, and each was checked in the file to have its branch among its
+ * ancestors (English stan1293, German stan1295 and Icelandic icel1247 under
+ * Germanic; French stan1290, Italian ital1282 and Romanian roma1327 under
+ * Romance; Irish iris1253, Welsh wels1247 and Breton bret1244 under Celtic;
+ * Russian russ1263, Polish poli1260 and Bulgarian bulg1262 under Slavic).
+ */
+export interface TreeDatum {
+    name: string;
+    children?: TreeDatum[];
+}
+/** Twelve Indo-European languages under four of its branches. */
+export declare const treeLRDemo: TreeDatum;

package/lib/types/charts/glance/util-a.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Rendered width of `text` in a text role (`t-label`, `t-axis`, ...), read
+ * from the page's own Inter. Falls back to the estimate until the font is in
+ * (and is not remembered then).
+ */
+export declare const textWidth: (text: string, role: string) => number;
+/** Width of the widest of `labels` in `role`, rounded up: room to reserve beside a plot. */
+export declare const labelRoom: (labels: string[], role?: string) => number;
+export declare const LADDER_FILL: string[];
+export declare const LADDER_STROKE: string[];
+/** Fill class for a ladder step, or the hero fill. */
+export declare const fillFor: (i: number, hero?: boolean) => string;
+/** Stroke class for a ladder step, or the hero stroke. */
+export declare const strokeFor: (i: number, hero?: boolean) => string;
+/**
+ * Ladder steps by rank: the largest value gets `steps[0]`, the next
+ * `steps[1]`, and so on (the last step repeats).
+ */
+export declare const rankTones: (values: number[], steps: number[]) => number[];
+/** Explicit plus and a true minus sign: +12, −18. */
+export declare const fmtSigned: (v: number) => string;
+export type Pt = [number, number];
+export declare const rectPts: (x0: number, y0: number, x1: number, y1: number) => Pt[];
+export declare const circlePts: (cx: number, cy: number, r: number) => Pt[];
+/**
+ * Annular sector between radii r0 < r1 and angles a0 < a1 (clockwise from
+ * 12 o'clock), trimmed by a parallel gap `g` on each radial side.
+ */
+export declare const sectorPts: (cx: number, cy: number, r0: number, r1: number, a0: number, a1: number, g: number) => Pt[];
+export declare const ptsPath: (pts: Pt[]) => string;
+export declare const blendPts: (a: Pt[], b: Pt[], t: number) => Pt[];

package/lib/types/charts/glance/util-b.d.ts

@@ -0,0 +1,12 @@
+/** Ladder step for rank `rank` of `n`, spread so the last stays readable at step `lightest`. */
+export declare const ladderStep: (rank: number, n: number, lightest?: number) => number;
+/** Deterministic log-normal samples: the shared normal draws, exponentiated. */
+export declare const logNormals: (seed: number, n: number, median: number, sigma: number) => number[];
+/** Gaussian kernel density of `values`, sampled at `at`. */
+export declare const density: (values: number[], at: number[], bandwidth: number) => number[];
+/** Silverman's rule-of-thumb bandwidth. */
+export declare const silverman: (values: number[]) => number;
+/** Height of the glance control slot: one control's 44px hit area. */
+export declare const CONTROL_SLOT_H = 44;
+/** How many hairlines a link of `value` gets: one to four, by its share of the heaviest. */
+export declare const bundleLines: (value: number, max: number) => number;

package/lib/types/charts/glance/violin.d.ts

@@ -0,0 +1,22 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { ViolinGroup } from "./violin.data.js";
+interface ViolinProps extends NoteProps {
+    data?: ViolinGroup[];
+    height?: number;
+    format?: (v: number) => string;
+    /** Unit noun for the tooltip, e.g. "towers". */
+    unit?: string;
+    /** Darkest = lowest median (true) or highest (false, e.g. the heaviest bells). */
+    lowIsBest?: boolean;
+    /** Index of the group to draw in the hero colour. */
+    highlight?: number;
+}
+/**
+ * G19 Tenor weights. One filled density silhouette per group, mirrored around
+ * its centre line; width = how many records sit at that value. A 2px
+ * paper-coloured rung marks the median, printed beside it. The lowest-median group
+ * (or the highlight, or the highest median when `lowIsBest` is false) is solid ink; the rest are hatched inside
+ * a 1px outline.
+ */
+export declare const Violin: (props: ViolinProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/glance/violin.data.d.ts

@@ -0,0 +1,24 @@
+export interface ViolinGroup {
+    label: string;
+    /** One value per record. */
+    values: number[];
+}
+/**
+ * Tenor weights: the weight of the heaviest bell, in hundredweight (cwt), for
+ * every full-circle ring of 6, 8, 10 and 12 bells, one value per tower.
+ *
+ * Source: Dove's Guide for Church Bell Ringers, Central Council of Church Bell
+ * Ringers, dove.csv, licensed Creative Commons Attribution-ShareAlike 4.0
+ * (credit the Central Council; data derived from it shares alike):
+ * https://dove.cccbr.org.uk/dove.csv (download page https://dove.cccbr.org.uk/downloads)
+ * Fetched 2026-10-15.
+ *
+ * Transform: rows with RingType "Full-circle ring" and Bells 6, 8, 10 or 12
+ * (2,958, 1,892, 303 and 139 towers); the column Wt, which is the tenor in
+ * pounds, was kept as given (blank weights dropped) and is in
+ * violin.tenors.json, sorted. Divided here by 112 to give hundredweight.
+ * Sanity: the heaviest tenor is Liverpool Cathedral's, 9,195 lb or 82 cwt, in
+ * the ring of 12; the median tenor is 10 cwt for six bells and 25.7 cwt for
+ * twelve. Dove marks some weights as approximate or estimated.
+ */
+export declare const violinDemo: ViolinGroup[];