openlimiter 0.1.0

package/dist/ingest.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import { MANUAL_FILE_MARKER, MANUAL_FILE_NAME } from "@openlimiter/connectors";
+import { mergeSnapshotCache, readJsonFileSafely, resolveStateDirectory } from "@openlimiter/core";
+/** Largest document accepted on standard input. */
+export const STDIN_BYTE_LIMIT = 262_144;
+/** Hard ceiling on how long a command waits for standard input. */
+export const STDIN_TIMEOUT_MILLISECONDS = 500;
+/** Largest manual document accepted from the state directory. */
+export const MANUAL_FILE_BYTE_LIMIT = 65_536;
+/**
+ * Read standard input without ever blocking a caller forever.
+ *
+ * A terminal is treated as no input at all, the stream is bounded by size, and
+ * a stream that never ends still resolves once the timeout elapses. Claude Code
+ * writes its statusline payload and closes the pipe, so the common path costs
+ * one tick rather than the full timeout.
+ */
+export async function readStandardInputText(stream = process.stdin, byteLimit = STDIN_BYTE_LIMIT, timeoutMilliseconds = STDIN_TIMEOUT_MILLISECONDS) {
+    if (stream.isTTY === true)
+        return null;
+    return await new Promise((resolve) => {
+        const chunks = [];
+        let total = 0;
+        let settled = false;
+        const collected = () => chunks.length === 0 ? null : Buffer.concat(chunks).toString("utf8");
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            stream.off("data", onData);
+            stream.off("end", onEnd);
+            stream.off("error", onError);
+            stream.pause();
+            resolve(value);
+        };
+        const onData = (chunk) => {
+            total += chunk.length;
+            if (total > byteLimit) {
+                finish(null);
+                return;
+            }
+            chunks.push(chunk);
+        };
+        const onEnd = () => finish(collected());
+        const onError = () => finish(null);
+        const timer = setTimeout(() => finish(collected()), timeoutMilliseconds);
+        stream.on("data", onData);
+        stream.on("end", onEnd);
+        stream.on("error", onError);
+        stream.resume();
+    });
+}
+/** Parse untrusted text as JSON without throwing. */
+export function parseJsonText(text) {
+    if (text === null)
+        return { ok: false };
+    const trimmed = text.trim();
+    if (trimmed === "" || trimmed.length > STDIN_BYTE_LIMIT)
+        return { ok: false };
+    try {
+        return { ok: true, value: JSON.parse(trimmed) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function manualFilePath(directory) {
+    return path.join(directory ?? resolveStateDirectory(), MANUAL_FILE_NAME);
+}
+/**
+ * Read the manual quota document from the state directory.
+ *
+ * The document is untrusted input. It is bounded by size, opened through the
+ * same descriptor first read as the cache, and handed to the manual connector
+ * for validation. A missing or unreadable file is simply no data.
+ */
+export async function readManualDocument(directory) {
+    const document = await readJsonFileSafely(manualFilePath(directory), MANUAL_FILE_BYTE_LIMIT);
+    return document.ok ? document.value : undefined;
+}
+/** Report whether a manual document is present, without reading it. */
+export async function manualFilePresent(directory) {
+    const document = await readJsonFileSafely(manualFilePath(directory), MANUAL_FILE_BYTE_LIMIT);
+    return document.ok;
+}
+/**
+ * Build the environment map a connector sees.
+ *
+ * Local facts that only the CLI can observe become explicit markers, so
+ * detection stays a pure function of the environment and doctor never claims a
+ * connector is ready when it can receive no data.
+ */
+export async function environmentWithLocalMarkers(environment, directory) {
+    const resolved = { ...environment };
+    if (await manualFilePresent(directory)) {
+        resolved[MANUAL_FILE_MARKER] = "available";
+    }
+    else {
+        delete resolved[MANUAL_FILE_MARKER];
+    }
+    return resolved;
+}
+/**
+ * Merge validated snapshots into the cache.
+ *
+ * Quota observed by one command stays visible to the next one. The read, the
+ * merge, and the write happen under one lock inside the core, so a concurrent
+ * writer cannot drop these rows.
+ */
+export async function persistSnapshots(incoming, directory) {
+    return await mergeSnapshotCache(incoming, directory ?? resolveStateDirectory());
+}
+//# sourceMappingURL=ingest.js.map

package/dist/ingest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.js","sourceRoot":"","sources":["../src/ingest.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EAGtB,MAAM,mBAAmB,CAAC;AAE3B,mDAAmD;AACnD,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC;AAExC,mEAAmE;AACnE,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAE9C,iEAAiE;AACjE,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAC;AAI7C;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,SAA4B,OAAO,CAAC,KAAK,EACzC,SAAS,GAAG,gBAAgB,EAC5B,mBAAmB,GAAG,0BAA0B;IAEhD,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACvC,OAAO,MAAM,IAAI,OAAO,CAAgB,CAAC,OAAO,EAAE,EAAE;QAClD,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,SAAS,GAAG,GAAkB,EAAE,CACpC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,CAAC,KAAoB,EAAQ,EAAE;YAC5C,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAC3B,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC7B,MAAM,CAAC,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,CAAC;QACjB,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,CAAC,KAAa,EAAQ,EAAE;YACrC,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC;YACtB,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;gBACtB,MAAM,CAAC,IAAI,CAAC,CAAC;gBACb,OAAO;YACT,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC;QACF,MAAM,KAAK,GAAG,GAAS,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QAC9C,MAAM,OAAO,GAAG,GAAS,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACzC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,EAAE,mBAAmB,CAAC,CAAC;QACzE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC1B,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACxB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC5B,MAAM,CAAC,MAAM,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,aAAa,CAAC,IAAmB;IAC/C,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;IACxC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5B,IAAI,OAAO,KAAK,EAAE,IAAI,OAAO,CAAC,MAAM,GAAG,gBAAgB;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;IAC9E,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,EAAE,CAAC;IAC7D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;IACvB,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,SAA6B;IACnD,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,qBAAqB,EAAE,EAAE,gBAAgB,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,SAA6B;IAE7B,MAAM,QAAQ,GAAG,MAAM,kBAAkB,CACvC,cAAc,CAAC,SAAS,CAAC,EACzB,sBAAsB,CACvB,CAAC;IACF,OAAO,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AAClD,CAAC;AAED,uEAAuE;AACvE,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,SAA6B;IACnE,MAAM,QAAQ,GAAG,MAAM,kBAAkB,CACvC,cAAc,CAAC,SAAS,CAAC,EACzB,sBAAsB,CACvB,CAAC;IACF,OAAO,QAAQ,CAAC,EAAE,CAAC;AACrB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,WAAyD,EACzD,SAA6B;IAE7B,MAAM,QAAQ,GAAuC,EAAE,GAAG,WAAW,EAAE,CAAC;IACxE,IAAI,MAAM,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC;QACvC,QAAQ,CAAC,kBAAkB,CAAC,GAAG,WAAW,CAAC;IAC7C,CAAC;SAAM,CAAC;QACN,OAAO,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,QAA6B,EAC7B,SAA6B;IAE7B,OAAO,MAAM,kBAAkB,CAC7B,QAAQ,EACR,SAAS,IAAI,qBAAqB,EAAE,CACrC,CAAC;AACJ,CAAC"}

package/dist/qr.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A QR encoder, written here so the package keeps its promise of zero third
+ * party runtime dependencies.
+ *
+ * It covers exactly what `openlimiter serve` needs and nothing more: byte mode,
+ * error correction level M, and versions 1 through 6. That ceiling is a real
+ * simplification rather than an arbitrary one, because version information
+ * blocks only appear from version 7 upward, so this encoder never has to write
+ * them. Version 6 carries 106 bytes, and the longest address this tool prints
+ * is around 55 characters, so the ceiling is roughly twice what it needs.
+ *
+ * The output is a square matrix of booleans. Rendering it is a separate step,
+ * so the encoder itself is pure and can be checked against the published test
+ * vectors without a terminal anywhere near it.
+ *
+ * References used: ISO/IEC 18004 tables 7, 9 and 13 for capacities, block
+ * structure and alignment centres, annex I for the worked example the tests
+ * check the Reed Solomon step against.
+ */
+/** Highest version this encoder writes. Above it, version blocks appear. */
+export declare const MAX_QR_VERSION = 6;
+/** Modules a version measures on a side. */
+export declare function qrSize(version: number): number;
+/**
+ * Reed Solomon error correction codewords for one block.
+ *
+ * Exported because it is the one step with a published test vector, which is
+ * how the tests prove the field arithmetic is right rather than merely
+ * self consistent.
+ */
+export declare function errorCorrectionCodewords(data: Uint8Array, count: number): Uint8Array;
+export interface QrMatrix {
+    readonly version: number;
+    readonly size: number;
+    readonly mask: number;
+    readonly modules: readonly (readonly boolean[])[];
+}
+/**
+ * Encode text as a QR matrix.
+ *
+ * Byte mode, error correction level M, and the mask chosen by running the four
+ * published penalty rules over all eight candidates.
+ */
+export declare function encodeQr(text: string): QrMatrix;
+export interface QrRenderOptions {
+    /**
+     * Paint each module with an explicit background colour.
+     *
+     * A scanner needs dark modules on a light field, and a terminal with a dark
+     * theme would otherwise invert the whole symbol and make it unreadable. When
+     * colour is off the symbol still renders, but only a light themed terminal
+     * will scan it.
+     */
+    color?: boolean;
+}
+/**
+ * Render a matrix as text, two module rows to every line.
+ *
+ * The upper half block character paints its top half in the foreground colour
+ * and its bottom half in the background colour, so one character carries two
+ * module rows and the symbol comes out roughly square in a terminal cell grid.
+ */
+export declare function renderQr(matrix: QrMatrix, options?: QrRenderOptions): string;
+//# sourceMappingURL=qr.d.ts.map

package/dist/qr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qr.d.ts","sourceRoot":"","sources":["../src/qr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,4EAA4E;AAC5E,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,4CAA4C;AAC5C,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9C;AAuED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,GACZ,UAAU,CAaZ;AAmVD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC;CACnD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAwB/C;AAOD,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAE,eAAoB,GAAG,MAAM,CA+BhF"}

package/dist/qr.js

@@ -0,0 +1,494 @@
+/**
+ * A QR encoder, written here so the package keeps its promise of zero third
+ * party runtime dependencies.
+ *
+ * It covers exactly what `openlimiter serve` needs and nothing more: byte mode,
+ * error correction level M, and versions 1 through 6. That ceiling is a real
+ * simplification rather than an arbitrary one, because version information
+ * blocks only appear from version 7 upward, so this encoder never has to write
+ * them. Version 6 carries 106 bytes, and the longest address this tool prints
+ * is around 55 characters, so the ceiling is roughly twice what it needs.
+ *
+ * The output is a square matrix of booleans. Rendering it is a separate step,
+ * so the encoder itself is pure and can be checked against the published test
+ * vectors without a terminal anywhere near it.
+ *
+ * References used: ISO/IEC 18004 tables 7, 9 and 13 for capacities, block
+ * structure and alignment centres, annex I for the worked example the tests
+ * check the Reed Solomon step against.
+ */
+/** Highest version this encoder writes. Above it, version blocks appear. */
+export const MAX_QR_VERSION = 6;
+/** Modules a version measures on a side. */
+export function qrSize(version) {
+    return 17 + version * 4;
+}
+/* Level M only. Every row is the published structure for that version. */
+const VERSIONS = [
+    { blocks: [16], ecPerBlock: 10, remainderBits: 0, alignment: [] },
+    { blocks: [28], ecPerBlock: 16, remainderBits: 7, alignment: [6, 18] },
+    { blocks: [44], ecPerBlock: 26, remainderBits: 7, alignment: [6, 22] },
+    { blocks: [32, 32], ecPerBlock: 18, remainderBits: 7, alignment: [6, 26] },
+    { blocks: [43, 43], ecPerBlock: 24, remainderBits: 7, alignment: [6, 30] },
+    { blocks: [27, 27, 27, 27], ecPerBlock: 16, remainderBits: 7, alignment: [6, 34] }
+];
+function specFor(version) {
+    const spec = VERSIONS[version - 1];
+    if (spec === undefined)
+        throw new Error("Unsupported QR version");
+    return spec;
+}
+function dataCodewords(spec) {
+    return spec.blocks.reduce((total, count) => total + count, 0);
+}
+/* ------------------------------------------------------------- GF(256) */
+const EXP = new Uint8Array(512);
+const LOG = new Uint8Array(256);
+{
+    let value = 1;
+    for (let i = 0; i < 255; i += 1) {
+        EXP[i] = value;
+        LOG[value] = i;
+        value <<= 1;
+        /* The primitive polynomial the QR standard fixes, x^8 + x^4 + x^3 + x^2 + 1. */
+        if (value & 0x100)
+            value ^= 0x11d;
+    }
+    for (let i = 255; i < 512; i += 1)
+        EXP[i] = EXP[i - 255] ?? 0;
+}
+function multiply(left, right) {
+    if (left === 0 || right === 0)
+        return 0;
+    return EXP[((LOG[left] ?? 0) + (LOG[right] ?? 0)) % 255] ?? 0;
+}
+/** The generator polynomial for a run of error correction codewords. */
+function generatorPolynomial(degree) {
+    let polynomial = new Uint8Array([1]);
+    for (let index = 0; index < degree; index += 1) {
+        const next = new Uint8Array(polynomial.length + 1);
+        for (let position = 0; position < polynomial.length; position += 1) {
+            const coefficient = polynomial[position] ?? 0;
+            next[position] = (next[position] ?? 0) ^ coefficient;
+            next[position + 1] =
+                (next[position + 1] ?? 0) ^ multiply(coefficient, EXP[index] ?? 0);
+        }
+        polynomial = next;
+    }
+    return polynomial;
+}
+/**
+ * Reed Solomon error correction codewords for one block.
+ *
+ * Exported because it is the one step with a published test vector, which is
+ * how the tests prove the field arithmetic is right rather than merely
+ * self consistent.
+ */
+export function errorCorrectionCodewords(data, count) {
+    const generator = generatorPolynomial(count);
+    const remainder = new Uint8Array(count);
+    for (const byte of data) {
+        const factor = byte ^ (remainder[0] ?? 0);
+        remainder.copyWithin(0, 1);
+        remainder[count - 1] = 0;
+        for (let index = 0; index < count; index += 1) {
+            remainder[index] =
+                (remainder[index] ?? 0) ^ multiply(generator[index + 1] ?? 0, factor);
+        }
+    }
+    return remainder;
+}
+/* --------------------------------------------------------------- bits */
+class BitWriter {
+    bits = [];
+    push(value, length) {
+        for (let index = length - 1; index >= 0; index -= 1) {
+            this.bits.push((value >>> index) & 1);
+        }
+    }
+    get length() {
+        return this.bits.length;
+    }
+    toBytes() {
+        const bytes = new Uint8Array(Math.ceil(this.bits.length / 8));
+        this.bits.forEach((bit, index) => {
+            if (bit === 1) {
+                const position = index >>> 3;
+                bytes[position] = (bytes[position] ?? 0) | (0x80 >>> (index & 7));
+            }
+        });
+        return bytes;
+    }
+}
+function chooseVersion(byteLength) {
+    for (let version = 1; version <= MAX_QR_VERSION; version += 1) {
+        /* Four bits of mode plus eight bits of length is exactly two codewords. */
+        if (byteLength + 2 <= dataCodewords(specFor(version)))
+            return version;
+    }
+    throw new Error("Text is too long for this QR encoder");
+}
+function buildCodewords(bytes, version) {
+    const spec = specFor(version);
+    const capacity = dataCodewords(spec);
+    const writer = new BitWriter();
+    writer.push(0b0100, 4);
+    /* Byte mode on versions 1 to 9 carries its length in eight bits. */
+    writer.push(bytes.length, 8);
+    for (const byte of bytes)
+        writer.push(byte, 8);
+    const terminator = Math.min(4, capacity * 8 - writer.length);
+    writer.push(0, terminator);
+    while (writer.length % 8 !== 0)
+        writer.push(0, 1);
+    const padded = Array.from(writer.toBytes());
+    /* The two pad codewords the standard fixes, alternating to the capacity. */
+    const pad = [0xec, 0x11];
+    const filled = padded.length;
+    while (padded.length < capacity) {
+        padded.push(pad[(padded.length - filled) % 2] ?? 0xec);
+    }
+    return Uint8Array.from(padded);
+}
+/** Split into blocks, add error correction, and interleave as the standard says. */
+function interleave(codewords, version) {
+    const spec = specFor(version);
+    const dataBlocks = [];
+    const ecBlocks = [];
+    let offset = 0;
+    for (const size of spec.blocks) {
+        const block = codewords.slice(offset, offset + size);
+        offset += size;
+        dataBlocks.push(block);
+        ecBlocks.push(errorCorrectionCodewords(block, spec.ecPerBlock));
+    }
+    const result = [];
+    const longest = Math.max(...spec.blocks);
+    for (let index = 0; index < longest; index += 1) {
+        for (const block of dataBlocks) {
+            const byte = block[index];
+            if (byte !== undefined)
+                result.push(byte);
+        }
+    }
+    for (let index = 0; index < spec.ecPerBlock; index += 1) {
+        for (const block of ecBlocks) {
+            const byte = block[index];
+            if (byte !== undefined)
+                result.push(byte);
+        }
+    }
+    return Uint8Array.from(result);
+}
+function emptyGrid(size) {
+    return Array.from({ length: size }, () => new Int8Array(size).fill(-1));
+}
+function place(grid, row, column, dark) {
+    const line = grid[row];
+    if (line === undefined)
+        return;
+    line[column] = dark ? 1 : 0;
+}
+function at(grid, row, column) {
+    return grid[row]?.[column] ?? -1;
+}
+function drawFinder(grid, row, column) {
+    for (let y = -1; y <= 7; y += 1) {
+        for (let x = -1; x <= 7; x += 1) {
+            const targetRow = row + y;
+            const targetColumn = column + x;
+            if (targetRow < 0 ||
+                targetColumn < 0 ||
+                targetRow >= grid.length ||
+                targetColumn >= grid.length)
+                continue;
+            const onRing = (y >= 0 && y <= 6 && (x === 0 || x === 6)) ||
+                (x >= 0 && x <= 6 && (y === 0 || y === 6));
+            const inCore = y >= 2 && y <= 4 && x >= 2 && x <= 4;
+            place(grid, targetRow, targetColumn, onRing || inCore);
+        }
+    }
+}
+function drawAlignment(grid, row, column) {
+    for (let y = -2; y <= 2; y += 1) {
+        for (let x = -2; x <= 2; x += 1) {
+            const ring = Math.max(Math.abs(x), Math.abs(y));
+            place(grid, row + y, column + x, ring !== 1);
+        }
+    }
+}
+function drawFunctionPatterns(grid, version) {
+    const size = grid.length;
+    drawFinder(grid, 0, 0);
+    drawFinder(grid, 0, size - 7);
+    drawFinder(grid, size - 7, 0);
+    for (let index = 8; index < size - 8; index += 1) {
+        const dark = index % 2 === 0;
+        place(grid, 6, index, dark);
+        place(grid, index, 6, dark);
+    }
+    /*
+     * One list of centres covers both axes, so every pair is a candidate. The
+     * three pairs that would land on a finder are the only ones skipped.
+     */
+    const centres = specFor(version).alignment;
+    for (const row of centres) {
+        for (const column of centres) {
+            const onFinder = (row === 6 && column === 6) ||
+                (row === 6 && column === size - 7) ||
+                (row === size - 7 && column === 6);
+            if (!onFinder)
+                drawAlignment(grid, row, column);
+        }
+    }
+    /* The dark module, fixed by the standard, and always dark. */
+    place(grid, size - 8, 8, true);
+    /* Reserve the format areas so data placement steps over them. */
+    for (let index = 0; index <= 8; index += 1) {
+        if (at(grid, 8, index) === -1)
+            place(grid, 8, index, false);
+        if (at(grid, index, 8) === -1)
+            place(grid, index, 8, false);
+    }
+    for (let index = 0; index < 8; index += 1) {
+        if (at(grid, 8, size - 1 - index) === -1)
+            place(grid, 8, size - 1 - index, false);
+        if (at(grid, size - 1 - index, 8) === -1)
+            place(grid, size - 1 - index, 8, false);
+    }
+}
+function functionMask(version) {
+    const size = qrSize(version);
+    const grid = emptyGrid(size);
+    drawFunctionPatterns(grid, version);
+    return Array.from({ length: size }, (_unused, row) => Array.from({ length: size }, (_ignored, column) => at(grid, row, column) !== -1));
+}
+/**
+ * Walk the symbol in the published order and drop the codeword bits in.
+ *
+ * The walk is two modules wide, starts at the bottom right, and alternates
+ * direction on every pair of columns. Column six carries the vertical timing
+ * pattern, so the pair that would straddle it shifts one column left and every
+ * later pair follows from there. Modules left over once the bits run out stay
+ * light, which is exactly what the remainder bits are.
+ */
+function placeData(grid, reserved, bits) {
+    const size = grid.length;
+    let bitIndex = 0;
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right = 5;
+        for (let step = 0; step < size; step += 1) {
+            for (let offset = 0; offset < 2; offset += 1) {
+                const column = right - offset;
+                const upward = ((right + 1) & 2) === 0;
+                const row = upward ? size - 1 - step : step;
+                if (reserved[row]?.[column] === true)
+                    continue;
+                let dark = false;
+                if (bitIndex < bits.length * 8) {
+                    const byte = bits[bitIndex >>> 3] ?? 0;
+                    dark = ((byte >>> (7 - (bitIndex & 7))) & 1) === 1;
+                }
+                bitIndex += 1;
+                place(grid, row, column, dark);
+            }
+        }
+    }
+}
+const MASKS = [
+    (row, column) => (row + column) % 2 === 0,
+    (row) => row % 2 === 0,
+    (_row, column) => column % 3 === 0,
+    (row, column) => (row + column) % 3 === 0,
+    (row, column) => (Math.floor(row / 2) + Math.floor(column / 3)) % 2 === 0,
+    (row, column) => ((row * column) % 2) + ((row * column) % 3) === 0,
+    (row, column) => (((row * column) % 2) + ((row * column) % 3)) % 2 === 0,
+    (row, column) => (((row + column) % 2) + ((row * column) % 3)) % 2 === 0
+];
+function applyMask(grid, reserved, mask) {
+    const rule = MASKS[mask];
+    if (rule === undefined)
+        throw new Error("Unknown mask");
+    const size = grid.length;
+    return Array.from({ length: size }, (_unused, row) => Array.from({ length: size }, (_ignored, column) => {
+        const value = at(grid, row, column) === 1;
+        if (reserved[row]?.[column] === true)
+            return value;
+        return rule(row, column) ? !value : value;
+    }));
+}
+function runPenalty(line) {
+    let penalty = 0;
+    let run = 1;
+    for (let index = 1; index < line.length; index += 1) {
+        if (line[index] === line[index - 1]) {
+            run += 1;
+            continue;
+        }
+        if (run >= 5)
+            penalty += 3 + (run - 5);
+        run = 1;
+    }
+    if (run >= 5)
+        penalty += 3 + (run - 5);
+    return penalty;
+}
+const FINDER_LIKE = [true, false, true, true, true, false, true, false, false, false, false];
+function finderPenalty(line) {
+    let penalty = 0;
+    for (let index = 0; index + 11 <= line.length; index += 1) {
+        const forward = FINDER_LIKE.every((value, offset) => line[index + offset] === value);
+        const backward = FINDER_LIKE.every((value, offset) => line[index + 10 - offset] === value);
+        if (forward || backward)
+            penalty += 40;
+    }
+    return penalty;
+}
+function penalty(modules) {
+    const size = modules.length;
+    let total = 0;
+    let dark = 0;
+    const columns = Array.from({ length: size }, () => []);
+    for (let row = 0; row < size; row += 1) {
+        const line = modules[row] ?? [];
+        total += runPenalty(line);
+        total += finderPenalty(line);
+        for (let column = 0; column < size; column += 1) {
+            const value = line[column] === true;
+            columns[column]?.push(value);
+            if (value)
+                dark += 1;
+            if (row > 0 && column > 0) {
+                const up = modules[row - 1]?.[column] === true;
+                const left = line[column - 1] === true;
+                const upLeft = modules[row - 1]?.[column - 1] === true;
+                if (value === up && value === left && value === upLeft)
+                    total += 3;
+            }
+        }
+    }
+    for (const column of columns) {
+        total += runPenalty(column);
+        total += finderPenalty(column);
+    }
+    const ratio = (dark * 100) / (size * size);
+    total += Math.floor(Math.abs(ratio - 50) / 5) * 10;
+    return total;
+}
+/** Fifteen bits of format information, error correction level M. */
+function formatBits(mask) {
+    /* Level M is 00, and the three mask bits follow it. */
+    const data = mask;
+    let remainder = data << 10;
+    for (let bit = 14; bit >= 10; bit -= 1) {
+        if ((remainder >>> bit) & 1)
+            remainder ^= 0x537 << (bit - 10);
+    }
+    return ((data << 10) | remainder) ^ 0x5412;
+}
+/**
+ * Write the fifteen format bits into both of the places they live.
+ *
+ * The first copy wraps the top left finder, the second is split between the
+ * strip under the top right finder and the strip beside the bottom left one.
+ * The dark module is rewritten last, because it sits inside the second copy's
+ * run and is fixed by the standard whatever the bits say.
+ */
+function writeFormat(modules, mask) {
+    const size = modules.length;
+    const bits = formatBits(mask);
+    const dark = (index) => ((bits >>> index) & 1) === 1;
+    const set = (row, column, value) => {
+        const line = modules[row];
+        if (line !== undefined)
+            line[column] = value;
+    };
+    for (let index = 0; index <= 5; index += 1)
+        set(index, 8, dark(index));
+    set(7, 8, dark(6));
+    set(8, 8, dark(7));
+    set(8, 7, dark(8));
+    for (let index = 9; index <= 14; index += 1)
+        set(8, 14 - index, dark(index));
+    for (let index = 0; index <= 7; index += 1)
+        set(8, size - 1 - index, dark(index));
+    for (let index = 8; index <= 14; index += 1)
+        set(size - 15 + index, 8, dark(index));
+    set(size - 8, 8, true);
+}
+/**
+ * Encode text as a QR matrix.
+ *
+ * Byte mode, error correction level M, and the mask chosen by running the four
+ * published penalty rules over all eight candidates.
+ */
+export function encodeQr(text) {
+    const bytes = new TextEncoder().encode(text);
+    const version = chooseVersion(bytes.length);
+    const codewords = interleave(buildCodewords(bytes, version), version);
+    const reserved = functionMask(version);
+    const grid = emptyGrid(qrSize(version));
+    drawFunctionPatterns(grid, version);
+    placeData(grid, reserved, codewords);
+    let best = null;
+    let bestMask = 0;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (let mask = 0; mask < MASKS.length; mask += 1) {
+        const candidate = applyMask(grid, reserved, mask);
+        writeFormat(candidate, mask);
+        const score = penalty(candidate);
+        if (score < bestScore) {
+            bestScore = score;
+            best = candidate;
+            bestMask = mask;
+        }
+    }
+    if (best === null)
+        throw new Error("No mask could be chosen");
+    return { version, size: qrSize(version), mask: bestMask, modules: best };
+}
+/* ------------------------------------------------------------ rendering */
+/** Modules of light margin around the symbol. Four is the published minimum. */
+const QUIET_ZONE = 4;
+/**
+ * Render a matrix as text, two module rows to every line.
+ *
+ * The upper half block character paints its top half in the foreground colour
+ * and its bottom half in the background colour, so one character carries two
+ * module rows and the symbol comes out roughly square in a terminal cell grid.
+ */
+export function renderQr(matrix, options = {}) {
+    const color = options.color ?? false;
+    const span = matrix.size + QUIET_ZONE * 2;
+    const dark = (row, column) => {
+        const y = row - QUIET_ZONE;
+        const x = column - QUIET_ZONE;
+        if (y < 0 || x < 0 || y >= matrix.size || x >= matrix.size)
+            return false;
+        return matrix.modules[y]?.[x] === true;
+    };
+    const lines = [];
+    for (let row = 0; row < span; row += 2) {
+        let line = "";
+        let previous = "";
+        for (let column = 0; column < span; column += 1) {
+            const top = dark(row, column);
+            const bottom = row + 1 < span ? dark(row + 1, column) : false;
+            if (!color) {
+                line += top && bottom ? "█" : top ? "▀" : bottom ? "▄" : " ";
+                continue;
+            }
+            /* Black on bright white, stated explicitly so the theme cannot invert it. */
+            const codes = (top ? "30" : "97") + ";" + (bottom ? "40" : "107");
+            if (codes !== previous) {
+                line += "\u001b[" + codes + "m";
+                previous = codes;
+            }
+            line += "▀";
+        }
+        lines.push(color ? line + "\u001b[0m" : line);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=qr.js.map