hoi4-agent-tools 4.3.0 → 4.4.0

package/dist/hoi4_agent_tools/map/relief/checks.js

@@ -0,0 +1,281 @@
+/**
+ * Self-checks of the synthesised terrain (ADR 0056). They read only the finished rasters and the
+ * resolved model, so they would also catch a regression in the generator. Findings are notes with
+ * `MAP_RELIEF_*`, `MAP_RANGE_*`, `MAP_PASS_*`, `MAP_VOLCANO_*` and `MAP_RIVER_*` codes.
+ */
+import { sampleAlong } from '../geography/index.js';
+import { LAND } from './grid.js';
+import { CREST_WANDER_SHARE } from './macro-relief.js';
+/** Highest quantised height within `radius` pixels of a point; -1 when the point is not land. */
+function maxAround(raster, cx, cy, radius) {
+    const { width, height, kind, heights } = raster;
+    const px = Math.min(width - 1, Math.max(0, Math.floor(cx)));
+    const py = Math.min(height - 1, Math.max(0, Math.floor(cy)));
+    if (kind[py * width + px] !== LAND)
+        return -1;
+    let best = 0;
+    const r = Math.ceil(radius);
+    for (let dy = -r; dy <= r; dy += 1) {
+        const y = py + dy;
+        if (y < 0 || y >= height)
+            continue;
+        for (let dx = -r; dx <= r; dx += 1) {
+            const x = px + dx;
+            if (x < 0 || x >= width || dx * dx + dy * dy > radius * radius)
+                continue;
+            const index = y * width + x;
+            if (kind[index] !== LAND)
+                continue;
+            if (heights[index] > best)
+                best = heights[index];
+        }
+    }
+    return best;
+}
+/** True where a pass saddle lies within `margin` of arc fraction `t`. */
+function inPassWindow(table, t, margin) {
+    return table.passes.some((pass) => Math.abs(t - pass.at) * table.length <= pass.halfLength * margin);
+}
+/**
+ * Crest, pass and volcano checks against the quantised heights. `MAP_PASS_NOT_LOWER` is an error:
+ * a gate that is not a gap would block a route the model declares.
+ */
+export function checkRangesAndFeatures(geography, tables, raster, peakOf, volcanoPeak) {
+    const notes = [];
+    const frame = { width: raster.width, height: raster.height };
+    for (const range of geography.ranges) {
+        const table = tables.find((candidate) => candidate.id === range.id);
+        if (table === undefined)
+            continue;
+        const samples = Math.max(8, Math.min(64, Math.floor(table.count / 8)));
+        let measured = 0;
+        let low = 0;
+        let worst = 1;
+        let worstAt = 0;
+        for (let k = 0; k < samples; k += 1) {
+            const t = 0.04 + (0.92 * k) / (samples - 1);
+            if (inPassWindow(table, t, 1.5))
+                continue;
+            const sample = sampleAlong(range.path, geography.frame, t);
+            const radius = Math.max(3, CREST_WANDER_SHARE * 1.2 * sample.halfWidth * raster.width);
+            const found = maxAround(raster, sample.x * raster.width, sample.y * raster.height, radius);
+            if (found < 0)
+                continue;
+            const target = peakOf(sample.peak);
+            measured += 1;
+            const ratio = found / target;
+            if (ratio < 0.9)
+                low += 1;
+            if (ratio < worst) {
+                worst = ratio;
+                worstAt = t;
+            }
+        }
+        if (measured >= 4 && low / measured > 0.2)
+            notes.push({
+                code: 'MAP_RANGE_CREST_LOW',
+                severity: 'warning',
+                message: `Range ${range.id} reaches less than 90% of its requested crest height along ${low} of ${measured} sampled points (worst ${Math.round(worst * 100)}% at ${Math.round(worstAt * 100)}% of its length); a plateau, lake or the coast may overlap it`,
+                details: {
+                    rangeId: range.id,
+                    sampled: measured,
+                    low,
+                    worstRatio: Math.round(worst * 100) / 100,
+                },
+            });
+    }
+    for (const pass of geography.passes) {
+        const range = geography.get('range', pass.rangeId);
+        const table = tables.find((candidate) => candidate.id === pass.rangeId);
+        if (range === undefined || table === undefined || pass.depth < 0.15)
+            continue;
+        const entry = table.passes.find((candidate) => candidate.id === pass.id);
+        if (entry === undefined)
+            continue;
+        const reach = (entry.halfLength * 1.5) / table.length;
+        const at = pass.at;
+        const probe = (t) => {
+            const sample = sampleAlong(range.path, frame, t);
+            const radius = Math.max(3, CREST_WANDER_SHARE * 1.2 * sample.halfWidth * raster.width);
+            return maxAround(raster, sample.x * raster.width, sample.y * raster.height, radius);
+        };
+        if (at - reach < 0 || at + reach > 1)
+            continue;
+        const center = probe(at);
+        const before = probe(at - reach);
+        const after = probe(at + reach);
+        if (center < 0 || before < 0 || after < 0)
+            continue;
+        const kmid = Math.min(table.count - 1, Math.round(at * (table.count - 1)));
+        const expected = Math.max(0, table.crest[kmid] - table.base[kmid]) * pass.depth;
+        if (center >= Math.min(before, after) - 0.25 * expected)
+            notes.push({
+                code: 'MAP_PASS_NOT_LOWER',
+                severity: 'error',
+                message: `Pass ${pass.id} through range ${pass.rangeId} is not lower than the crest either side of it (${center} against ${before} and ${after})`,
+                details: {
+                    passId: pass.id,
+                    rangeId: pass.rangeId,
+                    passHeight: center,
+                    flanks: [before, after],
+                },
+            });
+    }
+    for (const volcano of geography.volcanoes) {
+        const cx = volcano.at.x * raster.width;
+        const cy = volcano.at.y * raster.height;
+        const centre = raster.heights[Math.floor(cy) * raster.width + Math.floor(cx)];
+        const crater = volcano.crater * raster.width;
+        let ring = 0;
+        const r = Math.ceil(crater * 1.6);
+        for (let dy = -r; dy <= r; dy += 1)
+            for (let dx = -r; dx <= r; dx += 1) {
+                const d = Math.sqrt(dx * dx + dy * dy);
+                if (d < crater * 0.8 || d > crater * 1.6)
+                    continue;
+                const x = Math.floor(cx) + dx;
+                const y = Math.floor(cy) + dy;
+                if (x < 0 || y < 0 || x >= raster.width || y >= raster.height)
+                    continue;
+                const value = raster.heights[y * raster.width + x];
+                if (value > ring)
+                    ring = value;
+            }
+        void volcanoPeak;
+        if (raster.kind[Math.floor(cy) * raster.width + Math.floor(cx)] === LAND && ring - centre < 3)
+            notes.push({
+                code: 'MAP_VOLCANO_NO_CRATER',
+                severity: 'warning',
+                message: `Volcano ${volcano.id} has no crater at its centre (${centre} against a rim of ${ring}); widen its crater or its radius`,
+                details: { volcanoId: volcano.id, centre, rim: ring },
+            });
+    }
+    return notes;
+}
+/** Percentiles and the mean central step of the land heights. */
+export function reliefStatistics(raster) {
+    const { width, height, kind, heights } = raster;
+    const histogram = new Float64Array(256);
+    let landPixels = 0;
+    let maximum = 0;
+    let stepSum = 0;
+    let stepCount = 0;
+    for (let y = 0; y < height; y += 1)
+        for (let x = 0; x < width; x += 1) {
+            const index = y * width + x;
+            if (kind[index] !== LAND)
+                continue;
+            landPixels += 1;
+            const value = heights[index];
+            histogram[value] = histogram[value] + 1;
+            if (value > maximum)
+                maximum = value;
+            // Central height step of the half-resolution map: four full-resolution pixels apart.
+            if ((x & 1) === 0 && (y & 1) === 0 && x >= 2 && x < width - 2 && y >= 2 && y < height - 2) {
+                const gx = heights[index + 2] - heights[index - 2];
+                const gy = heights[index + 2 * width] - heights[index - 2 * width];
+                stepSum += (Math.abs(gx) + Math.abs(gy)) / 2;
+                stepCount += 1;
+            }
+        }
+    const percentile = (share) => {
+        const target = landPixels * share;
+        let seen = 0;
+        for (let value = 0; value < 256; value += 1) {
+            seen += histogram[value];
+            if (seen >= target)
+                return value;
+        }
+        return 255;
+    };
+    return {
+        landPixels,
+        median: landPixels === 0 ? 0 : percentile(0.5),
+        p99: landPixels === 0 ? 0 : percentile(0.99),
+        maximum,
+        meanStep: stepCount === 0 ? 0 : stepSum / stepCount,
+    };
+}
+/**
+ * Share of river pixels whose neighbourhood of 20 pixels either way along the river lies within
+ * `tolerance` pixels of one straight line: the measure of rivers that run as if drawn with a ruler.
+ * The base game measures 1.1% (staircase diagonals count as straight, as they look it). Only pixels
+ * with exactly two river neighbours are walked, so confluences and mouths are never counted.
+ */
+export function straightRiverShare(bitmap, width, height, tolerance = 1.5, half = 20) {
+    const isRiver = (x, y) => bitmap[y * width + x] <= 11;
+    const neighbours = (x, y, out) => {
+        let count = 0;
+        if (x + 1 < width && isRiver(x + 1, y))
+            out[count++] = y * width + x + 1;
+        if (x > 0 && isRiver(x - 1, y))
+            out[count++] = y * width + x - 1;
+        if (y + 1 < height && isRiver(x, y + 1))
+            out[count++] = (y + 1) * width + x;
+        if (y > 0 && isRiver(x, y - 1))
+            out[count++] = (y - 1) * width + x;
+        return count;
+    };
+    let river = 0;
+    let straight = 0;
+    const around = [0, 0, 0, 0];
+    const ahead = [0, 0, 0, 0];
+    const points = new Int32Array(2 * half + 1);
+    for (let y = 0; y < height; y += 1)
+        for (let x = 0; x < width; x += 1) {
+            if (!isRiver(x, y))
+                continue;
+            river += 1;
+            if (neighbours(x, y, around) !== 2)
+                continue;
+            points[half] = y * width + x;
+            let complete = true;
+            for (let side = 0; side < 2 && complete; side += 1) {
+                let previous = y * width + x;
+                let current = around[side];
+                for (let step = 1; step <= half; step += 1) {
+                    points[side === 0 ? half - step : half + step] = current;
+                    if (step === half)
+                        break;
+                    const cx = current % width;
+                    const cy = (current - cx) / width;
+                    const found = neighbours(cx, cy, ahead);
+                    let next = -1;
+                    let others = 0;
+                    for (let k = 0; k < found; k += 1)
+                        if (ahead[k] !== previous) {
+                            next = ahead[k];
+                            others += 1;
+                        }
+                    if (others !== 1) {
+                        complete = false;
+                        break;
+                    }
+                    previous = current;
+                    current = next;
+                }
+            }
+            if (!complete)
+                continue;
+            const a = points[0];
+            const b = points[2 * half];
+            const ax = a % width;
+            const ay = (a - ax) / width;
+            const dx = (b % width) - ax;
+            const dy = Math.floor(b / width) - ay;
+            const length = Math.sqrt(dx * dx + dy * dy);
+            if (length < half * 1.2)
+                continue;
+            let line = true;
+            for (let k = 1; k < 2 * half && line; k += 1) {
+                const p = points[k];
+                const px = p % width;
+                const py = (p - px) / width;
+                if (Math.abs((px - ax) * dy - (py - ay) * dx) / length > tolerance)
+                    line = false;
+            }
+            if (line)
+                straight += 1;
+        }
+    return { river, straight };
+}

