@howells/hairline 0.0.0-stage → 0.2.0

package/lib/types/charts/lupi/hourglass-stream.data.d.ts

@@ -0,0 +1,27 @@
+/**
+ * L13 Library earnings: how many UK writers, illustrators and others were paid
+ * at least a given sum for library loans in one year.
+ *
+ * Source: British Library, Public Lending Right (PLR) page, "Shown below is
+ * how the UK PLR earnings were distributed amongst registered contributors for
+ * the 2024/25 year" (payments by pay band, rate 12.40p a loan, minimum payment
+ * £1, maximum £6,600).
+ * Page: https://www.bl.uk/plr
+ * Fetched 2026-10-15. The page is British Library web content; only the
+ * published counts are used.
+ *
+ * Transform: the page gives payments per band: £1 to £99.99 19,039; £100 to
+ * £499.99 3,399; £500 to £999.99 973; £1,000 to £2,499.99 877; £2,500 to
+ * £4,999.99 393; £5,000 to £6,600 311 (total 24,992, which the bands sum to).
+ * Each stage is the cumulative count of payments at or above its threshold:
+ * £1 or more 24,992; £100 or more 5,953; £500 or more 2,554; £1,000 or more
+ * 1,581; £2,500 or more 704; £5,000 or more 311.
+ * Script: reference/scripts/L13/bands.py.
+ */
+/** One funnel stage and how many reached it. */
+export interface StageDatum {
+    label: string;
+    value: number;
+}
+/** Payments at or above each sum, UK PLR 2024/25. */
+export declare const hourglassDemo: StageDatum[];

package/lib/types/charts/lupi/hundred-field.d.ts

