@coywolf/emdash 0.35.13 → 0.35.15

package/src/ai/logic.test.ts

@@ -1,187 +0,0 @@
-/**
- * Unit tests for AI Enrichment's pure logic.
- * Run: node --test test/*.test.mjs (or node --test src/ai/*.test.ts)
- */
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-// @ts-ignore -- Node runs the .ts source directly; tsc doesn't need to resolve it.
-import * as L from "./logic.ts";
-
-const logic = L as typeof import("./logic.js");
-
-test("decodeJson tolerates fences, prose, and trailing text", () => {
-	assert.deepEqual(logic.decodeJson('```json\n[{"a":1}]\n```'), [{ a: 1 }]);
-	assert.deepEqual(logic.decodeJson('Here you go: {"a":2} hope that helps'), { a: 2 });
-	assert.equal(logic.decodeJson("no json here"), null);
-	assert.deepEqual(logic.decodeJson({ already: true }), { already: true });
-});
-
-test("parseMentions validates shape, types, duplicates, and the 12 cap", () => {
-	const rows = [
-		{ surface: "NYC", name: "New York City", type: "Place", description: "A city", primary: true },
-		{ name: "new york city", type: "Place" }, // duplicate (case-insensitive)
-		{ name: "Widget", type: "Gadget", description: "<b>thing</b>" }, // unknown type → Thing, tags stripped
-		{ type: "Person" }, // no name
-		"junk",
-		...Array.from({ length: 20 }, (_, i) => ({ name: `E${i}`, type: "Organization" })),
-	];
-	const out = logic.parseMentions(JSON.stringify(rows));
-	assert.equal(out.length, 12);
-	assert.deepEqual(out[0], { surface: "NYC", name: "New York City", type: "Place", description: "A city", primary: true });
-	assert.equal(out[1].type, "Thing");
-	assert.equal(out[1].description, "thing");
-	assert.equal(out[1].primary, false);
-	assert.deepEqual(logic.parseMentions("not json"), []);
-	assert.equal(logic.parseMentions('{"entities":[{"name":"X","type":"Thing"}]}').length, 1);
-});
-
-test("parseChoices keeps only QID strings", () => {
-	assert.deepEqual(logic.parseChoices('{"A":"q42","B":null,"C":"https://wikidata.org/Q1","D":7}'), { A: "Q42", B: null, C: null, D: null });
-	assert.deepEqual(logic.parseChoices("[1,2]"), {});
-});
-
-test("cleanDescription strips quotes and labels and caps at 155 on a word", () => {
-	assert.equal(logic.cleanDescription('"Meta description: A short summary."'), "A short summary.");
-	const long = "word ".repeat(60);
-	const out = logic.cleanDescription(long);
-	assert.ok([...out].length <= 155, `length ${[...out].length}`);
-	assert.ok(out.endsWith("…"));
-	assert.ok(!out.includes("wor…"));
-	assert.equal(logic.cleanDescription(""), "");
-});
-
-test("parseImageText validates and normalizes", () => {
-	const r = logic.parseImageText('{"alt_text":"Image of a dog running.","title":"Dog Running","caption":"A dog.","description":"x"}');
-	assert.deepEqual(r, { alt: "A dog running.", caption: "A dog.", title: "Dog Running" });
-	assert.equal(logic.parseImageText('{"alt_text":"","title":"Divider","caption":""}').alt, "");
-	assert.throws(() => logic.parseImageText(""), /empty response/);
-	assert.throws(() => logic.parseImageText("nope"), /could not be parsed/);
-	assert.throws(() => logic.parseImageText('{"caption":"only"}'), /usable/);
-});
-
-const human = { p31: ["Q5"], wikipedia: "", website: "" };
-const city = { p31: ["Q515"], wikipedia: "https://en.wikipedia.org/wiki/Paris", website: "https://paris.fr" };
-const disamb = { p31: ["Q4167410"], wikipedia: "", website: "" };
-
-test("grounding: candidates, choices restricted to real candidates", () => {
-	const mentions = [
-		{ surface: "", name: "Paris", type: "Place", description: "", primary: true },
-		{ surface: "", name: "Mercury", type: "Thing", description: "planet", primary: false },
-		{ surface: "", name: "Nobody", type: "Person", description: "", primary: false },
-	] as const;
-	const { mentions: grounded, ambiguous } = logic.attachCandidates([...mentions], [
-		[{ id: "Q90", label: "Paris", description: "capital of France" }],
-		[
-			{ id: "Q308", label: "Mercury", description: "planet" },
-			{ id: "Q925", label: "mercury", description: "element" },
-		],
-		[],
-	]);
-	assert.equal(grounded[0].qid, "Q90");
-	assert.deepEqual(ambiguous, [1]);
-	assert.equal(grounded[2].qid, "");
-	// A hallucinated QID is ignored; a listed one is accepted.
-	assert.equal(logic.applyChoices(grounded, ambiguous, { Mercury: "Q999" })[1].qid, "");
-	assert.equal(logic.applyChoices(grounded, ambiguous, { Mercury: "Q308" })[1].qid, "Q308");
-});
-
-test("verifyEntities drops disambiguation pages and Person/human mismatches", () => {
-	const m = (name: string, type: string, qid: string) => ({ surface: "", name, type, description: "", primary: false, qid, candidates: [] }) as never;
-	const out = logic.verifyEntities(
-		[m("Ada Lovelace", "Person", "Q7259"), m("Paris", "Place", "Q90"), m("Paris Hilton", "Place", "Q47899"), m("A Band", "Person", "Q1"), m("Mercury", "Thing", "Q2"), m("Unresolved", "Thing", ""), m("Dup", "Place", "Q90")],
-		{ Q7259: human, Q90: city, Q47899: human, Q1: { p31: ["Q215380"], wikipedia: "", website: "" }, Q2: disamb },
-	);
-	assert.deepEqual(
-		out.map((e) => e.qid),
-		["Q7259", "Q90"],
-	);
-	assert.equal(out[1].website, "https://paris.fr");
-});
-
-test("parseSearch reads a wbsearchentities response", () => {
-	assert.deepEqual(logic.parseSearch({ search: [{ id: "Q1", label: "Universe", description: "all" }, { id: "P31" }, {}] }), [{ id: "Q1", label: "Universe", description: "all" }]);
-});
-
-test("entityNodes builds about/mentions with sameAs", () => {
-	const nodes = logic.entityNodes([
-		{ name: "Paris", type: "Place", description: "City", qid: "Q90", wikipedia: "https://en.wikipedia.org/wiki/Paris", website: "", primary: true },
-		{ name: "X", type: "Thing", description: "", qid: "Q1", wikipedia: "", website: "", primary: false },
-		{ name: "Bad", type: "Thing", description: "", qid: "nope", wikipedia: "", website: "", primary: false },
-	]);
-	assert.deepEqual(nodes.about, [{ "@type": "Place", name: "Paris", sameAs: ["https://www.wikidata.org/wiki/Q90", "https://en.wikipedia.org/wiki/Paris"], description: "City" }]);
-	assert.deepEqual(nodes.mentions, [{ "@type": "Thing", name: "X", sameAs: "https://www.wikidata.org/wiki/Q1" }]);
-});
-
-test("Portable Text → plain text", () => {
-	const pt = [
-		{ _type: "block", children: [{ _type: "span", text: "Hello " }, { _type: "span", text: "world." }] },
-		{ _type: "image", asset: { _ref: "x" }, caption: "A caption" },
-		{ _type: "columns", columns: [{ content: [{ _type: "block", children: [{ text: "Nested." }] }] }] },
-	];
-	assert.equal(logic.portableTextToPlain(pt), "Hello world.\n\nA caption\n\nNested.");
-	const text = logic.entryPlainText({ body: pt, excerpt: "<p>Intro</p>", count: 3 }, [
-		{ slug: "excerpt", type: "text" },
-		{ slug: "body", type: "portableText" },
-		{ slug: "count", type: "number" },
-	]);
-	assert.ok(text.startsWith(" Intro") || text.startsWith("Intro"));
-	assert.ok(text.includes("Hello world."));
-	assert.equal(logic.entryPlainText({ body: pt }, [{ slug: "body", type: "portableText" }], 5), "Hello");
-});
-
-test("normalizeName and nameMatches ignore case, diacritics, and punctuation", () => {
-	assert.equal(logic.normalizeName("  Café-Müller, Inc. "), "cafe muller inc");
-	const c = { id: "Q1", label: "Beyoncé", description: "", aliases: ["Beyoncé Knowles"] };
-	assert.equal(logic.nameMatches({ name: "beyonce", surface: "" }, c), true);
-	assert.equal(logic.nameMatches({ name: "Queen B", surface: "Beyoncé Knowles" }, c), true);
-	assert.equal(logic.nameMatches({ name: "Beyoncé tour", surface: "" }, c), false);
-});
-
-test("attachCandidates drops search hits whose label/alias doesn't match, even a single one", () => {
-	const m = [
-		{ surface: "", name: "Acme Widgets", type: "Organization", description: "", primary: true },
-		{ surface: "the Met", name: "Metropolitan Museum of Art", type: "Organization", description: "", primary: false },
-	] as never;
-	const { mentions, ambiguous } = logic.attachCandidates(m, [
-		[{ id: "Q5", label: "Acme Corporation", description: "fictional company" }],
-		[
-			{ id: "Q160236", label: "Metropolitan Museum of Art", description: "art museum" },
-			{ id: "Q99", label: "Metropolitan Opera", description: "opera company", aliases: ["the Met"] },
-		],
-	]);
-	assert.equal(mentions[0].qid, "");
-	assert.equal(mentions[0].candidates.length, 0);
-	assert.deepEqual(ambiguous, [1]); // both match (label and alias): the model must choose
-});
-
-test("parseSearch keeps aliases and the matched text", () => {
-	const out = logic.parseSearch({ search: [{ id: "Q1", label: "A", aliases: ["Alpha"], match: { type: "alias", text: "Alef" } }] });
-	assert.deepEqual(out[0].aliases, ["Alpha", "Alef"]);
-});
-
-test("verifyEntities uses the Wikidata label as the name and rejects unverifiable items", () => {
-	const g = (name: string, type: string, qid: string, label: string) =>
-		({ surface: "", name, type, description: "", primary: true, qid, candidates: [{ id: qid, label, description: "" }] }) as never;
-	const out = logic.verifyEntities([g("nyc", "Place", "Q60", "New York City"), g("Ghost", "Thing", "Q404", "Ghost")], {
-		Q60: { p31: ["Q515"], wikipedia: "", website: "" },
-	});
-	assert.deepEqual(
-		out.map((e) => e.name),
-		["New York City"],
-	); // Q404 wasn't returned by Wikidata: dropped
-});
-
-test("typeCompatible: Person needs Q5; Organization/Place reject creative works; Organization rejects places", () => {
-	assert.equal(logic.typeCompatible("Person", []), false);
-	assert.equal(logic.typeCompatible("Person", ["Q5"]), true);
-	assert.equal(logic.typeCompatible("Organization", ["Q482994"]), false); // album, not the band
-	assert.equal(logic.typeCompatible("Organization", ["Q515"]), false); // city
-	assert.equal(logic.typeCompatible("Organization", ["Q4830453"]), true); // business
-	assert.equal(logic.typeCompatible("Organization", []), false);
-	assert.equal(logic.typeCompatible("Place", ["Q11424"]), false); // film
-	assert.equal(logic.typeCompatible("Place", ["Q515"]), true);
-	assert.equal(logic.typeCompatible("Thing", ["Q11424"]), true); // a film is a fine Thing
-	assert.equal(logic.typeCompatible("Thing", ["Q5"]), false);
-	assert.equal(logic.typeCompatible("Thing", ["Q4167410"]), false);
-});

