tryharness 0.7.22 → 0.7.25

package/lib/nudge.mjs

@@ -18,16 +18,50 @@ export function nudgeText(agent, tasks, unread = [], goals = [], swarm = "") {
 }
 
 function queueText(agent, tasks, unread, goals) {
-  const waiting = (tasks || []).filter((task) => task.status === "open" && (!task.target_agent || task.target_agent === agent));
-  const held = (tasks || []).filter((task) => task.claimed_by === agent && (task.status === "claimed" || task.status === "needs_input"));
-  if (!waiting.length && !held.length && !unread.length && !goals.length) return "";
-  const line = (task) => `- ${task.id}: ${task.objective}${task.origin_agent ? ` (from ${task.trust === "agent" && task.origin_chain?.length > 1 ? task.origin_chain.join(" → ") : task.origin_agent}${task.trust === "agent" ? ", agent-written" : ""})` : ""}${task.status === "needs_input" ? " · your question was answered" : ""}${task.thread_with ? ` · shared with ${task.thread_with}` : ""}`;
+  const waiting = (tasks || []).filter(
+    (task) =>
+      task.status === "open" &&
+      (!task.target_agent || task.target_agent === agent)
+  );
+  const held = (tasks || []).filter(
+    (task) =>
+      task.claimed_by === agent &&
+      (task.status === "claimed" || task.status === "needs_input")
+  );
+  if (!waiting.length && !held.length && !unread.length && !goals.length)
+    return "";
+  const line = (task) =>
+    `- ${task.id}: ${task.objective}${task.origin_agent ? ` (from ${task.trust === "agent" && task.origin_chain?.length > 1 ? task.origin_chain.join(" → ") : task.origin_agent}${task.trust === "agent" ? ", agent-written" : ""})` : ""}${task.status === "needs_input" ? " · your question was answered" : ""}${task.thread_with ? ` · shared with ${task.thread_with}` : ""}`;
   const parts = ["Harness task board:"];
-  if (waiting.length) parts.push(`${waiting.length} task${waiting.length === 1 ? "" : "s"} waiting for you:`, ...waiting.slice(0, 5).map(line));
-  if (held.length) parts.push(`${held.length} you already claimed:`, ...held.slice(0, 5).map(line));
-  if (unread.length) parts.push(...unread.slice(0, 5).map((row) => `- ${row.task_id}: ${row.count} new message${row.count === 1 ? "" : "s"} from ${row.sender} on "${row.objective}" (read_thread)`));
-  if (goals.length) parts.push(`You are on ${goals.length} goal room${goals.length === 1 ? "" : "s"} (read_room to catch up, post_to_room to contribute):`, ...goals.slice(0, 5).map((goal) => `- ${goal.id}: ${goal.objective} · ${goal.posts} posts`));
-  parts.push("Read one with get_task, claim it with claim_task before working, and report_task when done or stuck.");
+  if (waiting.length)
+    parts.push(
+      `${waiting.length} task${waiting.length === 1 ? "" : "s"} waiting for you:`,
+      ...waiting.slice(0, 5).map(line)
+    );
+  if (held.length)
+    parts.push(
+      `${held.length} you already claimed:`,
+      ...held.slice(0, 5).map(line)
+    );
+  if (unread.length)
+    parts.push(
+      ...unread
+        .slice(0, 5)
+        .map(
+          (row) =>
+            `- ${row.task_id}: ${row.count} new message${row.count === 1 ? "" : "s"} from ${row.sender} on "${row.objective}" (read_thread)`
+        )
+    );
+  if (goals.length)
+    parts.push(
+      `You are on ${goals.length} goal room${goals.length === 1 ? "" : "s"} (read_room to catch up, post_to_room to contribute):`,
+      ...goals
+        .slice(0, 5)
+        .map((goal) => `- ${goal.id}: ${goal.objective} · ${goal.posts} posts`)
+    );
+  parts.push(
+    "Read one with get_task, claim it with claim_task before working, and report_task when done or stuck."
+  );
   return parts.join("\n");
 }
 
