uomtiles 0.1.0

package/dist/src/fetcher.js

@@ -0,0 +1,208 @@
+import { Pool } from 'undici';
+import { DEFAULTS, UOM_BASE } from "./config.js";
+export class AdaptiveController {
+    qps;
+    inflightCap;
+    inflightNow = 0;
+    waiters = [];
+    lastTokenAt = Date.now();
+    tokens;
+    rateLimitedUntil = 0;
+    lastEvalAt = 0;
+    samples = [];
+    log = [];
+    constructor(initialQps) {
+        this.qps = Math.max(DEFAULTS.qpsMin, Math.min(DEFAULTS.qpsMax, initialQps));
+        this.tokens = this.qps;
+        this.inflightCap = Math.max(DEFAULTS.ctlInflightMin, Math.min(DEFAULTS.ctlInflightMax, this.qps));
+    }
+    get currentQps() { return this.qps; }
+    get currentInflightCap() { return this.inflightCap; }
+    get currentInflight() { return this.inflightNow; }
+    /** Refill token bucket based on elapsed time. */
+    refill() {
+        const now = Date.now();
+        const dt = (now - this.lastTokenAt) / 1000;
+        this.lastTokenAt = now;
+        this.tokens = Math.min(this.qps, this.tokens + dt * this.qps);
+    }
+    /** Try to wake waiters. */
+    pump() {
+        this.refill();
+        const now = Date.now();
+        while (this.waiters.length > 0 && now >= this.rateLimitedUntil && this.tokens >= 1 && this.inflightNow < this.inflightCap) {
+            const waiter = this.waiters.shift();
+            if (waiter.signal?.aborted)
+                continue;
+            this.tokens -= 1;
+            this.inflightNow += 1;
+            if (waiter.onAbort)
+                waiter.signal?.removeEventListener('abort', waiter.onAbort);
+            waiter.resolve();
+        }
+    }
+    /** Block until one token + inflight slot is available. */
+    async acquire(signal) {
+        if (signal?.aborted)
+            throw signal.reason instanceof Error ? signal.reason : new Error('request aborted');
+        return new Promise((resolve, reject) => {
+            const waiter = { resolve, reject, signal };
+            waiter.onAbort = () => {
+                const index = this.waiters.indexOf(waiter);
+                if (index >= 0)
+                    this.waiters.splice(index, 1);
+                reject(signal?.reason instanceof Error ? signal.reason : new Error('request aborted'));
+            };
+            signal?.addEventListener('abort', waiter.onAbort, { once: true });
+            this.waiters.push(waiter);
+            this.pump();
+            if (!this.waiters.includes(waiter))
+                return;
+            const tick = () => {
+                if (!this.waiters.includes(waiter))
+                    return;
+                this.pump();
+                if (!this.waiters.includes(waiter))
+                    return;
+                setTimeout(tick, 25);
+            };
+            setTimeout(tick, 25);
+        });
+    }
+    /** Must be called for every acquired slot (in finally). */
+    release() {
+        this.inflightNow = Math.max(0, this.inflightNow - 1);
+        this.pump();
+    }
+    record(outcome, latencyMs) {
+        const now = Date.now();
+        this.samples.push({ at: now, outcome, latencyMs });
+        if (this.samples.length > DEFAULTS.ctlWindowSize)
+            this.samples.shift();
+        this.maybeEvaluate(now);
+    }
+    maybeEvaluate(now) {
+        if (now - this.lastEvalAt < DEFAULTS.ctlMinIntervalMs)
+            return;
+        if (this.samples.length < Math.min(50, DEFAULTS.ctlWindowSize / 4))
+            return;
+        this.lastEvalAt = now;
+        const total = this.samples.length;
+        let ok = 0, rl = 0, sf = 0;
+        const lats = [];
+        for (const s of this.samples) {
+            if (s.outcome === 'ok') {
+                ok++;
+                lats.push(s.latencyMs);
+            }
+            else if (s.outcome === 'rate_limit')
+                rl++;
+            else
+                sf++;
+        }
+        const okRate = ok / total;
+        const sfRate = sf / total;
+        lats.sort((a, b) => a - b);
+        const p95 = lats.length ? lats[Math.min(lats.length - 1, Math.floor(lats.length * 0.95))] : 0;
+        const oldQps = this.qps;
+        const oldInflight = this.inflightCap;
+        let verdict = 'hold';
+        let reason = `ok=${(okRate * 100).toFixed(1)}% sf=${(sfRate * 100).toFixed(1)}% rl=${rl} p95=${p95.toFixed(0)}ms`;
+        if (rl > 0) {
+            this.qps = Math.max(DEFAULTS.qpsMin, Math.floor(this.qps * DEFAULTS.ctlRateLimitFactor));
+            this.inflightCap = Math.max(DEFAULTS.ctlInflightMin, Math.floor(this.inflightCap * DEFAULTS.ctlRateLimitFactor));
+            this.rateLimitedUntil = now + 5_000;
+            verdict = 'decrease(rate_limit)';
+        }
+        else if (sfRate > 0.10) {
+            // 10% soft-fail tolerance — saturated connection pool flakes briefly
+            // when we hit the real ceiling; 5% was too jumpy and caused oscillation.
+            this.qps = Math.max(DEFAULTS.qpsMin, Math.floor(this.qps * DEFAULTS.ctlSoftBackoffFactor));
+            this.inflightCap = Math.max(DEFAULTS.ctlInflightMin, Math.floor(this.inflightCap * DEFAULTS.ctlSoftBackoffFactor));
+            verdict = 'decrease(soft_fail)';
+        }
+        else if (p95 > DEFAULTS.ctlTargetP95Ms * DEFAULTS.ctlP95Tolerance) {
+            this.qps = Math.max(DEFAULTS.qpsMin, Math.floor(this.qps * DEFAULTS.ctlSoftBackoffFactor));
+            this.inflightCap = Math.max(DEFAULTS.ctlInflightMin, Math.floor(this.inflightCap * DEFAULTS.ctlSoftBackoffFactor));
+            verdict = 'decrease(p95)';
+        }
+        else if (okRate >= 0.98 && p95 < DEFAULTS.ctlTargetP95Ms) {
+            this.qps = Math.min(DEFAULTS.qpsMax, Math.max(this.qps + 1, Math.round(this.qps * DEFAULTS.ctlIncFactor)));
+            this.inflightCap = Math.min(DEFAULTS.ctlInflightMax, Math.max(this.inflightCap + 1, Math.round(this.inflightCap * DEFAULTS.ctlIncFactor)));
+            verdict = 'increase';
+        }
+        if (this.qps !== oldQps || this.inflightCap !== oldInflight) {
+            this.tokens = Math.min(this.tokens, this.qps);
+            this.log.push({ at: now, qps: this.qps, inflightCap: this.inflightCap, verdict, reason });
+            const keep = Math.floor(this.samples.length / 2);
+            this.samples.splice(0, this.samples.length - keep);
+            console.log(`[ctl] ${verdict} qps ${oldQps}->${this.qps} inflight ${oldInflight}->${this.inflightCap} ${reason}`);
+        }
+    }
+}
+export class UomFetcher {
+    pool;
+    ctl;
+    total = 0;
+    ok = 0;
+    rateLimited = 0;
+    netErr = 0;
+    constructor(qpsStart = DEFAULTS.qpsStart) {
+        this.pool = new Pool(UOM_BASE, {
+            connections: DEFAULTS.ctlConnectionsMax,
+            pipelining: 1,
+            keepAliveTimeout: 30_000,
+            keepAliveMaxTimeout: 60_000,
+        });
+        this.ctl = new AdaptiveController(qpsStart);
+    }
+    async get(pathWithQuery, opts = {}) {
+        await this.ctl.acquire(opts.signal);
+        const start = Date.now();
+        this.total++;
+        let status = 0;
+        let contentType = null;
+        let body = Buffer.alloc(0);
+        let errMessage;
+        let outcome = 'soft_fail';
+        try {
+            const timeout = AbortSignal.timeout(opts.timeoutMs ?? DEFAULTS.perLayerTimeoutMs);
+            const signal = opts.signal ? AbortSignal.any([timeout, opts.signal]) : timeout;
+            const r = await this.pool.request({
+                path: pathWithQuery,
+                method: 'GET',
+                signal,
+                headers: opts.headers,
+            });
+            const chunks = [];
+            for await (const c of r.body)
+                chunks.push(c);
+            body = Buffer.concat(chunks);
+            status = r.statusCode;
+            contentType = r.headers['content-type'] ?? null;
+            if (status === 429 || status === 503) {
+                this.rateLimited++;
+                outcome = 'rate_limit';
+            }
+            else if (status >= 200 && status < 400 && body.length > 0) {
+                this.ok++;
+                outcome = 'ok';
+            }
+            else {
+                outcome = 'soft_fail';
+            }
+        }
+        catch (e) {
+            this.netErr++;
+            errMessage = e?.message ?? String(e);
+            outcome = 'soft_fail';
+        }
+        const latencyMs = Date.now() - start;
+        this.ctl.record(outcome, latencyMs);
+        this.ctl.release();
+        return { status, contentType, body, errMessage, latencyMs };
+    }
+    async close() {
+        await this.pool.close();
+    }
+}

