Files
stack/packages/webui/tests/triage-route-store.test.mjs
jason.woltje c9fad00d25 fix(triage): review round for the route store
The file owner check has its own test through a file-owner seam, for
route.json on read and write and for route-receipts.jsonl on write. The
directory, temp file and a new receipts file get their modes on the open
descriptor, so a narrow umask cannot leave a route the next read refuses;
an existing receipts file is never repaired. A failed temp write refuses
and removes the temp file. A failure after the rename refuses as
triage-route-unrecorded and names the new revision. The input zone check
uses the stored cap's rule, so +05:00 refuses as an unknown zone. A
changed cap keeps its since, as an organization's token limits do, so
lowering the cap never drops tokens already counted (#1873, lane
triage-route-store).
2026-11-18 12:05:07 -06:00

425 lines
23 KiB
JavaScript

// #1873 triage-route-store: the owner-only file that holds Triage's model route and daily cap,
// <dataRoot>/triage/route.json (design report section 1, option C). Names only: no env value and
// no key. The directory is 0700 and the file 0600, both the running user's; a link, a non-file,
// a wrong mode or owner refuses. A write is compare-and-set on revision, atomic (temp file plus
// rename in the same directory), and appends one receipt line.
import { test } from "node:test";
import assert from "node:assert/strict";
import { spawn } from "node:child_process";
import { chmodSync, existsSync, linkSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import {
CAP_FIELDS, ROUTE_FIELDS, ROUTE_VERSION, RouteStoreError, capFor, readRoute, routePaths, validRoute, writeRoute,
} from "../src/triage-route-store.mjs";
const MODULE = new URL("../src/triage-route-store.mjs", import.meta.url).pathname;
const NOW = "2026-11-18T12:00:00.000Z";
const LATER = "2026-11-18T13:00:00.000Z";
const at = (iso) => () => new Date(iso);
const INPUT = { model: "glm-5", harness: "claude-code", limit: 200000, timeZone: "America/Chicago", by: "owner" };
function root(t) {
const dir = mkdtempSync(join(process.env.TMPDIR, "trs-"));
t.after(() => rmSync(dir, { recursive: true, force: true }));
return dir;
}
const code = (c) => (e) => e instanceof RouteStoreError && e.code === c;
// Unreadable with a given reason, so each check is shown to refuse on its own.
const unreadableFor = (re) => (e) => code("triage-route-unreadable")(e) && re.test(e.message);
const receipts = (dataRoot) => readFileSync(routePaths(dataRoot).receipts, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
const good = () => ({
version: 1, revision: 1, model: "glm-5", harness: "claude-code",
cap: { limit: 200000, since: NOW, reset: "00:00", timeZone: "America/Chicago" }, updatedAt: NOW, updatedBy: "owner",
});
// Write a doc straight to route.json at the right modes, to test the loader alone.
function plant(dataRoot, doc) {
const { dir, file } = routePaths(dataRoot);
mkdirSync(dir, { recursive: true, mode: 0o700 });
chmodSync(dir, 0o700);
writeFileSync(file, typeof doc === "string" ? doc : JSON.stringify(doc), { mode: 0o600 });
chmodSync(file, 0o600);
}
test("paths, field names and the reset rule each live in one place", () => {
const p = routePaths("/d");
assert.deepEqual(p, { dir: "/d/triage", file: "/d/triage/route.json", receipts: "/d/triage/route-receipts.jsonl", lock: "/d/triage/route.lock" });
assert.deepEqual([...ROUTE_FIELDS].sort(), ["cap", "harness", "model", "revision", "updatedAt", "updatedBy", "version"]);
assert.deepEqual([...CAP_FIELDS].sort(), ["limit", "reset", "since", "timeZone"]);
assert.equal(ROUTE_VERSION, 1);
// A new cap starts its count now and resets at 00:00 in the owner's zone.
assert.deepEqual(capFor({ limit: 5, timeZone: "UTC", previous: null, now: NOW }), { limit: 5, since: NOW, reset: "00:00", timeZone: "UTC" });
// A later cap keeps its since, changed or not, as an organization's token limits do: lowering
// the cap never drops the tokens already counted.
const prev = { limit: 5, since: NOW, reset: "00:00", timeZone: "UTC" };
assert.equal(capFor({ limit: 5, timeZone: "UTC", previous: prev, now: LATER }).since, NOW);
assert.equal(capFor({ limit: 2, timeZone: "UTC", previous: prev, now: LATER }).since, NOW);
assert.equal(capFor({ limit: 5, timeZone: "Europe/Berlin", previous: prev, now: LATER }).since, NOW);
});
test("no file reads as not set; a write then reads back the same route", (t) => {
const d = root(t);
assert.equal(readRoute(d), null);
const written = writeRoute(d, INPUT, { now: at(NOW) });
assert.deepEqual(written, good());
assert.deepEqual(readRoute(d), good());
const { dir, file } = routePaths(d);
assert.equal(lstatSync(dir).mode & 0o777, 0o700);
assert.equal(lstatSync(file).mode & 0o777, 0o600);
// The store holds names only: nothing shaped like an env value or a key.
const text = readFileSync(file, "utf8");
assert.doesNotMatch(text, /ANTHROPIC|_KEY|TOKEN|mst-|msk-|env/i);
// A second write bumps the revision and keeps the cap's since when the cap is the same.
const second = writeRoute(d, { ...INPUT, model: "glm-5.3-flash", revision: 1 }, { now: at(LATER) });
assert.equal(second.revision, 2);
assert.equal(second.model, "glm-5.3-flash");
assert.equal(second.cap.since, NOW);
assert.equal(second.updatedAt, LATER);
assert.deepEqual(readRoute(d), second);
// No temp file or lock is left behind.
assert.deepEqual(readdirSync(dir).sort(), ["route-receipts.jsonl", "route.json"]);
});
test("each write appends one receipt line with the old and the new value", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
writeRoute(d, { ...INPUT, limit: 1000 }, { now: at(LATER) });
const lines = receipts(d);
assert.equal(lines.length, 2);
assert.deepEqual(lines[0], { at: NOW, by: "owner", revision: 1, from: null, to: { model: "glm-5", harness: "claude-code", cap: good().cap } });
assert.equal(lines[1].revision, 2);
assert.deepEqual(lines[1].from, { model: "glm-5", harness: "claude-code", cap: good().cap });
assert.equal(lines[1].to.cap.limit, 1000);
assert.equal(lines[1].to.cap.since, NOW);
assert.equal(lstatSync(routePaths(d).receipts).mode & 0o777, 0o600);
// A refused write appends nothing.
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-stale"));
assert.equal(receipts(d).length, 2);
});
test("a stale revision refuses and leaves the file alone", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
writeRoute(d, { ...INPUT, limit: 7, revision: 1 }, { now: at(NOW) });
const before = readFileSync(routePaths(d).file, "utf8");
assert.throws(() => writeRoute(d, { ...INPUT, limit: 9, revision: 1 }, { now: at(LATER) }), code("triage-route-stale"));
assert.throws(() => writeRoute(d, { ...INPUT, limit: 9, revision: 3 }, { now: at(LATER) }), code("triage-route-stale"));
assert.equal(readFileSync(routePaths(d).file, "utf8"), before);
// Revision 0 means "only if there is no route yet".
assert.throws(() => writeRoute(d, { ...INPUT, revision: 0 }, { now: at(LATER) }), code("triage-route-stale"));
const e = root(t);
assert.equal(writeRoute(e, { ...INPUT, revision: 0 }, { now: at(NOW) }).revision, 1);
});
test("refused input shapes on a write", (t) => {
const d = root(t);
// Each input check refuses with its own message, so none rests only on the final shape check.
const bad = [
[{ ...INPUT, model: "" }, /model must be/], [{ ...INPUT, model: "Has Space" }, /model must be/],
[{ ...INPUT, model: "x".repeat(65) }, /model must be/], [{ ...INPUT, model: 5 }, /model must be/],
[{ ...INPUT, harness: "" }, /harness must be/], [{ ...INPUT, harness: "Claude" }, /harness must be/],
[{ ...INPUT, harness: "../pi" }, /harness must be/], [{ ...INPUT, harness: "x".repeat(33) }, /harness must be/],
[{ ...INPUT, limit: -1 }, /the cap must be/], [{ ...INPUT, limit: 1.5 }, /the cap must be/],
[{ ...INPUT, limit: "100" }, /the cap must be/], [{ ...INPUT, limit: 2 ** 53 }, /the cap must be/],
[{ ...INPUT, timeZone: undefined }, /a time zone is required/], [{ ...INPUT, timeZone: "" }, /time zone is unknown/],
[{ ...INPUT, timeZone: "Mars/Olympus_Mons" }, /time zone is unknown/], [{ ...INPUT, timeZone: "../etc" }, /time zone is unknown/],
[{ ...INPUT, timeZone: "+05:00" }, /time zone is unknown/],
[{ ...INPUT, by: "" }, /actor name/], [{ ...INPUT, by: "Owner Person" }, /actor name/],
[{ ...INPUT, revision: -1 }, /revision must be/], [{ ...INPUT, revision: "1" }, /revision must be/], [{ ...INPUT, revision: 1.5 }, /revision must be/],
[{ ...INPUT, env: { A: "b" } }, /unknown field env/], [{ ...INPUT, key: "mst-x" }, /unknown field key/],
[null, /not an object/], [[INPUT], /not an object/],
];
for (const [input, message] of bad) {
assert.throws(() => writeRoute(d, input, { now: at(NOW) }), (e) => code("triage-route-invalid")(e) && message.test(e.message), JSON.stringify(input));
}
// No time zone default: leaving it out refuses.
const { timeZone, ...noZone } = INPUT;
assert.throws(() => writeRoute(d, noZone, { now: at(NOW) }), (e) => code("triage-route-invalid")(e) && /a time zone is required/.test(e.message));
assert.equal(readRoute(d), null);
});
test("an unknown time zone refuses on write and on read", (t) => {
const d = root(t);
assert.throws(() => writeRoute(d, { ...INPUT, timeZone: "Atlantis/Lost" }, { now: at(NOW) }), code("triage-route-invalid"));
plant(d, { ...good(), cap: { ...good().cap, timeZone: "Atlantis/Lost" } });
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
});
test("each refused stored shape reads as unreadable", (t) => {
const g = good();
const shapes = {
"not json": "{",
"an array": [g],
"null": null,
"unknown field": { ...g, env: {} },
"unknown cap field": { ...g, cap: { ...g.cap, perTurn: 5 } },
"missing version": (({ version, ...r }) => r)(g),
"missing revision": (({ revision, ...r }) => r)(g),
"missing model": (({ model, ...r }) => r)(g),
"missing harness": (({ harness, ...r }) => r)(g),
"missing cap": (({ cap, ...r }) => r)(g),
"missing updatedAt": (({ updatedAt, ...r }) => r)(g),
"missing updatedBy": (({ updatedBy, ...r }) => r)(g),
"missing cap.limit": { ...g, cap: (({ limit, ...r }) => r)(g.cap) },
"missing cap.since": { ...g, cap: (({ since, ...r }) => r)(g.cap) },
"missing cap.reset": { ...g, cap: (({ reset, ...r }) => r)(g.cap) },
"missing cap.timeZone": { ...g, cap: (({ timeZone, ...r }) => r)(g.cap) },
"version 2": { ...g, version: 2 },
"revision 0": { ...g, revision: 0 },
"revision text": { ...g, revision: "1" },
"bad model": { ...g, model: "A B" },
"bad harness": { ...g, harness: "A/B" },
"cap an array": { ...g, cap: [1] },
"negative limit": { ...g, cap: { ...g.cap, limit: -1 } },
"bad reset": { ...g, cap: { ...g.cap, reset: "24:00" } },
"bad since": { ...g, cap: { ...g.cap, since: "2026-11-18" } },
"bad updatedAt": { ...g, updatedAt: "yesterday" },
"bad updatedBy": { ...g, updatedBy: "A B" },
};
for (const [name, doc] of Object.entries(shapes)) {
const d = root(t);
plant(d, doc);
assert.throws(() => readRoute(d), code("triage-route-unreadable"), name);
if (typeof doc !== "string") assert.equal(validRoute(doc), false, name);
}
assert.equal(validRoute(g), true);
// A write over an unreadable file refuses too; it never replaces what it could not read.
const d = root(t);
plant(d, { ...g, env: {} });
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), code("triage-route-unreadable"));
});
test("an oversized file is refused before it is parsed", (t) => {
const d = root(t);
plant(d, JSON.stringify(good()) + " ".repeat(70000));
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
});
test("a wrong mode on the directory or the file refuses", (t) => {
for (const mode of [0o755, 0o750, 0o711, 0o500]) {
const d = root(t);
plant(d, good());
chmodSync(routePaths(d).dir, mode);
assert.throws(() => readRoute(d), code("triage-route-unreadable"), `dir ${mode.toString(8)}`);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"), `dir ${mode.toString(8)}`);
chmodSync(routePaths(d).dir, 0o700);
}
for (const mode of [0o644, 0o640, 0o604, 0o400, 0o700]) {
const d = root(t);
plant(d, good());
chmodSync(routePaths(d).file, mode);
assert.throws(() => readRoute(d), code("triage-route-unreadable"), `file ${mode.toString(8)}`);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"), `file ${mode.toString(8)}`);
}
// A receipts file with the wrong mode refuses the write before the route changes.
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
chmodSync(routePaths(d).receipts, 0o644);
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER) }), code("triage-route-unreadable"));
assert.equal(readRoute(d).revision, 1);
});
test("a wrong owner refuses on the directory and the file", (t) => {
const d = root(t);
plant(d, good());
// Pretend to be another user: the store compares with the uid it is given.
const other = process.getuid() + 1;
// The files alone owned by someone else: route.json on read and write, the receipts on write.
assert.throws(() => readRoute(d, { fileUid: other }), unreadableFor(/route\.json is not owned by this user/));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW), fileUid: other }), unreadableFor(/route\.json is not owned by this user/));
const e = root(t);
writeRoute(e, INPUT, { now: at(NOW) });
unlinkSync(routePaths(e).file);
assert.throws(() => writeRoute(e, INPUT, { now: at(NOW), fileUid: other }), unreadableFor(/route-receipts\.jsonl is not owned by this user/));
assert.equal(existsSync(routePaths(e).file), false);
assert.throws(() => readRoute(d, { uid: other }), unreadableFor(/the triage directory is not owned by this user/));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW), uid: other }), unreadableFor(/the triage directory is not owned by this user/));
assert.equal(readRoute(d, { uid: process.getuid() }).revision, 1);
});
test("a link at the file, the directory or the receipts refuses; so does a non-file", (t) => {
// Symlink at route.json, to a valid route elsewhere.
let d = root(t);
plant(d, good());
const elsewhere = join(d, "elsewhere.json");
renameSync(routePaths(d).file, elsewhere);
symlinkSync(elsewhere, routePaths(d).file);
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"));
// A hard link at route.json.
d = root(t);
plant(d, good());
linkSync(routePaths(d).file, join(d, "hard.json"));
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
// Symlink at the triage directory, to a real 0700 directory holding a valid route.
d = root(t);
const real = join(d, "real");
mkdirSync(real, { mode: 0o700 });
writeFileSync(join(real, "route.json"), JSON.stringify(good()), { mode: 0o600 });
symlinkSync(real, routePaths(d).dir);
assert.throws(() => readRoute(d), unreadableFor(/the triage directory is a link/));
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), unreadableFor(/the triage directory is a link/));
// A directory where route.json should be.
d = root(t);
mkdirSync(routePaths(d).file, { recursive: true, mode: 0o700 });
chmodSync(routePaths(d).dir, 0o700);
assert.throws(() => readRoute(d), unreadableFor(/route\.json is not a regular file/));
// A file where the triage directory should be, at 0700 so only the directory check refuses it.
d = root(t);
writeFileSync(routePaths(d).dir, "x", { mode: 0o700 });
chmodSync(routePaths(d).dir, 0o700);
assert.throws(() => readRoute(d), unreadableFor(/the triage directory is not a directory/));
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), unreadableFor(/the triage directory is not a directory/));
// A symlink at the receipts file refuses the write and never follows it.
d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
const target = join(d, "target.jsonl");
writeFileSync(target, "", { mode: 0o600 });
unlinkSync(routePaths(d).receipts);
symlinkSync(target, routePaths(d).receipts);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-unreadable"));
assert.equal(readFileSync(target, "utf8"), "");
assert.equal(readRoute(d).revision, 1);
// A symlink at the lock path is not followed: the write refuses as busy.
d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
symlinkSync(join(d, "nowhere"), routePaths(d).lock);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-busy"));
assert.equal(existsSync(join(d, "nowhere")), false);
});
test("a write under a narrow umask still leaves 0700 and 0600, so the next read works", (t) => {
const d = root(t);
const old = process.umask(0o277);
let written;
try { written = writeRoute(d, INPUT, { now: at(NOW) }); } finally { process.umask(old); }
const { dir, file, receipts: r } = routePaths(d);
assert.equal(lstatSync(dir).mode & 0o777, 0o700);
assert.equal(lstatSync(file).mode & 0o777, 0o600);
assert.equal(lstatSync(r).mode & 0o777, 0o600);
assert.deepEqual(readRoute(d), written);
// An existing receipts file is never repaired: a wrong mode still refuses.
chmodSync(r, 0o644);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), unreadableFor(/route-receipts\.jsonl mode is not 0600/));
});
test("a failed temp write refuses and leaves the route; a failed receipt after the rename says so", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
const before = readFileSync(routePaths(d).file, "utf8");
const fail = (stage) => (s) => { if (s === stage) throw Object.assign(new Error("no space"), { code: "ENOSPC" }); };
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER), hook: fail("write") }), unreadableFor(/route\.json cannot be written/));
assert.equal(readFileSync(routePaths(d).file, "utf8"), before);
assert.deepEqual(readdirSync(routePaths(d).dir).sort(), ["route-receipts.jsonl", "route.json"]);
assert.equal(receipts(d).length, 1);
// After the rename the route has changed; the refusal names the new revision and the missing line.
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER), hook: fail("after-rename") }),
(e) => code("triage-route-unrecorded")(e) && /changed to revision 2, but its receipt line was not written/.test(e.message));
assert.equal(readRoute(d).revision, 2);
assert.equal(receipts(d).length, 1);
assert.deepEqual(readdirSync(routePaths(d).dir).sort(), ["route-receipts.jsonl", "route.json"]);
});
test("the store makes its directory 0700 but never the data root", (t) => {
const d = root(t);
assert.throws(() => writeRoute(join(d, "missing"), INPUT, { now: at(NOW) }), code("triage-route-unreadable"));
assert.equal(existsSync(join(d, "missing")), false);
});
test("two writers in one process: the second, while the first holds the lock, refuses busy", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
let inner = null;
const won = writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, {
now: at(LATER),
hook: (stage) => {
if (stage !== "before-rename") return;
try { writeRoute(d, { ...INPUT, limit: 2, revision: 1 }, { now: at(LATER) }); } catch (e) { inner = e; }
},
});
assert.equal(won.cap.limit, 1);
assert.ok(code("triage-route-busy")(inner), String(inner));
assert.equal(readRoute(d).cap.limit, 1);
assert.equal(receipts(d).length, 2);
});
// A child process that loads the store and writes once; prints {ok, code}. `wait` makes it hold
// at the given stage until the file `go` appears, so two children overlap for real.
const CHILD = `
import { writeRoute } from ${JSON.stringify(MODULE)};
import { existsSync, writeFileSync } from "node:fs";
const [dataRoot, limit, revision, wait, go, ready] = process.argv.slice(1);
try {
const r = writeRoute(dataRoot, { model: "glm-5", harness: "claude-code", limit: Number(limit), timeZone: "UTC", by: "owner", revision: Number(revision) }, {
hook: (stage) => {
if (stage === "crash") { if (wait === "crash") process.kill(process.pid, "SIGKILL"); return; }
if (stage !== wait) return;
writeFileSync(ready, "");
const end = Date.now() + 20000;
while (!existsSync(go) && Date.now() < end) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
},
});
console.log(JSON.stringify({ ok: true, limit: r.cap.limit }));
} catch (e) { console.log(JSON.stringify({ ok: false, code: e.code ?? String(e) })); }
`;
function child(args) {
return new Promise((resolve, reject) => {
const p = spawn(process.execPath, ["--input-type=module", "-e", CHILD, ...args], { stdio: ["ignore", "pipe", "pipe"] });
let out = "", err = "";
p.stdout.setEncoding("utf8").on("data", (c) => { out += c; });
p.stderr.setEncoding("utf8").on("data", (c) => { err += c; });
p.on("error", reject);
p.on("close", (status, signal) => resolve({ status, signal, out: out.trim(), err }));
});
}
async function until(path) {
const end = Date.now() + 20000;
while (!existsSync(path)) {
if (Date.now() > end) throw new Error(`timed out waiting for ${path}`);
await new Promise((r) => setTimeout(r, 20));
}
}
test("two writer processes racing on one revision: one wins, one refuses", async (t) => {
const d = root(t);
writeRoute(d, { ...INPUT, timeZone: "UTC" }, { now: at(NOW) });
const go = join(d, "go"), ready = join(d, "ready");
// The first holds just before its rename; the second starts then, with the same revision.
const first = child([d, "11", "1", "before-rename", go, ready]);
await until(ready);
const second = await child([d, "22", "1", "none", join(d, "unused"), join(d, "unused-ready")]);
writeFileSync(go, "");
const a = JSON.parse((await first).out), b = JSON.parse(second.out);
assert.deepEqual(a, { ok: true, limit: 11 });
assert.equal(b.ok, false);
assert.equal(b.code, "triage-route-busy");
assert.equal(readRoute(d).cap.limit, 11);
assert.equal(readRoute(d).revision, 2);
// After the winner, the loser's revision is stale.
const again = JSON.parse((await child([d, "22", "1", "none", join(d, "u2"), join(d, "u3")])).out);
assert.deepEqual(again, { ok: false, code: "triage-route-stale" });
// Started together with no pause, exactly one of two wins.
const both = await Promise.all([child([d, "33", "2", "none", join(d, "u4"), join(d, "u5")]), child([d, "44", "2", "none", join(d, "u6"), join(d, "u7")])]);
const results = both.map((r) => JSON.parse(r.out));
assert.equal(results.filter((r) => r.ok).length, 1, JSON.stringify(results));
assert.ok(results.filter((r) => !r.ok).every((r) => ["triage-route-busy", "triage-route-stale"].includes(r.code)), JSON.stringify(results));
assert.equal(readRoute(d).revision, 3);
assert.equal(receipts(d).length, 3);
});
test("a crash between the temp write and the rename leaves the old file", async (t) => {
const d = root(t);
const old = writeRoute(d, { ...INPUT, timeZone: "UTC" }, { now: at(NOW) });
const r = await child([d, "99", "1", "crash", join(d, "go"), join(d, "ready")]);
assert.equal(r.signal, "SIGKILL", r.err);
assert.deepEqual(readRoute(d), old);
assert.equal(receipts(d).length, 1);
// The temp file is still there, and the dead writer's lock refuses the next write, naming it.
const { dir, lock } = routePaths(d);
assert.ok(readdirSync(dir).some((n) => n.endsWith(".tmp")), readdirSync(dir).join(","));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), (e) => code("triage-route-busy")(e) && /not running/.test(e.message) && /route\.lock/.test(e.message));
// The person removes the lock by hand; the next write works and the read ignores the temp file.
unlinkSync(lock);
assert.equal(writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }).revision, 2);
assert.equal(readRoute(d).revision, 2);
});