altalandi 0.6.1 → 0.6.3

package/batch.mjs

@@ -4,12 +4,13 @@
 // The order of things is the safety story:
 //   1. plan      read every document and cut it into passages (segment.mjs,
 //                web.mjs); nothing is sent yet
-//   2. estimate  files, passages, characters and billing units, printed before
-//                anything is sent
+//   2. estimate  files, passages and the characters billed, with the price,
+//                printed before anything is sent
 //   3. consent   a y/N question in a terminal, or --yes; with neither, nothing
 //                is sent (--dry-run stops here on purpose)
-//   4. refine    one call per passage, 2 at a time by default; a 429 waits for
-//                Retry-After, a 402 stops the run cleanly
+//   4. refine    short passages go together in batch requests (/v1/refine/batch),
+//                longer ones one call each; 2 requests at a time by default; a
+//                429 waits for Retry-After, a 402 stops the run cleanly
 //   5. write     each file once all its passages are back; a passage whose
 //                meaning check did not pass keeps its original text; nothing is
 //                ever written inside the input
@@ -18,12 +19,13 @@
 // Every side effect is injectable (io), so the tests need no network, terminal
 // or API key.
 
+import { randomInt } from "node:crypto";
 import { existsSync, statSync } from "node:fs";
 import { mkdir, readdir, readFile, realpath, writeFile } from "node:fs/promises";
 import path from "node:path";
 
-import { refine } from "./client.mjs";
-import { writeBatchReport } from "./report.mjs";
+import { refine, refineBatch } from "./client.mjs";
+import { CHARS_PER_WORD, charsEquivalent, formatChars, formatIsk, writeBatchReport } from "./report.mjs";
 import { assemble, FORMATS, isConfigJson, repairCodeSpans, segment, segmentMarkdown, splitForApi } from "./segment.mjs";
 import { pagePath, readPage, readSite, safeSegment, userAgent } from "./web.mjs";
 
@@ -39,6 +41,23 @@ const MAX_RETRY_WAIT_MS = 5 * 60_000; // a longer Retry-After means "come back l
 const MAX_RATE_LIMIT_RETRIES = 8;
 const MAX_TRANSIENT_RETRIES = 2;
 const ERRORS_IN_A_ROW_TO_STOP = 3;
+// Short passages go to /v1/refine/batch: each is billed at least 130 characters
+// there instead of the 250-character call minimum, which is paid once per
+// request. A request
+// stays small enough to come back well inside the web proxy's ~300 s timeout
+// (the server refines 4 at a time: ~40 short items take a minute or two).
+export const BATCH_PASSAGE_MAX_CHARS = 1500;
+export const BATCH_MAX_ITEMS = 40;
+export const BATCH_MAX_CHARS = 6000;
+// When /v1/pricing says neither (minimumBillableChars / batchItemMinimumChars)
+// nor the word units of an older engine.
+const MIN_BILLABLE_CHARS = 250;
+const BATCH_ITEM_MIN_CHARS = 130;
+// One run is one job ("verk") on the account: every request names it, and each
+// file or page is a part. The engine keeps a title of 120 and a part of 300.
+export const JOB_ID_PATTERN = /^j_[A-Za-z0-9_-]{8,64}$/;
+const JOB_TITLE_MAX = 120;
+const JOB_PART_MAX = 300;
 const DOMAINS = ["general", "marketing", "data-analysis", "childrens-fiction"];
 const REGISTERS = ["formal", "neutral", "warm"];
 
@@ -60,10 +79,19 @@ const preview = (s, n = 72) => {
   return one.length > n ? `${one.slice(0, n - 1)}…` : one;
 };
 
