strom-research 1.0.0

package/dist/core/age.js

@@ -0,0 +1,95 @@
+// Ages as records state them ("aged 27", "27 let", "3 Monate") in the GEDCOM
+// 5.5.1 form: "27y", "27y 3m", "3m 12d", "<1y", ">60y", INFANT, STILLBORN,
+// CHILD. An age at an event is the most common clue to a birth year.
+const KEYWORDS = new Set(["INFANT", "STILLBORN", "CHILD"]);
+/** Words for years, months, weeks and days in the languages of old records and of users. */
+const UNITS = [
+    [/^(y|yr|yrs|year|years|r|rok|roku|roky|let|l|j|jahr|jahre|jahren|lat|lata|rok[uó]w|an|ans|anni|anno|annorum|annos|años|ano|anos|år|ar|év|ev|ann)\.?$/i, "y"],
+    [/^(m|mo|mos|month|months|měs|mes|měsíc|měsíce|měsíců|mesic|mesice|mesicu|monat|monate|monaten|mies|miesiąc|miesiące|miesięcy|mois|mese|mesi|meses|mån|hónap)\.?$/i, "m"],
+    [/^(w|wk|wks|week|weeks|t|týd|týden|týdny|týdnů|tyden|tydny|woche|wochen|tydz|tydzień|tygodnie|tygodni|sem|semaine|semaines|settimana|settimane)\.?$/i, "w"],
+    [/^(d|day|days|den|dny|dní|dni|dnů|tag|tage|tagen|dzień|jour|jours|giorno|giorni|días|dias)\.?$/i, "d"],
+];
+/** INFANT, STILLBORN, CHILD in words (folded): the forms humanAge writes, and the Strom app's. */
+const WORDS = {
+    infant: "INFANT", kojenec: "INFANT", saugling: "INFANT", niemowle: "INFANT",
+    stillborn: "STILLBORN", "mrtve narozene": "STILLBORN", "mrtve narozeny": "STILLBORN", totgeboren: "STILLBORN", "martwo urodzone": "STILLBORN",
+    child: "CHILD", dite: "CHILD", kind: "CHILD", dziecko: "CHILD",
+};
+/** Is `s` a valid GEDCOM 5.5.1 age? */
+export function isGedcomAge(s) {
+    return KEYWORDS.has(s) || /^[<>]?(?:\d{1,3}y(?: \d{1,2}m)?(?: \d{1,3}d)?|\d{1,2}m(?: \d{1,3}d)?|\d{1,3}d)$/.test(s);
+}
+/** Words around an age that carry no amount: "aged", "ve věku", "aetatis", "asi". */
+const FILLER = /^(aged|age|at|of|about|circa|ca|c|asi|cca|ve|věku|věk|stáří|v|im|alter|von|etwa|aetatis|aetat|około|w|wieku|environ|âgé|âgée|de|di|età|and|und|a|i|et|e|y)\.?$/i;
+/** Normalise an age to GEDCOM form, or undefined when it cannot be read. */
+export function normalizeAge(input) {
+    const raw = input.trim().replace(/\s+/g, " ");
+    if (!raw)
+        return undefined;
+    const up = raw.toUpperCase();
+    if (KEYWORDS.has(up))
+        return up;
+    // the keywords in words, as programs write them back ("kojenec", "mrtvě narozené", "Säugling")
+    const word = WORDS[raw.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase()];
+    if (word)
+        return word;
+    if (isGedcomAge(raw))
+        return raw;
+    let rest = raw.replace(/,(?!\d)/g, " ").trim();
+    let sign = "";
+    if (/^[<>]/.test(rest)) {
+        sign = rest[0];
+        rest = rest.slice(1).trim();
+    }
+    if (/^\d{1,3}$/.test(rest))
+        return `${sign}${Number(rest)}y`; // "27" alone means years
+    const parts = { y: 0, m: 0, d: 0 };
+    let seen = false;
+    let pendingUnit; // "annorum 25": the unit before the number
+    const tokens = rest.match(/\d+(?:[.,]\d+)?|[^\d\s]+/g) ?? [];
+    const unitOf = (w) => (w ? UNITS.find(([re]) => re.test(w))?.[1] : undefined);
+    for (let i = 0; i < tokens.length; i++) {
+        const tok = tokens[i];
+        const n = Number(tok.replace(",", "."));
+        if (!Number.isFinite(n)) {
+            const u = unitOf(tok);
+            if (u)
+                pendingUnit = u;
+            else if (!FILLER.test(tok))
+                return undefined;
+            continue;
+        }
+        let unit = unitOf(tokens[i + 1]);
+        if (unit)
+            i++;
+        else
+            unit = pendingUnit ?? "y";
+        pendingUnit = undefined;
+        if (unit === "w")
+            parts.d += Math.round(n * 7);
+        else if (unit === "y" && !Number.isInteger(n)) {
+            parts.y += Math.floor(n);
+            parts.m += Math.round((n % 1) * 12);
+        }
+        else
+            parts[unit] += Math.round(n);
+        seen = true;
+    }
+    if (!seen)
+        return undefined;
+    const out = [parts.y ? `${parts.y}y` : "", parts.m ? `${parts.m}m` : "", parts.d ? `${parts.d}d` : ""].filter(Boolean).join(" ");
+    return out && isGedcomAge(`${sign}${out}`) ? `${sign}${out}` : undefined;
+}
+const HUMAN = {
+    en: { y: "y", m: "m", d: "d", INFANT: "infant", STILLBORN: "stillborn", CHILD: "child" },
+    cs: { y: "let", m: "měs.", d: "dní", INFANT: "kojenec", STILLBORN: "mrtvě narozené", CHILD: "dítě" },
+    de: { y: "J.", m: "Mon.", d: "Tage", INFANT: "Säugling", STILLBORN: "totgeboren", CHILD: "Kind" },
+    pl: { y: "lat", m: "mies.", d: "dni", INFANT: "niemowlę", STILLBORN: "martwo urodzone", CHILD: "dziecko" },
+};
+/** "27y 3m" → "27 let 3 měs." in the research language (for notes a reader sees). */
+export function humanAge(age, lang) {
+    const t = HUMAN[lang] ?? HUMAN.en;
+    if (KEYWORDS.has(age))
+        return t[age];
+    return age.replace(/(\d+)([ymd])/g, (_, n, u) => `${n} ${t[u]}`);
+}

