@mailwoman/resolver-wof-sqlite 9.1.0 → 9.3.0

package/out/uprn/lookup.js

@@ -0,0 +1,149 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Node reader for `uprn.db` — the OS Open UPRN layer (`uprn-schema.ts`). Two probes:
+ *
+ *   - **`coordinateOf(uprn)`**: rowid B-tree hit on the `uprn` integer PK.
+ *   - **`nearestUPRN(lat, lon, radiusM)`**: bounded nearest-point search over the res-9 `h3_cell`
+ *     index — ring-by-ring `gridDisk` expansion with chunked `IN` probes and haversine ranking.
+ *     Rings stop as soon as geometry proves no unprobed cell could beat the best hit — a distance
+ *     bound, not POILookup's row-count accumulation, so the early exit can never strand a nearer
+ *     point in an unprobed ring.
+ *
+ *   ## `null` is a claim, scoped by coverage
+ *
+ *   OS designates Open UPRN complete for GB (every UPRN in AddressBase Premium with geometry), and
+ *   the builder writes `layer_coverage` with basis `designated` for every cell the product touches.
+ *   So a `null` from either probe inside a covered cell is evidence of absence — "no such published
+ *   GB UPRN" / "no UPRN within the radius". Outside coverage (Northern Ireland, the Isle of Man, the
+ *   Channel Islands, open water) it is UNKNOWN, per the meaning-of-zero rule — callers building
+ *   negative evidence must consult `readLayerCoverage`, not this reader alone.
+ *
+ *   `latLngToCell`/`gridDisk` come from `h3-js`; the 48-bit short-cell packing is
+ *   `@mailwoman/spatial`'s `shortCellToInt` via `uprnFullCell` — never reimplemented here.
+ */
+import { haversineKm, shortCellToInt } from "@mailwoman/spatial";
+import { DatabaseClient } from "@mailwoman/sqlite/client";
+import { gridDisk } from "h3-js";
+import { allRows } from "#sqlite-utils";
+import { uprnFullCell } from "#uprn/schema";
+/**
+ * Conservative FLOOR on how much CENTRE distance one unit of res-9 GRID distance buys, metres. Adjacent centres sit √3
+ * × edge apart (avg edge 174.4 m → ≈302 m); the worst bearing across a ring costs a further ×0.866, and H3's projection
+ * distortion shrinks edges by well under the slack this leaves (the true worst is ≈217 m per grid step). Dividing a
+ * radius by this over-counts rings and can never miss a cell; multiplying a grid distance by it under-states reach and
+ * can never end the ring walk early.
+ */
+const RES9_CENTER_SPACING_FLOOR_M = 150;
+/**
+ * Conservative CEILING on a res-9 cell's centre-to-vertex distance, metres (avg edge 174.4 m; distortion stays well
+ * under this). A point within `radiusM` of the query sits in a cell whose CENTRE is within `radiusM` + this.
+ */
+const RES9_CELL_RADIUS_CEILING_M = 300;
+/**
+ * Hard ceiling on `radiusM`. Keeps the probe bounded (10 km → ~72 rings ≈ 15.8k cells ≈ 18 `IN` chunks); a caller who
+ * wants a wider search than "which property is this coordinate" has outgrown this reader and should say so loudly.
+ */
+export const UPRN_MAX_NEAREST_RADIUS_M = 10_000;
+/**
+ * `IN`-list chunk size for the cell probe — far under SQLite's 32,766 bound-variable ceiling.
+ */
+const CELL_PROBE_CHUNK = 900;
+/**
+ * Node reader over `uprn.db`. `implements Disposable` so callers can `using lookup = new UPRNLookup(...)` — the same
+ * precedent as {@link POILookup}.
+ */
+export class UPRNLookup {
+    #db;
+    /**
+     * Resources this instance opened. A connection handed in by a caller is NOT in here, so disposal cannot reach it —
+     * ownership is membership rather than a flag a later branch has to check.
+     */
+    #resources = new DisposableStack();
+    /**
+     * `uprn` → its point (rowid-alias PK hit).
+     */
+    #coordinateProbe;
+    constructor(opts) {
+        if (opts.database) {
+            this.#db = opts.database;
+        }
+        else if (opts.databasePath) {
+            this.#db = this.#resources.use(new DatabaseClient(opts.databasePath, { readOnly: true }));
+        }
+        else {
+            throw new Error("UPRNLookup needs `databasePath` or `database`");
+        }
+        this.#coordinateProbe = this.#db.prepare("SELECT lat, lon FROM uprn WHERE uprn = ?");
+    }
+    /**
+     * The WGS84 point OS publishes for `uprn`, or `null` when the layer holds no such UPRN (see the module docstring for
+     * what that `null` claims).
+     */
+    coordinateOf(uprn) {
+        const row = this.#coordinateProbe.get(uprn);
+        return row ? { latitude: row.lat, longitude: row.lon } : null;
+    }
+    /**
+     * The single nearest UPRN within `radiusM` metres of the query point, or `null` when no UPRN lies inside the radius.
+     *
+     * Bounded two ways: `radiusM` is capped at {@link UPRN_MAX_NEAREST_RADIUS_M}, and rings expand outward only until no
+     * unprobed cell could beat the best hit found so far (or the radius, when nothing has been found). The stop rule is
+     * geometric — a cell at grid distance `g` holds no point nearer than `g` × spacing floor − cell radius, using the
+     * same conservative constants the reach math uses — so unlike POILookup's row-count accumulation there is no
+     * early-exit ambiguity: a break can never strand a nearer point in an unprobed ring. This is what keeps a
+     * capped-radius call over dense ground at milliseconds instead of a full-disk fetch (measured 6.4 s → 13 ms for a 10
+     * km radius over central London, 41.6M-row layer; an empty-sea miss at the cap runs the full expansion, 74 ms).
+     *
+     * @throws {RangeError} When `radiusM` is not a positive finite number, or exceeds the cap.
+     */
+    nearestUPRN(latitude, longitude, radiusM) {
+        if (!Number.isFinite(radiusM) || radiusM <= 0) {
+            throw new RangeError(`nearestUPRN: radiusM must be a positive finite number, received ${radiusM}`);
+        }
+        if (radiusM > UPRN_MAX_NEAREST_RADIUS_M) {
+            throw new RangeError(`nearestUPRN: radiusM ${radiusM} exceeds the ${UPRN_MAX_NEAREST_RADIUS_M} m cap`);
+        }
+        const origin = uprnFullCell(latitude, longitude);
+        const seenCells = new Set();
+        let best = null;
+        // `ring` is H3 grid distance; the loop terminates because the break bound is at most radiusM, which the
+        // RangeError above caps.
+        for (let ring = 0;; ring++) {
+            // A cell at grid distance `ring` holds no point nearer than this. Once it exceeds what could still
+            // win — the best hit so far, or the radius itself — further rings cannot improve the answer.
+            const closestPossibleM = ring * RES9_CENTER_SPACING_FLOOR_M - RES9_CELL_RADIUS_CEILING_M;
+            if (closestPossibleM > Math.min(radiusM, best?.distanceM ?? radiusM))
+                break;
+            // gridDisk(origin, ring) returns the WHOLE disk out to `ring`; diffing against what's already been
+            // probed derives just this ring's new cells (the POILookup pattern).
+            const diskCells = gridDisk(origin, ring);
+            const newCells = [];
+            for (const cell of diskCells) {
+                if (!seenCells.has(cell)) {
+                    seenCells.add(cell);
+                    newCells.push(shortCellToInt(cell));
+                }
+            }
+            for (let i = 0; i < newCells.length; i += CELL_PROBE_CHUNK) {
+                const chunk = newCells.slice(i, i + CELL_PROBE_CHUNK);
+                const placeholders = chunk.map(() => "?").join(", ");
+                // Prepared fresh per chunk arity — a cold, per-call path, same posture as POILookup's batched hydration.
+                const rows = allRows(this.#db.prepare(`SELECT uprn, lat, lon FROM uprn WHERE h3_cell IN (${placeholders})`), ...chunk);
+                for (const row of rows) {
+                    const distanceM = haversineKm(latitude, longitude, row.lat, row.lon) * 1000;
+                    if (distanceM <= radiusM && (best === null || distanceM < best.distanceM)) {
+                        best = { uprn: row.uprn, latitude: row.lat, longitude: row.lon, distanceM };
+                    }
+                }
+            }
+        }
+        return best;
+    }
+    [Symbol.dispose]() {
+        this.#resources[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=lookup.js.map

package/out/uprn/lookup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.js","sourceRoot":"","sources":["../../lib/uprn/lookup.ts"],"names":[],"mappings":"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"}

package/out/uprn/schema.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Typed schema for `uprn.db` — the OS Open UPRN spatial layer: every GB Unique Property Reference
+ *   Number with its WGS84 point, so mailwoman results can carry UPRN as an interoperability key
+ *   beside our own `@mailwoman/address-id`. One rowid table keyed `uprn INTEGER PRIMARY KEY` (the
+ *   rowid alias — the optimal shape for an integer-PK point table; `WITHOUT ROWID` buys nothing
+ *   here), plus a secondary res-9 `h3_cell` index for the bounded nearest-point probe.
+ *
+ *   ## Coordinates are OS's own WGS84 columns
+ *
+ *   The source CSV publishes BOTH coordinate systems per row — OSGB36 eastings/northings AND WGS84
+ *   `LATITUDE`/`LONGITUDE`. This layer stores OS's own lat/lon verbatim and never reconverts from
+ *   eastings: `@mailwoman/spatial`'s `osgb36ToWGS84` is a 7-parameter Helmert with a measured p95 of
+ *   4.18 m, and re-deriving what the publisher already computed (with OSTN15, exactly) would replace
+ *   their answer with a strictly worse one.
+ *
+ *   ## Why `h3_cell` exists at all
+ *
+ *   The layer contract requires every domain row to be addressable by at least one spine key —
+ *   `writeLayerManifest` throws on a manifest that declares none — and UPRN is its own id space, not
+ *   H3/WOF/address-id/street. The res-9 short cell (`shortCellToInt`, the same packing as poi.db and
+ *   the OSM situs extracts) is the spine that fits a point table, and its index doubles as the
+ *   `nearestUPRN` ring probe.
+ *
+ *   The DB also embeds the layer-contract tables from `@mailwoman/core/layers`; the builder
+ *   (`packages/mailwoman/lib/gazetteer-pipeline/uprn-layer.ts`) writes the manifest and per-res-6-cell
+ *   coverage.
+ */
+import type { LayerContractDatabase } from "@mailwoman/core/layers";
+import { type H3Cell } from "@mailwoman/spatial";
+import type { Kysely } from "kysely";
+/**
+ * Resolution the `uprn` table's `h3_cell` column is keyed at — the shared layer-spine resolution (poi.db, the OSM situs
+ * extracts).
+ */
+export declare const UPRN_H3_RESOLUTION = 9;
+/**
+ * Resolution of the layer's `layer_coverage` cells — coarse, per the contract (matches poi.db).
+ */
+export declare const UPRN_COVERAGE_H3_RESOLUTION = 6;
+/**
+ * One UPRN point. `uprn` is the rowid alias, so the primary probe (`coordinateOf`) is a rowid B-tree hit.
+ */
+export interface UPRNTable {
+    /**
+     * The Unique Property Reference Number — up to 12 digits, so always within `Number.MAX_SAFE_INTEGER`.
+     */
+    uprn: number;
+    /**
+     * WGS84 latitude, as OS published it (never reconverted from eastings — see the module docstring).
+     */
+    lat: number;
+    /**
+     * WGS84 longitude, as OS published it.
+     */
+    lon: number;
+    /**
+     * 48-bit short H3 cell at {@link UPRN_H3_RESOLUTION} (`uprnH3Cell`) — the layer-contract spine key and the
+     * `nearestUPRN` probe index.
+     */
+    h3_cell: number;
+}
+/**
+ * Build-provenance key/value pairs the fixed `layer_manifest` columns have no room for: quality-drop counts, the header
+ * as found, the upstream licence text verbatim (the Code-Point provenance discipline).
+ */
+export interface UPRNMetaTable {
+    key: string;
+    value: string;
+}
+export interface UPRNDatabase extends LayerContractDatabase {
+    uprn: UPRNTable;
+    uprn_meta: UPRNMetaTable;
+}
+/**
+ * The full res-9 cell for a UPRN point — the ONE derivation both the builder and every consumer share, so a fixture
+ * built by a test and a row built by the real ingest can never disagree on which cell a coordinate keys to.
+ */
+export declare function uprnFullCell(latitude: number, longitude: number): H3Cell;
+/**
+ * The `h3_cell` column value for a UPRN point: {@link uprnFullCell} packed to the shared 48-bit short-cell integer.
+ */
+export declare function uprnH3Cell(latitude: number, longitude: number): number;
+export declare function createUPRNTable(db: Kysely<UPRNDatabase>): Promise<void>;
+export declare function createUPRNMetaTable(db: Kysely<UPRNDatabase>): Promise<void>;
+/**
+ * Secondary index for the `nearestUPRN` ring probe. Builders call this AFTER the bulk load (index-after-load).
+ */
+export declare function createUPRNIndexes(db: Kysely<UPRNDatabase>): Promise<void>;
+//# sourceMappingURL=schema.d.ts.map

package/out/uprn/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../lib/uprn/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AACnE,OAAO,EAAkB,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAEhE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEpC;;;GAGG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC;;GAEG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAA;AAE5C;;GAEG;AACH,MAAM,WAAW,SAAS;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;IACX;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;IACX;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAA;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,YAAa,SAAQ,qBAAqB;IAC1D,IAAI,EAAE,SAAS,CAAA;IACf,SAAS,EAAE,aAAa,CAAA;CACxB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAExE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAsB,eAAe,CAAC,EAAE,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ7E;AAED,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAMjF;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/E"}

package/out/uprn/schema.js

@@ -0,0 +1,78 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Typed schema for `uprn.db` — the OS Open UPRN spatial layer: every GB Unique Property Reference
+ *   Number with its WGS84 point, so mailwoman results can carry UPRN as an interoperability key
+ *   beside our own `@mailwoman/address-id`. One rowid table keyed `uprn INTEGER PRIMARY KEY` (the
+ *   rowid alias — the optimal shape for an integer-PK point table; `WITHOUT ROWID` buys nothing
+ *   here), plus a secondary res-9 `h3_cell` index for the bounded nearest-point probe.
+ *
+ *   ## Coordinates are OS's own WGS84 columns
+ *
+ *   The source CSV publishes BOTH coordinate systems per row — OSGB36 eastings/northings AND WGS84
+ *   `LATITUDE`/`LONGITUDE`. This layer stores OS's own lat/lon verbatim and never reconverts from
+ *   eastings: `@mailwoman/spatial`'s `osgb36ToWGS84` is a 7-parameter Helmert with a measured p95 of
+ *   4.18 m, and re-deriving what the publisher already computed (with OSTN15, exactly) would replace
+ *   their answer with a strictly worse one.
+ *
+ *   ## Why `h3_cell` exists at all
+ *
+ *   The layer contract requires every domain row to be addressable by at least one spine key —
+ *   `writeLayerManifest` throws on a manifest that declares none — and UPRN is its own id space, not
+ *   H3/WOF/address-id/street. The res-9 short cell (`shortCellToInt`, the same packing as poi.db and
+ *   the OSM situs extracts) is the spine that fits a point table, and its index doubles as the
+ *   `nearestUPRN` ring probe.
+ *
+ *   The DB also embeds the layer-contract tables from `@mailwoman/core/layers`; the builder
+ *   (`packages/mailwoman/lib/gazetteer-pipeline/uprn-layer.ts`) writes the manifest and per-res-6-cell
+ *   coverage.
+ */
+import { shortCellToInt } from "@mailwoman/spatial";
+import { latLngToCell } from "h3-js";
+/**
+ * Resolution the `uprn` table's `h3_cell` column is keyed at — the shared layer-spine resolution (poi.db, the OSM situs
+ * extracts).
+ */
+export const UPRN_H3_RESOLUTION = 9;
+/**
+ * Resolution of the layer's `layer_coverage` cells — coarse, per the contract (matches poi.db).
+ */
+export const UPRN_COVERAGE_H3_RESOLUTION = 6;
+/**
+ * The full res-9 cell for a UPRN point — the ONE derivation both the builder and every consumer share, so a fixture
+ * built by a test and a row built by the real ingest can never disagree on which cell a coordinate keys to.
+ */
+export function uprnFullCell(latitude, longitude) {
+    return latLngToCell(latitude, longitude, UPRN_H3_RESOLUTION);
+}
+/**
+ * The `h3_cell` column value for a UPRN point: {@link uprnFullCell} packed to the shared 48-bit short-cell integer.
+ */
+export function uprnH3Cell(latitude, longitude) {
+    return shortCellToInt(uprnFullCell(latitude, longitude));
+}
+export async function createUPRNTable(db) {
+    await db.schema
+        .createTable("uprn")
+        .addColumn("uprn", "integer", (c) => c.primaryKey())
+        .addColumn("lat", "real", (c) => c.notNull())
+        .addColumn("lon", "real", (c) => c.notNull())
+        .addColumn("h3_cell", "integer", (c) => c.notNull())
+        .execute();
+}
+export async function createUPRNMetaTable(db) {
+    await db.schema
+        .createTable("uprn_meta")
+        .addColumn("key", "text", (c) => c.primaryKey())
+        .addColumn("value", "text", (c) => c.notNull())
+        .execute();
+}
+/**
+ * Secondary index for the `nearestUPRN` ring probe. Builders call this AFTER the bulk load (index-after-load).
+ */
+export async function createUPRNIndexes(db) {
+    await db.schema.createIndex("uprn_h3_cell").on("uprn").column("h3_cell").execute();
+}
+//# sourceMappingURL=schema.js.map

package/out/uprn/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../lib/uprn/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAE,cAAc,EAAe,MAAM,oBAAoB,CAAA;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAGpC;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAA;AAEnC;;GAEG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAA;AAuC5C;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,QAAgB,EAAE,SAAiB;IAC/D,OAAO,YAAY,CAAC,QAAQ,EAAE,SAAS,EAAE,kBAAkB,CAAW,CAAA;AACvE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,QAAgB,EAAE,SAAiB;IAC7D,OAAO,cAAc,CAAC,YAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAA;AACzD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,EAAwB;IAC7D,MAAM,EAAE,CAAC,MAAM;SACb,WAAW,CAAC,MAAM,CAAC;SACnB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC;SACnD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SAC5C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SAC5C,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SACnD,OAAO,EAAE,CAAA;AACZ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,EAAwB;IACjE,MAAM,EAAE,CAAC,MAAM;SACb,WAAW,CAAC,WAAW,CAAC;SACxB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC;SAC/C,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;SAC9C,OAAO,EAAE,CAAA;AACZ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,EAAwB;IAC/D,MAAM,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAA;AACnF,CAAC"}

package/out/weights-overlay-linker.d.ts

@@ -0,0 +1,299 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * Shared development tooling for weights overlays: the symlink primitives every overlay linker uses, the
+ * placetype-pair index build, and the manifest form ({@link materializeDevOverlay}) each locale's
+ * `scripts/link-dev-weights.ts` declares itself in.
+ */
+/**
+ * Replicate `ln -sf SRC DEST` ATOMICALLY: symlink under a temp name, then rename over the destination. A plain
+ * unlink-then-symlink leaves a no-file window that concurrent vitest workers can hit mid-suite — bit CI on 2026-07-24.
+ * rename(2) replaces the destination atomically.
+ */
+export declare function linkForce(src: string, dest: string): Promise<void>;
+/**
+ * Remove a leftover local file/symlink so the #1179 base-weights fallback engages.
+ */
+export declare function removeIfPresent(dest: string): Promise<void>;
+/**
+ * Symlink one soft-feed sibling into an overlay, warning rather than failing when the source is absent.
+ *
+ * Every one of these artifacts is OPTIONAL by design — the runtime has a fallback for each, so a fresh worktree that
+ * has not built the gazetteer still geocodes. That is why the miss prints the consequence instead of throwing: the
+ * operator needs to know which channel just resolved OFF, not to have the link step abort.
+ */
+export declare function linkSoftFeedSibling(source: string, destination: string, consequenceIfMissing: string): Promise<boolean>;
+/**
+ * The calibrated pair-index emission bias every shipped artifact is built at today — the R5/R6/R9/R10/R11 bars were all
+ * measured at δ=10 (each linker's own docstring carries its locale's receipt).
+ */
+export declare const PAIR_INDEX_DELTA = 10;
+/**
+ * The decoder transition-entry bonus (TRANSITION-BETA build, 2026-07-24 — operator-approved β=5 from the
+ * transition-level probe). en-nz deliberately builds WITHOUT one (unmeasured there): the two magnitudes are calibrated
+ * independently, and a locale earning one says nothing about the other.
+ */
+export declare const PAIR_INDEX_TRANSITION_BETA = 5;
+/**
+ * The WHOLE-EDGE parent-bias magnitude (#46, default-on 2026-08-04) at the verdict's recommended δ=5 — see
+ * `docs/records/evals/2026-08-04-pix1-whole-edge-verdict.md`. Only the measured locales (us/gb/nz/fr) pass it; the
+ * D-rule's answer to an unmeasured locale is a per-locale absence, not an inherited magnitude.
+ */
+export declare const PAIR_INDEX_PARENT_DELTA = 5;
+/**
+ * What one pair-index build has to say about itself. Everything else is shared.
+ */
+export interface PairIndexOverlay {
+    /**
+     * Workspace directory name, e.g. `neural-weights-de-de`.
+     */
+    packageDir: string;
+    /**
+     * ISO country code passed to `gazetteer pair-index --country`, and the suffix of the built artifact (`de` →
+     * `pair-index-de.bin`). NOT the locale tag: `en-in` builds `pair-index-in.bin`.
+     */
+    country: string;
+    /**
+     * Calibrated magnitudes the locale's bars were measured at. Baked into the artifact's PIX1 header, which is how the
+     * freshness check notices a change to any of them. An ABSENT `transitionBeta`/`parentDelta` means the flag is not
+     * passed and the header carries no such key — a real state, distinct from zero (see `PairIndexHeader.parentDelta`).
+     * The whole calibration feeds both the build FLAGS and the staleness EXPECTATION, so the two cannot disagree.
+     */
+    delta: number;
+    transitionBeta?: number;
+    parentDelta?: number;
+    /**
+     * Source FILES whose md5s the build records, in the order `gazetteer pair-index` records them. The freshness guard
+     * compares EVERY one against the existing header (#1734): a partial comparison leaves the guard blind to the rest,
+     * and a stale artifact then keeps reporting itself fresh while the data it was built from has moved. Empty means the
+     * build's source cannot be file-hashed (fr's BAN directory) and freshness rests on the magnitudes alone. Default: the
+     * WOF admin DB.
+     */
+    sources?: string[];
+    /**
+     * Inputs that must exist before a build is attempted — a missing one warns and returns, because a fresh clone has no
+     * data root and `yarn test` invokes the linkers to verify auto-resolve. Default: `sources`.
+     */
+    inputs?: string[];
+    /**
+     * Extra CLI args naming the build's sources (`--source`, `--borough-db`, `--pairs-jsonl`, `--ban-dir`). Default:
+     * `--borough-db <admin db>`.
+     */
+    extraArgs?: string[];
+    /**
+     * Refuse to trust an existing artifact smaller than this. fr-fr's guard: a pair index built from the WRONG source can
+     * carry matching magnitudes, and size is the one signal the header cannot fake.
+     */
+    minimumPlausibleBytes?: number;
+}
+/**
+ * The header fields a dev-weights freshness guard reads.
+ */
+export interface PairIndexHeaderFields {
+    delta: number;
+    transitionBeta: number | undefined;
+    parentDelta: number | undefined;
+    schemaVersion: number;
+    /**
+     * One md5 per source the build read, in fold order. Empty on a header that recorded none.
+     */
+    sourceMD5s: string[];
+}
+/**
+ * Minimal PIX1 header reader — magic + header only, reimplemented so a data-only weights package gains no dependency on
+ * `@mailwoman/neural` (which pulls onnxruntime-node) to read a few fields. `neural/pair-index-resolver.ts`'s own header
+ * parse is the source of truth this must follow.
+ *
+ * Shared by the overlay build below AND by the four hand-written base linkers
+ * (`neural-weights-{en-us,en-gb,en-nz,fr-fr}/scripts/link-dev-weights.ts`), which each carried their own near-copy
+ * before 2026-08-04 — the ×5 clone the taste audit named, and the reason three of them were schema-blind while this one
+ * was not.
+ */
+export declare function peekPairIndexHeaderFields(path: string): Promise<PairIndexHeaderFields>;
+/**
+ * Md5 of `path`, cached in a standard `md5sum`-format sidecar (`<hash> <filename>`) beside it so a multi-gigabyte
+ * source is hashed once per change rather than once per linker run. The sidecar is trusted only when at least as new as
+ * the source; a missing or stale sidecar recomputes and rewrites, so the cache self-heals.
+ *
+ * The shared home for the copies the base linkers (`en-us`, `en-gb`, `en-nz`) each carry — new callers import this one.
+ */
+export declare function md5FileWithSidecar(path: string): Promise<string>;
+/**
+ * The calibrated magnitudes a linker bakes into its artifact. `undefined` means the flag is NOT passed and the header
+ * carries no such key — a real state, distinct from zero (see `PairIndexHeader.parentDelta`), so the comparison below
+ * is `!==` against `undefined` rather than a truthiness test.
+ */
+export interface PairIndexCalibration {
+    delta: number;
+    transitionBeta?: number;
+    parentDelta?: number;
+}
+/**
+ * Why an existing `pair-index-*.bin` is stale against `expected`, or `undefined` when its header matches. Covers the
+ * FORMAT (schemaVersion) and every calibrated magnitude; source-md5 freshness stays with the caller, because each base
+ * linker passes a different set of sources and only it knows what they are.
+ *
+ * One place so a magnitude added to the header cannot be checked by some linkers and not others — which is exactly how
+ * three of the four base linkers ended up unable to notice a schema bump.
+ */
+export declare function pairIndexStaleReason(header: PairIndexHeaderFields, expected: PairIndexCalibration): string | undefined;
+/**
+ * The PIX1 schema this tree's reader requires. MUST equal `KNOWN_SCHEMA_VERSION` in `neural/pair-index-resolver.ts` —
+ * they are two ends of one fact, and this copy exists only because a data-only overlay must not gain a dependency on
+ * `@mailwoman/neural` (onnxruntime-node) to read one header field. Bump BOTH in the same commit; a schema bump that
+ * leaves this behind makes every dev checkout rebuild-loop or serve an artifact the runtime refuses.
+ *
+ * The freshness guard must compare it: a guard that checks only delta + source md5 reads a format-obsolete binary as
+ * "current" and leaves every dev checkout with artifacts the runtime refuses — the R5 freshness-guard lesson, format
+ * edition. Also compared by the four hand-written base linkers (`neural-weights-{en-us,en-gb,en-nz,fr-fr}`), which
+ * import this constant rather than re-typing the number.
+ */
+export declare const REQUIRED_PAIR_INDEX_SCHEMA = 3;
+/**
+ * Warn when the per-locale FST a linker just symlinked was built from a DIFFERENT admin database than the one on disk
+ * now.
+ *
+ * WHY IT WARNS RATHER THAN REBUILDS, unlike its pair-index sibling above. A pair index is seconds of work and the
+ * linker owns its whole recipe. A locale FST is a multi-minute build whose output goes to a STAGING dir on purpose —
+ * the swap into `fst-per-locale/` is operator-approved after the battery, because an FST changes decoder behaviour and
+ * the D-rule does not let that land unmeasured. So the guard's job is to make the drift impossible to miss, and to name
+ * the command that starts fixing it. It is also why a stale FST is never fatal: the artifact is a decode-time bias
+ * list, and a dev tree must still run.
+ *
+ * The source-side half of the comparison lives here rather than in `fst-freshness.ts` for the same reason
+ * `pairIndexStaleReason` splits: only the caller knows which database it built against. All three FST-linking base
+ * packages build against the same one, so they share this rather than each pinning it.
+ */
+export declare function warnIfFSTStale(fstPath: string, locale: string): Promise<void>;
+/**
+ * Symlink the per-locale FST gazetteer (`fst-<locale>.bin`) from the shared build area
+ * (`$MAILWOMAN_DATA_ROOT/wof/fst-per-locale/`) into an overlay so `resolveWeights` surfaces `fstPath` in dev and the
+ * runtime pipeline can auto-wire the gazetteer + street-context check, then run {@link warnIfFSTStale} on the linked
+ * artifact. The publish flow stages the real binary (release-sequenced).
+ */
+export declare function linkLocaleFST(destDir: string, locale: string): Promise<void>;
+/**
+ * Symlink the sealed locale-general street-morphology FST (`$MAILWOMAN_DATA_ROOT/wof/fst-street-morphology.bin`,
+ * `mailwoman gazetteer build street-morphology`) into an overlay so `resolveWeights` surfaces `streetMorphologyPath` in
+ * dev and the street-context check (#1315) deserializes the artifact instead of rebuilding from the libpostal
+ * dictionaries per process. Missing is non-fatal — the runtime loader's dictionary-build fallback covers it.
+ */
+export declare function linkStreetMorphologyFST(destDir: string): Promise<void>;
+/**
+ * Build `pair-index-<country>.bin` into the overlay, skipping the work when the artifact on disk was already built at
+ * these magnitudes FROM the sources on disk (see {@link pairIndexIsFresh}). The calibration object drives both the
+ * staleness expectation and the CLI flags, so a magnitude cannot be checked by the guard and dropped from the build.
+ *
+ * Exits non-zero on a failed build. Missing INPUTS (an unbuilt CLI, an absent source) warn and return instead: a fresh
+ * clone has neither, and `yarn test` invokes this to verify auto-resolve, so a hard failure there would be a failure to
+ * have run a build yet rather than a real fault.
+ */
+export declare function buildPairIndexOverlay(overlay: PairIndexOverlay): Promise<void>;
+/**
+ * A soft-feed sibling an overlay links: where it comes from, the name it takes in the overlay, and the consequence line
+ * printed when the source is missing (the link is warn-and-continue; the channel resolves OFF).
+ */
+export interface SoftFeedLink {
+    source: string;
+    name: string;
+    consequenceIfMissing: string;
+}
+/**
+ * The committed soft-feed lexicons as links, by channel, read from `release.config.json` so the filename a manifest
+ * links is the one the release ships. `streetType` is offered for completeness; the manifests link the evidence
+ * lexicons by the generation their CARD names instead (`evidenceLexiconsFromCard`).
+ */
+export declare function committedSoftFeedLinks(): Promise<{
+    anchor: SoftFeedLink;
+    country: SoftFeedLink;
+    streetType?: SoftFeedLink;
+}>;
+/**
+ * The slice of a weights package's committed `model-card.json` the dev materialization reads: the shipped digests the
+ * release re-verifies against the published tarball, and the channel requirements that name evidence lexicons.
+ */
+export interface WeightsCard {
+    files_md5?: Record<string, string>;
+    requires?: Record<string, {
+        lexicon?: string;
+        span_mode?: string;
+    } | undefined>;
+}
+/**
+ * What one locale's `scripts/link-dev-weights.ts` declares, so an overlay is a manifest plus a call rather than a
+ * script cloned from a sibling. Every step is optional and runs only when named, in a fixed order: model pair,
+ * soft-feed siblings, card-named evidence lexicons, postcode binary, pair index, FSTs.
+ */
+export interface DevOverlayManifest {
+    /**
+     * The overlay's locale tag, lower-case. The workspace is `neural-weights-<locale>` and the artifacts land in
+     * `$MAILWOMAN_DATA_ROOT/weights/<locale>/`, never in the tracked package: the binaries are not in git, so
+     * materializing them there made a fresh worktree unable to geocode, made `yarn test` mutate a tracked directory, and
+     * put a symlink into a publish tarball (`YN0035`).
+     */
+    locale: string;
+    /**
+     * What happens to `model.onnx` + `tokenizer.model`. `link`: the pair is symlinked from the paths
+     * `release.config.json`'s `weights` block names under the data root (`$MAILWOMAN_DEV_MODEL` /
+     * `$MAILWOMAN_DEV_TOKENIZER` override them), and when `digestCard` names a workspace the linked default bytes must
+     * match that workspace's card `files_md5` — the #397 drift guard, which fails loud instead of grading the wrong
+     * model; an override skips the check and says so. `inherit`: the package declares `mailwoman.baseWeights`, so any
+     * local pair is REMOVED — a stale local file shadows the base fallback and silently serves outdated bytes. Omitted:
+     * the pair is left to `packages/release-kit/lib/weights/link-weights-overlay.ts`, the recipe writer.
+     */
+    model?: {
+        kind: "link";
+        digestCard?: string;
+    } | {
+        kind: "inherit";
+    } | {
+        kind: "char";
+        family: string;
+    };
+    /**
+     * Soft-feed siblings linked warn-and-continue, in order.
+     */
+    softFeed?: ReadonlyArray<SoftFeedLink>;
+    /**
+     * Link the evidence lexicons the overlay's own card names under `requires.<channel>.lexicon`, so the generation comes
+     * from the card the loader reads and a card bump moves the artifact with it. `street-type-lexicon-v*.json` is
+     * committed under `data/gazetteer/`; `locality-surface-lexicon-v*.json` is 7–13 MB and lives in the data root.
+     */
+    evidenceLexiconsFromCard?: boolean;
+    /**
+     * Build `postcode-<country>.bin` from a WOF postcode extract through the compiled `gazetteer postcode-binary` CLI,
+     * skipped when already present (it rebuilds in seconds, and the extract is versionless on disk).
+     */
+    postcodeBinary?: {
+        country: string;
+        database: string;
+    };
+    /**
+     * The placetype-pair index build, minus `packageDir`, which follows from `locale`.
+     */
+    pairIndex?: Omit<PairIndexOverlay, "packageDir">;
+    /**
+     * Link `fst-<locale>.bin` with its freshness warning.
+     */
+    localeFST?: boolean;
+    /**
+     * Link the shared street-morphology FST.
+     */
+    streetMorphologyFST?: boolean;
+}
+/**
+ * What a materialized overlay hands back for the locale-specific step a manifest cannot express (en-gb's
+ * card-conditional postcode binary is the one that exists).
+ */
+export interface DevOverlay {
+    destDir: string;
+    cli: string;
+    card: WeightsCard | undefined;
+}
+/**
+ * Materialize one locale's dev overlay from its manifest. The steps run in the order {@link DevOverlayManifest}
+ * documents, each independent on disk, and the result carries what a locale-specific step needs afterwards.
+ */
+export declare function materializeDevOverlay(manifest: DevOverlayManifest): Promise<DevOverlay>;
+//# sourceMappingURL=weights-overlay-linker.d.ts.map

package/out/weights-overlay-linker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights-overlay-linker.d.ts","sourceRoot":"","sources":["../lib/weights-overlay-linker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA6BH;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASxE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUjE;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACxC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC,CAYlB;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAElC;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAE3C;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAA;IACf;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,aAAa,EAAE,MAAM,CAAA;IACrB;;OAEG;IACH,UAAU,EAAE,MAAM,EAAE,CAAA;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA2B5F;AAOD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAsBtE;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,EAAE,oBAAoB,GAC5B,MAAM,GAAG,SAAS,CAgBpB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAE3C;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUnF;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYlF;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM5E;AAuFD;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2EpF;AAID;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,oBAAoB,EAAE,MAAM,CAAA;CAC5B;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC;IACvD,MAAM,EAAE,YAAY,CAAA;IACpB,OAAO,EAAE,YAAY,CAAA;IACrB,UAAU,CAAC,EAAE,YAAY,CAAA;CACzB,CAAC,CAsBD;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC,CAAA;CAC/E;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACtG;;OAEG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;IACtC;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAA;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IACtD;;OAEG;IACH,SAAS,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAA;IAChD;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;OAEG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,WAAW,GAAG,SAAS,CAAA;CAC7B;AA2KD;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,CAuD7F"}