-/** Every whitespace token is at least one billing unit; a long unbroken token
- *  is one unit per 20 characters (the server's rule, docs/api/README.md). */
-const billingTokens = (text) => text.split(/\s+/).filter(Boolean)
-  .reduce((n, t) => n + Math.max(1, Math.ceil(t.length / 20)), 0);
+/** A new job id: `j_`, the UTC date (yyyymmdd) and 10 random [a-z0-9]. */
+export function newJobId(now = Date.now()) {
+  const abc = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const date = new Date(now).toISOString().slice(0, 10).replace(/-/g, "");
+  return `j_${date}${Array.from({ length: 10 }, () => abc[randomInt(abc.length)]).join("")}`;
+}
+
+/** At most n code points, so a cut never splits a surrogate pair. */
+const cap = (s, n) => [...String(s)].slice(0, n).join("");
+
+/** Billable characters: every Unicode code point of the trimmed text, spaces,
+ *  punctuation and line breaks included (the server's rule). */
+export const billableChars = (text) => [...String(text).trim()].length;
 
 /** The real path of p, or of its deepest existing ancestor plus the rest, so a
  *  symlinked --out is compared where it really points. */
@@ -147,9 +175,10 @@ async function planFolder(opts, io) {
       }
     }
     file.status = file.note ? "copy" : "refine";
+    file.part = rel;
     files.push(file);
   }
-  return { mode: "folder", label: opts.target, input, output, outputIsFolder: true, files };
+  return { mode: "folder", label: opts.target, title: path.basename(given), input, output, outputIsFolder: true, files };
 }
 
 const withSource = (page) => `<!-- Source: ${page.url} -->\n\n${page.markdown}\n`;
@@ -158,7 +187,7 @@ function pageFile(page, rel, target) {
   const text = withSource(page);
   const { units } = segmentMarkdown(text);
   return {
-    path: rel, source: page.url, target, format: "md", text, units,
+    path: rel, source: page.url, part: page.url, target, format: "md", text, units,
     status: units.length ? "refine" : "copy", note: units.length ? undefined : "nothing to refine",
   };
 }
@@ -172,7 +201,7 @@ async function planWeb(opts, io, log) {
     const name = `${last === "index" ? safeSegment(new URL(page.url).host) : last}-is.md`;
     let target = path.resolve(cwd, opts.out || name);
     if (existsSync(target) && statSync(target).isDirectory()) target = path.join(target, name);
-    return { mode: "page", label: opts.target, output: target, outputIsFolder: false, files: [pageFile(page, path.basename(target), target)] };
+    return { mode: "page", label: opts.target, title: new URL(page.url).host, output: target, outputIsFolder: false, files: [pageFile(page, path.basename(target), target)] };
   }
   log(`Reading ${opts.target} (up to ${plural(opts.maxPages, "page", "pages")}) …`);
   const { pages, skipped, source } = await readSite(opts.target, {
@@ -187,7 +216,7 @@ async function planWeb(opts, io, log) {
     taken.add(rel.toLowerCase());
     return pageFile(page, rel, path.join(output, ...rel.split("/")));
   });
-  return { mode: "site", label: opts.target, output, outputIsFolder: true, files, skipped, discovery: source };
+  return { mode: "site", label: opts.target, title: new URL(pages[0].url).host, output, outputIsFolder: true, files, skipped, discovery: source };
 }
 
 // ── calls ───────────────────────────────────────────────────────────────────
@@ -213,7 +242,8 @@ function buildCalls(files, maxChars) {
       continue;
     }
     budgetUsed += added;