package/dist/core/apps.js

@@ -0,0 +1,74 @@
+// The desktop apps of the agents — the easiest way in for a person who has
+// never used an AI agent: no terminal, the agent in a window of its own.
+// strom finds them (by name, or by the link they open on Windows and Linux),
+// and opens a conversation in one with a link: the tree folder and the first
+// message filled in. The person confirms the folder and sends the message.
+//
+//   Claude (Anthropic)   claude://code/new?folder=…&q=…      the Code tab, a local session
+//   ChatGPT / Codex      codex://new?path=…&prompt=…
+//   OpenCode             opencode://new?cwd=…&q=…
+//
+// Antigravity has an app too, but no known link that opens a conversation:
+// strom talks to it in the terminal (agy).
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { userHome } from "./paths.js";
+import { AGENTS, findAgent, which } from "./which.js";
+const q = encodeURIComponent;
+export const DESKTOP_APPS = {
+    claude: { agent: "claude", name: "Claude", scheme: "claude", mac: ["Claude.app"], linux: "claude-desktop", link: (f, m) => `claude://code/new?folder=${q(f)}&q=${q(m)}` },
+    codex: { agent: "codex", name: "ChatGPT (Codex)", scheme: "codex", mac: ["Codex.app", "ChatGPT.app"], link: (f, m) => `codex://new?path=${q(f)}&prompt=${q(m)}` },
+    opencode: { agent: "opencode", name: "OpenCode", scheme: "opencode", mac: ["OpenCode.app"], link: (f, m) => `opencode://new?cwd=${q(f)}&q=${q(m)}` },
+};
+const seen = new Map();
+/** Is this agent's desktop app on this computer? (STROM_APP_DIRS: folders to look in instead — tests.) */
+export function hasDesktopApp(agent, env, platform = process.platform) {
+    const app = DESKTOP_APPS[agent];
+    if (!app)
+        return false;
+    const key = `${agent}|${platform}|${env.STROM_APP_DIRS ?? ""}|${env.HOME ?? env.USERPROFILE ?? ""}`;
+    const known = seen.get(key);
+    if (known !== undefined)
+        return known;
+    let found = false;
+    if (env.STROM_APP_DIRS !== undefined)
+        found = env.STROM_APP_DIRS.split(path.delimiter).some((d) => d && app.mac.some((n) => fs.existsSync(path.join(d, n))));
+    else if (platform === "darwin")
+        found = ["/Applications", path.join(userHome(env), "Applications")].some((d) => app.mac.some((n) => fs.existsSync(path.join(d, n))));
+    else if (platform === "win32") {
+        // An installed app registers its link for the user or for everyone.
+        found = ["HKCU", "HKLM"].some((root) => spawnSync("reg", ["query", `${root}\\Software\\Classes\\${app.scheme}`], { stdio: "ignore", windowsHide: true }).status === 0);
+    }
+    else {
+        if (app.linux && which(app.linux, env, platform))
+            found = true;
+        else {
+            const r = spawnSync("xdg-mime", ["query", "default", `x-scheme-handler/${app.scheme}`], { encoding: "utf8", env: env });
+            found = r.status === 0 && Boolean(r.stdout?.trim());
+        }
+    }
+    seen.set(key, found);
+    return found;
+}
+/** The agents strom can drive that are on this computer, in strom's order. */
+export function agentsHere(env, platform = process.platform) {
+    return AGENTS.map((a) => ({ id: a.id, cli: Boolean(findAgent(a.command, env, platform)), app: hasDesktopApp(a.id, env, platform) })).filter((a) => a.cli || a.app);
+}
+/**
+ * The user's choice, else the app when it is there (the easiest way), else
+ * the terminal. An agent without an app, or an app strom cannot open, is the
+ * terminal whatever the choice.
+ */
+export function whereToTalk(agent, chosen, env) {
+    const here = agentsHere(env).find((a) => a.id === agent);
+    if (!here?.app)
+        return "terminal";
+    if (!here.cli)
+        return "app";
+    return chosen === "terminal" ? "terminal" : "app";
+}
+/** Is strom run by an agent inside a desktop app? (Claude Code says where it runs.) */
+export function inDesktopApp(env) {
+    return /desktop/i.test(env.CLAUDE_CODE_ENTRYPOINT ?? "");
+}

