pendingyou 0.8.0 → 0.10.0

package/dist/mod.js

@@ -0,0 +1,87 @@
+// The wake mod (0.10.0, guide 2.24): the Pending You plugin's mod, which this package carries in mod/ for Claude Code
+// set up with `npx pendingyou init` and no plugin. Claude Code 2.1.287 and later load it from CLAUDE_CODE_PLUGIN_DIRS
+// (`env` in ~/.claude/settings.json). Every session then learns the cards it posts, checks them through its own
+// Pending You connection, and is woken when the person answers, with no hold running; a hold an agent still starts is
+// answered by the mod. `init` adds the copy inside the hooks' private copy (install.ts), keeping every other entry and
+// replacing an older version's; `uninstall` takes it out; `status` says whether it's there. With the Pending You plugin
+// installed too, the two copies agree that one acts.
+import { join } from 'node:path';
+/** The first Claude Code that loads mods. */
+export const MOD_CLAUDE = '2.1.287';
+/** Where Claude Code finds plugin folders to load as --plugin-dir does. */
+export const PLUGIN_DIRS = 'CLAUDE_CODE_PLUGIN_DIRS';
+/** The Pending You plugins, which carry the same mod: production's, and staging's for our own testing. */
+export const PLUGINS_WITH_MOD = ['pending-you@pendingyou', 'pending-you-staging@pendingyou-staging'];
+/** The mod in a copy of this package (its folder in node_modules). */
+export const modDir = (packageRoot) => join(packageRoot, 'mod');
+/** Claude Code's version from `claude --version` ("2.1.289 (Claude Code)"); null when it can't be read. */
+export function claudeVersion(output) {
+    return /^\s*(\d+\.\d+\.\d+)\b/.exec(output)?.[1] ?? null;
+}
+/** Whether that Claude Code loads mods (2.1.287 or later). */
+export function loadsMods(version) {
+    const have = version.split('.').map(Number);
+    const want = MOD_CLAUDE.split('.').map(Number);
+    for (let index = 0; index < want.length; index++) {
+        const a = have[index] ?? 0;
+        const b = want[index] ?? 0;
+        if (a !== b)
+            return a > b;
+    }
+    return true;
+}
+/** Whether a CLAUDE_CODE_PLUGIN_DIRS entry is a copy of this mod, from any version of this package. */
+export const isOurModDir = (entry) => /(^|[\\/])node_modules[\\/]pendingyou[\\/]mod[\\/]?$/.test(entry.trim());
+/** What Claude Code splits CLAUDE_CODE_PLUGIN_DIRS on. */
+export const separatorFor = (platform) => (platform === 'win32' ? ';' : ':');
+const objectAt = (parent, key) => {
+    const value = parent[key];
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+};
+/** The entries of CLAUDE_CODE_PLUGIN_DIRS in settings' `env`; null when it's there but isn't text. */
+export function pluginDirs(settings, separator) {
+    const env = objectAt(settings, 'env');
+    if (settings.env !== undefined && env === null)
+        return null;
+    const value = env?.[PLUGIN_DIRS];
+    if (value === undefined)
+        return [];
+    if (typeof value !== 'string')
+        return null;
+    return value.split(separator).filter((entry) => entry.trim() !== '');
+}
+/**
+ * Settings with the mod at `dir` in CLAUDE_CODE_PLUGIN_DIRS, or with none of ours when `dir` is null: every other entry
+ * kept as it was, in its place, and any copy of ours (an older version's) replaced. `changed` is false when there was
+ * nothing to do; `invalid` says why the settings were left alone.
+ */
+export function withModDir(settings, dir, separator) {
+    const entries = pluginDirs(settings, separator);
+    if (entries === null)
+        return {
+            invalid: `Claude Code’s settings have an “env” or ${PLUGIN_DIRS} that I can’t read, so I left them alone.`,
+        };
+    if (dir?.includes(separator))
+        return { invalid: `The wake mod’s folder has a “${separator}” in its path: ${dir}` };
+    const wanted = [...entries.filter((entry) => !isOurModDir(entry)), ...(dir ? [dir] : [])];
+    if (wanted.join(separator) === entries.join(separator))
+        return { settings, changed: false };
+    const next = structuredClone(settings);
+    const env = objectAt(next, 'env') ?? {};
+    if (wanted.length)
+        env[PLUGIN_DIRS] = wanted.join(separator);
+    else
+        delete env[PLUGIN_DIRS];
+    if (Object.keys(env).length)
+        next.env = env;
+    else
+        delete next.env;
+    return { settings: next, changed: true };
+}
+/** Whether settings enable a Pending You plugin, which carries the mod itself. */
+export function pluginEnabled(settings) {
+    const enabled = objectAt(settings, 'enabledPlugins');
+    return PLUGINS_WITH_MOD.some((id) => enabled?.[id] === true);
+}