package/dist/hoi4_agent_tools/map/relief/fields.js

@@ -0,0 +1,15 @@
+/**
+ * The typed interface between terrain synthesis and the stages that read its fields: the
+ * feature-aware partition (ADR 0058), the border-naturalness metric (ADR 0059), climate and biome and the
+ * composite renders. Every field is a plain typed array with its grid size, so a consumer needs
+ * no knowledge of how it was made (ADR 0056).
+ */
+/** What makes a pixel a barrier; the flags combine in `BarrierField.sources`. */
+export const BARRIER_RIVER = 1;
+export const BARRIER_CREST = 2;
+export const BARRIER_STEEP = 4;
+export const BARRIER_LAKE_SHORE = 8;
+/** A range declared `barrier: 'impassable'`, outside its pass gaps. */
+export const BARRIER_WALL = 16;
+/** A range declared `barrier: 'fort-line'`, outside its pass gaps. */
+export const BARRIER_FORT_LINE = 32;

package/dist/hoi4_agent_tools/map/relief/full-resolution.js

@@ -0,0 +1,133 @@
+/**
+ * Full-resolution height field (ADR 0056): the macro relief upsampled bilinearly with the macro
+ * kind as a mask, plus fractal and ridged detail weighted by the mountain footprint, plus the coast
+ * ramp. Heights stay floating point until the very end, so shading never terraces.
+ */
+import { rowStrips } from '../geography/index.js';
+import { LAND } from './grid.js';
+import { LAND_FLOOR } from './macro-relief.js';
+import { clamp, fractal2, lerp, ridged2, smoothstep } from './math.js';
+/** Length of the coast ramp, in pixels: land stands at the floor at the shore and free of it from here. */
+export const COAST_RAMP_PIXELS = 6;
+/**
+ * Four-neighbour distance of land pixels from the nearest water pixel: 1 for land next to water,
+ * up to `limit`; 0 for water and for land farther than `limit`.
+ */
+export function landEdgeDistance(kind, width, height, limit) {
+    const total = width * height;
+    const distance = new Uint8Array(total);
+    const queue = new Int32Array(total);
+    let head = 0;
+    let tail = 0;
+    for (let pixel = 0; pixel < total; pixel += 1) {
+        if (kind[pixel] !== LAND)
+            continue;
+        const x = pixel % width;
+        const touchesWater = (x > 0 && kind[pixel - 1] !== LAND) ||
+            (x < width - 1 && kind[pixel + 1] !== LAND) ||
+            (pixel >= width && kind[pixel - width] !== LAND) ||
+            (pixel < total - width && kind[pixel + width] !== LAND);
+        if (touchesWater) {
+            distance[pixel] = 1;
+            queue[tail++] = pixel;
+        }
+    }
+    while (head < tail) {
+        const pixel = queue[head++];
+        const next = distance[pixel] + 1;
+        if (next > limit)
+            continue;
+        const x = pixel % width;
+        const visit = (other) => {
+            if (kind[other] === LAND && distance[other] === 0) {
+                distance[other] = next;
+                queue[tail++] = other;
+            }
+        };
+        if (x > 0)
+            visit(pixel - 1);
+        if (x < width - 1)
+            visit(pixel + 1);
+        if (pixel >= width)
+            visit(pixel - width);
+        if (pixel < total - width)
+            visit(pixel + width);
+    }
+    return distance;
+}
+/**
+ * Float heights of land at full resolution, in map values. Water pixels hold 0: their heights are
+ * a function of the distance to land and are written when the field is quantised.
+ */
+export function buildFullResolutionHeights(input) {
+    const { macro, kind, width, height, seed } = input;
+    const mw = macro.width;
+    const mh = macro.height;
+    const out = new Float32Array(width * height);
+    const edge = landEdgeDistance(kind, width, height, COAST_RAMP_PIXELS);
+    const wavelength = Math.max(12, 0.0046 * width);
+    const broad = Math.max(24, 0.0125 * width);
+    const detailAmplitude = 0.4 + 1.2 * input.detail;
+    const heights = macro.heights;
+    const macroKind = macro.kind;
+    for (const strip of rowStrips({ width, height }, 64)) {
+        input.signal?.throwIfAborted();
+        for (let y = strip.y0; y < strip.y1; y += 1) {
+            const v = (y - 0.5) / 2;
+            const vy0 = clamp(Math.floor(v), 0, mh - 1);
+            const vy1 = vy0 + 1 < mh ? vy0 + 1 : vy0;
+            const ty = clamp(v - vy0, 0, 1);
+            for (let x = 0; x < width; x += 1) {
+                const pixel = y * width + x;
+                if (kind[pixel] !== LAND)
+                    continue;
+                const u = (x - 0.5) / 2;
+                const ux0 = clamp(Math.floor(u), 0, mw - 1);
+                const ux1 = ux0 + 1 < mw ? ux0 + 1 : ux0;
+                const tx = clamp(u - ux0, 0, 1);
+                // Masked bilinear: only land cells contribute, so the coast does not sag to zero.
+                const i00 = vy0 * mw + ux0;
+                const i10 = vy0 * mw + ux1;
+                const i01 = vy1 * mw + ux0;
+                const i11 = vy1 * mw + ux1;
+                const w00 = macroKind[i00] === LAND ? (1 - tx) * (1 - ty) : 0;
+                const w10 = macroKind[i10] === LAND ? tx * (1 - ty) : 0;
+                const w01 = macroKind[i01] === LAND ? (1 - tx) * ty : 0;
+                const w11 = macroKind[i11] === LAND ? tx * ty : 0;
+                const total = w00 + w10 + w01 + w11;
+                let level;
+                let footprint;
+                if (total > 1e-6) {
+                    level =
+                        (heights[i00] * w00 +
+                            heights[i10] * w10 +
+                            heights[i01] * w01 +
+                            heights[i11] * w11) /
+                            total;
+                    footprint =
+                        (macro.footprint[i00] * w00 +
+                            macro.footprint[i10] * w10 +
+                            macro.footprint[i01] * w01 +
+                            macro.footprint[i11] * w11) /
+                            total;
+                }
+                else {
+                    level = LAND_FLOOR + 3;
+                    footprint = 0;
+                }
+                // Detail: ridged crests and gullies in the mountains, quiet roughness on the plains.
+                const warpX = (fractal2(seed + 211, x, y, broad, 2) - 0.5) * 2 * wavelength * 0.9;
+                const warpY = (fractal2(seed + 223, x, y, broad, 2) - 0.5) * 2 * wavelength * 0.9;
+                const ridge = ridged2(seed + 101, x + warpX, y + warpY, wavelength, 3);
+                const rolling = fractal2(seed + 131, x, y, broad, 3) - 0.5;
+                const amplitude = detailAmplitude * (0.5 + 5.5 * footprint);
+                let h = level + (ridge - 0.45) * 2 * amplitude + rolling * 2 * detailAmplitude * 0.6;
+                const near = edge[pixel];
+                if (near > 0 && near <= COAST_RAMP_PIXELS)
+                    h = lerp(LAND_FLOOR, Math.max(h, LAND_FLOOR), smoothstep((near - 1) / (COAST_RAMP_PIXELS - 1)));
+                out[pixel] = h < LAND_FLOOR ? LAND_FLOOR : h;
+            }
+        }
+    }
+    return out;
+}