package/dist/core/assets.js

@@ -0,0 +1,34 @@
+// Files shipped with strom (method pack, templates). They live in assets/
+// next to src/ and dist/, so the same relative path works from both.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "assets");
+export function assetPath(...parts) {
+    return path.join(ROOT, ...parts);
+}
+const cache = new Map();
+export function readAsset(...parts) {
+    const file = assetPath(...parts);
+    if (cache.has(file))
+        return cache.get(file);
+    try {
+        const text = fs.readFileSync(file, "utf8");
+        cache.set(file, text);
+        return text;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Method text for a task level: the core plus the level's own page (+ reading for work in books). */
+export function methodFor(level) {
+    const parts = [readAsset("method", "core.md")];
+    if (level)
+        parts.push(readAsset("method", `${level}.md`));
+    if (level && ["link", "verify", "enrich"].includes(level))
+        parts.push(readAsset("method", "recording.md"));
+    if (level && ["link", "verify", "enrich", "intake"].includes(level))
+        parts.push(readAsset("method", "reading.md"));
+    return parts.filter(Boolean).join("\n");
+}

package/dist/core/awake.js

@@ -0,0 +1,33 @@
+// Keep the computer awake while agents work (the old workflow lost hours when
+// a Mac fell asleep mid-session). Built-in OS tools only; ends with strom.
+import { spawn } from "node:child_process";
+import { which } from "./which.js";
+export function keepAwake(env) {
+    let child;
+    try {
+        if (process.platform === "darwin")
+            child = spawn("caffeinate", ["-i", "-w", String(process.pid)], { stdio: "ignore" });
+        else if (process.platform === "win32")
+            child = spawn("powershell", [
+                "-NoProfile",
+                "-Command",
+                "$s='[DllImport(\"kernel32.dll\")] public static extern uint SetThreadExecutionState(uint f);';" +
+                    "$t=Add-Type -MemberDefinition $s -Name Awake -Namespace Strom -PassThru;" +
+                    "while($true){$t::SetThreadExecutionState(0x80000001)|Out-Null;Start-Sleep 50}",
+            ], { stdio: "ignore", windowsHide: true });
+        else if (which("systemd-inhibit", env))
+            child = spawn("systemd-inhibit", ["--what=idle:sleep", "--who=strom", "--why=research session", "sleep", "infinity"], { stdio: "ignore" });
+    }
+    catch {
+        child = undefined;
+    }
+    child?.on("error", () => undefined);
+    return () => {
+        try {
+            child?.kill();
+        }
+        catch {
+            // already gone
+        }
+    };
+}

package/dist/core/browser.js

@@ -0,0 +1,281 @@
+// Images through the user's own browser. strom does not drive a browser — the
+// agent does, with its browser tools (Claude in Chrome). strom plans what the
+// browser fetches: the addresses the connector located, the file names, the
+// times its limiter reserved. It gives the agent a script to run in a tab of
+// the images' site, which fetches them one by one at that pace and saves each
+// into the browser's downloads folder under its name. strom then takes the
+// files over from there, checks them like any download and registers them with
+// where they came from. What the browser got from the archive (a refusal) goes
+// into the limiter's memory, as if strom had got it.
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { userHome } from "./paths.js";
+import { readJsonIfExists, writeJson } from "./json.js";
+/** The longest one script waits between its images: a browser tool call must end in time. */
+export const SCRIPT_MS = 40_000;
+/** A plan is run within this time, or it is over (its times are long past): fetch again. */
+export const PLAN_TTL_MS = 15 * 60_000;
+/** A plan whose files never came is forgotten after this. */
+export const KEEP_MS = 7 * 24 * 3600_000;
+/** Browser tools of Claude in Chrome an agent may use for a connector's site. */
+export const CHROME_ALLOW = [
+    "tabs_context_mcp",
+    "tabs_create_mcp",
+    "tabs_close_mcp",
+    "navigate",
+    "javascript_tool",
+    "read_page",
+    "get_page_text",
+    "find",
+    "form_input",
+    "computer",
+    "read_console_messages",
+    "read_network_requests",
+    "list_connected_browsers",
+    "select_browser",
+    "switch_browser",
+    "resize_window",
+].map((t) => `mcp__claude-in-chrome__${t}`);
+/** Never: a file of this computer uploaded to a web site, the user's own browser shortcuts, a batch the rules cannot see into. */
+export const CHROME_DENY = ["file_upload", "upload_image", "shortcuts_execute", "gif_creator", "browser_batch"].map((t) => `mcp__claude-in-chrome__${t}`);
+/** The permission rule of Claude in Chrome for one site. */
+export const chromeDomain = (host) => `ClaudeInChromeDomain(${host.replace(/^\*\./, "").toLowerCase()})`;
+/** The folder a browser saves downloads into by default: ~/Downloads, or what the desktop names it (Linux). */
+export function downloadsDir(env, platform = process.platform) {
+    const home = userHome(env);
+    if (platform === "linux") {
+        const cfg = env.XDG_CONFIG_HOME || path.join(home, ".config");
+        try {
+            const m = /^XDG_DOWNLOAD_DIR="([^"]*)"/m.exec(fs.readFileSync(path.join(cfg, "user-dirs.dirs"), "utf8"));
+            if (m?.[1])
+                return m[1].replace(/^\$HOME/, home);
+        }
+        catch {
+            // no desktop settings: the usual name
+        }
+    }
+    return path.join(home, "Downloads");
+}
+const safe = (s) => s.normalize("NFC").replace(/[^\p{L}\p{M}\p{N}._-]+/gu, "_").replace(/^[._]+/, "") || "x";
+/** The name a planned image is saved under: strom-<connector>-<book>-0009 (a part: …-0009-part). */
+export function fileBase(connector, book, n, part) {
+    return `strom-${connector}-${safe(book)}-${String(n).padStart(4, "0")}${part ? "-part" : ""}`;
+}
+function plansDir(root) {
+    return path.join(root, ".strom", "browser");
+}
+export function savePlan(root, plan) {
+    writeJson(path.join(plansDir(root), `${plan.id}.json`), plan);
+}
+/** The plans of a tree still waiting for their files (of one connector), oldest first; forgotten ones removed. */
+export function loadPlans(root, connector, now = Date.now()) {
+    const dir = plansDir(root);
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    for (const f of fs.readdirSync(dir).filter((x) => x.endsWith(".json")).sort()) {
+        const p = readJsonIfExists(path.join(dir, f));
+        if (!p || !Array.isArray(p.items))
+            continue;
+        if ((!p.items.length && !p.pages?.length) || now - p.created > KEEP_MS) {
+            fs.rmSync(path.join(dir, f), { force: true });
+            continue;
+        }
+        if (!connector || p.connector === connector)
+            out.push(p);
+    }
+    return out;
+}
+export function removePlan(root, id) {
+    fs.rmSync(path.join(plansDir(root), `${id}.json`), { force: true });
+}
+/** The script the agent runs in a tab of the plan's site (top-level await). It returns one line: "strom-result 9:200:412918 10:403". */
+export function planScript(plan) {
+    // the page of the image as the referrer, as the portal's own viewer sends it (a browser allows it on the same site)
+    const ref = (u) => (u && URL.canParse(u) && new URL(u).origin === plan.origin ? { ref: u } : {});
+    const data = { origin: plan.origin, open: plan.open, until: plan.until, gap: plan.gap, items: plan.items.map((i) => ({ n: i.n, src: i.src, file: i.file, at: i.at, ...ref(i.url) })) };
+    return `await (async () => {
+  const plan = ${JSON.stringify(data)};
+  if (location.origin !== plan.origin) return "strom: this tab is on " + location.origin + " — open " + plan.open + " first";
+  if (Date.now() > plan.until) return "strom: this plan is over — run strom fetch again for a new one";
+  const ext = { "image/jpeg": ".jpg", "image/png": ".png", "image/tiff": ".tif", "image/webp": ".webp", "image/gif": ".gif", "image/jp2": ".jp2" };
+  const out = [];
+  let last = 0;
+  for (const it of plan.items) {
+    const wait = Math.max(it.at, last + plan.gap) - Date.now();
+    if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+    last = Date.now();
+    let res;
+    try {
+      res = await fetch(it.src, it.ref ? { credentials: "include", referrer: it.ref } : { credentials: "include" });
+    } catch (e) {
+      out.push(it.n + ":failed");
+      break;
+    }
+    if (!res.ok) {
+      out.push(it.n + ":" + res.status);
+      break;
+    }
+    const blob = await res.blob();
+    const a = document.createElement("a");
+    a.href = URL.createObjectURL(blob);
+    a.download = it.file + (ext[blob.type.split(";")[0].trim()] || ".jpg");
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    setTimeout(() => URL.revokeObjectURL(a.href), 60000);
+    out.push(it.n + ":" + res.status + ":" + blob.size);
+  }
+  return "strom-result " + out.join(" ");
+})()`;
+}
+/** The line the script returned: "strom-result 9:200:412918 10:403 11:failed". */
+export function parseResult(s) {
+    const out = [];
+    for (const tok of s.replace(/^\s*["']?\s*strom-result\s*/i, "").split(/[\s,"']+/)) {
+        const m = /^(\d+|p[0-9a-f]{16}):(\d{3}|failed)(?::(\d+))?$/.exec(tok);
+        if (!m)
+            continue;
+        const page = m[1].startsWith("p") ? m[1].slice(1) : undefined;
+        out.push({ n: page ? 0 : Number(m[1]), ...(page ? { page } : {}), ...(m[2] === "failed" ? { failed: true } : { status: Number(m[2]) }), ...(m[3] ? { bytes: Number(m[3]) } : {}) });
+    }
+    return out;
+}
+const UNFINISHED = /\.(crdownload|part|download|tmp)$/i;
+/**
+ * The downloaded file of a planned name: "<base>.jpg", or "<base> (1).jpg" when the
+ * browser had one of that name already — the newest. Names are compared composed
+ * (a folder may give them back decomposed); the path is the folder's own.
+ */
+export function findDownload(dir, base) {
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return { others: [] };
+    }
+    const want = base.normalize("NFC");
+    const esc = want.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`^${esc}(?: \\(\\d+\\))?\\.[\\p{L}\\p{N}]{2,5}$`, "u");
+    const found = [];
+    let unfinished = false;
+    for (const name of names) {
+        const nfc = name.normalize("NFC");
+        if (!nfc.startsWith(want))
+            continue;
+        if (UNFINISHED.test(nfc)) {
+            unfinished = true;
+            continue;
+        }
+        if (!re.test(nfc))
+            continue;
+        const file = path.join(dir, name);
+        found.push({ file, at: fs.statSync(file).mtimeMs });
+    }
+    found.sort((a, b) => b.at - a.at);
+    const [best, ...rest] = found;
+    return { ...(best ? { file: best.file } : {}), others: rest.map((f) => f.file), ...(!best && unfinished ? { unfinished: true } : {}) };
+}
+// ── pages through the browser (a portal behind a bot check) ─────────────────
+/** A request's key: the same request is the same page (and the connector asks the same, run after run). */
+export function pageKey(r) {
+    return crypto.createHash("sha256").update(`${r.method} ${r.url}\n${r.body ?? ""}`).digest("hex").slice(0, 16);
+}
+/** A page kept this long answers the connector again; then the browser asks for it anew. */
+export const PAGE_TTL_MS = 24 * 3600_000;
+const pagesDir = (root, connector) => path.join(root, ".strom", "browser", "pages", connector);
+export function loadPage(root, connector, key, now = Date.now()) {
+    const p = readJsonIfExists(path.join(pagesDir(root, connector), `${key}.json`));
+    if (!p || now - p.at > PAGE_TTL_MS)
+        return undefined;
+    return { status: p.status, contentType: p.type, headers: p.headers, url: p.finalUrl, body: Buffer.from(p.body, "base64") };
+}
+export function savePage(root, connector, req, got, now = Date.now()) {
+    const kept = { key: req.key, method: req.method, url: req.url, at: now, status: got.status, type: got.contentType, headers: got.headers, finalUrl: got.url, body: got.body.toString("base64") };
+    writeJson(path.join(pagesDir(root, connector), `${req.key}.json`), kept);
+}
+/** What a browser saved for a page: the file the page script wrote, or why it is not one. */
+export function readSavedPage(file) {
+    let o;
+    try {
+        o = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return "not a page saved by strom's script (not JSON)";
+    }
+    if (o.strom !== "page" || typeof o.status !== "number" || typeof o.body !== "string")
+        return "not a page saved by strom's script";
+    const headers = o.headers && typeof o.headers === "object" ? Object.fromEntries(Object.entries(o.headers).map(([k, v]) => [k.toLowerCase(), String(v)])) : {};
+    return { status: o.status, contentType: String(o.type ?? ""), headers, url: String(o.url ?? ""), body: Buffer.from(o.body, "base64") };
+}
+/**
+ * A page that is a check whether a person is there (Imperva/Incapsula, Cloudflare, a captcha), not
+ * the page asked for: its name, or undefined. The services put their scripts into every page they
+ * guard, so a script alone is no check: a check is a small page with little else (found live).
+ */
+export function botCheck(body, headers = {}) {
+    const buf = typeof body === "string" ? Buffer.from(body) : body;
+    const text = buf.subarray(0, 64 * 1024).toString("latin1").toLowerCase();
+    const small = buf.length < 16 * 1024;
+    // what a reader sees of it: the text without tags and scripts
+    const words = text.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<[^>]+>/g, " ").replace(/\s+/g, " ").trim().length;
+    const bare = small && words < 400;
+    const header = (name) => Object.entries(headers).find(([k]) => k.toLowerCase() === name)?.[1];
+    if (/incapsula incident id|request unsuccessful\. incapsula/.test(text) || (bare && /_incapsula_resource/.test(text)))
+        return "Imperva (Incapsula)";
+    if (/^challenge/i.test(header("cf-mitigated") ?? "") || /<title>(just a moment\.\.\.|attention required! \| cloudflare)<\/title>/.test(text) || (bare && /cf-challenge|cf_chl_|challenge-platform/.test(text)))
+        return "Cloudflare";
+    if (bare && /ddos-guard/.test(text))
+        return "DDoS-Guard";
+    if (bare && /g-recaptcha|h-captcha|hcaptcha\.com|recaptcha\/api\.js/.test(text))
+        return "a captcha";
+    return undefined;
+}
+/** Headers a page's own script may send (a browser sets the rest itself: cookies, the user agent). */
+const PAGE_HEADERS = new Set(["accept", "accept-language", "content-type", "x-requested-with"]);
+/** The script that asks the plan's pages in the tab (top-level await): each saved as <file>.json; it returns "strom-result p<key>:200:5120". */
+export function pageScript(plan) {
+    const pages = (plan.pages ?? []).map((p) => {
+        const h = Object.fromEntries(Object.entries(p.headers).filter(([k]) => PAGE_HEADERS.has(k.toLowerCase())));
+        const ref = Object.entries(p.headers).find(([k]) => k.toLowerCase() === "referer")?.[1];
+        return { key: p.key, method: p.method, url: p.url, file: p.file, at: p.at, headers: h, ...(p.body !== undefined ? { body: p.body } : {}), ...(ref && URL.canParse(ref) && new URL(ref).origin === plan.origin ? { ref } : {}) };
+    });
+    const data = { origin: plan.origin, open: plan.open, until: plan.until, gap: plan.gap, pages };
+    return `await (async () => {
+  const plan = ${JSON.stringify(data)};
+  if (location.origin !== plan.origin) return "strom: this tab is on " + location.origin + " — open " + plan.open + " first";
+  if (Date.now() > plan.until) return "strom: this plan is over — run the strom command again for a new one";
+  const out = [];
+  let last = 0;
+  for (const p of plan.pages) {
+    const wait = Math.max(p.at, last + plan.gap) - Date.now();
+    if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+    last = Date.now();
+    let res;
+    try {
+      res = await fetch(p.url, { method: p.method, headers: p.headers, credentials: "include", ...(p.body !== undefined ? { body: p.body } : {}), ...(p.ref ? { referrer: p.ref } : {}) });
+    } catch (e) {
+      out.push("p" + p.key + ":failed");
+      break;
+    }
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    let bin = "";
+    for (let i = 0; i < bytes.length; i += 32768) bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 32768));
+    const headers = {};
+    res.headers.forEach((v, k) => (headers[k] = v));
+    const saved = { strom: "page", status: res.status, type: res.headers.get("content-type") || "", url: res.url, headers, body: btoa(bin) };
+    const a = document.createElement("a");
+    a.href = URL.createObjectURL(new Blob([JSON.stringify(saved)], { type: "application/json" }));
+    a.download = p.file + ".json";
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    setTimeout(() => URL.revokeObjectURL(a.href), 60000);
+    out.push("p" + p.key + ":" + res.status + ":" + bytes.length);
+    if (res.status === 401 || res.status === 403 || res.status === 429) break;
+  }
+  return "strom-result " + out.join(" ");
+})()`;
+}