package/dist/src/geographic-grid.js

@@ -0,0 +1,162 @@
+export const GEOGRAPHIC_GRID_LEVEL = 18;
+export const GEOGRAPHIC_GRID_STEP = 360 / 2 ** GEOGRAPHIC_GRID_LEVEL;
+export function mercatorLatitude(globalY, worldSize) {
+    return 180 / Math.PI * Math.atan(Math.sinh(Math.PI - 2 * Math.PI * globalY / worldSize));
+}
+export function mercatorY(latitude, worldSize) {
+    const radians = latitude * Math.PI / 180;
+    return worldSize * (1 - Math.log(Math.tan(radians) + 1 / Math.cos(radians)) / Math.PI) / 2;
+}
+export function geographicGridLines(extent) {
+    const childrenPerSide = 2 ** (extent.sourceZ - extent.parentZ);
+    const worldSize = 256 * 2 ** extent.sourceZ;
+    const globalX0 = extent.parentX * childrenPerSide * 256;
+    const globalY0 = extent.parentY * childrenPerSide * 256;
+    const xPitch = worldSize / 2 ** GEOGRAPHIC_GRID_LEVEL;
+    const xLines = [];
+    for (let x = Math.floor(globalX0 / xPitch) * xPitch; x <= globalX0 + extent.width; x += xPitch) {
+        xLines.push(x - globalX0);
+    }
+    const latitudeTop = mercatorLatitude(globalY0, worldSize);
+    const latitudeBottom = mercatorLatitude(globalY0 + extent.width, worldSize);
+    const yLines = [];
+    for (let k = Math.ceil(latitudeTop / GEOGRAPHIC_GRID_STEP); k >= Math.floor(latitudeBottom / GEOGRAPHIC_GRID_STEP); k--) {
+        const y = mercatorY(k * GEOGRAPHIC_GRID_STEP, worldSize) - globalY0;
+        if (y >= -8 && y <= extent.width + 8)
+            yLines.push(y);
+    }
+    yLines.sort((a, b) => a - b);
+    return { xLines, yLines };
+}
+export function vectorizeGeographicGrid(mask, extent) {
+    if (mask.length !== extent.width * extent.width) {
+        throw new RangeError(`mask length ${mask.length} does not match ${extent.width}x${extent.width}`);
+    }
+    const { xLines, yLines } = geographicGridLines(extent);
+    const rows = yLines.length - 1;
+    const columns = xLines.length - 1;
+    const cells = new Uint8Array(rows * columns);
+    for (let row = 0; row < rows; row++)
+        for (let column = 0; column < columns; column++) {
+            const clippedX0 = Math.max(0, xLines[column]);
+            const clippedX1 = Math.min(extent.width, xLines[column + 1]);
+            const clippedY0 = Math.max(0, yLines[row]);
+            const clippedY1 = Math.min(extent.width, yLines[row + 1]);
+            if (clippedX0 >= clippedX1 || clippedY0 >= clippedY1)
+                continue;
+            const x = Math.min(extent.width - 1, Math.floor((clippedX0 + clippedX1) / 2));
+            const y = Math.min(extent.width - 1, Math.floor((clippedY0 + clippedY1) / 2));
+            if (mask[y * extent.width + x]) {
+                cells[row * columns + column] = 1;
+            }
+        }
+    const active = new Map();
+    const rects = [];
+    for (let row = 0; row < rows; row++) {
+        const runs = [];
+        let column = 0;
+        while (column < columns) {
+            if (!cells[row * columns + column]) {
+                column++;
+                continue;
+            }
+            const column0 = column;
+            while (column < columns && cells[row * columns + column])
+                column++;
+            runs.push([column0, column]);
+        }
+        const next = new Map();
+        for (const [col0, col1] of runs) {
+            const key = `${col0}:${col1}`;
+            const previous = active.get(key);
+            if (previous && previous.row1 === row) {
+                previous.row1 = row + 1;
+                next.set(key, previous);
+            }
+            else {
+                next.set(key, { col0, row0: row, col1, row1: row + 1 });
+            }
+        }
+        for (const [key, rect] of active)
+            if (!next.has(key))
+                rects.push(rect);
+        active.clear();
+        for (const [key, rect] of next)
+            active.set(key, rect);
+    }
+    for (const rect of active.values())
+        rects.push(rect);
+    return { rects, xLines, yLines };
+}
+export function renderGeographicGrid(model, sourceWidth, targetWidth) {
+    const scale = targetWidth / sourceWidth;
+    const output = new Uint8Array(targetWidth * targetWidth);
+    for (const rect of model.rects) {
+        const x0 = Math.max(0, Math.round(model.xLines[rect.col0] * scale));
+        const y0 = Math.max(0, Math.round(model.yLines[rect.row0] * scale));
+        const x1 = Math.min(targetWidth, Math.round(model.xLines[rect.col1] * scale));
+        const y1 = Math.min(targetWidth, Math.round(model.yLines[rect.row1] * scale));
+        for (let y = y0; y < y1; y++)
+            output.fill(1, y * targetWidth + x0, y * targetWidth + x1);
+    }
+    return output;
+}
+export function renderGeographicGridTile(model, extent, targetZ, tileX, tileY) {
+    if (targetZ < extent.parentZ)
+        throw new RangeError('target tile must not be below the grid root zoom');
+    const rootScale = 2 ** (targetZ - extent.parentZ);
+    if (Math.floor(tileX / rootScale) !== extent.parentX || Math.floor(tileY / rootScale) !== extent.parentY) {
+        return new Uint8Array(256 * 256);
+    }
+    const scale = 2 ** (targetZ - extent.sourceZ);
+    const sourceRootSize = 256 * 2 ** (extent.sourceZ - extent.parentZ);
+    const sourceX0 = extent.parentX * sourceRootSize;
+    const sourceY0 = extent.parentY * sourceRootSize;
+    const tileX0 = tileX * 256;
+    const tileY0 = tileY * 256;
+    const output = new Uint8Array(256 * 256);
+    for (const rect of model.rects) {
+        const x0 = Math.max(0, Math.round((sourceX0 + model.xLines[rect.col0]) * scale) - tileX0);
+        const y0 = Math.max(0, Math.round((sourceY0 + model.yLines[rect.row0]) * scale) - tileY0);
+        const x1 = Math.min(256, Math.round((sourceX0 + model.xLines[rect.col1]) * scale) - tileX0);
+        const y1 = Math.min(256, Math.round((sourceY0 + model.yLines[rect.row1]) * scale) - tileY0);
+        if (x0 >= x1 || y0 >= y1)
+            continue;
+        for (let y = y0; y < y1; y++)
+            output.fill(1, y * 256 + x0, y * 256 + x1);
+    }
+    return output;
+}
+export function differenceStats(generated, official) {
+    if (generated.length !== official.length)
+        throw new RangeError('masks must have equal lengths');
+    let diff = 0;
+    let generatedOnly = 0;
+    let officialOnly = 0;
+    for (let i = 0; i < generated.length; i++)
+        if (generated[i] !== official[i]) {
+            diff++;
+            if (generated[i])
+                generatedOnly++;
+            else
+                officialOnly++;
+        }
+    return { diff, generatedOnly, officialOnly, rate: diff / generated.length };
+}
+export function auditGridAlignedEdges(mask, width, height, xLines, yLines) {
+    if (mask.length !== width * height)
+        throw new RangeError(`mask length ${mask.length} does not match ${width}x${height}`);
+    const allowedX = new Set(xLines);
+    const allowedY = new Set(yLines);
+    let offGridVerticalTransitions = 0;
+    let offGridHorizontalTransitions = 0;
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            const index = y * width + x;
+            if (x > 0 && mask[index] !== mask[index - 1] && !allowedX.has(x))
+                offGridVerticalTransitions++;
+            if (y > 0 && mask[index] !== mask[index - width] && !allowedY.has(y))
+                offGridHorizontalTransitions++;
+        }
+    return { offGridVerticalTransitions, offGridHorizontalTransitions };
+}