@@ -0,0 +1,18 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { ShareDatum } from "./hundred-field.data.js";
+interface HundredFieldProps extends NoteProps {
+    data?: ShareDatum[];
+    height?: number;
+    /** What one seed stands for, used in the tooltip ("donors"). */
+    unit?: string;
+    /** Group drawn in the hero colour. Defaults to the largest. */
+    highlight?: string;
+}
+/**
+ * L14 A hundred donors. A hundred donors as one engraved seed head: a
+ * sunflower of exactly a hundred seeds, cut into contiguous wedges by blood
+ * type, each with its own glyph. The largest is the hero, in solid
+ * ink seeds.
+ */
+export declare const HundredField: (props: HundredFieldProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/hundred-field.data.d.ts

@@ -0,0 +1,24 @@
+/**
+ * L14 A hundred donors: the blood types of a hundred blood donors in England.
+ *
+ * Source: NHS Blood and Transplant, "Blood types" page, the list "the
+ * percentage of donors with each blood type" (data accurate at February 2026;
+ * figures rounded to the nearest whole number by NHSBT).
+ * Page: https://www.blood.co.uk/why-give-blood/blood-types/
+ * Fetched 2026-10-15.
+ *
+ * Transform: the eight percentages are copied unchanged: O positive 36, O
+ * negative 14, A positive 28, A negative 8, B positive 8, B negative 3, AB
+ * positive 2, AB negative 1. They sum to exactly 100, so each is read as
+ * donors in a hundred. The page's prose says "just 2%" for B negative, which
+ * disagrees with its own list (3%); the list is used. The types are ordered
+ * around the head so that the three smallest wedges sit apart and their
+ * labels do not collide.
+ */
+/** One group's share of the whole, in units (donors in a hundred). */
+export interface ShareDatum {
+    label: string;
+    value: number;
+}
+/** The blood types of a hundred donors, NHS Blood and Transplant, 2026. */
+export declare const hundredFieldDemo: ShareDatum[];

package/lib/types/charts/lupi/launch-fan.d.ts

@@ -0,0 +1,37 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { LaunchFanDatum } from "./launch-fan.data.js";
+/** The time unit of a fan: launches, readings and rings count these. */
+export type FanUnit = "month" | "week";
+interface LaunchFanProps extends NoteProps {
+    data?: LaunchFanDatum[];
+    /** The last week: where every spoke ends. Same as `periods`. */
+    weeks?: number;
+    /**
+     * The last period, in `unit`s: where every spoke ends. Defaults to
+     * `weeks`, else the demo's 24 weeks, else 20 weeks or 24 months.
+     */
+    periods?: number;
+    /**
+     * What `launch`, `weekly` and `periods` count. "month" (the default)
+     * spaces rings every 3, 6 or 12 months by span; "week" every five weeks.
+     */
+    unit?: FanUnit;
+    /**
+     * The calendar date of a period: rings then read in the broadsheet style
+     * ("Mar 2025 · Apr · May") and tooltips name the day (weeks) or month
+     * (months). Without it periods read "W14" or "M14".
+     */
+    periodDate?: (period: number) => Date;
+    height?: number;
+    format?: (v: number) => string;
+    /** Name of the spoke drawn in ink. Defaults to the largest. */
+    highlight?: string;
+}
+/**
+ * L1 Spring arrivals. One spoke per entity, fanned through a quarter turn and
+ * ordered by arrival. Distance along the spoke is time: the big dot sits at the
+ * arrival week or month (area = peak reading), and a 1px rung crosses the spoke
+ * at every one since, as long as that period's reading.
+ */
+export declare const LaunchFan: (props: LaunchFanProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/launch-fan.data.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Twelve summer migrants in Britain: the week each arrives and how its share of
+ * bird records climbs, March to August 2025.
+ *
+ * Source: GBIF occurrence search, the eBird Observation Dataset (Cornell Lab
+ * of Ornithology, CC BY 4.0, https://doi.org/10.15468/aomfnb) and the other
+ * datasets GBIF aggregates, restricted to country GB. Each count is
+ * https://api.gbif.org/v1/occurrence/search?country=GB&taxonKey=<key>&eventDate=<first day>,<last day>&limit=0
+ * for 24 consecutive 7-day weeks from 2025-03-01 to 2025-08-15, once for each
+ * species and once for all birds (taxonKey=212, class Aves). The species
+ * keys came from https://api.gbif.org/v1/species/match: Northern wheatear Oenanthe oenanthe (5231240), Sand martin Riparia riparia (2489160), Chiffchaff Phylloscopus collybita (2493091), Swallow Hirundo rustica (9515886), Willow warbler Phylloscopus trochilus (2493052), Cuckoo Cuculus canorus (5231918), Whitethroat Curruca communis (10507373), House martin Delichon urbicum (2489214), Nightingale Luscinia megarhynchos (7660710), Garden warbler Sylvia borin (2492942), Swift Apus apus (5228676), Spotted flycatcher Muscicapa striata (2492576).
+ * Fetched 2026-10-15 (saved to reference/raw/L1/gbif_weekly_2025.json).
+ * GBIF counts drift as records are added, so a refetch will differ a little.
+ * BTO BirdTrack reporting rates, the plan's first choice, are not offered as a
+ * download.
+ *
+ * Transform: a species' reading for a week is its record count divided by the
+ * count of all bird records that week, in per cent, to two decimals (a share
+ * of records, not a BirdTrack-style reporting rate). `size` is the largest
+ * weekly reading. `launch` is the 1-based week (1 is the week from 1 March)
+ * of the first reading at or above a quarter of the species' own peak. `weekly[t]` is the
+ * reading t weeks after that week, through week 24; weekly[0] is the arrival
+ * week itself. Spokes are sorted by `launch` in the chart. Chiffchaff, which
+ * winters here in small numbers, arrives in week 2 on this rule; the
+ * quarter-of-peak threshold is mine and is the one judgment in the transform.
+ * Script: reference/scripts/L1/emit.py.
+ */
+export interface LaunchFanDatum {
+    name: string;
+    /** Week (or month, with `unit="month"`) of arrival, 1-based. */
+    launch: number;
+    /** Peak reading. Sizes the arrival dot. */
+    size: number;
+    /** One reading per week (or month) from arrival on; sizes the small dots. */
+    weekly?: number[];
+}
+/** Weeks in the demo span: 1 March 2025 starts week 1, week 24 ends 15 August. */
+export declare const ARRIVAL_WEEKS = 24;
+/** The first day of demo week `n` (week 1 starts on 1 March 2025). */
+export declare const arrivalWeekDate: (n: number) => Date;
+export declare const launchFanDemo: LaunchFanDatum[];

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

@@ -0,0 +1,20 @@
+import type { MatrixData } from "./matrix-heat.data.js";
+interface MatrixHeatProps {
+    data?: MatrixData;
+    /** Four lower bounds splitting values into five shades. */
+    thresholds?: [number, number, number, number];
+    /** Unit suffix for legend and tooltip, e.g. "%". */
+    unit?: string;
+    /** Cell to frame as the key cell: [row, col]. Defaults to the largest value. */
+    highlight?: [number, number];
+    height?: number;
+    format?: (v: number) => string;
+}
+/**
+ * L16 Letter pairs. Two discrete dimensions, one tile per pair: a halftone
+ * screen on paper whose dot grows in five steps with the value, the number
+ * set on it. The strongest pair is the one ink crosshatch, its number
+ * knocked out in paper; cells with no value (the diagonal) are a 4px hatch.
+ */
+export declare const MatrixHeat: (props: MatrixHeatProps) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,29 @@
+/**
+ * L16 Letter pairs: which letter comes next, for the eight commonest letters.
+ *
+ * Sources: Peter Norvig, "English Letter Frequency Counts: Mayzner Revisited"
+ * (letter ranking, from Google Books Ngrams, 3.56 trillion letters), and his
+ * two-letter sequence counts, count_2l.txt (data files used under his
+ * published terms; the counts are facts).
+ * Pages: https://norvig.com/mayzner.html
+ * File: https://norvig.com/ngrams/count_2l.txt
+ * Fetched 2026-10-15.
+ *
+ * Transform: the eight commonest letters are the first eight rows of the
+ * "Letter Counts" table (E T A O I N S R). For each, every count of that
+ * letter followed by another letter inside a word is totalled over all 26
+ * following letters; each of the eight following letters is then that count
+ * as a percentage of the total, rounded to a whole number. Row = the first
+ * letter, column = the letter after it, so rows do not sum to 100 (the other
+ * eighteen letters follow too). The diagonal is real (EE, TT and so on).
+ * Script: reference/scripts/L16/bigrams.py.
+ */
+/** A grid of values over two discrete dimensions. */
+export interface MatrixData {
+    /** Row labels; columns use the same labels unless `cols` is given. */
+    rows: string[];
+    cols?: string[];
+    /** values[row][col]; null = no value (e.g. the diagonal). */
+    values: (number | null)[][];
+}
+export declare const matrixHeatDemo: MatrixData;

package/lib/types/charts/lupi/parallel-coordinates.d.ts

@@ -0,0 +1,23 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { ParallelData } from "./parallel-coordinates.data.js";
+interface ParallelCoordinatesProps extends NoteProps {
+    data?: ParallelData;
+    height?: number;
+    format?: (v: number) => string;
+    /** Name of the entity to draw in ink and label at the end. */
+    highlight?: string;
+    /**
+     * Widest the block of axes gets, in px. Defaults to 600, which suits a
+     * gallery card; pass `Infinity` to fill a full-width row.
+     */
+    maxWidth?: number;
+}
+/**
+ * L20 Twelve cheeses. Entities across three to six continuous axes, laid
+ * over an engraved ground: the full range of every entity between each pair
+ * of axes stippled, the middle half hatched, each axis carrying a rug of its
+ * values. The rest are faint hairlines; the highlighted entity is in ink,
+ * dotted at each axis and named.
+ */
+export declare const ParallelCoordinates: (props: ParallelCoordinatesProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/parallel-coordinates.data.d.ts

@@ -0,0 +1,40 @@
+/**
+ * L20 Twelve cheeses: what is in 100 g of each.
+ *
+ * Source: Public Health England, McCance and Widdowson's The Composition of
+ * Foods Integrated Dataset (CoFID) 2021, workbook sheets "1.3 Proximates"
+ * (protein, fat) and "1.4 Inorganics" (calcium, sodium). Open Government
+ * Licence v3.0.
+ * Page: https://www.gov.uk/government/publications/composition-of-foods-integrated-dataset-cofid
+ * File: https://assets.publishing.service.gov.uk/media/60538b91e90e07527df82ae4/McCance_Widdowsons_Composition_of_Foods_Integrated_Dataset_2021..xlsx
+ * Fetched 2026-10-15.
+ *
+ * Transform: twelve foods of the cheese group (BL), chosen as a spread of
+ * styles and countries, taken by CoFID food code: Cheddar 12-346 (English),
+ * Stilton 12-367 (blue), Brie 12-344 (rind removed), Camembert 12-345, Edam
+ * 12-355, Emmental 12-493, Parmesan 12-526 (fresh), Feta 12-525, Mozzarella
+ * 12-360 (fresh), Roquefort 12-177, Mascarpone 12-490 and Cottage 12-539
+ * (plain). Fat and protein are in grams, calcium and sodium in milligrams, all
+ * per 100 g, copied unchanged. Sodium is shown, not salt, so no conversion is
+ * applied.
+ * Script: reference/scripts/L20/cheeses.py (with xl.py).
+ */
+/** One vertical axis: which value it reads and the range it spans (bottom → top). */
+export interface ParallelAxis {
+    key: string;
+    label: string;
+    domain: [number, number];
+    /** Suffix for this axis's values, e.g. "%" or "k". */
+    unit?: string;
+}
+/** One entity: a value for every axis key. */
+export interface ParallelRow {
+    name: string;
+    values: Record<string, number>;
+}
+export interface ParallelData {
+    axes: ParallelAxis[];
+    rows: ParallelRow[];
+}
+/** Twelve cheeses, per 100 g. */
+export declare const parallelDemo: ParallelData;

package/lib/types/charts/lupi/radial-convergence.d.ts

@@ -0,0 +1,15 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { ConvergenceItem } from "./radial-convergence.data.js";
+interface RadialConvergenceProps extends NoteProps {
+    data?: ConvergenceItem[];
+    height?: number;
+    /** Noun for the tooltip, e.g. "storm". */
+    noun?: string;
+}
+/**
+ * L5 Named storms. Many items on one dotted ring, each claimed by one
+ * of a few themes; hairlines bundle inward to the theme's hub (area =
+ * count). Only the hubs are labelled; items name themselves on hover.
+ */
+export declare const RadialConvergence: (props: RadialConvergenceProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/radial-convergence.data.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Every storm the Met Office lists as named for the UK, Ireland and the
+ * Netherlands in the six storm seasons from 2020/21 to 2025/26, each claimed
+ * by its season.
+ *
+ * Source: Met Office UK Storm Centre, one summary page per season:
+ * https://weather.metoffice.gov.uk/warnings-and-advice/uk-storm-centre/uk-storm-season-2020-21
+ * (and -2021-22, -2022-23, -2023-24, -2024-25, -202526 for 2025/26; index:
+ * https://www.metoffice.gov.uk/weather/warnings-and-advice/uk-storm-centre/index).
+ * Fetched 2026-10-15 (saved to reference/raw/L5/).
+ *
+ * Transform: the "Name" column of each season's table is read, in the order
+ * the page lists the storms (by date named), with the season as the theme.
+ * Storms named by a neighbouring service (for example Alex by Meteo France,
+ * Malik by DMI, Darcy by KNMI) are kept, because the Met Office lists them
+ * in its season tables. 43 storms in all. Seasons run September to August.
+ * Script: reference/scripts/L5/emit.py.
+ */
+export interface ConvergenceItem {
+    id: string;
+    theme: string;
+}
+/** Named storms in order of naming, each with its season. */
+export declare const radialConvergenceDemo: ConvergenceItem[];

package/lib/types/charts/lupi/radial-patchwork.d.ts

@@ -0,0 +1,16 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { PatchworkEvent } from "./radial-patchwork.data.js";
+interface RadialPatchworkProps extends NoteProps {
+    data?: PatchworkEvent[];
+    height?: number;
+    /** What a flagged (crosshatched) wedge means, e.g. "class M or stronger". */
+    outlined?: string;
+}
+/**
+ * L10 Solar flares. Events overlaid on a 24-hour dial: wedge angle = time
+ * of day, angular width = duration, reach = size (linear in `size`, which is
+ * already on a log scale). Overlap is read by hatch pitch, open to dense;
+ * flagged wedges are crosshatched in ink.
+ */
+export declare const RadialPatchwork: (props: RadialPatchworkProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/radial-patchwork.data.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A week of solar flares on the 24-hour dial: the hour each began (UTC), how
+ * long it lasted, how strong its peak was, and the three of class M.
+ *
+ * Source: NOAA Space Weather Prediction Center, GOES X-ray flare list for the
+ * last seven days (primary satellite):
+ * https://services.swpc.noaa.gov/json/goes/primary/xray-flares-7-day.json
+ * Fetched 2026-10-15 (saved to reference/raw/L10b/). Public domain (US
+ * government work). Replaces the RNLI Return of Service, which has no
+ * duration, people-aided or life-saved fields.
+ *
+ * Transform: the list holds 57 flares from 2026-10-08 22:33 to 2026-10-15
+ * 21:31 UTC. One has no peak time, class or flux yet (begun 2026-10-14 08:22)
+ * and is dropped, leaving 56. For the rest: `hour` is the begin time as hours
+ * since midnight UTC, to three decimals (about a minute); `minutes` is
+ * end_time minus begin_time; `size` is log10 of the peak flux (max_xrlong, in
+ * watts per square metre) plus 8, so a B1 flare is 1, a C1 is 2 and an M1 is
+ * 3; `label` is max_class as given; `flagged` is true for class M or X
+ * (three flares, all M). Script: reference/scripts/L10/emit.py.
+ */
+export interface PatchworkEvent {
+    id: string;
+    /** Start time as hours since midnight (0–24). */
+    hour: number;
+    /** Duration in minutes: sets the wedge's angular width. */
+    minutes: number;
+    /** Strength on a log scale: sets the wedge's reach. */
+    size: number;
+    /** Shown in the tooltip, e.g. the flare class "M6.4". */
+    label: string;
+    /** Crosshatched in the hero colour when true: class M or stronger. */
+    flagged?: boolean;
+}
+/** One week of flares, 8 to 15 October 2026. */
+export declare const radialPatchworkDemo: PatchworkEvent[];

package/lib/types/charts/lupi/ridgeline.d.ts

@@ -0,0 +1,23 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { RidgeSeries } from "./ridgeline.data.js";
+interface RidgelineProps extends NoteProps {
+    data?: RidgeSeries[];
+    /** Value range of the shared x axis. */
+    domain?: [number, number];
+    /** Kernel bandwidth in data units; defaults to 1/26 of the domain. */
+    bandwidth?: number;
+    /** Number of axis intervals (ticks = intervals + 1). */
+    ticks?: number;
+    height?: number;
+    format?: (v: number) => string;
+    /** Ridge drawn in the hero colour. Defaults to the first. */
+    highlight?: string;
+}
+/**
+ * L19 January by decade. Three to eight distributions stacked with overlap.
+ * Each crest is a density outline over paper and a 4px diagonal hatch, so
+ * the rows overlap like terrain; the hero is crosshatched. A dot marks each
+ * peak, and its value sits at the right-hand end of the ridge's baseline.
+ */
+export declare const Ridgeline: (props: RidgelineProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/ridgeline.data.d.ts

@@ -0,0 +1,19 @@
+/**
+ * L19 January by decade: every January day in six decades, daily mean CET.
+ * Source: Met Office Hadley Centre Central England Temperature (HadCET),
+ * v2.1.1.0 + provisional, https://www.metoffice.gov.uk/hadobs/hadcet/data/download.html
+ * Fetched 2026-10-15.
+ * File: meantemp_daily_totals.txt (date and value to 0.1 °C, -99.9 for a
+ * missing day; none are missing in the years used).
+ * Transform: for each decade (1770s is 1772 to 1779, because the series
+ * starts on 1 January 1772; the others are the ten years from 1820, 1870,
+ * 1920, 1970 and 2010), all 31 days of January, the values as they stand.
+ * That is 248 values for the 1770s and 310 for each of the others.
+ */
+/** One distribution: its name and the raw samples. */
+export interface RidgeSeries {
+    label: string;
+    values: number[];
+}
+/** Daily mean Central England temperature (°C) on every January day, by decade. */
+export declare const ridgelineDemo: RidgeSeries[];

package/lib/types/charts/lupi/trend-lineage.d.ts

@@ -0,0 +1,18 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { LineageDatum } from "./trend-lineage.data.js";
+interface TrendLineageProps extends NoteProps {
+    data?: LineageDatum[];
+    /** First and last year on the axis; defaults to the data's span. */
+    years?: [number, number];
+    height?: number;
+    /** Area drawn in the hero colour. Defaults to the oldest still in use. */
+    highlight?: string;
+}
+/**
+ * L11 Sea areas. One column per sea area, time running down the page.
+ * Filled dot = added, hollow = renamed or redrawn, dotted = suspended years;
+ * the line runs on to the floor if the area is still in use today, and stops
+ * at a small dot where it was dropped. The oldest area in use is the hero.
+ */
+export declare const TrendLineage: (props: TrendLineageProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/trend-lineage.data.d.ts

@@ -0,0 +1,56 @@
+/** One sea area's life: when it was added, changed, suspended or dropped. */
+export interface LineageDatum {
+    name: string;
+    /** Year it was first added (fractions allowed: 2017.5 = mid-2017). */
+    shipped: number;
+    /** Years it was renamed, split or otherwise redrawn. */
+    reworked?: number[];
+    /** Spans when it sat out of use, drawn dotted. */
+    dormant?: [number, number][];
+    /** Year it was dropped from the forecast. Omit if it is still in use. */
+    retired?: number;
+}
+/**
+ * Ten shipping forecast sea areas, 1924 to today: when each was added,
+ * renamed or redrawn, and (Tay) dropped. One row per area under its current
+ * name; the years are those of the forecast chart, not of the name's first use
+ * in the broadcast.
+ *
+ * Sources (fetched 2026-10-15; every year below is read from these):
+ *  [FS] Met Office, National Meteorological Library and Archive, "Factsheet 8
+ *       The Shipping Forecast" (PDF, text and Figures 3 to 8):
+ *       https://www.metoffice.gov.uk/api/assets/file/factsheet_8_shipping_forecast_2025pdf?prefix=assets
+ *       (linked from https://www.metoffice.gov.uk/research/library-and-archive/publications/factsheets)
+ *  [MO] Met Office, "Tragedy and warnings: the origins of the shipping forecast":
+ *       https://www.metoffice.gov.uk/about-us/who-we-are/our-history/tragedy-and-warnings-the-origins-of-the-shipping-forecast
+ *  [RMG] Royal Museums Greenwich, "History of the Shipping Forecast" (2002 rename):
+ *       https://www.rmg.co.uk/stories/maritime-history/shipping-forecast
+ *
+ * Rows:
+ *  Forties: added 1924 (FS Figure 3 map; MO lists it among seven areas "with us
+ *    since the very first Shipping Forecast transmission"); divided in 1956, its northern half named Viking
+ *    (FS "these changes were introduced in 1956"; MO).
+ *  Dogger: added 1924 (FS Figure 3; MO); divided in 1956, its north-eastern half
+ *    named Fisher (FS; MO).
+ *  Tay: on the 1924 map (FS Figure 3) and the 1932 map (FS Figure 4), absent from
+ *    the chart adopted in 1949 (FS Figure 5; FS text: the earlier divisions
+ *    "were omitted and 18 new names added"). The Met Office gives no day for the
+ *    drop, so 1949 is the first chart without it.
+ *  German Bight: first on the 1949 chart as Heligoland (FS Figure 5); renamed
+ *    German Bight in 1956 (FS; MO).
+ *  FitzRoy: first on the 1949 chart as Finisterre (FS Figure 5); renamed FitzRoy
+ *    in February 2002 (FS; MO; RMG).
+ *  Rockall: added 1949 (MO "In 1949, many new areas ... were added, including
+ *    Rockall, Bailey and Fast Net"; FS Figure 5).
+ *  Fisher and Viking: new in 1956 (FS; MO).
+ *  North Utsire and South Utsire: introduced August 1984 (FS; MO).
+ *
+ * Left out because no fetched source supports them: the Minches merging into
+ * Hebrides in 1983 (only Country Life and an uncited Wikipedia line say so, and
+ * the Met Office's 1949 and 1956 to 1984 charts, FS Figures 5 and 6, show no
+ * Minches area at all), and Viking being resized in 1984 (FS says only that
+ * common North Sea boundaries were introduced that August).
+ *
+ * Transform: none beyond reading each year off the sources above.
+ */
+export declare const trendLineageDemo: LineageDatum[];

package/lib/types/charts/lupi/type-colonnade.d.ts

@@ -0,0 +1,20 @@
+import type { NoteProps } from "../../schema/options.js";
+import type { OwnershipDatum } from "./type-colonnade.data.js";
+interface TypeColonnadeProps extends NoteProps {
+    data?: OwnershipDatum[];
+    height?: number;
+    /** How many of the largest owners to draw in the hero colour. Default 1. */
+    strong?: number;
+    /** Noun for the tooltip count, e.g. "lights". */
+    unit?: string;
+    /** Owner to draw in the hero colour. */
+    highlight?: string;
+}
+/**
+ * L12 Lights by keeper. Many-to-one keeping: every light is a hollow dot, strung
+ * at one even pitch and grouped by owner, and each dot runs a straight
+ * hairline to its owner on the right, so every owner gathers a clean fan.
+ * Owner disc area = how many it owns, engraved; light names are on hover.
+ */
+export declare const TypeColonnade: (props: TypeColonnadeProps) => import("react").JSX.Element;
+export {};

package/lib/types/charts/lupi/type-colonnade.data.d.ts

@@ -0,0 +1,30 @@
+/**
+ * L12 Lights by keeper: the working lighthouses of England, by who keeps them.
+ *
+ * Source: Wikipedia, "List of lighthouses in England", the table of lighthouses
+ * (name, county, year built, operator). The page's NGA numbers refer to the US
+ * National Geospatial-Intelligence Agency's List of Lights.
+ * Page: https://en.wikipedia.org/wiki/List_of_lighthouses_in_England
+ * Fetched 2026-10-15.
+ *
+ * Transform: all 84 rows of the first table. The operator is the one named in
+ * the Operator column; where a cell names a change of hands the operator
+ * "from" the later date is the current one (Guile Point East: Trinity House;
+ * Happisburgh: Happisburgh Lighthouse Trust; Maryport New: Maryport Harbour
+ * Authority; Plymouth Breakwater: Ministry of Defence). Flamborough Head lists
+ * Trinity House and East Riding of Yorkshire Council together with no dates,
+ * so it is left out, leaving 83. Operators are grouped into keepers: Trinity
+ * House (43), Harbours (34: harbour boards and commissions, port companies
+ * and authorities, Gloucester Harbour Trustees, Watchet Marina, Associated
+ * British Ports), Councils (4: North Yorkshire, Somerset), Trust (1:
+ * Happisburgh Lighthouse Trust) and Defence (1: the Ministry of Defence).
+ * Lights are listed alphabetically.
+ * Script: reference/scripts/L12/keepers.py (and parse.py).
+ */
+/** One owned thing and who owns it. */
+export interface OwnershipDatum {
+    name: string;
+    owner: string;
+}
+/** 83 lights, listed alphabetically by name. */
+export declare const typeColonnadeDemo: OwnershipDatum[];

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

@@ -0,0 +1,9 @@
+/**
+ * Point on a circle. `deg` is a clock angle: 0 = up (12 o'clock), increasing
+ * clockwise, so 90 = right.
+ */
+export declare const clock: (cx: number, cy: number, r: number, deg: number) => [number, number];
+/** Annular sector between two clock angles (degrees) and two radii. */
+export declare const sectorPath: (cx: number, cy: number, r0: number, r1: number, a0: number, a1: number) => string;
+/** Open arc between two clock angles. */
+export declare const arcPath: (cx: number, cy: number, r: number, a0: number, a1: number) => string;

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

@@ -0,0 +1,11 @@
+/** Smooth vertical S-curve between two points (tangents vertical at both ends). */
+export declare const vCurve: (x1: number, y1: number, x2: number, y2: number, bend?: number) => string;
+/** One threshold step for `byStep`. */
+export interface Step<T> {
+    min: number;
+    out: T;
+}
+/** Pick a value by threshold without nested ternaries: the first step whose `min` is met wins. */
+export declare const byStep: <T>(value: number, steps: readonly Step<T>[], fallback: T) => T;
+/** Index of the largest value (the first, on a tie); 0 when empty. */
+export declare const argMax: (values: readonly number[]) => number;

package/lib/types/charts/maps/choropleth.d.ts

@@ -0,0 +1,33 @@
+import type { GeoProjection } from "d3-geo";
+import type { FeatureCollection } from "geojson";
+import type { ChoroplethDatum, Region } from "./geo.js";
+export interface ChoroplethProps {
+    ariaLabel: string;
+    data: ChoroplethDatum[];
+    /** Legend and tooltip text for regions without a value; omit to leave them out of the legend. */
+    emptyLabel?: string;
+    format: (v: number) => string;
+    /** Keys printed on the map. The first is the hero: set in solid ink when it is in the top step. */
+    labels: string[];
+    /** Upper cap on the map height. */
+    maxHeight?: number;
+    /** Map height as a share of width. */
+    aspect: number;
+    note?: string;
+    /** Fits a projection into [width, height] for the given outlines. */
+    project: (size: [number, number], outlines: FeatureCollection) => GeoProjection;
+    regions: Region[];
+    /** Short form for legend and in-map labels, e.g. 96k. */
+    short: (v: number) => string;
+    /** Four ascending breaks → five steps on the halftone ladder. */
+    thresholds: [number, number, number, number];
+    /** Unit after the value in the tooltip, e.g. "sign-ups". */
+    unit?: string;
+}
+/**
+ * Shared choropleth plot: real outlines, value in five quantized steps as
+ * an engraved dot screen (the hero alone in solid ink), no value as bare
+ * paper, 1px outlines, a hover tooltip and a key row whose keys isolate one
+ * step on hover.
+ */
+export declare const Choropleth: (props: ChoroplethProps) => import("react").JSX.Element;

package/lib/types/charts/maps/geo.d.ts

@@ -0,0 +1,48 @@
+import type { geoPath } from "d3-geo";
+import type { Feature } from "geojson";
+/** One outline on a map: a stable key (postal code, country name), a display name and its geometry. */
+export interface Region {
+    feature: Feature;
+    key: string;
+    name: string;
+}
+/** The parts of an imported TopoJSON file this module reads: geometry ids and names. */
+interface TopologyJson<K extends string> {
+    objects: Record<K, {
+        geometries: {
+            id?: string;
+            properties: {
+                name: string;
+            };
+        }[];
+    }>;
+    type: string;
+}
+/** Turn an imported TopoJSON file into keyed regions, checking it is a topology at the boundary. */
+export declare const regionsFrom: <K extends string>(raw: TopologyJson<K>, object: K, keyOf: (id: string, name: string) => string) => Region[];
+/** Centroid of the largest polygon, so Alaska or Hawaii don't drag a label off the mainland. */
+export declare const mainCentroid: (f: Feature, path: ReturnType<typeof geoPath>) => [number, number];
+/** A region's value. `label` overrides the text printed on the map; dx/dy move that label off the region with a leader. */
+export interface ChoroplethDatum {
+    dx?: number;
+    dy?: number;
+    key: string;
+    label?: string;
+    value: number;
+}
+/**
+ * Drops a region's remote specks: a cluster of its parts (pieces within 5°
+ * of each other) holding under 1% of its largest part's area and lying over
+ * 15° from every other part. On a world map Hawaii is such a cluster: a
+ * lone dot in the Pacific that reads as a stray mark, while the mainland
+ * already carries the value. With countries-110m this removes Hawaii only.
+ */
+export declare const withoutRemoteIslets: (region: Region) => Region;
+/**
+ * Drops a region's minor parts that straddle the antimeridian. A projection
+ * centred on Greenwich splits such a part and throws one half to the map's
+ * opposite edge (a sliver of Fiji alone at the far left), where it reads as
+ * a stray mark. The region's largest part is always kept.
+ */
+export declare const withoutWrappedParts: (region: Region) => Region;
+export {};