-    for (const [text, call] of fresh) calls.set(text, call);
+    // A call belongs to the first file that sends it: that file is its part.
+    for (const [text, call] of fresh) calls.set(text, Object.assign(call, { part: file.part }));
     for (const unit of file.units) {
       unit.file = file;
       for (const call of new Set(unit.calls)) call.units.push(unit);
@@ -222,6 +252,49 @@ function buildCalls(files, maxChars) {
   return [...calls.values()];
 }
 
+/** The requests of a run: short calls together in batches of at most
+ *  BATCH_MAX_ITEMS items and BATCH_MAX_CHARS characters, longer ones alone.
+ *  A batch takes whole files: when a file's short calls fit in a batch of
+ *  their own but not in the room left in the open one, that batch is closed
+ *  and the file starts the next, so a file is split only when it alone is
+ *  bigger than a batch. Small files still share a batch (named by the first
+ *  file's part). The limits are unchanged, and closing a batch early costs
+ *  nothing: two or more items are already past the call minimum. */
+export function groupCalls(calls) {
+  const requests = [];
+  let open = null;
+  const isShort = (c) => c.text.length <= BATCH_PASSAGE_MAX_CHARS;
+  for (let i = 0; i < calls.length;) {
+    let end = i;
+    while (end < calls.length && calls[end].part === calls[i].part) end++;
+    const file = calls.slice(i, end);
+    i = end;
+    const short = file.filter(isShort);
+    const chars = short.reduce((n, c) => n + c.text.length, 0);
+    const fitsAlone = short.length <= BATCH_MAX_ITEMS && chars <= BATCH_MAX_CHARS;
+    if (open && short.length && fitsAlone
+      && (open.calls.length + short.length > BATCH_MAX_ITEMS || open.chars + chars > BATCH_MAX_CHARS)) open = null;
+    for (const call of file) {
+      if (!isShort(call)) { requests.push({ batch: false, calls: [call] }); continue; }
+      if (open && (open.calls.length >= BATCH_MAX_ITEMS || open.chars + call.text.length > BATCH_MAX_CHARS)) open = null;
+      if (!open) { open = { batch: true, calls: [], chars: 0 }; requests.push(open); }
+      open.calls.push(call);
+      open.chars += call.text.length;
+    }
+  }
+  return requests;
+}
+
+/** Characters a request is billed: the call minimum for one text; for a batch,
+ *  each item at least the item minimum, the call minimum once for the request. */
+function jobChars(job, pricing) {
+  if (!job.batch) return Math.max(pricing.minChars, billableChars(job.calls[0].text));
+  const items = job.calls.reduce((n, c) => n + Math.max(pricing.itemMinChars, billableChars(c.text)), 0);
+  return Math.max(pricing.minChars, items);
+}
+
+const fin = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+
 async function fetchPricing(baseUrl, fetchImpl) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 5000);
@@ -230,12 +303,20 @@ async function fetchPricing(baseUrl, fetchImpl) {
     if (!res.ok) return null;
     const p = JSON.parse(await res.text());
     const lane = p?.tiers?.standard?.fast;
-    if (!Number.isFinite(p?.minimumBillableUnits) || !lane) return null;
+    if (!lane || typeof lane !== "object") return null;
+    // Characters (billingUnit "character"); an engine from before the switch
+    // gives word units, converted with charsPerWord.
+    const cpw = fin(p.charsPerWord) > 0 ? p.charsPerWord : CHARS_PER_WORD;
+    const chars = (c, u) => fin(p[c]) ?? (fin(p[u]) != null ? Math.round(p[u] * cpw) : null);
+    // The tier's price already carries its weight, as iskPer1000Units did.
+    const per100 = fin(lane.iskPer100Chars) ?? (fin(lane.iskPer1000Units) != null ? lane.iskPer1000Units / 10 / cpw : null);
     return {
-      minUnits: p.minimumBillableUnits,
+      minChars: chars("minimumBillableChars", "minimumBillableUnits") ?? MIN_BILLABLE_CHARS,
+      itemMinChars: chars("batchItemMinimumChars", "batchItemMinimumUnits") ?? BATCH_ITEM_MIN_CHARS,
       multiplier: Number(lane.multiplier) || 1,
-      iskPer1000: Number(lane.iskPer1000Units),
-      freeDaily: Number(p.accountFreeDailyUnits) || 0,
+      iskPerChar: per100 != null ? per100 / 100 : null,
+      freeDaily: chars("accountFreeDailyChars", "accountFreeDailyUnits") ?? 0,
+      charsPerWord: cpw,
     };
   } catch {
     return null;
@@ -244,14 +325,22 @@ async function fetchPricing(baseUrl, fetchImpl) {
   }
 }
 