@@ -35,17 +69,35 @@ function queueText(agent, tasks, unread, goals) {
 export function queueDigest(agent, tasks, unread = [], goals = []) {
   return [
     ...(tasks || [])
-      .filter((task) => (task.status === "open" && (!task.target_agent || task.target_agent === agent)) || (task.claimed_by === agent && ["claimed", "needs_input"].includes(task.status)))
+      .filter(
+        (task) =>
+          (task.status === "open" &&
+            (!task.target_agent || task.target_agent === agent)) ||
+          (task.claimed_by === agent &&
+            ["claimed", "needs_input"].includes(task.status))
+      )
       .map((task) => `${task.id}:${task.status}:${task.version}`),
     ...unread.map((row) => `${row.task_id}:unread:${row.count}`),
     ...goals.map((goal) => `${goal.id}:goal:${goal.posts}`),
-  ].sort().join("|");
+  ]
+    .sort()
+    .join("|");
 }
 
 export async function boardQueue(agent) {
   try {
-    const response = await daemonRequest({ command: "board.list", agent, unread: true, swarm: true }, 1_500);
-    return response?.ok ? { tasks: response.tasks, unread: response.unread || [], goals: response.goals || [], swarm: response.swarm || null } : null;
+    const response = await daemonRequest(
+      { command: "board.list", agent, unread: true, swarm: true },
+      1_500
+    );
+    return response?.ok
+      ? {
+          tasks: response.tasks,
+          unread: response.unread || [],
+          goals: response.goals || [],
+          swarm: response.swarm || null,
+        }
+      : null;
   } catch {
     return null;
   }
@@ -53,15 +105,40 @@ export async function boardQueue(agent) {
 
 // What this agent was last told, in the Harness home: the queue's digest and the swarm's.
 const toldFile = (agent, homeDir) => path.join(homeDir, `nudge-${agent}.json`);
-function lastTold(agent, homeDir) { try { return JSON.parse(fs.readFileSync(toldFile(agent, homeDir), "utf8")); } catch { return {}; } }
-function noteTold(agent, homeDir, told) { try { fs.writeFileSync(toldFile(agent, homeDir), JSON.stringify({ ...lastTold(agent, homeDir), ...told, at: new Date().toISOString() }), { mode: 0o600 }); } catch {} }
+function lastTold(agent, homeDir) {
+  try {
+    return JSON.parse(fs.readFileSync(toldFile(agent, homeDir), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function noteTold(agent, homeDir, told) {
+  try {
+    fs.writeFileSync(
+      toldFile(agent, homeDir),
+      JSON.stringify({
+        ...lastTold(agent, homeDir),
+        ...told,
+        at: new Date().toISOString(),
+      }),
+      { mode: 0o600 }
+    );
+  } catch {}
+}
 
 /** What a session is told when it starts: its queue and the whole swarm. */
 export async function boardNudge(agent, homeDir = paths.home) {
   const queue = await boardQueue(agent);
   if (!queue) return "";
-  if (queue.swarm?.digest) noteTold(agent, homeDir, { swarm: queue.swarm.digest });
-  return nudgeText(agent, queue.tasks, queue.unread, queue.goals, queue.swarm?.text || "");
+  if (queue.swarm?.digest)
+    noteTold(agent, homeDir, { swarm: queue.swarm.digest });
+  return nudgeText(
+    agent,
+    queue.tasks,
+    queue.unread,
+    queue.goals,
+    queue.swarm?.text || ""
+  );
 }
 
 // Only what changed since this agent last saw its queue: a hook that runs on every prompt
@@ -76,40 +153,90 @@ export async function boardNudgeIfChanged(agent, homeDir = paths.home) {
   const queueMoved = digest !== (last.digest ?? null);
   const swarmMoved = Boolean(swarm?.digest) && swarm.digest !== last.swarm;
   if (!queueMoved && !swarmMoved) return "";
-  noteTold(agent, homeDir, { digest, ...(swarm?.digest ? { swarm: swarm.digest } : {}) });
-  const told = !queueMoved ? "" : digest ? queueText(agent, tasks, unread, goals) : (last.digest ? "Harness task board: nothing waits for you now." : "");
+  noteTold(agent, homeDir, {
+    digest,
+    ...(swarm?.digest ? { swarm: swarm.digest } : {}),
+  });
+  const told = !queueMoved
+    ? ""
+    : digest
+      ? queueText(agent, tasks, unread, goals)
+      : last.digest
+        ? "Harness task board: nothing waits for you now."
+        : "";
   return [told, swarmMoved ? swarm.text : ""].filter(Boolean).join("\n\n");
 }
 
 // The prompt hook also tells the daemon the person typed in this session: the agent process is the hook's parent, or
 // its grandparent when the hook runs through a shell.
-export const PS = ["/bin/ps", "/usr/bin/ps"].find((file) => fs.existsSync(file)) || "ps";
+export const PS =
+  ["/bin/ps", "/usr/bin/ps"].find((file) => fs.existsSync(file)) || "ps";
 
 function agentPids() {
   const pids = [process.ppid];
-  try { const up = Number(spawnSync(PS, ["-o", "ppid=", "-p", String(process.ppid)], { encoding: "utf8" }).stdout.trim()); if (up > 1) pids.push(up); } catch {}
+  try {
+    const up = Number(
+      spawnSync(PS, ["-o", "ppid=", "-p", String(process.ppid)], {
+        encoding: "utf8",
+      }).stdout.trim()
+    );
+    if (up > 1) pids.push(up);
+  } catch {}
   return pids;
 }
 
 // Where the session runs, as its own environment says (the agent's, which the hook shares): places.mjs reads it.
-const placeOf = (input) => ({ sessionId: input?.session_id, folder: input?.cwd || process.cwd(), env: placeEnv(process.env) });
+const placeOf = (input) => ({
+  sessionId: input?.session_id,
+  folder: input?.cwd || process.cwd(),
+  env: placeEnv(process.env),
+});
 
 // An extension or plugin running inside the agent passes its own process ids.
 export async function notePrompt(agent, input = null, pids = agentPids()) {
-  try { await daemonRequest({ command: "board.prompted", agent, pids, ...(input?.session_id ? placeOf(input) : {}) }, 1_500); } catch {}
+  try {
+    await daemonRequest(
+      {
+        command: "board.prompted",
+        agent,
+        pids,
+        ...(input?.session_id ? placeOf(input) : {}),
+      },
+      1_500
+    );
+  } catch {}
 }
 
 /** A session starting says where it runs. */
 export async function notePlace(agent, input, pids = agentPids()) {
   if (!input?.session_id) return;
-  try { await daemonRequest({ command: "board.live.place", agent, pids, ...placeOf(input) }, 1_500); } catch {}
+  try {
+    await daemonRequest(
+      { command: "board.live.place", agent, pids, ...placeOf(input) },
+      1_500
+    );
+  } catch {}
+}
+
+/** A turn ended with nothing more to do: the session waits for the person, and the buddy can say so. */
+export async function noteTurn(agent, input, pids = agentPids()) {
+  if (!input?.session_id) return;
+  try {
+    await daemonRequest(
+      { command: "board.live.turn", agent, pids, ...placeOf(input) },
+      1_500
+    );
+  } catch {}
 }
 
 // What the person sent this session from Harness (daemon board.live.say), taken once.
 export async function takeMessages(agent, sessionId) {
   if (!sessionId) return [];
   try {
-    const response = await daemonRequest({ command: "board.live.take", agent, sessionId }, 1_500);
+    const response = await daemonRequest(
+      { command: "board.live.take", agent, sessionId },
+      1_500
+    );
     return response?.ok ? response.messages || [] : [];
   } catch {
     return [];
@@ -117,7 +244,11 @@ export async function takeMessages(agent, sessionId) {
 }
 
 export function messagesText(messages) {
-  return messages.map((message) => `The person sent you this from Harness:\n\n${message.text}`).join("\n\n");
+  return messages
+    .map(
+      (message) => `The person sent you this from Harness:\n\n${message.text}`
+    )
+    .join("\n\n");
 }
 
 // The JSON the agent hands every hook on stdin (session_id among it); null when there is none.
@@ -125,10 +256,23 @@ async function hookInput() {
   if (process.stdin.isTTY) return null;
   let text = "";
   process.stdin.setEncoding("utf8");
-  const read = new Promise((resolve) => { process.stdin.on("data", (chunk) => { text += chunk; }); process.stdin.on("end", resolve); process.stdin.on("error", resolve); });
-  await Promise.race([read, new Promise((resolve) => setTimeout(resolve, 1_000).unref())]);
+  const read = new Promise((resolve) => {
+    process.stdin.on("data", (chunk) => {
+      text += chunk;
+    });
+    process.stdin.on("end", resolve);
+    process.stdin.on("error", resolve);
+  });
+  await Promise.race([
+    read,
+    new Promise((resolve) => setTimeout(resolve, 1_000).unref()),
+  ]);
   process.stdin.destroy();
-  try { return JSON.parse(text); } catch { return null; }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
@@ -139,12 +283,26 @@ if (import.meta.url === `file://${process.argv[1]}`) {
   if (process.argv.includes("--stop")) {
     // The Stop hook: a message waiting for this session keeps the agent going with it.
     const messages = await takeMessages(agent, sessionId);
-    if (messages.length) process.stdout.write(JSON.stringify({ decision: "block", reason: messagesText(messages) }) + "\n");
+    if (messages.length)
+      process.stdout.write(
+        JSON.stringify({ decision: "block", reason: messagesText(messages) }) +
+          "\n"
+      );
+    else await noteTurn(agent, input);
   } else {
     if (process.argv.includes("--if-changed")) await notePrompt(agent, input);
     else await notePlace(agent, input);
-    const messages = process.argv.includes("--if-changed") ? await takeMessages(agent, sessionId) : [];
-    const text = [messages.length ? messagesText(messages) : "", process.argv.includes("--if-changed") ? await boardNudgeIfChanged(agent) : await boardNudge(agent)].filter(Boolean).join("\n\n");
+    const messages = process.argv.includes("--if-changed")
+      ? await takeMessages(agent, sessionId)
+      : [];
+    const text = [
+      messages.length ? messagesText(messages) : "",
+      process.argv.includes("--if-changed")
+        ? await boardNudgeIfChanged(agent)
+        : await boardNudge(agent),
+    ]
+      .filter(Boolean)
+      .join("\n\n");
     if (text) process.stdout.write(text + "\n");
   }
 }

package/lib/ocr.mjs

@@ -0,0 +1,380 @@
+import fs from "node:fs";
+import path from "node:path";
+import pngjs from "pngjs";
+import jpeg from "jpeg-js";
+
+// On-device OCR for images that leave the computer (redact.mjs), with the browser's PP-OCR pair (localmodels.mjs "ocr")
+// ported to plain Node. The detector marks text as a probability map; each connected region of it becomes a box (DB
+// post-processing on axis-aligned regions, the shape screen text has), widened back to the text's full extent. Each
+// box is then read alone at the image's full resolution (per box, as the browser does: batching crops of different
+// widths changed reads), and every character keeps the stretch of the box it was read from, so part of a line can be
+// covered.
+
+// Larger images are refused rather than decoded (a 5 MB PNG can hold far more pixels than any screen).
+export const MAX_PIXELS = 40e6;
+// The detector's own settings (its inference.yml: thresh 0.2, box_thresh 0.45, unclip_ratio 1.4) at a long side of
+// 960 to 2,048 pixels: a retina screenshot is shrunk to 2,048 across, a small image is enlarged.
+const DET = {
+  min: 960,
+  max: 2_048,
+  thresh: 0.2,
+  boxThresh: 0.45,
+  unclip: 1.4,
+  mean: [0.485, 0.456, 0.406],
+  std: [0.229, 0.224, 0.225],
+};
+const REC = { height: 48, mean: [0.5, 0.5, 0.5], std: [0.5, 0.5, 0.5] };
+// Boxes read per scheduler job, so a long image does not hold the ONNX lane from the firewall's checks.
+const REC_PER_JOB = 24;
+
+export const imageKind = (bytes) =>
+  bytes?.length > 8 &&
+  bytes[0] === 0x89 &&
+  bytes[1] === 0x50 &&
+  bytes[2] === 0x4e &&
+  bytes[3] === 0x47
+    ? "png"
+    : bytes?.length > 3 &&
+        bytes[0] === 0xff &&
+        bytes[1] === 0xd8 &&
+        bytes[2] === 0xff
+      ? "jpeg"
+      : null;
+
+/** { width, height, data: RGBA } from PNG or JPEG bytes; null for any other format. Throws on a broken or oversized image. */
+export function decodeImage(bytes) {
+  const buffer = Buffer.from(
+    bytes.buffer ?? bytes,
+    bytes.byteOffset ?? 0,
+    bytes.byteLength ?? bytes.length
+  );
+  const kind = imageKind(buffer);
+  if (kind === "png") {
+    if (buffer.readUInt32BE(16) * buffer.readUInt32BE(20) > MAX_PIXELS)
+      throw new Error("the image is too large to check");
+    const { width, height, data } = pngjs.PNG.sync.read(buffer);
+    return { width, height, data };
+  }
+  if (kind === "jpeg")
+    return jpeg.decode(buffer, {
+      useTArray: true,
+      formatAsRGBA: true,
+      maxResolutionInMP: MAX_PIXELS / 1e6,
+      maxMemoryUsageInMB: 1_024,
+    });
+  return null;
+}
+
+/** The recogniser's characters, from the character_dict list in its inference.yml. */
+export function characterList(yml) {
+  const lines = yml.split(/\r?\n/);
+  const out = [];
+  for (const line of lines.slice(
+    lines.findIndex((each) => /^\s*character_dict:\s*$/.test(each)) + 1
+  )) {
+    const item = line.match(/^\s*- (.*)$/);
+    if (!item) break;
+    const value = item[1];
+    out.push(
+      value.startsWith("'")
+        ? value.slice(1, -1).replace(/''/g, "'")
+        : value.startsWith('"')
+          ? JSON.parse(value)
+          : value
+    );
+  }
+  if (!out.length)
+    throw new Error("the recogniser's character list is missing");
+  return out;
+}
+
+// Per axis, the source pixels and weights behind each output pixel: their average when shrinking, bilinear when growing.
+function taps(start, length, count, limit) {
+  const scale = length / count;
+  const at = (p) => Math.min(limit - 1, Math.max(0, p));
+  const out = new Array(count);
+  for (let i = 0; i < count; i += 1) {
+    const list = [];
+    if (scale > 1) {
+      const a = start + i * scale,
+        b = a + scale;
+      for (let p = Math.floor(a); p < b; p += 1) {
+        const w = Math.min(b, p + 1) - Math.max(a, p);
+        if (w > 0) list.push(at(p), w / scale);
+      }
+    } else {
+      const c = start + (i + 0.5) * scale - 0.5,
+        p = Math.floor(c),
+        f = c - p;
+      list.push(at(p), 1 - f, at(p + 1), f);
+    }
+    out[i] = list;
+  }
+  return out;
+}
+
+/** A region of the image resampled to width x height as a normalized BGR tensor (PaddleOCR's models read OpenCV's BGR); transparency is laid on white. */
+function tensorOf(image, [x0, y0, x1, y1], width, height, { mean, std }) {
+  const xs = taps(x0, x1 - x0, width, image.width),
+    ys = taps(y0, y1 - y0, height, image.height);
+  const plane = width * height,
+    out = new Float32Array(3 * plane),
+    data = image.data,
+    stride = image.width * 4;
+  for (let j = 0; j < height; j += 1) {
+    const ty = ys[j];
+    for (let i = 0; i < width; i += 1) {
+      const tx = xs[i];
+      let r = 0,
+        g = 0,
+        b = 0;
+      for (let v = 0; v < ty.length; v += 2) {
+        const row = ty[v] * stride,
+          wy = ty[v + 1];
+        for (let u = 0; u < tx.length; u += 2) {
+          const p = row + tx[u] * 4,
+            w = wy * tx[u + 1],
+            a = data[p + 3] / 255,
+            white = 255 * (1 - a);
+          r += (data[p] * a + white) * w;
+          g += (data[p + 1] * a + white) * w;
+          b += (data[p + 2] * a + white) * w;
+        }
+      }
+      const k = j * width + i;
+      out[k] = (b / 255 - mean[0]) / std[0];
+      out[plane + k] = (g / 255 - mean[1]) / std[1];
+      out[2 * plane + k] = (r / 255 - mean[2]) / std[2];
+    }
+  }
+  return out;
+}
+
+// DB post-processing: the regions above the threshold whose mean probability passes the box threshold, each grown by
+// area x unclip / perimeter on every side (the detector is trained on text shrunk by that much).
+function regions(map, width, height) {
+  const seen = new Uint8Array(width * height),
+    stack = new Int32Array(width * height),
+    boxes = [];
+  for (let start = 0; start < map.length; start += 1) {
+    if (seen[start] || map[start] <= DET.thresh) continue;
+    seen[start] = 1;
+    let top = 0,
+      x0 = width,
+      y0 = height,
+      x1 = -1,
+      y1 = -1,
+      sum = 0,
+      count = 0;
+    stack[top++] = start;
+    const visit = (q) => {
+      if (!seen[q] && map[q] > DET.thresh) {
+        seen[q] = 1;
+        stack[top++] = q;
+      }
+    };
+    while (top) {
+      const p = stack[--top],
+        x = p % width,
+        y = (p - x) / width;
+      sum += map[p];
+      count += 1;
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+      if (x > 0) visit(p - 1);
+      if (x < width - 1) visit(p + 1);
+      if (y > 0) visit(p - width);
+      if (y < height - 1) visit(p + width);
+    }
+    const w = x1 - x0 + 1,
+      h = y1 - y0 + 1;
+    if (Math.min(w, h) < 3 || sum / count < DET.boxThresh) continue;
+    const d = (w * h * DET.unclip) / (2 * (w + h));
+    boxes.push([x0 - d, y0 - d, x1 + 1 + d, y1 + 1 + d]);
+  }
+  return boxes;
+}
+
+// The detector's memory grows with its input (about 1 KB a pixel: 1.6 GB for a 2048x1280 screenshot, measured
+// October 14), and ONNX Runtime keeps memory for every input shape it has run. So the detector reads full-width bands
+// WINDOW rows tall, always the same shape (rows past the image and columns up to a multiple of 512 repeat its edge), and
+// the probability map is stitched from rows at least MARGIN from a band's edge. Lines are never cut: regions are found
+// on the whole map. On the image-redaction eval's screens this found what one pass did, and the OCR models' memory
+// levelled off at 544 MB instead of growing past 2 GB (160-row bands; 256 rows: 766 MB and about 10% faster).
+const BAND = 160,
+  MARGIN = 32,
+  WINDOW = BAND + 2 * MARGIN;
+
+async function detect(image, { ort, graph }) {
+  const long = Math.max(image.width, image.height);
+  const ratio = Math.min(DET.max, Math.max(DET.min, long)) / long;
+  const width = Math.max(32, Math.round((image.width * ratio) / 32) * 32),
+    height = Math.max(32, Math.round((image.height * ratio) / 32) * 32);
+  const columns = Math.ceil(width / 512) * 512;
+  const session = await graph("det/inference.onnx");
+  const sx = image.width / width,
+    sy = image.height / height;
+  const map = new Float32Array(width * height);
+  for (let top = 0; top < height; top += BAND) {
+    const a = Math.max(0, Math.min(top - MARGIN, height - WINDOW)),
+      rows = Math.min(WINDOW, height - a);
+    const pixels = tensorOf(
+        image,
+        [0, a * sy, image.width, (a + rows) * sy],
+        width,
+        rows,
+        DET
+      ),
+      input = new Float32Array(3 * WINDOW * columns);
+    // Padding repeats the edge pixels: a flat block beside the image made the detector see text in empty space.
+    for (let c = 0; c < 3; c += 1)
+      for (let y = 0; y < WINDOW; y += 1) {
+        const from = (c * rows + Math.min(y, rows - 1)) * width,
+          to = (c * WINDOW + y) * columns;
+        input.set(pixels.subarray(from, from + width), to);
+        input.fill(pixels[from + width - 1], to + width, to + columns);
+      }
+    const band = (
+      await session.run({
+        [session.inputNames[0]]: new ort.Tensor("float32", input, [
+          1,
+          3,
+          WINDOW,
+          columns,
+        ]),
+      })
+    )[session.outputNames[0]].data;
+    for (let y = top; y < Math.min(height, top + BAND); y += 1)
+      map.set(
+        band.subarray((y - a) * columns, (y - a) * columns + width),
+        y * width
+      );
+  }
+  return regions(map, width, height)
+    .map(([x0, y0, x1, y1]) => [
+      Math.max(0, x0 * sx),
+      Math.max(0, y0 * sy),
+      Math.min(image.width, x1 * sx),
+      Math.min(image.height, y1 * sy),
+    ])
+    .filter(([x0, y0, x1, y1]) => x1 - x0 >= 4 && y1 - y0 >= 4);
+}
+
+// ONNX Runtime keeps memory for every input shape it has run (400 crop widths: 108 MB grew to 513 MB, October 14), so
+// crops are padded on the right to a few widths, with 0 after normalization as PaddleOCR's own batches pad. Over this
+// eval's screens that changed 16 of 845 lines, by spacing or a dash, none of a planted value.
+const bucket = (width) =>
+  width <= 512 ? Math.ceil(width / 32) * 32 : Math.ceil(width / 64) * 64;
+
+// CTC greedy decoding that keeps, for each character, the output steps it was read over (each step is a fixed slice of
+// the crop's width).
+async function recognise(image, box, characters, { ort, graph }) {
+  const session = await graph("rec/inference.onnx");
+  const [x0, y0, x1, y1] = box;
+  const width = Math.max(8, Math.round((REC.height * (x1 - x0)) / (y1 - y0)));
+  const padded = bucket(width),
+    crop = tensorOf(image, box, width, REC.height, REC),
+    tensor = new Float32Array(3 * REC.height * padded);
+  for (let row = 0; row < 3 * REC.height; row += 1)
+    tensor.set(crop.subarray(row * width, (row + 1) * width), row * padded);
+  const input = new ort.Tensor("float32", tensor, [1, 3, REC.height, padded]);
+  const out = (await session.run({ [session.inputNames[0]]: input }))[
+    session.outputNames[0]
+  ];
+  const [, all, classes] = out.dims,
+    data = out.data;
+  const steps = Math.min(all, Math.ceil((all * width) / padded));
+  const space = classes === characters.length + 2 ? classes - 1 : -1;
+  const pixels = ((x1 - x0) / width) * (padded / all);
+  const read = [];
+  let total = 0,
+    previous = 0;
+  for (let t = 0; t < steps; t += 1) {
+    let best = 0,
+      p = data[t * classes];
+    for (let c = 1; c < classes; c += 1)
+      if (data[t * classes + c] > p) {
+        p = data[t * classes + c];
+        best = c;
+      }
+    if (best && best === previous)
+      read[read.length - 1].to = x0 + (t + 1) * pixels;
+    else if (best) {
+      read.push({
+        ch: best === space ? " " : (characters[best - 1] ?? ""),
+        from: x0 + t * pixels,
+        to: x0 + (t + 1) * pixels,
+      });
+      total += p;
+    }
+    previous = best;
+  }
+  // One entry per UTF-16 unit, so chars lines up with the text's indexes.
+  const text = read.map((each) => each.ch).join("");
+  const chars = read.flatMap(({ ch, from, to }) =>
+    Array.from({ length: ch.length }, () => [Math.floor(from), Math.ceil(to)])
+  );
+  const lead = text.length - text.trimStart().length,
+    kept = text.trim().length;
+  return {
+    text: text.trim(),
+    box: [Math.floor(x0), Math.floor(y0), Math.ceil(x1), Math.ceil(y1)],
+    score: read.length ? total / read.length : 0,
+    chars: chars.slice(lead, lead + kept),
+  };
+}
+
+// Top to bottom, left to right within a row (rows: boxes whose tops are within a quarter of their combined height).
+const readingOrder = (lines) =>
+  lines.sort((a, b) =>
+    Math.abs(a.box[1] - b.box[1]) <
+    (a.box[3] - a.box[1] + b.box[3] - b.box[1]) / 4
+      ? a.box[0] - b.box[0]
+      : a.box[1] - b.box[1]
+  );
+
+export function createOcr({ inference }) {
+  let characters = null;
+  /**
+   * The text in an image: { width, height, lines: [{ text, box: [x0, y0, x1, y1], score, chars: [[x0, x1]] }], ms }, boxes
+   * in the image's pixels. Takes PNG or JPEG bytes or a decoded { width, height, data: RGBA }.
+   */
+  const read = async (input, { lane = "handoff" } = {}) => {
+    const started = performance.now();
+    const image = input?.data && input.width ? input : decodeImage(input);
+    if (!image) throw new Error("only PNG and JPEG images can be read");
+    const boxes = await inference.onnx("ocr", (model) => detect(image, model), {
+      lane,
+    });
+    const lines = [];
+    for (let i = 0; i < boxes.length; i += REC_PER_JOB) {
+      lines.push(
+        ...(await inference.onnx(
+          "ocr",
+          async (model) => {
+            characters ||= characterList(
+              fs.readFileSync(
+                path.join(model.dir, "rec", "inference.yml"),
+                "utf8"
+              )
+            );
+            const read = [];
+            for (const box of boxes.slice(i, i + REC_PER_JOB))
+              read.push(await recognise(image, box, characters, model));
+            return read;
+          },
+          { lane }
+        ))
+      );
+    }
+    return {
+      width: image.width,
+      height: image.height,
+      lines: readingOrder(lines.filter((line) => line.text)),
+      ms: Math.round(performance.now() - started),
+    };
+  };
+  return { read };
+}