package/dist/core/calibration.js

@@ -0,0 +1,48 @@
+// Page ↔ image calibration of a record set.
+/** Fit page = a·image + b to numeric calibration points. */
+export function fitCalibration(points) {
+    const num = points.map((p) => ({ x: p.image, y: Number.parseInt(p.page, 10) })).filter((p) => Number.isFinite(p.y));
+    if (num.length < 2)
+        return undefined;
+    const n = num.length;
+    const mx = num.reduce((s, p) => s + p.x, 0) / n;
+    const my = num.reduce((s, p) => s + p.y, 0) / n;
+    const sxx = num.reduce((s, p) => s + (p.x - mx) ** 2, 0);
+    if (sxx === 0)
+        return undefined;
+    const a = num.reduce((s, p) => s + (p.x - mx) * (p.y - my), 0) / sxx;
+    const b = my - a * mx;
+    const maxError = Math.max(...num.map((p) => Math.abs(a * p.x + b - p.y)));
+    return { a, b, maxError };
+}
+export function calibrationLine(b) {
+    if (b.calibration.length === 0)
+        return undefined;
+    const fit = fitCalibration(b.calibration);
+    const pts = b.calibration.map((c) => `${c.image}→${c.page}`).join(" ");
+    if (!fit)
+        return `calibration ${pts}`;
+    const formula = `page ≈ ${+fit.a.toFixed(3)}·image ${fit.b >= 0 ? "+" : "−"} ${Math.abs(+fit.b.toFixed(2))}`;
+    const quality = fit.maxError < 0.51 ? "consistent" : `INCONSISTENT (off by up to ${fit.maxError.toFixed(1)} — the book is not linear; measure, do not compute)`;
+    return `calibration ${pts} · ${formula} · ${quality}`;
+}
+/** The page on an image: measured, or computed from a consistent calibration ("≈"). */
+export function pageOf(b, image) {
+    const exact = b.calibration.find((c) => c.image === image);
+    if (exact)
+        return exact.page;
+    const fit = fitCalibration(b.calibration);
+    if (!fit || fit.maxError >= 0.51)
+        return undefined;
+    return `≈${Math.round(fit.a * image + fit.b)}`;
+}
+/** The image a page is on, from a consistent calibration (undefined when the book is not linear). */
+export function imageOf(b, page) {
+    const exact = b.calibration.find((c) => Number.parseInt(c.page, 10) === page);
+    if (exact)
+        return exact.image;
+    const fit = fitCalibration(b.calibration);
+    if (!fit || fit.maxError >= 0.51 || fit.a === 0)
+        return undefined;
+    return Math.round((page - fit.b) / fit.a);
+}