-function estimateLines(plan, calls, pricing, opts) {
+function estimateLines(plan, calls, jobs, pricing, opts) {
   const refining = plan.files.filter((f) => f.status === "refine");
   const passages = refining.reduce((n, f) => n + f.units.length, 0);
   const chars = calls.reduce((n, c) => n + c.text.length, 0);
   const lines = [
     `${plural(refining.length, "file", "files")}, ${plural(passages, "passage", "passages")}, about ${fmt(chars)} characters`
-      + `${calls.length !== passages ? ` (${plural(calls.length, "call", "calls")}: repeated passages are sent once)` : ""}.`,
+      + `${calls.length !== passages ? ` (${fmt(calls.length)} to send: repeated passages are sent once)` : ""}.`,
   ];
+  const batches = jobs.filter((j) => j.batch);
+  if (calls.length) {
+    const together = batches.reduce((n, j) => n + j.calls.length, 0);
+    const alone = jobs.length - batches.length;
+    lines.push(`${plural(jobs.length, "request", "requests")}: `
+      + [together && `${plural(together, "short passage", "short passages")} together in ${plural(batches.length, "batch", "batches")}`,
+        alone && `${plural(alone, "longer passage", "longer passages")} one by one`].filter(Boolean).join(", ") + ".");
+  }
   const copied = plan.files.filter((f) => f.status === "copy").length;
   if (copied) lines.push(`${plural(copied, "more file has", "more files have")} nothing to refine and ${copied === 1 ? "is" : "are"} copied unchanged.`);
   const over = plan.files.filter((f) => f.status === "over-budget");
@@ -260,10 +349,16 @@ function estimateLines(plan, calls, pricing, opts) {
       + `(from ${over[0].path} on).`);
   }
   if (pricing && calls.length) {
-    const units = calls.reduce((n, c) => n + Math.max(pricing.minUnits, billingTokens(c.text)), 0) * pricing.multiplier;
-    const isk = Number.isFinite(pricing.iskPer1000) ? `, about ${fmt((units * pricing.iskPer1000) / 1000)} kr if paid from credit` : "";
-    lines.push(`Billing: about ${fmt(units)} units (at least ${fmt(pricing.minUnits)} a call)${isk}.`
-      + `${pricing.freeDaily ? ` The free allowance is ${fmt(pricing.freeDaily)} units a day.` : ""}`);
+    // In Icelandic, as on the site: characters, one equivalent and krónur;
+    // never the rate per 100 characters.
+    const raw = jobs.reduce((n, j) => n + jobChars(j, pricing), 0);
+    const billed = raw * pricing.multiplier;
+    const isk = pricing.iskPerChar != null ? raw * pricing.iskPerChar : null;
+    const price = isk != null ? `, um ${formatIsk(isk >= 10 ? Math.round(isk) : isk)} ef greitt er af inneign` : "";
+    lines.push(`Kostnaður: um ${formatChars(billed)} (${charsEquivalent(billed)})${price}.`);
+    const rule = `Hvert kall telst minnst ${formatChars(pricing.minChars)}`
+      + (batches.length ? `; margir stuttir textar í einu kalli minnst ${formatChars(pricing.itemMinChars)} hver.` : ".");
+    lines.push(rule + (pricing.freeDaily ? ` ${formatChars(pricing.freeDaily)} á dag eru ókeypis.` : ""));
   }
   return lines;
 }