package/dist/oauth.js

@@ -3,11 +3,14 @@
 // consent page with PKCE (S256), and hears the code back on a one-time loopback address (127.0.0.1, any free port).
 // The consent page recognises the command line by that name and the loopback address, and gives it a grant that only
 // hears answers to your Claude Code assistants' questions: it isn't an assistant, and can't ask or answer anything.
+// On a computer with no browser it signs in with a code instead (RFC 8628, signInWithDevice), and there `init` asks
+// for more: a Claude Code connection of this computer's own, whose token Claude Code's MCP server uses too (remote.ts).
 //
 // Access tokens last 15 minutes and refresh on their own; refresh tokens rotate on every use. Nothing here prints or
 // logs a token, a code or a verifier.
 import { createHash, randomBytes } from 'node:crypto';
 import { createServer } from 'node:http';
+import { qrLines } from "./qr.js";
 import { VERSION } from "./version.js";
 /** The name the consent page knows the command line by (apps/pendingyou/worker/oauth/authorize.ts). */
 export const CLIENT_NAME = 'Pending You CLI';
@@ -237,18 +240,31 @@ export async function revoke(io, origin, clientId, refreshToken) {
     }
 }
 /**
- * Device sign-in (RFC 8628) for a computer with no browser: shows a short code and where to enter it, then polls until
- * the person presses Allow on their phone (or Cancel, or the code runs out).
+ * Device sign-in (RFC 8628) for a computer with no browser: shows a short code, where to enter it and, at a terminal, a
+ * QR code that opens that page with the code filled in; then polls until the person presses Allow on their phone (or
+ * Cancel, or the code runs out).
  */
 export async function signInWithDevice(io, options) {
     const metadata = await discover(io, options.origin);
-    const clientId = await register(io, metadata);
-    const started = await io.fetch(`${options.origin}/oauth/device`, {
+    const begin = (client) => io.fetch(`${options.origin}/oauth/device`, {
         method: 'POST',
         headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
-        body: new URLSearchParams({ client_id: clientId, scope: SCOPE }).toString(),
+        body: new URLSearchParams({
+            client_id: client,
+            scope: SCOPE,
+            ...(options.machine ? { machine: options.machine } : {}),
+            ...(options.connection ? { assistant: 'claude-code' } : {}),
+        }).toString(),
         signal: AbortSignal.timeout(15_000),
     });
+    let clientId = options.clientId || (await register(io, metadata));
+    let started = await begin(clientId);
+    if (started.status === 401 && options.clientId) {
+        // Pending You no longer knows that client (a registration lapses after 90 days unused): register again.
+        await started.body?.cancel();
+        clientId = await register(io, metadata);
+        started = await begin(clientId);
+    }
     const start = (await started.json().catch(() => ({})));
     if (!started.ok || typeof start.device_code !== 'string' || typeof start.user_code !== 'string')
         throw new OAuthError(start.error ?? `http_${started.status}`, start.error === 'slow_down'
@@ -257,8 +273,13 @@ export async function signInWithDevice(io, options) {
     const page = start.verification_uri ?? `${options.origin}/device`;
     if (new URL(page).origin !== options.origin)
         throw new OAuthError('discovery', 'Pending You sent the sign-in page somewhere else.');
+    const direct = start.verification_uri_complete ?? `${page}?code=${start.user_code}`;
+    const qr = io.interactive && new URL(direct).origin === options.origin ? qrLines(direct, io.env) : null;
     io.err(`On your phone or any browser, open ${page} and enter this code:\n\n    ${start.user_code}\n\n` +
-        `Or go straight to ${start.verification_uri_complete ?? `${page}?code=${start.user_code}`}\nWaiting for you to press Allow…\n`);
+        (qr
+            ? `Or scan this with your phone’s camera, which opens it with the code filled in:\n\n${qr.join('\n')}\n\nOr go straight to ${direct}\n`
+            : `Or go straight to ${direct}\n`) +
+        'Waiting for you to press Allow…\n');
     let interval = Math.max(1, start.interval ?? 5) * 1000;
     const deadline = io.now() + Math.max(60, start.expires_in ?? 600) * 1000;
     for (;;) {

package/dist/pickup.js

@@ -6,8 +6,10 @@
 //   Pending You: …"). While signed in, it also adds one short line (REMINDER) to every message, so an assistant
 //   deep in a long conversation still puts what it needs from the person on a card, and that line names this folder's
 //   cards still waiting on the person (openLine), so one they answer in chat gets cancelled with answeredHere. That's
-//   one small request per message (the open cards, and answers too while a hold from this computer is outstanding),
-//   time-boxed short; on any error, or from a server too old to list open cards, the line is the plain reminder.
+//   one small request per message (the open cards and this folder's answers together), time-boxed short; on any
+//   error, or from a server too old to list open cards, the line is the plain reminder. Until 0.10.0 it looked for
+//   answers only while a hold had left an entry behind, so an answer to a card no hold ever waited on stayed unheard
+//   until the next session (2026-10-04).
 //
 // Both also add one line when the session's pendingyou MCP server is another Pending You than the hooks' origin
 // (environment.ts): its cards would go where these hooks, and maybe its person, don't look.
@@ -15,13 +17,14 @@
 // Whatever they print, Claude Code adds to the conversation. A hook must never get in the way: each is time-boxed,
 // has a hard deadline (main.ts) after which it prints only its fallback, never refreshes the sign-in itself (api.ts),
 // prints nothing when there's nothing new, never repeats an answer it handed over, and always exits 0.
-import { getJson, SignInNeeded } from "./api.js";
+import { getJson, SESSION_APP, SignInNeeded } from "./api.js";
 import { readCredential } from "./credentials.js";
 import { environmentWarning } from "./environment.js";
-import { clip, describe, isClosed } from "./format.js";
-import { markHanded, momentOf, waitingOn, wasHanded } from "./state.js";
+import { clip, describe } from "./format.js";
+import { holdCommand } from "./hold.js";
+import { markHanded, momentOf, wasHanded } from "./state.js";
 /** Each request's own limit, inside the hook's 3-second deadline (main.ts). */
-const TIME_BOX_MS = { pickup: 2500, handoff: 2000, open: 1500 };
+const TIME_BOX_MS = { pickup: 2500, handoff: 2000 };
 /** What every message carries while signed in (about 18 tokens). */
 export const REMINDER = 'Pending You: anything you need from your person also goes on a card.';
 /** The most open cards the line names, and how much of each title. */
@@ -87,26 +90,25 @@ export async function pickup(io, options, hook = { fallback: '' }) {
         warning = await environmentWarning(io, cwd, origin);
         if (warning)
             hook.fallback = `${warning}\n`;
-        // The hand-off hears answers only while a hold from this computer is outstanding; it always asks for open cards.
-        let answers = true;
+        // The hand-off asks for this folder's answers and its open cards in one request, whether or not a hold ran.
         if (mode === 'handoff') {
             if ((await readCredential(io, origin)) === null)
                 return 0;
             line = REMINDER;
             hook.fallback = `${[REMINDER, warning].filter(Boolean).join('\n')}\n`;
-            answers = (await waitingOn(io, origin)).length > 0;
         }
         const query = new URLSearchParams([
             ...folderForms(cwd, io.home).map((form) => ['cwd', form]),
-            ['limit', answers ? '5' : '0'],
+            ['limit', '5'],
             ...(mode === 'handoff' ? [['open', String(OPEN_SHOWN)]] : []),
+            ['source', SESSION_APP],
         ]);
-        const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, answers ? TIME_BOX_MS[mode] : TIME_BOX_MS.open, io.signal, { hook: true });
+        const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, TIME_BOX_MS[mode], io.signal, { hook: true });
         if (status !== 200)
             return 0;
         if (mode === 'handoff')
             line = openLine(body.open);
-        if (!answers || !Array.isArray(body.requests))
+        if (!Array.isArray(body.requests))
             return 0;
         const fresh = [];
         for (const heard of body.requests)
@@ -114,7 +116,7 @@ export async function pickup(io, options, hook = { fallback: '' }) {
                 fresh.push(heard);
         if (fresh.length === 0)
             return 0;
-        const again = (id) => `run \`npx pendingyou hold ${id}\` in the background`;
+        const again = (id) => `run \`${holdCommand(id, origin)}\` in the background`;
         // One write, the line included: at the deadline a hook has printed all of this or none of it. Printed before it's
         // marked as handed over, so a hook cut off in between repeats an answer rather than losing it.
         io.out(`${[
@@ -129,11 +131,7 @@ export async function pickup(io, options, hook = { fallback: '' }) {
         ].join('\n')}\n`);
         line = null;
         warning = null;
-        await markHanded(io, origin, fresh.map((heard) => ({
-            requestId: heard.requestId,
-            moment: momentOf(heard),
-            closed: isClosed(heard),
-        })));
+        await markHanded(io, origin, fresh.map((heard) => ({ requestId: heard.requestId, moment: momentOf(heard) })));
         return 0;
     }
     catch (error) {

package/dist/qr.js

@@ -0,0 +1,365 @@
+// A QR code for the device sign-in's link (0.10.0), so the person can scan it from the terminal with their phone
+// instead of typing the address: on a computer reached over SSH, that phone is where they approve the code. The
+// command line has no dependencies, so this is a small encoder of its own: byte mode, versions 1–9 (up to 180 bytes at
+// level M), every error correction level, and the standard's mask choice (lowest penalty). It follows Project Nayuki's
+// QR Code generator, as uqr does (the app's phone code, onboarding.tsx); apps/pendingyou/test/cli-qr.test.ts checks it
+// against uqr module for module.
+const LEVELS = {
+    L: { index: 0, format: 1 },
+    M: { index: 1, format: 0 },
+    Q: { index: 2, format: 3 },
+    H: { index: 3, format: 2 },
+};
+/** Byte mode's character count is 8 bits up to version 9; this encoder stops there. */
+const MAX_VERSION = 9;
+/** Error correction codewords per block, by level, then version (index 0 unused). */
+const ECC_PER_BLOCK = [
+    [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30],
+    [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22],
+    [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20],
+    [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24],
+];
+/** Error correction blocks, by level, then version (index 0 unused). */
+const BLOCKS = [
+    [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2],
+    [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5],
+    [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8],
+    [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8],
+];
+const bit = (value, index) => ((value >>> index) & 1) !== 0;
+/** Modules left for data and error correction once the function patterns are drawn. */
+function rawModules(version) {
+    let result = (16 * version + 128) * version + 64;
+    if (version >= 2) {
+        const align = Math.floor(version / 7) + 2;
+        result -= (25 * align - 10) * align - 55;
+        if (version >= 7)
+            result -= 36;
+    }
+    return result;
+}
+const dataCodewords = (version, level) => Math.floor(rawModules(version) / 8) -
+    (ECC_PER_BLOCK[level]?.[version] ?? 0) * (BLOCKS[level]?.[version] ?? 0);
+/** GF(256) multiplication, modulo x^8 + x^4 + x^3 + x^2 + 1. */
+function multiply(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z;
+}
+function divisor(degree) {
+    const result = new Array(degree).fill(0);
+    result[degree - 1] = 1;
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+        for (let j = 0; j < result.length; j++) {
+            result[j] = multiply(result[j], root);
+            if (j + 1 < result.length)
+                result[j] = result[j] ^ result[j + 1];
+        }
+        root = multiply(root, 2);
+    }
+    return result;
+}
+function remainder(data, by) {
+    const result = by.map(() => 0);
+    for (const byte of data) {
+        const factor = byte ^ result.shift();
+        result.push(0);
+        by.forEach((coefficient, index) => {
+            result[index] = result[index] ^ multiply(coefficient, factor);
+        });
+    }
+    return result;
+}
+/** The data codewords with each block's error correction, interleaved as the standard places them. */
+function interleave(data, version, level) {
+    const blocks = BLOCKS[level]?.[version];
+    const eccLength = ECC_PER_BLOCK[level]?.[version];
+    const raw = Math.floor(rawModules(version) / 8);
+    const short = blocks - (raw % blocks);
+    const shortLength = Math.floor(raw / blocks);
+    const by = divisor(eccLength);
+    const all = [];
+    for (let index = 0, at = 0; index < blocks; index++) {
+        const block = data.slice(at, at + shortLength - eccLength + (index < short ? 0 : 1));
+        at += block.length;
+        const ecc = remainder(block, by);
+        if (index < short)
+            block.push(0);
+        all.push([...block, ...ecc]);
+    }
+    const result = [];
+    for (let i = 0; i < (all[0]?.length ?? 0); i++)
+        all.forEach((block, j) => {
+            if (i !== shortLength - eccLength || j >= short)
+                result.push(block[i]);
+        });
+    return result;
+}
+class Grid {
+    version;
+    /** The level's format bits (L 1, M 0, Q 3, H 2). */
+    format;
+    size;
+    modules;
+    /** Function modules (finders, timing, alignment, format and version), which data and masks never touch. */
+    reserved;
+    constructor(version, format) {
+        this.version = version;
+        this.format = format;
+        this.size = version * 4 + 17;
+        this.modules = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+        this.reserved = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+    }
+    set(x, y, dark) {
+        ;
+        this.modules[y][x] = dark;
+        this.reserved[y][x] = true;
+    }
+    functionPatterns() {
+        for (let i = 0; i < this.size; i++) {
+            this.set(6, i, i % 2 === 0);
+            this.set(i, 6, i % 2 === 0);
+        }
+        for (const [x, y] of [
+            [3, 3],
+            [this.size - 4, 3],
+            [3, this.size - 4],
+        ])
+            for (let dy = -4; dy <= 4; dy++)
+                for (let dx = -4; dx <= 4; dx++) {
+                    const distance = Math.max(Math.abs(dx), Math.abs(dy));
+                    const [xx, yy] = [x + dx, y + dy];
+                    if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size)
+                        this.set(xx, yy, distance !== 2 && distance !== 4);
+                }
+        // Alignment patterns everywhere on the grid of positions but the three finder corners.
+        const positions = this.alignments();
+        const last = positions.length - 1;
+        for (const [i, a] of positions.entries())
+            for (const [j, b] of positions.entries()) {
+                if ((i === 0 && j === 0) || (i === 0 && j === last) || (i === last && j === 0))
+                    continue;
+                for (let dy = -2; dy <= 2; dy++)
+                    for (let dx = -2; dx <= 2; dx++)
+                        this.set(a + dx, b + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+            }
+        this.formatBits(0);
+        if (this.version >= 7) {
+            let rest = this.version;
+            for (let i = 0; i < 12; i++)
+                rest = (rest << 1) ^ ((rest >>> 11) * 0x1f25);
+            const bits = (this.version << 12) | rest;
+            for (let i = 0; i < 18; i++) {
+                const a = this.size - 11 + (i % 3);
+                const b = Math.floor(i / 3);
+                this.set(a, b, bit(bits, i));
+                this.set(b, a, bit(bits, i));
+            }
+        }
+    }
+    alignments() {
+        if (this.version === 1)
+            return [];
+        const count = Math.floor(this.version / 7) + 2;
+        const step = Math.ceil((this.version * 4 + 4) / (count * 2 - 2)) * 2;
+        const result = [6];
+        for (let at = this.size - 7; result.length < count; at -= step)
+            result.splice(1, 0, at);
+        return result;
+    }
+    formatBits(mask) {
+        const data = (this.format << 3) | mask;
+        let rest = data;
+        for (let i = 0; i < 10; i++)
+            rest = (rest << 1) ^ ((rest >>> 9) * 0x537);
+        const bits = ((data << 10) | rest) ^ 0x5412;
+        for (let i = 0; i <= 5; i++)
+            this.set(8, i, bit(bits, i));
+        this.set(8, 7, bit(bits, 6));
+        this.set(8, 8, bit(bits, 7));
+        this.set(7, 8, bit(bits, 8));
+        for (let i = 9; i < 15; i++)
+            this.set(14 - i, 8, bit(bits, i));
+        for (let i = 0; i < 8; i++)
+            this.set(this.size - 1 - i, 8, bit(bits, i));
+        for (let i = 8; i < 15; i++)
+            this.set(8, this.size - 15 + i, bit(bits, i));
+        this.set(8, this.size - 8, true);
+    }
+    codewords(data) {
+        let i = 0;
+        for (let right = this.size - 1; right >= 1; right -= 2) {
+            if (right === 6)
+                right = 5;
+            for (let vertical = 0; vertical < this.size; vertical++)
+                for (let j = 0; j < 2; j++) {
+                    const x = right - j;
+                    const upward = ((right + 1) & 2) === 0;
+                    const y = upward ? this.size - 1 - vertical : vertical;
+                    if (!this.reserved[y]?.[x] && i < data.length * 8) {
+                        ;
+                        this.modules[y][x] = bit(data[i >>> 3], 7 - (i & 7));
+                        i++;
+                    }
+                }
+        }
+    }
+    /** XORs the data modules with a mask pattern; applying it twice undoes it. */
+    mask(mask) {
+        for (let y = 0; y < this.size; y++)
+            for (let x = 0; x < this.size; x++) {
+                const flip = [
+                    (x + y) % 2 === 0,
+                    y % 2 === 0,
+                    x % 3 === 0,
+                    (x + y) % 3 === 0,
+                    (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+                    ((x * y) % 2) + ((x * y) % 3) === 0,
+                    (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,
+                    (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+                ][mask];
+                if (flip && !this.reserved[y]?.[x])
+                    this.modules[y][x] = !this.modules[y]?.[x];
+            }
+    }
+    /** The standard's penalty for the modules as they are: runs, boxes, finder look-alikes and imbalance. */
+    penalty() {
+        let result = 0;
+        const at = (x, y) => this.modules[y]?.[x];
+        for (const across of [true, false]) {
+            for (let line = 0; line < this.size; line++) {
+                let color = false;
+                let run = 0;
+                const history = [0, 0, 0, 0, 0, 0, 0];
+                for (let along = 0; along < this.size; along++) {
+                    const dark = across ? at(along, line) : at(line, along);
+                    if (dark === color) {
+                        run++;
+                        if (run === 5)
+                            result += 3;
+                        else if (run > 5)
+                            result++;
+                    }
+                    else {
+                        this.addHistory(run, history);
+                        if (!color)
+                            result += this.finderLike(history) * 40;
+                        color = dark;
+                        run = 1;
+                    }
+                }
+                if (color) {
+                    this.addHistory(run, history);
+                    run = 0;
+                }
+                this.addHistory(run + this.size, history);
+                result += this.finderLike(history) * 40;
+            }
+        }
+        for (let y = 0; y < this.size - 1; y++)
+            for (let x = 0; x < this.size - 1; x++) {
+                const color = at(x, y);
+                if (color === at(x + 1, y) && color === at(x, y + 1) && color === at(x + 1, y + 1))
+                    result += 3;
+            }
+        const dark = this.modules.reduce((sum, row) => sum + row.filter(Boolean).length, 0);
+        const total = this.size * this.size;
+        result += (Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1) * 10;
+        return result;
+    }
+    addHistory(run, history) {
+        history.pop();
+        history.unshift(history[0] === 0 ? run + this.size : run);
+    }
+    finderLike(history) {
+        const [a = 0, n = 0, c = 0, d = 0, e = 0, f = 0, g = 0] = history;
+        const core = n > 0 && c === n && d === n * 3 && e === n && f === n;
+        return (core && a >= n * 4 && g >= n ? 1 : 0) + (core && g >= n * 4 && a >= n ? 1 : 0);
+    }
+}
+/**
+ * `text` as a QR code in byte mode, the smallest version that holds it at level `ecc` (M unless asked), with the mask
+ * the standard's penalty prefers (or `mask`). Null when it's longer than version 9 holds.
+ */
+export function qrCode(text, options = {}) {
+    const bytes = [...new TextEncoder().encode(text)];
+    const { index: level, format } = LEVELS[options.ecc ?? 'M'];
+    let version = 1;
+    // Mode (4 bits), the count (8 bits), then the bytes.
+    const used = 4 + 8 + bytes.length * 8;
+    while (version <= MAX_VERSION && used > dataCodewords(version, level) * 8)
+        version++;
+    if (version > MAX_VERSION)
+        return null;
+    const capacity = dataCodewords(version, level) * 8;
+    const bits = [];
+    const append = (value, length) => {
+        for (let i = length - 1; i >= 0; i--)
+            bits.push((value >>> i) & 1);
+    };
+    append(0b0100, 4);
+    append(bytes.length, 8);
+    for (const byte of bytes)
+        append(byte, 8);
+    append(0, Math.min(4, capacity - bits.length));
+    append(0, (8 - (bits.length % 8)) % 8);
+    for (let pad = 0xec; bits.length < capacity; pad ^= 0xec ^ 0x11)
+        append(pad, 8);
+    const data = new Array(bits.length / 8).fill(0);
+    bits.forEach((value, i) => {
+        data[i >>> 3] = data[i >>> 3] | (value << (7 - (i & 7)));
+    });
+    const grid = new Grid(version, format);
+    grid.functionPatterns();
+    grid.codewords(interleave(data, version, level));
+    let mask = options.mask ?? -1;
+    if (mask < 0) {
+        let lowest = Number.POSITIVE_INFINITY;
+        for (let candidate = 0; candidate < 8; candidate++) {
+            grid.mask(candidate);
+            grid.formatBits(candidate);
+            const score = grid.penalty();
+            if (score < lowest) {
+                lowest = score;
+                mask = candidate;
+            }
+            grid.mask(candidate);
+        }
+    }
+    grid.mask(mask);
+    grid.formatBits(mask);
+    return { version, mask, modules: grid.modules.map((row) => [...row]) };
+}
+/** Dark on light whatever the terminal's colours: black text on a white background, then back to normal. */
+const ON = '\u001b[30;47m';
+const OFF = '\u001b[0m';
+/** Light modules around the code, so a camera finds its edges. */
+const QUIET = 2;
+/**
+ * The code as terminal lines: two rows of modules a line, drawn with half blocks, dark on light, with a quiet zone.
+ * Null when the text is too long for a code, or the terminal can't be trusted with colours (NO_COLOR, TERM=dumb).
+ */
+export function qrLines(text, env = {}) {
+    if (env.NO_COLOR || env.TERM === 'dumb')
+        return null;
+    const code = qrCode(text);
+    if (!code)
+        return null;
+    const size = code.modules.length + QUIET * 2;
+    const dark = (x, y) => code.modules[y - QUIET]?.[x - QUIET] === true;
+    const lines = [];
+    for (let y = 0; y < size; y += 2) {
+        let line = '';
+        for (let x = 0; x < size; x++) {
+            const top = dark(x, y);
+            const bottom = y + 1 < size && dark(x, y + 1);
+            line += top ? (bottom ? '█' : '▀') : bottom ? '▄' : ' ';
+        }
+        lines.push(`${ON}${line}${OFF}`);
+    }
+    return lines;
+}