package/src/ai/queue.test.ts

@@ -1,97 +0,0 @@
-/**
- * Unit tests for AI Enrichment queue batching.
- * Run: node --test test/*.test.mjs (or node --test src/ai/*.test.ts)
- */
-import assert from "node:assert/strict";
-import { test } from "node:test";
-
-// @ts-ignore -- Node runs the .ts source directly; tsc doesn't need to resolve it.
-import * as L from "./logic.ts";
-
-const logic = L as typeof import("./logic.js");
-type Job = import("./logic.js").QueueJob;
-
-const job = (id: string, due: number, kind: Job["kind"] = "entry"): { id: string; data: Job } => ({
-	id,
-	data: { kind, due, attempts: 0, enqueuedAt: 0, ...(kind === "media" ? { mediaId: id } : { collection: "posts", entryId: id }) },
-});
-
-test("planBatch takes due jobs in due order up to the per-tick limit", () => {
-	const jobs = [job("c", 300), job("a", 100), job("future", 10_000), job("b", 200)];
-	const out = logic.planBatch(jobs, { now: 1000, perTick: 2, remainingCalls: 100, callsPerJob: () => 3 });
-	assert.deepEqual(
-		out.map((j) => j.id),
-		["a", "b"],
-	);
-});
-
-test("planBatch respects the daily call budget and keeps each kind in order", () => {
-	const jobs = [job("entry1", 1), job("img", 2, "media"), job("entry2", 3)];
-	const cost = (j: Job) => (j.kind === "media" ? 1 : 3);
-	assert.deepEqual(
-		logic.planBatch(jobs, { now: 10, perTick: 10, remainingCalls: 4, callsPerJob: cost }).map((j) => j.id),
-		["entry1", "img"],
-	);
-	// Not enough budget for the first entry: no entry runs (entry2 doesn't jump the line), but the image can.
-	assert.deepEqual(
-		logic.planBatch(jobs, { now: 10, perTick: 10, remainingCalls: 2, callsPerJob: cost }).map((j) => j.id),
-		["img"],
-	);
-	assert.deepEqual(logic.planBatch(jobs, { now: 10, perTick: 10, remainingCalls: -5, callsPerJob: cost }), []);
-});
-
-test("deferJob pushes the job to Retry-After without an attempt, and gives up deferring after MAX_DEFERRALS in a row", () => {
-	const j = job("a", 0).data;
-	const once = logic.deferJob(j, 1_000, 30_000);
-	assert.deepEqual(once, { ...j, deferrals: 1, due: 31_000 });
-	assert.equal(once!.attempts, 0);
-	const tenth = logic.deferJob({ ...j, deferrals: logic.MAX_DEFERRALS - 1 }, 1_000, 30_000);
-	assert.equal(tenth?.deferrals, logic.MAX_DEFERRALS);
-	assert.equal(logic.deferJob({ ...j, deferrals: logic.MAX_DEFERRALS }, 1_000, 30_000), null, "the next one counts as a failed attempt");
-	assert.equal(logic.MAX_DEFERRALS, 10);
-});
-
-test("retryAt backs off and gives up after MAX_ATTEMPTS", () => {
-	const j = job("a", 0).data;
-	assert.equal(logic.retryAt({ ...j, attempts: 0 }, 0), 5 * 60_000);
-	assert.equal(logic.retryAt({ ...j, attempts: 1 }, 0), 20 * 60_000);
-	assert.equal(logic.retryAt({ ...j, attempts: logic.MAX_ATTEMPTS - 1 }, 0), null);
-});
-
-test("mergeJob debounces: later due wins, force sticks, attempts reset", () => {
-	const first: Job = { kind: "entry", collection: "posts", entryId: "1", due: 100, attempts: 2, enqueuedAt: 50, force: true };
-	const next: Job = { kind: "entry", collection: "posts", entryId: "1", due: 500, attempts: 0, enqueuedAt: 400 };
-	assert.deepEqual(logic.mergeJob(first, next), { ...next, force: true, enqueuedAt: 50, attempts: 0 });
-	assert.deepEqual(logic.mergeJob(null, next), next);
-});
-
-test("queueId and dayKey", () => {
-	assert.equal(logic.queueId({ kind: "entry", collection: "posts", entryId: "x" }), "entry:posts:x");
-	assert.equal(logic.queueId({ kind: "media", mediaId: "m" }), "media:m");
-	assert.equal(logic.dayKey(Date.UTC(2026, 9, 3, 23, 59)), "2026-10-03");
-});
-
-test("planBatch alternates kinds so a backlog of entries can't starve images", () => {
-	const jobs = [job("e1", 1), job("e2", 2), job("e3", 3), job("e4", 4), job("m1", 50, "media"), job("m2", 60, "media")];
-	const out = logic.planBatch(jobs, { now: 100, perTick: 4, remainingCalls: 100, callsPerJob: () => 1 });
-	assert.deepEqual(
-		out.map((j) => j.id),
-		["e1", "m1", "e2", "m2"],
-	);
-});
-
-test("planBatch stays within the subrequest budget; an expensive kind stops without blocking a cheap one", () => {
-	const jobs = [job("e1", 1), job("e2", 2), job("m1", 3, "media"), job("m2", 4, "media")];
-	const out = logic.planBatch(jobs, {
-		now: 100,
-		perTick: 10,
-		remainingCalls: 100,
-		callsPerJob: () => 1,
-		subrequests: 20,
-		subrequestsPerJob: (j: Job) => (j.kind === "entry" ? 16 : 1),
-	});
-	assert.deepEqual(
-		out.map((j) => j.id),
-		["e1", "m1", "m2"],
-	);
-});