@@ -354,6 +449,11 @@ export async function runBatch(opts, io = {}) {
   const maxPages = opts.maxPages ?? 20;
   if (!Number.isInteger(maxPages) || maxPages < 1) { log("--max-pages must be a positive whole number."); return EXIT_ERROR; }
   if (opts.site && !isUrl) { log("--site needs a URL, such as https://example.com"); return EXIT_ERROR; }
+  if (opts.part !== undefined) { log("--part is for one text. A folder or site run names each part by its file or page."); return EXIT_ERROR; }
+  if (opts.job !== undefined && !JOB_ID_PATTERN.test(String(opts.job))) {
+    log("--job must be j_ followed by 8 to 64 letters, digits, _ or - (for example j_20261013a1b2c3).");
+    return EXIT_ERROR;
+  }
   // Checked here, not by the API: a bad value would otherwise fail every call.
   if (!DOMAINS.includes(opts.domain ?? "general")) { log(`--domain must be one of: ${DOMAINS.join(", ")}`); return EXIT_ERROR; }
   if (!REGISTERS.includes(opts.register ?? "neutral")) { log(`--register must be one of: ${REGISTERS.join(", ")}`); return EXIT_ERROR; }
@@ -369,6 +469,7 @@ export async function runBatch(opts, io = {}) {
     return EXIT_ERROR;
   }
   const calls = buildCalls(plan.files, opts.maxChars);
+  const jobs = groupCalls(calls);
   const baseUrl = (opts.baseUrl || "https://altalandi.is/api").replace(/\/+$/, "");
   const where = `${plan.label} → ${display(plan.output, cwd)}`;
   const refining = () => plan.files.filter((f) => f.status === "refine");
@@ -379,7 +480,7 @@ export async function runBatch(opts, io = {}) {
   }
   // The public tariff: no key, no text sent, nothing charged.
   const pricing = calls.length ? await fetchPricing(baseUrl, fetchImpl) : null;
-  const estimate = estimateLines(plan, calls, pricing, opts);
+  const estimate = estimateLines(plan, calls, jobs, pricing, opts);
 
   if (opts.dryRun) {
     if (opts.json) {
@@ -434,7 +535,18 @@ export async function runBatch(opts, io = {}) {
     await writeFile(target, data);
   };
 
-  const state = { stop: null, pausedUntil: 0, errorsInARow: 0 };
+  const state = { stop: null, pausedUntil: 0, errorsInARow: 0, noBatch: false, billed: null, billedChars: null, approx: false };
+  // What a response says it billed: characters, or the word units of an
+  // engine from before the switch (converted, and marked as approximate).
+  const bill = (data) => {
+    const b = data?.billing || {};
+    const units = fin(b.units) ?? fin(data?.units);
+    if (units != null) state.billed = (state.billed ?? 0) + units;
+    const chars = fin(b.characters) ?? fin(data?.characters);
+    if (chars == null && units == null) return;
+    if (chars == null) state.approx = true;
+    state.billedChars = (state.billedChars ?? 0) + (chars ?? units * (pricing?.charsPerWord ?? CHARS_PER_WORD));
+  };
   const stop = (reason, message) => { if (!state.stop) state.stop = { reason, message }; };
 
   for (const f of plan.files.filter((x) => x.status === "copy")) {
@@ -448,20 +560,40 @@ export async function runBatch(opts, io = {}) {
     ...(opts.noStore ? { contribute: false } : {}),
     ...(io.fetch ? { fetch: io.fetch } : {}),
   };
+  // One job for the whole run (--job joins an existing one); each request names
+  // its part: the file's relative path, or the page URL.
+  const runJob = {
+    id: opts.job || newJobId(now()),
+    title: cap(opts.jobTitle || plan.title || plan.label || "", JOB_TITLE_MAX),
+  };
+  const withPart = (part) => ({
+    ...requestOptions,
+    job: { id: runJob.id, ...(runJob.title ? { title: runJob.title } : {}), ...(part ? { part: cap(part, JOB_PART_MAX) } : {}) },
+  });
+  // The job's page, from the first response that names it (an older engine never does).
+  const noteJob = (data) => {
+    if (state.jobUrl) return;
+    const url = [data?.jobUrl, data?.items?.[0]?.jobUrl].find((u) => typeof u === "string" && u);
+    if (url) Object.assign(state, { jobUrl: url, jobId: typeof data.jobId === "string" && data.jobId ? data.jobId : runJob.id });
+  };
 
   const pause = async () => {
     for (let left = state.pausedUntil - now(); left > 0; left = state.pausedUntil - now()) await wait(left);
   };
 
-  const callOnce = async (call) => {
+  // One request with the run's retry rules: `send` is one /v1/refine or one
+  // /v1/refine/batch call. A batch endpoint the server does not have (404/405,
+  // an older self-hosted engine) answers { unsupported }.
+  const attempt = async (send, { batch = false } = {}) => {
     let rateLimited = 0;
     let transient = 0;
     for (;;) {
       await pause();
       if (state.stop) return { skipped: true };
       try {
-        return { data: await refine(call.text, requestOptions) };
+        return { data: await send() };
       } catch (e) {
+        if (batch && (e.status === 404 || e.status === 405)) return { unsupported: true };
         if (e.status === 429) {
           rateLimited++;
           const ms = Number.isFinite(e.retryAfterMs) ? e.retryAfterMs : Math.min(60_000, 2000 * 2 ** (rateLimited - 1));
@@ -515,32 +647,99 @@ export async function runBatch(opts, io = {}) {
     }
   };
 
-  const done = async (call) => {
-    if (call.result.skipped) return;
-    if (call.result.error) {
-      state.errorsInARow++;
-      if (state.errorsInARow >= ERRORS_IN_A_ROW_TO_STOP) stop("error", `${state.errorsInARow} calls in a row failed; the last: ${call.result.error}`);
-    } else {
-      state.errorsInARow = 0;
+  const countError = (error) => {
+    state.errorsInARow++;
+    if (state.errorsInARow >= ERRORS_IN_A_ROW_TO_STOP) stop("error", `${state.errorsInARow} calls in a row failed; the last: ${error}`);
+  };
+
+  const done = async (job) => {
+    if (job.calls.some((c) => c.result?.skipped)) return;
+    if (job.failed) countError(job.failed); // a whole request failed: one error, not one per passage
+    else {
+      for (const call of job.calls) {
+        if (call.result.error) countError(call.result.error);
+        else state.errorsInARow = 0;
+      }
     }
-    for (const unit of call.units) {
-      if (unit.status || !unit.calls.every((c) => c.result && !c.result.skipped)) continue;
-      settle(unit);
-      const file = unit.file;
-      if (file.status === "refine" && file.units.every((u) => u.status)) await finish(file);
+    for (const call of job.calls) {
+      for (const unit of call.units) {
+        if (unit.status || !unit.calls.every((c) => c.result && !c.result.skipped)) continue;
+        settle(unit);
+        const file = unit.file;
+        if (file.status === "refine" && file.units.every((u) => u.status)) await finish(file);
+      }
     }
   };
 
+  const single = async (call) => {
+    const r = await attempt(() => refine(call.text, withPart(call.part)));
+    if (r.data) { bill(r.data); noteJob(r.data); }
+    return r;
+  };
+
+  /** One batch request; every item is mapped back to its call by id. */
+  const sendBatch = async (job) => {
+    const items = job.calls.map((c, k) => ({ id: String(k), text: c.text }));
+    // A batch that holds several small files is named by its first.
+    const r = await attempt(() => refineBatch(items, withPart(job.calls[0].part)), { batch: true });
+    if (!r.data) return r;
+    const data = r.data;
+    bill(data);
+    noteJob(data);
+    const byId = new Map(data.items.map((it) => [String(it.id), it]));
+    const artifacts = data.quality?.encodingArtifacts || [];
+    job.calls.forEach((call, k) => {
+      const item = byId.get(String(k));
+      if (!item) call.result = { error: "the batch response has no result for this passage" };
+      else if (item.error) call.result = { error: String(item.error) };
+      else {
+        // The batch's quality block covers every item; keep the mojibake guard per item.
+        const own = artifacts.filter((a) => a && String(item.output).includes(a));
+        call.result = { data: { ...item, id: data.id || undefined, quality: { encodingArtifacts: own } } };
+      }
+    });
+    return { done: true };
+  };
+
+  const alone = (job) => job.calls.map((call) => ({ batch: false, calls: [call] }));
   const hadWork = refining().length > 0;
-  const queue = [...calls];
+  const queue = [...jobs];
   const worker = async () => {
     while (queue.length && !state.stop) {
-      const call = queue.shift();
-      call.result = await callOnce(call);
-      await done(call);
+      const job = queue.shift();
+      if (job.batch && state.noBatch) { queue.unshift(...alone(job)); continue; }
+      if (!job.batch) {
+        job.calls[0].result = await single(job.calls[0]);
+      } else {
+        const r = await sendBatch(job);
+        if (r.unsupported) {
+          if (!state.noBatch) {
+            state.noBatch = true;
+            log("Note: this server has no batch endpoint (/v1/refine/batch), so every passage is sent on its own "
+              + `(each call is billed at least ${fmt(pricing?.minChars ?? MIN_BILLABLE_CHARS)} characters).`);
+          }
+          queue.unshift(...alone(job));
+          fill(); // one batch became many calls: use every worker for them
+          continue;
+        }
+        if (!r.done) {
+          for (const call of job.calls) call.result = r;
+          if (r.error) job.failed = r.error;
+        }
+      }
+      await done(job);
     }
   };
-  await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(1, calls.length)) }, worker));
+  const running = [];
+  let active = 0;
+  function fill() {
+    while (active < concurrency && queue.length && !state.stop) {
+      active++;
+      running.push(worker().finally(() => { active--; }));
+    }
+  }
+  fill();
+  while (running.length) await Promise.all(running.splice(0));
 
   for (const f of plan.files) if (f.status === "refine") f.status = "unfinished";
 
@@ -576,8 +775,15 @@ export async function runBatch(opts, io = {}) {
       kept: count("kept"),
       failed: count("failed"),
       characters: calls.filter((c) => c.result && !c.result.skipped).reduce((n, c) => n + c.text.length, 0),
+      // What the server says it billed, summed over the responses (null: none
+      // said). billedCharacters is what is shown; units is the word equivalent.
+      billedCharacters: state.billedChars == null ? null
+        : state.approx ? Math.round(state.billedChars / 10) * 10 : Math.round(state.billedChars),
+      ...(state.approx ? { billedCharactersApprox: true } : {}),
+      units: state.billed,
     },
     ...(plan.skipped?.length ? { skippedPages: plan.skipped } : {}),
+    ...(state.jobUrl ? { jobId: state.jobId, jobUrl: state.jobUrl } : {}),
     files,
   };
 
@@ -612,6 +818,11 @@ export async function runBatch(opts, io = {}) {
   log(`\n${state.stop ? "Partly done" : "Done"}: ${plural(t.written + t.unchanged + t.copied, "file", "files")} in ${display(plan.output, cwd)}`
     + `${t.copied ? ` (${fmt(t.copied)} copied unchanged)` : ""}.`
     + (hadWork ? ` Passages: ${fmt(t.changed)} changed, ${fmt(t.unchangedPassages)} needed no change, ${fmt(t.kept)} kept as they were, ${fmt(t.failed)} failed.` : ""));
+  // One link for the whole run, never one per call.
+  if (summary.jobUrl) log(`Verkið: ${summary.jobUrl}`);
+  if (t.billedCharacters != null) {
+    log(`Rukkað: ${t.billedCharactersApprox ? "um " : ""}${formatChars(t.billedCharacters)} (${charsEquivalent(t.billedCharacters)}).`);
+  }
   if (t.kept) log(`${plural(t.kept, "passage keeps", "passages keep")} the original text because a check did not pass; the report lists ${t.kept === 1 ? "it" : "them"}.`);
   if (t.overBudget) log(`${plural(t.overBudget, "file was", "files were")} left out for --max-chars.`);
   if (summary.report) log(`Report: ${display(summary.report, cwd)}`);