package/dist/hoi4_agent_tools/map/relief/grid.js

@@ -0,0 +1,190 @@
+/**
+ * Raster helpers for relief and hydrology synthesis: bilinear sampling, chamfer distances,
+ * component labelling and a packed binary heap. All results are deterministic.
+ */
+import { SQRT2 } from './math.js';
+/** Cell kinds used throughout the synthesis: the same codes as the world generator. */
+export const SEA = 0;
+export const LAND = 1;
+export const LAKE = 2;
+/** Bilinear sample at continuous cell coordinates; cell centres lie on integers. Clamped at the border. */
+export function bilinear(field, width, height, u, v) {
+    const fu = u < 0 ? 0 : u > width - 1 ? width - 1 : u;
+    const fv = v < 0 ? 0 : v > height - 1 ? height - 1 : v;
+    const x0 = Math.floor(fu);
+    const y0 = Math.floor(fv);
+    const x1 = x0 + 1 < width ? x0 + 1 : x0;
+    const y1 = y0 + 1 < height ? y0 + 1 : y0;
+    const tx = fu - x0;
+    const ty = fv - y0;
+    const a = field[y0 * width + x0];
+    const b = field[y0 * width + x1];
+    const c = field[y1 * width + x0];
+    const d = field[y1 * width + x1];
+    return a + (b - a) * tx + (c - a) * ty + (a - b - c + d) * tx * ty;
+}
+/**
+ * Euclidean-like distance in cells from every cell to the nearest cell where `source` is non-zero,
+ * by a two-pass chamfer with weights 1 and sqrt(2). Cells farther than `limit` hold `limit`.
+ */
+export function chamferDistance(source, width, height, limit = 65_535) {
+    const distance = new Float32Array(width * height);
+    for (let index = 0; index < distance.length; index += 1)
+        distance[index] = source[index] !== 0 ? 0 : limit;
+    for (let y = 0; y < height; y += 1)
+        for (let x = 0; x < width; x += 1) {
+            const index = y * width + x;
+            let best = distance[index];
+            if (best === 0)
+                continue;
+            if (x > 0)
+                best = Math.min(best, distance[index - 1] + 1);
+            if (y > 0) {
+                best = Math.min(best, distance[index - width] + 1);
+                if (x > 0)
+                    best = Math.min(best, distance[index - width - 1] + SQRT2);
+                if (x < width - 1)
+                    best = Math.min(best, distance[index - width + 1] + SQRT2);
+            }
+            distance[index] = best;
+        }
+    for (let y = height - 1; y >= 0; y -= 1)
+        for (let x = width - 1; x >= 0; x -= 1) {
+            const index = y * width + x;
+            let best = distance[index];
+            if (best === 0)
+                continue;
+            if (x < width - 1)
+                best = Math.min(best, distance[index + 1] + 1);
+            if (y < height - 1) {
+                best = Math.min(best, distance[index + width] + 1);
+                if (x < width - 1)
+                    best = Math.min(best, distance[index + width + 1] + SQRT2);
+                if (x > 0)
+                    best = Math.min(best, distance[index + width - 1] + SQRT2);
+            }
+            distance[index] = best > limit ? limit : best;
+        }
+    return distance;
+}
+/** Offsets of the eight neighbours: east, south-east, south, south-west, west, north-west, north, north-east. */
+export const NEIGHBOUR_DX = [1, 1, 0, -1, -1, -1, 0, 1];
+export const NEIGHBOUR_DY = [0, 1, 1, 1, 0, -1, -1, -1];
+export const NEIGHBOUR_LENGTH = [1, SQRT2, 1, SQRT2, 1, SQRT2, 1, SQRT2];
+/**
+ * Four-connected components of cells for which `inside` is true. Returns the per-cell component
+ * index (-1 outside any component), the component sizes and one seed cell of each.
+ */
+export function labelComponents(width, height, inside) {
+    const total = width * height;
+    const label = new Int32Array(total).fill(-1);
+    const sizes = [];
+    const seeds = [];
+    const queue = new Int32Array(total);
+    for (let start = 0; start < total; start += 1) {
+        if (label[start] !== -1 || !inside(start))
+            continue;
+        const id = sizes.length;
+        let head = 0;
+        let tail = 0;
+        queue[tail++] = start;
+        label[start] = id;
+        while (head < tail) {
+            const cell = queue[head++];
+            const x = cell % width;
+            if (x > 0 && label[cell - 1] === -1 && inside(cell - 1)) {
+                label[cell - 1] = id;
+                queue[tail++] = cell - 1;
+            }
+            if (x < width - 1 && label[cell + 1] === -1 && inside(cell + 1)) {
+                label[cell + 1] = id;
+                queue[tail++] = cell + 1;
+            }
+            if (cell >= width && label[cell - width] === -1 && inside(cell - width)) {
+                label[cell - width] = id;
+                queue[tail++] = cell - width;
+            }
+            if (cell < total - width && label[cell + width] === -1 && inside(cell + width)) {
+                label[cell + width] = id;
+                queue[tail++] = cell + width;
+            }
+        }
+        sizes.push(tail);
+        seeds.push(start);
+    }
+    return { label, sizes, seeds };
+}
+/**
+ * A packed binary min-heap of (key, id) pairs. Ties on the key are broken by the smaller id, so the
+ * pop order never depends on insertion history.
+ */
+export class MinHeap {
+    #keys;
+    #ids;
+    #length = 0;
+    /** The key of the entry returned by the last `pop`. */
+    popKey = 0;
+    constructor(capacity) {
+        this.#keys = new Float32Array(capacity);
+        this.#ids = new Int32Array(capacity);
+    }
+    get length() {
+        return this.#length;
+    }
+    clear() {
+        this.#length = 0;
+    }
+    push(key, id) {
+        if (this.#length === this.#keys.length) {
+            // Lazy-deletion searches push a cell more than once: grow instead of dropping entries.
+            const keys = new Float32Array(this.#keys.length * 2);
+            const ids = new Int32Array(this.#ids.length * 2);
+            keys.set(this.#keys);
+            ids.set(this.#ids);
+            this.#keys = keys;
+            this.#ids = ids;
+        }
+        let index = this.#length++;
+        while (index > 0) {
+            const parent = (index - 1) >>> 1;
+            const parentKey = this.#keys[parent];
+            if (!(key < parentKey || (key === parentKey && id < this.#ids[parent])))
+                break;
+            this.#keys[index] = parentKey;
+            this.#ids[index] = this.#ids[parent];
+            index = parent;
+        }
+        this.#keys[index] = key;
+        this.#ids[index] = id;
+    }
+    /** Remove and return the id of the smallest entry; `popKey` holds its key. */
+    pop() {
+        const topId = this.#ids[0];
+        this.popKey = this.#keys[0];
+        this.#length -= 1;
+        const length = this.#length;
+        if (length === 0)
+            return topId;
+        const key = this.#keys[length];
+        const id = this.#ids[length];
+        let index = 0;
+        while (index * 2 + 1 < length) {
+            let child = index * 2 + 1;
+            if (child + 1 < length) {
+                const right = this.#keys[child + 1];
+                const left = this.#keys[child];
+                if (right < left || (right === left && this.#ids[child + 1] < this.#ids[child]))
+                    child += 1;
+            }
+            const childKey = this.#keys[child];
+            if (!(childKey < key || (childKey === key && this.#ids[child] < id)))
+                break;
+            this.#keys[index] = childKey;
+            this.#ids[index] = this.#ids[child];
+            index = child;
+        }
+        this.#keys[index] = key;
+        this.#ids[index] = id;
+        return topId;
+    }
+}