package/src/ai/wikidata.test.ts

@@ -1,184 +0,0 @@
-/**
- * Unit tests for the Wikidata client: the SPARQL details query, parsing its
- * results, and how non-OK answers (429, maxlag) are handled.
- * Run: node --test test/*.test.mjs
- */
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { test } from "node:test";
-
-// @ts-ignore -- Node runs the .ts source directly; tsc doesn't need to resolve it.
-import * as L from "./logic.ts";
-// @ts-ignore -- as above.
-import * as W from "./wikidata.ts";
-
-const logic = L as typeof import("./logic.js");
-const wikidata = W as typeof import("./wikidata.js");
-const fixture = (name: string) => JSON.parse(readFileSync(new URL(`../../test/fixtures/${name}`, import.meta.url), "utf8"));
-const UA = "CoywolfPack/0.0.0 (https://example.com) EmDash";
-
-/** A fetcher that records requests and answers with the given responses in turn. */
-function fakeFetch(...responses: Response[]) {
-	const calls: Array<{ url: string; init?: RequestInit }> = [];
-	const fetcher = async (url: string, init?: RequestInit) => {
-		calls.push({ url, init });
-		const next = responses.shift();
-		if (!next) throw new Error("unexpected request");
-		return next;
-	};
-	return { fetcher, calls };
-}
-
-/** Run `fn` with console.warn captured. */
-async function warnings<T>(fn: () => Promise<T>): Promise<{ result?: T; error?: unknown; warned: unknown[][] }> {
-	const warned: unknown[][] = [];
-	const original = console.warn;
-	console.warn = (...args: unknown[]) => void warned.push(args);
-	try {
-		return { result: await fn(), warned };
-	} catch (error) {
-		return { error, warned };
-	} finally {
-		console.warn = original;
-	}
-}
-
-const json = (body: unknown, init: ResponseInit = {}) => new Response(JSON.stringify(body), { ...init, headers: { "content-type": "application/json", ...(init.headers ?? {}) } });
-
-test("detailsQuery takes only Q-ids, once each, and the sitelink only for a plain language code", () => {
-	const q = logic.detailsQuery(["Q90", "Q90", "q5", "P31", "Q1 } . ?x ?y ?z", "Q42"], "en");
-	assert.match(q, /VALUES \?item \{ wd:Q90 wd:Q42 \}/);
-	assert.doesNotMatch(q, /\?x|P31 \}|q5/);
-	assert.match(q, /schema:isPartOf <https:\/\/en\.wikipedia\.org\/>/);
-	assert.match(q, /FILTER\(\?r != wikibase:DeprecatedRank\)/);
-	assert.match(q, /SELECT \?item \?class \?website \?rank \?title/);
-	assert.match(q, /ps:P856 \?website ; wikibase:rank \?rank \. FILTER\(\?rank != wikibase:DeprecatedRank\)/);
-	assert.doesNotMatch(logic.detailsQuery(["Q1"], "e>n"), /wikipedia/);
-});
-
-test("parseSparqlDetails gives the same details the wbgetentities parser did (recorded Q90, Q42, Q95, Q1, Q2)", () => {
-	const parsed = logic.parseSparqlDetails(fixture("wikidata-details.sparql.json"), "en");
-	const expected: Record<string, { p31: string[] }> = fixture("wikidata-details.expected.json");
-	// SPARQL rows have no statement order, and P31 order doesn't matter to verification.
-	const sorted = (o: Record<string, { p31: string[] }>) => Object.fromEntries(Object.entries(o).map(([k, v]) => [k, { ...v, p31: [...v.p31].sort() }]));
-	assert.deepEqual(sorted(parsed!), sorted(expected));
-});
-
-test("parseSparqlDetails keeps Q-ids and http(s) websites only, and rejects non-SPARQL bodies", () => {
-	const row = (fields: Record<string, string>) => Object.fromEntries(Object.entries(fields).map(([k, value]) => [k, { type: "uri", value }]));
-	const E = "http://www.wikidata.org/entity/";
-	const out = logic.parseSparqlDetails(
-		{
-			results: {
-				bindings: [
-					row({ item: `${E}Q7`, class: `${E}Q5` }),
-					row({ item: `${E}Q7`, class: `${E}Q5` }),
-					row({ item: `${E}Q7`, class: "http://www.wikidata.org/.well-known/genid/abc" }),
-					row({ item: `${E}Q7`, website: "ftp://example.com/" }),
-					row({ item: `${E}Q7`, website: "https://example.com/" }),
-					row({ item: `${E}Q7`, title: "A/B: C d" }),
-					row({ item: `${E}L1`, class: `${E}Q5` }),
-					row({ item: `${E}Q8` }),
-				],
-			},
-		},
-		"en",
-	);
-	assert.deepEqual(out, {
-		Q7: { p31: ["Q5"], wikipedia: "https://en.wikipedia.org/wiki/A/B:_C_d", website: "https://example.com/" },
-		Q8: { p31: [], wikipedia: "", website: "" },
-	});
-	assert.equal(logic.parseSparqlDetails({ error: "nope" }, "en"), null);
-	assert.equal(logic.parseSparqlDetails(null, "en"), null);
-});
-
-test("parseSparqlDetails picks one website regardless of row order: preferred rank, then https, then the smallest URL", () => {
-	const E = "http://www.wikidata.org/entity/";
-	const R = "http://wikiba.se/ontology#";
-	const site = (qid: string, website: string, rank = "NormalRank") => ({ item: { type: "uri", value: `${E}${qid}` }, website: { type: "uri", value: website }, rank: { type: "uri", value: `${R}${rank}` } });
-	const rows = [
-		site("Q1", "https://zzz.example/"),
-		site("Q1", "http://preferred.example/", "PreferredRank"),
-		site("Q1", "https://aaa.example/"),
-		site("Q2", "http://aaa.example/"),
-		site("Q2", "https://zzz.example/"),
-		site("Q3", "https://b.example/"),
-		site("Q3", "https://a.example/"),
-	];
-	const pick = (bindings: unknown[]) => Object.fromEntries(Object.entries(logic.parseSparqlDetails({ results: { bindings } }, "en")!).map(([k, v]) => [k, v.website]));
-	const expected = { Q1: "http://preferred.example/", Q2: "https://zzz.example/", Q3: "https://a.example/" };
-	assert.deepEqual(pick(rows), expected);
-	assert.deepEqual(pick([...rows].reverse()), expected);
-	// The recorded Q90 lists two websites with the http one first: the https one is kept.
-	assert.equal(logic.parseSparqlDetails(fixture("wikidata-details.sparql.json"), "en")!.Q90.website, "https://www.paris.fr/");
-});
-
-test("userAgent follows the Wikimedia policy, with the repository as contact when the site has no URL", () => {
-	assert.equal(logic.userAgent("1.2.3", "https://example.com"), "CoywolfPack/1.2.3 (https://example.com) EmDash");
-	assert.equal(logic.userAgent("1.2.3", undefined), "CoywolfPack/1.2.3 (https://github.com/coywolf-llc/coywolf-pack) EmDash");
-	assert.equal(logic.userAgent("1.2.3", ""), "CoywolfPack/1.2.3 (https://github.com/coywolf-llc/coywolf-pack) EmDash");
-});
-
-test("entityDetails makes one SPARQL request to query.wikidata.org", async () => {
-	const { fetcher, calls } = fakeFetch(json(fixture("wikidata-details.sparql.json")));
-	const details = await wikidata.entityDetails(fetcher, ["Q90", "Q42", "Q95", "Q1", "Q2", "bogus"], "en", UA);
-	assert.equal(calls.length, 1);
-	const url = new URL(calls[0].url);
-	assert.equal(url.origin + url.pathname, `https://${wikidata.WIKIDATA_QUERY_HOST}/sparql`);
-	assert.equal(url.searchParams.get("format"), "json");
-	assert.match(url.searchParams.get("query")!, /wd:Q90 wd:Q42 wd:Q95 wd:Q1 wd:Q2 \}/);
-	const headers = calls[0].init?.headers as Record<string, string>;
-	assert.equal(headers["user-agent"], UA);
-	assert.equal(headers.accept, "application/sparql-results+json");
-	assert.deepEqual(Object.keys(details!).sort(), ["Q1", "Q2", "Q42", "Q90", "Q95"]);
-	// Nothing to look up: no request.
-	assert.deepEqual(await wikidata.entityDetails(fakeFetch().fetcher, ["P31"], "en", UA), {});
-});
-
-test("a non-OK answer is logged with its status and Retry-After; a 500 means 'didn't answer'", async () => {
-	const { result, warned } = await warnings(() => wikidata.entityDetails(fakeFetch(new Response("down", { status: 503, headers: { "retry-after": "30" } })).fetcher, ["Q1"], "en", UA));
-	assert.equal(result, null);
-	assert.equal(warned.length, 1);
-	assert.match(String(warned[0][0]), /query\.wikidata\.org.*HTTP 503/);
-	assert.deepEqual(warned[0][1], { retryAfter: "30" });
-	// Search: an empty result that isn't cached, so the next run asks again.
-	const search = fakeFetch(new Response("down", { status: 502 }), json({ search: [{ id: "Q64", label: "Berlin" }] }));
-	const first = await warnings(() => wikidata.searchCandidates(search.fetcher, "Berlin-uncached", "en", UA));
-	assert.deepEqual(first.result, []);
-	assert.match(String(first.warned[0][0]), /www\.wikidata\.org.*HTTP 502/);
-	assert.deepEqual(await wikidata.searchCandidates(search.fetcher, "Berlin-uncached", "en", UA), [{ id: "Q64", label: "Berlin", description: "" }]);
-});
-
-test("HTTP 429 defers the job until Retry-After instead of failing it", async () => {
-	const sparql = await warnings(() => wikidata.entityDetails(fakeFetch(new Response("slow down", { status: 429, headers: { "retry-after": "120" } })).fetcher, ["Q1"], "en", UA));
-	assert.ok(sparql.error instanceof wikidata.WikidataBusyError);
-	assert.equal((sparql.error as InstanceType<typeof wikidata.WikidataBusyError>).retryAfterMs, 120_000);
-	assert.deepEqual(sparql.warned[0][1], { retryAfter: "120" });
-	const search = await warnings(() => wikidata.searchCandidates(fakeFetch(new Response("", { status: 429 })).fetcher, "Paris-429", "en", UA));
-	assert.ok(search.error instanceof wikidata.WikidataBusyError);
-	assert.equal((search.error as InstanceType<typeof wikidata.WikidataBusyError>).retryAfterMs, 60_000, "no Retry-After: a minute");
-});
-
-test("api.php calls send maxlag=5, and a maxlag answer defers like a 429", async () => {
-	const lagged = json({ error: { code: "maxlag", info: "Waiting for a database server: 6 seconds lagged." } }, { headers: { "retry-after": "5" } });
-	const { fetcher, calls } = fakeFetch(lagged);
-	const { error, warned } = await warnings(() => wikidata.searchCandidates(fetcher, "Paris-lag", "fr", UA));
-	const url = new URL(calls[0].url);
-	assert.equal(url.host, wikidata.WIKIDATA_HOST);
-	assert.equal(url.searchParams.get("maxlag"), "5");
-	assert.equal(url.searchParams.get("action"), "wbsearchentities");
-	assert.equal(url.searchParams.get("language"), "fr");
-	assert.ok(error instanceof wikidata.WikidataBusyError);
-	assert.equal((error as InstanceType<typeof wikidata.WikidataBusyError>).retryAfterMs, 5_000);
-	assert.match(String(warned[0][0]), /maxlag/);
-});
-
-test("retryAfterMs reads seconds or an HTTP date, within 5 seconds to an hour", () => {
-	const now = Date.parse("2026-10-07T12:00:00Z");
-	assert.equal(wikidata.retryAfterMs("30", now), 30_000);
-	assert.equal(wikidata.retryAfterMs("Wed, 07 Oct 2026 12:02:00 GMT", now), 120_000);
-	assert.equal(wikidata.retryAfterMs(null, now), 60_000);
-	assert.equal(wikidata.retryAfterMs("soon", now), 60_000);
-	assert.equal(wikidata.retryAfterMs("0", now), 5_000);
-	assert.equal(wikidata.retryAfterMs("86400", now), 3_600_000);
-});