@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.6

package/bundled-test-harness/assets/index-writer-test-B_bR2fjw.js

@@ -0,0 +1,3040 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { $ as sweepUnreferencedScopedCSS, Br as testRealmURL, Ca as IndexWriter, Ds as CachingDefinitionLookup, Ia as coerceTypes, Ka as VirtualNetwork, Lr as testRRI, Nc as mergeErrorDetail, Pc as mergeErrorsByGeneration, Ra as persistFileMeta, l as internalKeyFor, va as IndexQueryEngine, wa as jobStagingId } from "./runtime-common-BTaLJEw-.js";
+import { T as rri, w as ri } from "./paths-C9-NYXnM.js";
+import { w as baseCardRef } from "./constants-Icc0nFW-.js";
+import { b as getContext } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { r as setupTest } from "./dist-Ds4JDBNZ.js";
+import { T as makeRenderer, at as setupIndex, b as getDbAdapter, h as createPrerenderAuth } from "./mock-matrix-FjsXmU7-.js";
+import "./code-equality-assertion-Dco7Q4O6.js";
+//#region tests/unit/index-writer-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealmURL2 = ri(`http://test-realm/test2/`);
+var testRealmURLObject = new URL(testRealmURL);
+var internalKeysFor = (vn, ...refs) => refs.map((ref) => internalKeyFor(ref, testRealmURLObject, vn));
+var makeCardResource = (id, name, adoptsFrom) => ({
+	id: testRRI(id),
+	type: "card",
+	attributes: { name },
+	meta: { adoptsFrom }
+});
+var makeCardTypeSummary = (codeRef, displayName, iconHTML, total) => ({
+	total,
+	code_ref: codeRef,
+	display_name: displayName,
+	icon_html: iconHTML
+});
+var writeInstance = async (batch, opts) => {
+	let timestamp = Date.now();
+	await batch.updateEntry(new URL(`${testRealmURL}${opts.id}.json`), {
+		type: "instance",
+		resource: makeCardResource(opts.id, opts.name, opts.adoptsFrom),
+		lastModified: timestamp,
+		resourceCreatedAt: timestamp,
+		searchData: { name: opts.name },
+		deps: new Set([`${testRealmURL}${opts.adoptsFrom.name.toLowerCase()}`]),
+		displayNames: opts.displayNames,
+		types: opts.types,
+		iconHTML: opts.iconHTML
+	});
+};
+var plantRealmMeta = async (adapter, generation, value) => adapter.execute(`INSERT INTO realm_meta (realm_url, generation, value, indexed_at)
+     VALUES ($1, $2, $3, $4)`, { bind: [
+	testRealmURL,
+	generation,
+	JSON.stringify(value),
+	String(Date.now())
+] });
+var fetchRealmMetaRows = async (adapter) => adapter.execute(`SELECT value FROM realm_meta r WHERE r.realm_url = $1`, {
+	bind: [testRealmURL],
+	coerceTypes: { value: "JSON" }
+});
+var fetchRealmMeta = async (adapter) => {
+	let rows = await fetchRealmMetaRows(adapter);
+	let raw = rows[0]?.value;
+	return {
+		rows,
+		value: raw?.instances ?? [],
+		files: raw?.files ?? []
+	};
+};
+(0, import_qunit.module)("Unit | index-writer", function(hooks) {
+	let adapter;
+	let indexWriter;
+	let indexQueryEngine;
+	let virtualNetwork;
+	setupTest(hooks);
+	hooks.before(async function() {
+		adapter = await getDbAdapter();
+	});
+	hooks.beforeEach(async function() {
+		await adapter.reset();
+		indexWriter = new IndexWriter(adapter);
+		let owner = getContext().owner;
+		await makeRenderer();
+		let localIndexer = owner.lookup("service:local-indexer");
+		virtualNetwork = new VirtualNetwork();
+		let definitionLookup = new CachingDefinitionLookup(adapter, localIndexer.prerenderer, virtualNetwork, createPrerenderAuth);
+		definitionLookup.registerRealm({
+			url: testRealmURL,
+			async getRealmOwnerUserId() {
+				return "@user1:localhost";
+			},
+			async visibility() {
+				return "private";
+			}
+		});
+		indexQueryEngine = new IndexQueryEngine(adapter, definitionLookup, virtualNetwork);
+	});
+	(0, import_qunit.test)("sweepUnreferencedScopedCSS drops rows no live row references, scoped to the given realm", async function(assert) {
+		let liveHash = "1".repeat(32);
+		let tombstonedHash = "2".repeat(32);
+		let orphanHash = "3".repeat(32);
+		let foreignHash = "4".repeat(32);
+		let prerenderedOnlyHash = "5".repeat(32);
+		let freshHash = "6".repeat(32);
+		let hashedDep = (hash) => `${testRealmURL}style-source.gts.md5-${hash}.glimmer-scoped.css`;
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_generation: 1
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				realm_url: testRealmURL,
+				deps: [hashedDep(liveHash)]
+			},
+			{
+				url: `${testRealmURL}2.json`,
+				realm_url: testRealmURL,
+				is_deleted: true,
+				deps: [hashedDep(tombstonedHash)]
+			},
+			{
+				url: `${testRealmURL2}A.json`,
+				realm_url: testRealmURL2,
+				deps: [hashedDep(foreignHash)]
+			}
+		]);
+		await adapter.execute(`INSERT INTO prerendered_html (url, file_alias, realm_url, type, generation, last_known_good_deps)
+       VALUES ('${testRealmURL}3.json', '${testRealmURL}3.json', '${testRealmURL}', 'instance', 1,
+               '${JSON.stringify([hashedDep(prerenderedOnlyHash)])}')`);
+		let sweepable = Date.now() - 2880 * 60 * 1e3;
+		for (let [realmUrl, hash, lastInternedAt] of [
+			[
+				testRealmURL,
+				liveHash,
+				sweepable
+			],
+			[
+				testRealmURL,
+				tombstonedHash,
+				sweepable
+			],
+			[
+				testRealmURL,
+				orphanHash,
+				sweepable
+			],
+			[
+				testRealmURL,
+				prerenderedOnlyHash,
+				sweepable
+			],
+			[
+				testRealmURL,
+				freshHash,
+				Date.now()
+			],
+			[
+				testRealmURL2,
+				foreignHash,
+				sweepable
+			]
+		]) await adapter.execute(`INSERT INTO scoped_css (realm_url, hash, css, last_interned_at)
+         VALUES ('${realmUrl}', '${hash}', '.x {}', ${lastInternedAt})`);
+		let swept = await sweepUnreferencedScopedCSS(adapter, testRealmURL);
+		assert.strictEqual(swept, 2, "the orphan and the tombstone-only rows were swept");
+		let remaining = await adapter.execute(`SELECT realm_url, hash FROM scoped_css ORDER BY hash`);
+		assert.deepEqual(remaining, [
+			{
+				realm_url: testRealmURL,
+				hash: liveHash
+			},
+			{
+				realm_url: testRealmURL2,
+				hash: foreignHash
+			},
+			{
+				realm_url: testRealmURL,
+				hash: prerenderedOnlyHash
+			},
+			{
+				realm_url: testRealmURL,
+				hash: freshHash
+			}
+		], "the live-referenced, prerendered-only-referenced, within-grace, and other realm's rows survived");
+	});
+	(0, import_qunit.test)("can perform invalidations for a instance entry", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_generation: 5
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}2.json`]
+			},
+			{
+				url: `${testRealmURL}2.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}4.json`]
+			},
+			{
+				url: `${testRealmURL}3.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}2.json`]
+			},
+			{
+				url: `${testRealmURL}4.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: []
+			},
+			{
+				url: `${testRealmURL}5.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: []
+			},
+			{
+				url: `${testRealmURL2}A.json`,
+				generation: 5,
+				realm_url: testRealmURL2,
+				deps: []
+			}
+		]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}4.json`)]);
+		let invalidations = batch.invalidations;
+		assert.deepEqual(invalidations.sort(), [
+			`${testRealmURL}1.json`,
+			`${testRealmURL}2.json`,
+			`${testRealmURL}3.json`,
+			`${testRealmURL}4.json`
+		]);
+		let invalidatedEntries = await adapter.execute("SELECT url, realm_url, is_deleted FROM boxel_index_pending WHERE generation = 2 ORDER BY url COLLATE \"POSIX\"", { coerceTypes: { is_deleted: "BOOLEAN" } });
+		assert.deepEqual(invalidatedEntries, [
+			1,
+			2,
+			3,
+			4
+		].map((i) => ({
+			url: `${testRealmURL}${i}.json`,
+			realm_url: testRealmURL,
+			is_deleted: true
+		})), "the \"work-in-progress\" version of the index entries have been marked as deleted");
+		let otherRealms = await adapter.execute(`SELECT url, realm_url, generation, is_deleted FROM boxel_index WHERE realm_url != '${testRealmURL}'`, { coerceTypes: { is_deleted: "BOOLEAN" } });
+		assert.deepEqual(otherRealms, [{
+			url: `${testRealmURL2}A.json`,
+			realm_url: testRealmURL2,
+			generation: 5,
+			is_deleted: null
+		}], "the index entries from other realms are unchanged");
+		let generations = await adapter.execute("select realm_url, current_generation from realm_generations ORDER BY realm_url COLLATE \"POSIX\"");
+		assert.deepEqual(generations, [{
+			realm_url: `${testRealmURL}`,
+			current_generation: 1
+		}, {
+			realm_url: `${testRealmURL2}`,
+			current_generation: 5
+		}], "the \"production\" realm generations are correct");
+	});
+	(0, import_qunit.test)("prefetchFileMeta serves per-visit created-at + content-meta lookups from one batched read", async function(assert) {
+		let seeded = await persistFileMeta(adapter, testRealmURL, [
+			{
+				path: "1.json",
+				contentHash: "hash-1",
+				contentSize: 11
+			},
+			{
+				path: "2.json",
+				contentHash: "hash-2",
+				contentSize: 22
+			},
+			{ path: "3.json" }
+		]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.prefetchFileMeta([
+			"1.json",
+			"2.json",
+			"3.json",
+			"4.json"
+		]);
+		let executeCalls = 0;
+		let origExecute = adapter.execute.bind(adapter);
+		adapter.execute = (sql, opts) => {
+			executeCalls++;
+			return origExecute(sql, opts);
+		};
+		try {
+			assert.deepEqual(await batch.getContentMeta("1.json"), {
+				contentHash: "hash-1",
+				contentSize: 11
+			});
+			assert.deepEqual(await batch.getContentMeta("2.json"), {
+				contentHash: "hash-2",
+				contentSize: 22
+			});
+			assert.deepEqual(await batch.getContentMeta("3.json"), {
+				contentHash: void 0,
+				contentSize: void 0
+			}, "a file with a row but no persisted hash/size is served as undefined from the cache");
+			assert.strictEqual(await batch.ensureFileCreatedAt("1.json"), seeded.get("1.json").createdAt, "created_at is served from the cache");
+			assert.strictEqual(executeCalls, 0, "prefetched lookups make no DB round-trips");
+		} finally {
+			adapter.execute = origExecute;
+		}
+		let created4 = await batch.ensureFileCreatedAt("4.json");
+		assert.true(created4 > 0, "an unprefetched file still gets a created_at via the per-path fallback");
+		assert.deepEqual(await batch.getContentMeta("4.json"), {
+			contentHash: void 0,
+			contentSize: void 0
+		}, "an unprefetched file with no hash/size falls back to a per-path read");
+	});
+	(0, import_qunit.test)("buffered index writes defer until flush, and a dependency read flushes them first", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, void 0, { splitPrerenderHtml: true });
+		let depURL = new URL(`${testRealmURL}a.json`);
+		let dependentURL = new URL(`${testRealmURL}b.json`);
+		let fileEntry = (name) => ({
+			type: "file",
+			lastModified: 1,
+			resourceCreatedAt: 1,
+			deps: /* @__PURE__ */ new Set(),
+			searchData: { name }
+		});
+		await batch.bufferEntry(depURL, fileEntry("a"));
+		await batch.bufferEntry(dependentURL, fileEntry("b"));
+		assert.deepEqual([...batch.invalidations].sort(), [depURL.href, dependentURL.href], "buffered URLs join the invalidation set synchronously");
+		let beforeFlush = await adapter.execute(`SELECT url FROM boxel_index_pending WHERE realm_url = $1`, { bind: [testRealmURL] });
+		assert.deepEqual(beforeFlush, [], "no rows are written while buffered");
+		let depRows = await batch.getDependencyRows([depURL.href]);
+		assert.deepEqual(depRows.map((r) => r.url), [depURL.href], "the dependency read returns the now-flushed buffered row");
+		let afterFlush = await adapter.execute(`SELECT url FROM boxel_index_pending WHERE realm_url = $1 ORDER BY url COLLATE "POSIX"`, { bind: [testRealmURL] });
+		assert.deepEqual(afterFlush, [{ url: depURL.href }, { url: dependentURL.href }], "the flush coalesced all buffered rows into the pending table");
+	});
+	(0, import_qunit.test)("can perform invalidations for a module change via instance deps", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_generation: 5
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				file_alias: `${testRealmURL}1.json`,
+				type: "instance",
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}employee`, `${testRealmURL}person`]
+			},
+			{
+				url: `${testRealmURL}2.json`,
+				file_alias: `${testRealmURL}2.json`,
+				type: "instance",
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}1.json`]
+			},
+			{
+				url: `${testRealmURL}3.json`,
+				file_alias: `${testRealmURL}3.json`,
+				type: "instance",
+				generation: 1,
+				realm_url: testRealmURL,
+				deps: []
+			}
+		]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}person.gts`)]);
+		let invalidations = batch.invalidations;
+		assert.deepEqual(invalidations.sort(), [
+			`${testRealmURL}1.json`,
+			`${testRealmURL}2.json`,
+			`${testRealmURL}person.gts`
+		]);
+	});
+	(0, import_qunit.test)("invalidations reach dependents whose rows exist only in the production index", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], {
+			working: [],
+			production: [
+				{
+					url: `${testRealmURL}1.json`,
+					file_alias: `${testRealmURL}1.json`,
+					type: "instance",
+					generation: 1,
+					realm_url: testRealmURL,
+					deps: [`${testRealmURL}person`]
+				},
+				{
+					url: `${testRealmURL}2.json`,
+					file_alias: `${testRealmURL}2.json`,
+					type: "instance",
+					generation: 1,
+					realm_url: testRealmURL,
+					deps: [`${testRealmURL}1.json`]
+				},
+				{
+					url: `${testRealmURL}3.json`,
+					file_alias: `${testRealmURL}3.json`,
+					type: "instance",
+					generation: 1,
+					realm_url: testRealmURL,
+					is_deleted: true,
+					deps: [`${testRealmURL}person`]
+				}
+			]
+		}, { prerenderedHtml: false });
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}person.gts`)]);
+		assert.deepEqual(batch.invalidations.sort(), [
+			`${testRealmURL}1.json`,
+			`${testRealmURL}2.json`,
+			`${testRealmURL}person.gts`
+		]);
+	});
+	(0, import_qunit.test)("invalidations don't cross realm boundaries", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_generation: 5
+		}], [{
+			url: `${testRealmURL2}luke.json`,
+			file_alias: `${testRealmURL2}luke.json`,
+			type: "instance",
+			generation: 1,
+			realm_url: testRealmURL2,
+			deps: [`${testRealmURL}person`]
+		}]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}person.gts`)]);
+		let invalidations = batch.invalidations;
+		assert.deepEqual(invalidations, [`${testRealmURL}person.gts`]);
+	});
+	(0, import_qunit.test)("can update an index entry", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			pristine_doc: {
+				id: `${testRealmURL}1.json`,
+				type: "card",
+				attributes: { name: "Mango" },
+				meta: { adoptsFrom: {
+					module: rri(`./person`),
+					name: "Person"
+				} }
+			},
+			search_doc: { name: "Mango" },
+			deps: [`${testRealmURL}person`],
+			types: [{
+				module: rri(`./person`),
+				name: "Person"
+			}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork))
+		}]);
+		let resource = {
+			id: testRRI("1.json"),
+			type: "card",
+			attributes: { name: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri(`./fancy-person`),
+				name: "FancyPerson"
+			} }
+		};
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance",
+			resource,
+			lastModified: Date.now(),
+			resourceCreatedAt: Date.now(),
+			searchData: { name: "Van Gogh" },
+			deps: new Set([`${testRealmURL}fancy-person`]),
+			displayNames: [
+				"Fancy Person",
+				"Person",
+				"Card"
+			],
+			types: [
+				{
+					module: rri(`./fancy-person`),
+					name: "FancyPerson"
+				},
+				{
+					module: rri(`./person`),
+					name: "Person"
+				},
+				baseCardRef
+			].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork))
+		});
+		let [liveVersion] = await adapter.execute(`SELECT generation, pristine_doc, search_doc, deps, types FROM boxel_index WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: {
+				pristine_doc: "JSON",
+				search_doc: "JSON",
+				deps: "JSON",
+				types: "JSON"
+			}
+		});
+		assert.deepEqual(liveVersion, {
+			generation: 1,
+			pristine_doc: {
+				id: `${testRealmURL}1.json`,
+				type: "card",
+				attributes: { name: "Mango" },
+				meta: { adoptsFrom: {
+					module: rri(`./person`),
+					name: "Person"
+				} }
+			},
+			search_doc: { name: "Mango" },
+			deps: [`${testRealmURL}person`],
+			types: [{
+				module: rri(`./person`),
+				name: "Person"
+			}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork))
+		}, "live version of the doc has not changed");
+		let [wipVersion] = await adapter.execute(`SELECT generation, pristine_doc, search_doc, deps, types FROM boxel_index_pending WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: {
+				pristine_doc: "JSON",
+				search_doc: "JSON",
+				deps: "JSON",
+				types: "JSON"
+			}
+		});
+		assert.deepEqual(wipVersion, {
+			generation: 2,
+			pristine_doc: {
+				id: `${testRealmURL}1.json`,
+				type: "card",
+				attributes: { name: "Van Gogh" },
+				meta: { adoptsFrom: {
+					module: rri(`./fancy-person`),
+					name: "FancyPerson"
+				} }
+			},
+			search_doc: { name: "Van Gogh" },
+			deps: [`${testRealmURL}fancy-person`],
+			types: [
+				{
+					module: rri(`./fancy-person`),
+					name: "FancyPerson"
+				},
+				{
+					module: rri(`./person`),
+					name: "Person"
+				},
+				baseCardRef
+			].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork))
+		}, "WIP version of the doc exists");
+		await batch.done();
+		let [finalVersion] = await adapter.execute(`SELECT generation, pristine_doc, search_doc, deps, types FROM boxel_index WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: {
+				pristine_doc: "JSON",
+				search_doc: "JSON",
+				deps: "JSON",
+				types: "JSON"
+			}
+		});
+		assert.deepEqual(finalVersion, {
+			generation: 2,
+			pristine_doc: {
+				id: `${testRealmURL}1.json`,
+				type: "card",
+				attributes: { name: "Van Gogh" },
+				meta: { adoptsFrom: {
+					module: rri(`./fancy-person`),
+					name: "FancyPerson"
+				} }
+			},
+			search_doc: { name: "Van Gogh" },
+			deps: [`${testRealmURL}fancy-person`],
+			types: [
+				{
+					module: rri(`./fancy-person`),
+					name: "FancyPerson"
+				},
+				{
+					module: rri(`./person`),
+					name: "Person"
+				},
+				baseCardRef
+			].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork))
+		}, "final version of the doc exists");
+	});
+	(0, import_qunit.test)("sanitizes jsonb-illegal code points in content columns before write", async function(assert) {
+		const NUL = "\0";
+		const LONE_HIGH = "\ud83e";
+		const LONE_LOW = "\udde9";
+		const VALID_EMOJI = "🧩";
+		const REPLACEMENT = "�";
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let resource = {
+			id: testRRI("1.json"),
+			type: "card",
+			attributes: {
+				name: `Van${NUL}Gogh`,
+				bio: `high:${LONE_HIGH} emoji:${VALID_EMOJI} low:${LONE_LOW}`
+			},
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance",
+			resource,
+			lastModified: Date.now(),
+			resourceCreatedAt: Date.now(),
+			searchData: {
+				name: `Van${NUL}Gogh`,
+				bio: `high:${LONE_HIGH} emoji:${VALID_EMOJI} low:${LONE_LOW}`
+			},
+			markdown: `# Title${NUL} ${LONE_HIGH} keep ${VALID_EMOJI}`,
+			deps: new Set([`${testRealmURL}person`]),
+			displayNames: [`Person${NUL}`],
+			types: [{
+				module: rri(`./person`),
+				name: "Person"
+			}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork))
+		});
+		let [row] = await adapter.execute(`SELECT pristine_doc, search_doc, display_names FROM boxel_index_pending WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: {
+				pristine_doc: "JSON",
+				search_doc: "JSON",
+				display_names: "JSON"
+			}
+		});
+		let pristine = row.pristine_doc;
+		let search = row.search_doc;
+		let displayNames = row.display_names;
+		assert.strictEqual(pristine.attributes?.name, `Van${REPLACEMENT}Gogh`, "NUL in pristine_doc string is replaced");
+		assert.strictEqual(search.name, `Van${REPLACEMENT}Gogh`, "NUL in search_doc string is replaced");
+		assert.strictEqual(search.bio, `high:${REPLACEMENT} emoji:${VALID_EMOJI} low:${REPLACEMENT}`, "lone surrogates are replaced while the valid emoji pair is preserved");
+		let [renderedRow] = await adapter.execute(`SELECT markdown FROM prerendered_html_pending WHERE url = $1`, { bind: [`${testRealmURL}1.json`] });
+		assert.strictEqual(renderedRow.markdown, `# Title${REPLACEMENT} ${REPLACEMENT} keep ${VALID_EMOJI}`, "markdown column is sanitized and keeps the valid emoji");
+		assert.deepEqual(displayNames, [`Person${REPLACEMENT}`], "display_names entries are sanitized");
+	});
+	(0, import_qunit.test)("lands prerendered HTML on the prerendered_html channel and swaps it into production on done", async function(assert) {
+		let types = [{
+			module: rri(`./person`),
+			name: "Person"
+		}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork));
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance"
+		}]);
+		let resource = {
+			id: testRRI("1.json"),
+			type: "card",
+			attributes: { name: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		let embeddedHtml = Object.fromEntries(types.map((type) => [type, `<div class="embedded">${type}</div>`]));
+		let fittedHtml = Object.fromEntries(types.map((type) => [type, `<div class="fitted">${type}</div>`]));
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance",
+			resource,
+			lastModified: Date.now(),
+			resourceCreatedAt: Date.now(),
+			searchData: { name: "Van Gogh" },
+			deps: new Set([`${testRealmURL}person`]),
+			displayNames: ["Person", "Card"],
+			types,
+			embeddedHtml,
+			fittedHtml,
+			isolatedHtml: `<div class="isolated">Isolated</div>`,
+			atomHtml: `<span class="atom">Atom</span>`,
+			headHtml: `<span class="head">Head</span>`,
+			iconHTML: `<svg>icon</svg>`,
+			markdown: "Van Gogh markdown"
+		});
+		await batch.done();
+		let [rendered] = await adapter.execute(`SELECT url, realm_url, type, fitted_html, embedded_html, isolated_html, atom_html, head_html, markdown, deps, generation, is_deleted, error_doc
+       FROM prerendered_html WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: {
+				fitted_html: "JSON",
+				embedded_html: "JSON",
+				deps: "JSON",
+				error_doc: "JSON",
+				is_deleted: "BOOLEAN"
+			}
+		});
+		assert.deepEqual(rendered, {
+			url: `${testRealmURL}1.json`,
+			realm_url: testRealmURL,
+			type: "instance",
+			fitted_html: fittedHtml,
+			embedded_html: embeddedHtml,
+			isolated_html: `<div class="isolated">Isolated</div>`,
+			atom_html: `<span class="atom">Atom</span>`,
+			head_html: `<span class="head">Head</span>`,
+			markdown: "Van Gogh markdown",
+			deps: [`${testRealmURL}person`],
+			generation: 2,
+			is_deleted: false,
+			error_doc: null
+		}, "prerendered_html carries the HTML at the job generation");
+		let [indexRow] = await adapter.execute(`SELECT icon_html FROM boxel_index WHERE url = $1`, { bind: [`${testRealmURL}1.json`] });
+		assert.strictEqual(indexRow.icon_html, `<svg>icon</svg>`, "icon_html lives on boxel_index (not part of prerendered_html)");
+	});
+	(0, import_qunit.test)("tombstones the prerendered_html row on delete, preserving last-known HTML", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance"
+		}]);
+		let resource = {
+			id: testRRI("1.json"),
+			type: "card",
+			attributes: { name: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		let batch1 = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch1.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch1.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance",
+			resource,
+			lastModified: Date.now(),
+			resourceCreatedAt: Date.now(),
+			searchData: { name: "Van Gogh" },
+			deps: new Set([`${testRealmURL}person`]),
+			displayNames: ["Person"],
+			types: [{
+				module: rri(`./person`),
+				name: "Person"
+			}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork)),
+			isolatedHtml: `<div class="isolated">Isolated</div>`,
+			markdown: "Van Gogh markdown"
+		});
+		await batch1.done();
+		let batch2 = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch2.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch2.done();
+		let [rendered] = await adapter.execute(`SELECT is_deleted, isolated_html, markdown, generation FROM prerendered_html WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: { is_deleted: "BOOLEAN" }
+		});
+		assert.true(rendered.is_deleted, "prerendered_html row is tombstoned");
+		assert.strictEqual(rendered.isolated_html, `<div class="isolated">Isolated</div>`, "last-known HTML is preserved on the tombstone");
+		assert.strictEqual(rendered.generation, 3, "tombstone stamped at the deleting job generation");
+		let [indexRow] = await adapter.execute(`SELECT is_deleted FROM boxel_index WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: { is_deleted: "BOOLEAN" }
+		});
+		assert.true(indexRow.is_deleted, "boxel_index row is tombstoned in lockstep");
+	});
+	const SQLITE_BIND_BUDGET = 900;
+	const seedRenderedRows = (count) => {
+		let rows = [];
+		for (let i = 1; i <= count; i++) rows.push({
+			url: `${testRealmURL}${i}.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			isolated_html: `<div class="isolated">${i}</div>`
+		});
+		return rows;
+	};
+	const seededUrls = (rows) => rows.map((row) => new URL(row.url));
+	(0, import_qunit.test)("tombstone upserts are chunked and still tombstone every row", async function(assert) {
+		const URL_COUNT = 120;
+		let indexRows = seedRenderedRows(URL_COUNT);
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], indexRows);
+		let oversized = [];
+		let originalExecute = adapter.execute.bind(adapter);
+		let spy = async (sql, opts) => {
+			let table = /INSERT INTO (boxel_index_pending|prerendered_html_pending)/.exec(sql)?.[1];
+			let binds = opts?.bind?.length ?? 0;
+			if (table && binds > SQLITE_BIND_BUDGET) oversized.push({
+				table,
+				binds
+			});
+			return originalExecute(sql, opts);
+		};
+		adapter.execute = spy;
+		try {
+			let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+			await batch.invalidate(seededUrls(indexRows));
+			await batch.done();
+		} finally {
+			adapter.execute = originalExecute;
+		}
+		assert.deepEqual(oversized, [], "every tombstone upsert is chunked within the adapter bind budget");
+		let indexed = await adapter.execute(`SELECT is_deleted FROM boxel_index WHERE realm_url = $1`, {
+			bind: [testRealmURL],
+			coerceTypes: { is_deleted: "BOOLEAN" }
+		});
+		assert.strictEqual(indexed.filter((row) => row.is_deleted).length, URL_COUNT, "every boxel_index row is tombstoned");
+		let rendered = await adapter.execute(`SELECT is_deleted FROM prerendered_html WHERE realm_url = $1`, {
+			bind: [testRealmURL],
+			coerceTypes: { is_deleted: "BOOLEAN" }
+		});
+		assert.strictEqual(rendered.filter((row) => row.is_deleted).length, URL_COUNT, "every prerendered_html row is tombstoned");
+	});
+	(0, import_qunit.test)("promotes prerendered_html_pending rows resumed from a prior job attempt", async function(assert) {
+		let url = `${testRealmURL}1.json`;
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], {
+			working: [{
+				url,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				staging_id: jobStagingId(42, 1),
+				last_modified: String(17e8),
+				is_deleted: false,
+				deps: [],
+				types: [],
+				isolated_html: `<div class="isolated">Resumed</div>`,
+				markdown: "Resumed markdown"
+			}],
+			production: []
+		});
+		await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 2,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		})).done();
+		let [rendered] = await adapter.execute(`SELECT isolated_html, markdown FROM prerendered_html WHERE url = $1`, { bind: [url] });
+		assert.strictEqual(rendered?.isolated_html, `<div class="isolated">Resumed</div>`, "resumed row HTML is promoted to prerendered_html");
+		assert.strictEqual(rendered?.markdown, "Resumed markdown", "resumed row markdown is promoted to prerendered_html");
+		let [indexRow] = await adapter.execute(`SELECT url FROM boxel_index WHERE url = $1`, { bind: [url] });
+		assert.strictEqual(indexRow?.url, url, "the boxel_index row is promoted in lockstep for resumed rows");
+	});
+	(0, import_qunit.test)("mirrors an error entry onto prerendered_html, preserving last-known-good HTML", async function(assert) {
+		let url = `${testRealmURL}1.json`;
+		let types = [{
+			module: rri(`./person`),
+			name: "Person"
+		}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork));
+		let resource = {
+			id: testRRI("1"),
+			type: "card",
+			attributes: { name: "Mango" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			is_deleted: false,
+			pristine_doc: resource,
+			search_doc: { name: "Mango" },
+			display_names: ["Person"],
+			deps: [`${testRealmURL}person`],
+			last_known_good_deps: [`${testRealmURL}person`],
+			types,
+			isolated_html: `<div class="isolated">Last known good</div>`,
+			markdown: "Last known good markdown"
+		}]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(url), {
+			type: "instance-error",
+			error: {
+				message: "boom",
+				status: 500,
+				additionalErrors: []
+			}
+		});
+		await batch.done();
+		let [rendered] = await adapter.execute(`SELECT isolated_html, markdown, error_doc, is_deleted FROM prerendered_html WHERE url = $1`, {
+			bind: [url],
+			coerceTypes: {
+				error_doc: "JSON",
+				is_deleted: "BOOLEAN"
+			}
+		});
+		assert.strictEqual(rendered?.error_doc?.message, "boom", "the error rides on prerendered_html.error_doc");
+		assert.strictEqual(rendered?.isolated_html, `<div class="isolated">Last known good</div>`, "last-known-good HTML is preserved on the error row");
+		assert.strictEqual(rendered?.markdown, "Last known good markdown", "last-known-good markdown is preserved on the error row");
+		assert.false(rendered?.is_deleted, "an error row is not a tombstone");
+	});
+	(0, import_qunit.test)("error entry includes last known good state when available", async function(assert) {
+		let types = [{
+			module: rri(`./person`),
+			name: "Person"
+		}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork));
+		let modified = Date.now();
+		let resource = {
+			id: testRRI("1"),
+			type: "card",
+			attributes: { name: "Mango" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			pristine_doc: resource,
+			search_doc: { name: "Mango" },
+			display_names: [`Person`],
+			deps: [`${testRealmURL}person`],
+			last_known_good_deps: [`${testRealmURL}person`],
+			types,
+			last_modified: String(modified),
+			resource_created_at: String(modified),
+			embedded_html: Object.fromEntries(types.map((type) => [type, `<div class="embedded">Embedded HTML for ${type}</div>`])),
+			fitted_html: Object.fromEntries(types.map((type) => [type, `<div class="fitted">Fitted HTML for ${type}</div>`])),
+			isolated_html: `<div class="isolated">Isolated HTML</div>`,
+			atom_html: `<span class="atom">Atom HTML</span>`,
+			head_html: null,
+			icon_html: "<svg>test icon</svg>"
+		}]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance-error",
+			error: {
+				message: "test error",
+				status: 500,
+				additionalErrors: []
+			}
+		});
+		await batch.done();
+		let [rawErrorEntry] = await adapter.execute("SELECT * FROM boxel_index WHERE generation = 2 AND type = 'instance' AND has_error = TRUE ORDER BY url COLLATE \"POSIX\"", { coerceTypes });
+		let { indexed_at: _remove, diagnostics, ...errorEntry } = rawErrorEntry;
+		assert.ok(errorEntry.error_doc, "row has an error_doc");
+		let { diagnostics: errorDocDiagnostics, ...errorDocWithoutDiagnostics } = errorEntry.error_doc;
+		errorEntry.error_doc = errorDocWithoutDiagnostics;
+		assert.deepEqual(errorEntry, {
+			url: `${testRealmURL}1.json`,
+			file_alias: `${testRealmURL}1`,
+			generation: 2,
+			host_shell_generation: null,
+			source_content_hash: null,
+			relationship_deps: null,
+			realm_url: testRealmURL,
+			type: "instance",
+			has_error: true,
+			pristine_doc: resource,
+			error_doc: {
+				message: "test error",
+				status: 500,
+				id: `${testRealmURL}1.json`,
+				additionalErrors: []
+			},
+			search_doc: { name: "Mango" },
+			display_names: [`Person`],
+			deps: [`${testRealmURL}person`],
+			last_known_good_deps: [`${testRealmURL}person`],
+			types,
+			last_modified: String(modified),
+			resource_created_at: String(modified),
+			is_deleted: null,
+			icon_html: "<svg>test icon</svg>"
+		}, "the error entry includes last known good state of instance");
+		assert.ok(diagnostics, "diagnostics populated on error row");
+		assert.strictEqual(typeof diagnostics, "object", "diagnostics is an object");
+		assert.deepEqual(errorDocDiagnostics, diagnostics, "error_doc.diagnostics mirrors diagnostics");
+	});
+	(0, import_qunit.test)("error entry keeps freshly-stamped synthetic search keys over the last-known-good doc", async function(assert) {
+		let timestamp = Date.now();
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "file",
+			search_doc: {
+				name: "1.json",
+				extra: "keep-me"
+			},
+			last_modified: String(timestamp),
+			resource_created_at: String(timestamp)
+		}]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "file-error",
+			error: {
+				message: "dep in error",
+				status: 500,
+				additionalErrors: []
+			},
+			searchData: {
+				name: "1.json",
+				_isCardInstanceFile: true,
+				_title: "1.json"
+			}
+		});
+		await batch.done();
+		let [row] = await adapter.execute("SELECT search_doc FROM boxel_index WHERE generation = 2 AND type = 'file' AND has_error = TRUE", { coerceTypes });
+		assert.deepEqual(row.search_doc, {
+			name: "1.json",
+			extra: "keep-me",
+			_isCardInstanceFile: true,
+			_title: "1.json"
+		}, "error row merges freshly-stamped synthetic keys onto the last-known-good doc");
+	});
+	(0, import_qunit.test)("strips jsonb-illegal code points from error_doc and diagnostics on write", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance-error",
+			error: {
+				message: "Unexpected token \0\ud800 JFIF is not valid JSON",
+				status: 500,
+				additionalErrors: [{
+					message: "nested \0 binary",
+					status: 500,
+					additionalErrors: []
+				}]
+			},
+			diagnostics: { renderStage: "load\0links" }
+		});
+		await batch.done();
+		let [row] = await adapter.execute("SELECT * FROM boxel_index WHERE has_error = TRUE AND generation = 2", { coerceTypes });
+		assert.ok(row?.error_doc, "error row persisted despite binary in message");
+		let nul = String.fromCharCode(0);
+		let hasIllegalCodePoint = (s) => s.includes(nul) || /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(s);
+		assert.notOk(hasIllegalCodePoint(row.error_doc.message), "illegal code points stripped from the error message");
+		assert.true(row.error_doc.message.includes("JFIF"), "the readable remainder of the message is preserved");
+		assert.notOk(hasIllegalCodePoint(row.error_doc.additionalErrors[0].message), "illegal code points stripped from nested additionalErrors too");
+		assert.strictEqual(row.diagnostics.renderStage, "load�links", "illegal code points stripped from diagnostics strings too");
+	});
+	(0, import_qunit.test)("copies the render's host-shell generation onto the row", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}rendered.json`), {
+			type: "file",
+			lastModified: 1,
+			resourceCreatedAt: 1,
+			deps: /* @__PURE__ */ new Set(),
+			searchData: { name: "rendered" },
+			diagnostics: { warmedHostShellGeneration: 9 }
+		});
+		await batch.updateEntry(new URL(`${testRealmURL}failed.json`), {
+			type: "instance-error",
+			error: {
+				message: "boom",
+				status: 500,
+				additionalErrors: []
+			},
+			diagnostics: { warmedHostShellGeneration: 9 }
+		});
+		await batch.updateEntry(new URL(`${testRealmURL}unstamped.json`), {
+			type: "file",
+			lastModified: 1,
+			resourceCreatedAt: 1,
+			deps: /* @__PURE__ */ new Set(),
+			searchData: { name: "unstamped" },
+			diagnostics: { hostShellHash: "b778fe76" }
+		});
+		await batch.done();
+		let rows = await adapter.execute(`SELECT url, host_shell_generation FROM boxel_index
+       WHERE realm_url = $1 ORDER BY url`, { bind: [testRealmURL] });
+		assert.deepEqual(rows.map((r) => [r.url.replace(testRealmURL, ""), r.host_shell_generation]), [
+			["failed.json", 9],
+			["rendered.json", 9],
+			["unstamped.json", null]
+		], "the number reaches the success row and the error row, and absence stays null");
+	});
+	(0, import_qunit.module)("an error row over a published row", function(hooks) {
+		const PUBLISHED_GENERATION = 3;
+		const RENDER_GENERATION = 9;
+		hooks.beforeEach(async function() {
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], [{
+				url: `${testRealmURL}1.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				host_shell_generation: PUBLISHED_GENERATION,
+				pristine_doc: {
+					id: `${testRealmURL}1.json`,
+					type: "card",
+					attributes: { name: "Mango" },
+					meta: { adoptsFrom: {
+						module: rri(`./person`),
+						name: "Person"
+					} }
+				},
+				search_doc: { name: "Mango" }
+			}]);
+		});
+		let generationOnRow = async () => {
+			let [row] = await adapter.execute(`SELECT host_shell_generation FROM boxel_index WHERE url = $1`, { bind: [`${testRealmURL}1.json`] });
+			return row.host_shell_generation;
+		};
+		(0, import_qunit.test)("a published error takes the render's generation", async function(assert) {
+			let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+			await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+				type: "instance-error",
+				error: {
+					message: "boom",
+					status: 500,
+					additionalErrors: []
+				},
+				diagnostics: { warmedHostShellGeneration: RENDER_GENERATION }
+			});
+			await batch.done();
+			assert.strictEqual(await generationOnRow(), RENDER_GENERATION);
+		});
+		(0, import_qunit.test)("a withheld failure keeps the published generation", async function(assert) {
+			let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+			await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+				type: "instance-error",
+				error: {
+					message: "boom",
+					status: 500,
+					additionalErrors: []
+				},
+				diagnostics: {
+					warmedHostShellGeneration: RENDER_GENERATION,
+					staleShellFailure: ["instance"]
+				}
+			});
+			await batch.done();
+			let [row] = await adapter.execute(`SELECT host_shell_generation, has_error FROM boxel_index WHERE url = $1`, {
+				bind: [`${testRealmURL}1.json`],
+				coerceTypes: { has_error: "BOOLEAN" }
+			});
+			assert.false(row.has_error, "the failure was withheld");
+			assert.strictEqual(row.host_shell_generation, PUBLISHED_GENERATION, "the row still serves the published render, so it keeps its generation");
+		});
+	});
+	(0, import_qunit.test)("error entry does not include last known good state when not available", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance-error",
+			error: {
+				message: "test error",
+				status: 500,
+				additionalErrors: []
+			}
+		});
+		await batch.done();
+		let [rawErrorEntry] = await adapter.execute("SELECT * FROM boxel_index WHERE generation = 2 AND type = 'instance' AND has_error = TRUE ORDER BY url COLLATE \"POSIX\"", { coerceTypes });
+		let { indexed_at: _remove, diagnostics, ...errorEntry } = rawErrorEntry;
+		assert.ok(errorEntry.error_doc, "row has an error_doc");
+		let { diagnostics: errorDocDiagnostics, ...errorDocWithoutDiagnostics } = errorEntry.error_doc;
+		errorEntry.error_doc = errorDocWithoutDiagnostics;
+		assert.deepEqual(errorEntry, {
+			url: `${testRealmURL}1.json`,
+			file_alias: `${testRealmURL}1`,
+			generation: 2,
+			host_shell_generation: null,
+			source_content_hash: null,
+			relationship_deps: null,
+			realm_url: testRealmURL,
+			type: "instance",
+			has_error: true,
+			pristine_doc: null,
+			error_doc: {
+				message: "test error",
+				status: 500,
+				id: `${testRealmURL}1.json`,
+				additionalErrors: []
+			},
+			search_doc: null,
+			display_names: null,
+			deps: [],
+			last_known_good_deps: null,
+			types: null,
+			last_modified: null,
+			resource_created_at: null,
+			is_deleted: false,
+			icon_html: null
+		}, "the error entry does not include last known good state of instance");
+		assert.ok(diagnostics, "diagnostics populated on error row");
+		assert.strictEqual(typeof diagnostics, "object", "diagnostics is an object");
+		assert.deepEqual(errorDocDiagnostics, diagnostics, "error_doc.diagnostics mirrors diagnostics");
+	});
+	(0, import_qunit.test)("normalizes error doc id and deps", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}nested/1.json`), {
+			type: "instance-error",
+			error: {
+				id: null,
+				message: "test error",
+				status: 404,
+				deps: ["../headless-skill-set", `${testRealmURL}other-card`],
+				additionalErrors: null
+			}
+		});
+		await batch.done();
+		let [{ error_doc: errorDoc, deps }] = await adapter.execute("SELECT error_doc, deps FROM boxel_index WHERE generation = 2 AND type = 'instance' AND has_error = TRUE ORDER BY url COLLATE \"POSIX\"", { coerceTypes });
+		assert.strictEqual(errorDoc?.id, `${testRealmURL}nested/1.json`, "id defaults to entry url");
+		assert.deepEqual(errorDoc?.deps, [`${testRealmURL}headless-skill-set`, `${testRealmURL}other-card`], "error doc deps are canonicalized");
+		assert.deepEqual(deps, [`${testRealmURL}headless-skill-set`, `${testRealmURL}other-card`], "entry deps include normalized error deps");
+	});
+	(0, import_qunit.test)("error_doc within budget is persisted unchanged", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let inputError = {
+			message: "small parent error",
+			status: 500,
+			title: "Render error",
+			stack: "Error: small\n    at thing (/x.js:1:1)",
+			additionalErrors: [{
+				status: 500,
+				message: "inner err",
+				stack: "Error: inner\n    at inner (/y.js:1:1)",
+				additionalErrors: [{
+					status: 500,
+					message: "inner inner — preserved end-to-end",
+					additionalErrors: null
+				}]
+			}]
+		};
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance-error",
+			error: { ...inputError }
+		});
+		await batch.done();
+		let [{ error_doc: errorDoc }] = await adapter.execute("SELECT error_doc FROM boxel_index WHERE has_error = TRUE AND type = 'instance'", { coerceTypes });
+		assert.ok(errorDoc, "error_doc was persisted");
+		assert.strictEqual(errorDoc.message, inputError.message, "message preserved verbatim");
+		assert.strictEqual(errorDoc.stack, inputError.stack, "top-level stack preserved verbatim");
+		assert.strictEqual(errorDoc.additionalErrors.length, 1, "additionalErrors length preserved");
+		let kept = errorDoc.additionalErrors[0];
+		assert.strictEqual(kept.message, "inner err", "inherited message preserved");
+		assert.ok(Array.isArray(kept.additionalErrors), "nested additionalErrors retained for in-budget docs");
+		assert.strictEqual(kept.additionalErrors[0].message, "inner inner — preserved end-to-end", "second-level nesting preserved verbatim");
+	});
+	(0, import_qunit.test)("oversized error_doc is shed progressively until it fits", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let entries = Array.from({ length: 50 }, (_, i) => ({
+			status: 500,
+			message: `dep err ${i}`,
+			stack: "x".repeat(1024 * 1024),
+			additionalErrors: [{
+				status: 500,
+				message: "inherited nested",
+				additionalErrors: null
+			}]
+		}));
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance-error",
+			error: {
+				message: "parent",
+				status: 500,
+				stack: "short",
+				additionalErrors: entries
+			}
+		});
+		await batch.done();
+		let [{ error_doc: errorDoc }] = await adapter.execute("SELECT error_doc FROM boxel_index WHERE has_error = TRUE AND type = 'instance'", { coerceTypes });
+		assert.ok(errorDoc, "error_doc was persisted");
+		assert.ok(JSON.stringify(errorDoc).length <= 8 * 1024 * 1024, "persisted error_doc fits the 8 MiB budget");
+		assert.strictEqual(errorDoc.message, "parent", "top-level message untouched");
+		assert.strictEqual(errorDoc.additionalErrors.length, 50, "entry count preserved (no late-stage capping)");
+		assert.strictEqual(errorDoc.additionalErrors[0].message, "dep err 0", "per-entry message untouched");
+		assert.ok(Array.isArray(errorDoc.additionalErrors[0].additionalErrors), "nested additionalErrors retained (step 4 did not run)");
+		assert.ok(errorDoc.additionalErrors[0].stack.length < 1024 * 1024, "per-entry stacks were trimmed (step 1 ran)");
+	});
+	(0, import_qunit.test)("can get an error doc", async function(assert) {
+		await setupIndex(adapter, [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			has_error: true,
+			error_doc: {
+				message: "test error",
+				status: 500,
+				id: `${testRealmURL}1.json`,
+				additionalErrors: []
+			}
+		}]);
+		let entry = await indexQueryEngine.getInstance(new URL(`${testRealmURL}1`));
+		if (entry?.type === "instance-error") {
+			assert.ok(entry.lastModified, "lastModified exists");
+			entry.lastModified = null;
+			assert.deepEqual(entry, {
+				type: "instance-error",
+				error: {
+					message: "test error",
+					status: 500,
+					id: `${testRealmURL}1.json`,
+					additionalErrors: []
+				},
+				canonicalURL: `${testRealmURL}1.json`,
+				generation: 1,
+				realmURL: testRealmURL,
+				instance: null,
+				lastModified: null,
+				resourceCreatedAt: null,
+				isolatedHtml: null,
+				embeddedHtml: null,
+				fittedHtml: null,
+				atomHtml: null,
+				headHtml: null,
+				markdown: null,
+				searchDoc: null,
+				types: null,
+				indexedAt: null,
+				deps: null,
+				captures: null,
+				sourceContentHash: null
+			});
+		} else assert.ok(false, `expected index entry to not be a card document`);
+	});
+	(0, import_qunit.test)("allows multiple index entries for the same url with different types", async function(assert) {
+		let timestamp = Date.now();
+		let resource = {
+			id: `${testRealmURL}1`,
+			type: "card",
+			attributes: { name: "Mango" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		await setupIndex(adapter, [{
+			url: `${testRealmURL}1.json`,
+			type: "instance",
+			pristine_doc: resource,
+			last_modified: String(timestamp),
+			resource_created_at: String(timestamp)
+		}, {
+			url: `${testRealmURL}1.json`,
+			type: "file",
+			search_doc: { name: "1.json" }
+		}]);
+		let rows = await adapter.execute("SELECT url, type FROM boxel_index WHERE url = $1 ORDER BY type COLLATE \"POSIX\"", { bind: [`${testRealmURL}1.json`] });
+		assert.deepEqual(rows, [{
+			url: `${testRealmURL}1.json`,
+			type: "file"
+		}, {
+			url: `${testRealmURL}1.json`,
+			type: "instance"
+		}], "index rows include file and instance entries");
+		let entry = await indexQueryEngine.getInstance(new URL(`${testRealmURL}1`));
+		assert.strictEqual(entry?.type, "instance", "instance entry is accessible");
+	});
+	(0, import_qunit.test)("can get \"production\" index entry", async function(assert) {
+		let originalModified = Date.now();
+		let originalResource = {
+			id: `${testRealmURL}1`,
+			type: "card",
+			attributes: { name: "Mango" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			pristine_doc: originalResource,
+			last_modified: String(originalModified),
+			resource_created_at: String(originalModified)
+		}]);
+		let resource = {
+			id: testRRI("1.json"),
+			type: "card",
+			attributes: { name: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance",
+			resource,
+			lastModified: Date.now(),
+			resourceCreatedAt: Date.now(),
+			searchData: { name: "Van Gogh" },
+			deps: /* @__PURE__ */ new Set(),
+			displayNames: [],
+			types: []
+		});
+		let entry = await indexQueryEngine.getInstance(new URL(`${testRealmURL}1`));
+		if (entry?.type === "instance") assert.deepEqual(entry, {
+			type: "instance",
+			generation: 1,
+			realmURL: testRealmURL,
+			canonicalURL: `${testRealmURL}1.json`,
+			instance: {
+				id: testRRI("1"),
+				type: "card",
+				attributes: { name: "Mango" },
+				meta: { adoptsFrom: {
+					module: rri(`./person`),
+					name: "Person"
+				} }
+			},
+			lastModified: originalModified,
+			resourceCreatedAt: originalModified,
+			searchDoc: null,
+			deps: null,
+			types: null,
+			indexedAt: null,
+			isolatedHtml: null,
+			atomHtml: null,
+			embeddedHtml: null,
+			fittedHtml: null,
+			headHtml: null,
+			markdown: null,
+			captures: null,
+			sourceContentHash: null,
+			renderError: null
+		});
+		else assert.ok(false, `expected index entry to not be an error document`);
+	});
+	(0, import_qunit.test)("can get work in progress card", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			pristine_doc: {
+				attributes: { name: "Mango" },
+				meta: { adoptsFrom: {
+					module: rri(`./person`),
+					name: "Person"
+				} }
+			}
+		}]);
+		let resource = {
+			id: testRRI("1.json"),
+			type: "card",
+			attributes: { name: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		let now = Date.now();
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance",
+			resource,
+			lastModified: now,
+			resourceCreatedAt: now,
+			searchData: { name: "Van Gogh" },
+			deps: /* @__PURE__ */ new Set(),
+			displayNames: [],
+			types: [],
+			sourceContentHash: "abc123"
+		});
+		let entry = await indexQueryEngine.getInstance(new URL(`${testRealmURL}1`), { pendingStagingId: batch.stagingId });
+		if (entry?.type === "instance") {
+			assert.ok(entry?.indexedAt, "the indexed_at field was set");
+			delete entry?.indexedAt;
+			assert.deepEqual(entry, {
+				type: "instance",
+				generation: 2,
+				realmURL: testRealmURL,
+				canonicalURL: `${testRealmURL}1.json`,
+				instance: {
+					id: testRRI("1.json"),
+					type: "card",
+					attributes: { name: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: rri(`./person`),
+						name: "Person"
+					} }
+				},
+				lastModified: now,
+				resourceCreatedAt: now,
+				searchDoc: { name: "Van Gogh" },
+				deps: [],
+				types: [],
+				isolatedHtml: null,
+				embeddedHtml: null,
+				fittedHtml: null,
+				atomHtml: null,
+				headHtml: null,
+				markdown: null,
+				captures: null,
+				sourceContentHash: "abc123",
+				renderError: null
+			});
+		} else assert.ok(false, `expected index entry to not be an error document`);
+	});
+	(0, import_qunit.test)("persists and reads back markdown for an instance entry", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let resource = {
+			id: testRRI("1.json"),
+			type: "card",
+			attributes: { name: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		let now = Date.now();
+		let markdown = "# Van Gogh\n\n- email: vangogh@example.com";
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance",
+			resource,
+			lastModified: now,
+			resourceCreatedAt: now,
+			searchData: { name: "Van Gogh" },
+			deps: /* @__PURE__ */ new Set(),
+			displayNames: [],
+			types: [],
+			markdown
+		});
+		let entry = await indexQueryEngine.getInstance(new URL(`${testRealmURL}1`), { pendingStagingId: batch.stagingId });
+		if (entry?.type === "instance") assert.strictEqual(entry.markdown, markdown, "markdown round-trips through updateEntry + getInstance");
+		else assert.ok(false, `expected index entry to be an instance (got ${entry?.type})`);
+	});
+	(0, import_qunit.test)("returns undefined when getting a deleted card", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			is_deleted: true
+		}]);
+		let entry = await indexQueryEngine.getInstance(new URL(`${testRealmURL}1`));
+		assert.strictEqual(entry, void 0, "deleted entries return undefined");
+	});
+	(0, import_qunit.test)("can perform invalidations for an instance with deps more than a thousand", async function(assert) {
+		let indexRows = [];
+		for (let i = 1; i <= 1002; i++) indexRows.push({
+			url: `${testRealmURL}${i}.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			deps: [...i <= 1 ? [] : [`${testRealmURL}1.json`]]
+		});
+		indexRows.sort((a, b) => a.url.localeCompare(b.url));
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], indexRows);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		let invalidations = batch.invalidations;
+		assert.ok(invalidations.length > 1e3, "Can invalidate more than 1000");
+		assert.deepEqual(invalidations.sort(), indexRows.map((r) => r.url));
+		let invalidatedEntries = await adapter.execute("SELECT url, realm_url, is_deleted FROM boxel_index_pending WHERE generation = 2 ORDER BY url COLLATE \"POSIX\"", { coerceTypes: { is_deleted: "BOOLEAN" } });
+		assert.deepEqual(invalidatedEntries, indexRows.map((indexRow) => ({
+			url: indexRow.url,
+			realm_url: indexRow.realm_url,
+			is_deleted: true
+		})), "the \"work-in-progress\" version of the index entries have been marked as deleted");
+		let generations = await adapter.execute("select realm_url, current_generation from realm_generations ORDER BY realm_url COLLATE \"POSIX\"");
+		assert.deepEqual(generations, [{
+			realm_url: `${testRealmURL}`,
+			current_generation: 1
+		}], "the \"production\" realm generations are correct");
+	});
+	(0, import_qunit.test)("update realm meta when indexing is done", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./person"),
+			name: "Person"
+		}, baseCardRef);
+		let fancyPersonTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./fancy-person"),
+			name: "FancyPerson"
+		}, {
+			module: rri("./person"),
+			name: "Person"
+		}, baseCardRef);
+		let petTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./pet"),
+			name: "Pet"
+		}, {
+			module: rri("./card-api"),
+			name: "CardDef"
+		}, baseCardRef);
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			pristine_doc: {
+				id: `${testRealmURL}1`,
+				type: "card",
+				attributes: { name: "Mango" },
+				meta: { adoptsFrom: {
+					module: rri(`./person`),
+					name: "Person"
+				} }
+			},
+			search_doc: { name: "Mango" },
+			display_names: [`Person`],
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			icon_html: iconHTML
+		}]);
+		let resource2 = makeCardResource("2", "Van Gogh", {
+			module: rri("./fancy-person"),
+			name: "FancyPerson"
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}2.json`)]);
+		let timestamp = Date.now();
+		await batch.updateEntry(new URL(`${testRealmURL}2.json`), {
+			type: "instance",
+			resource: resource2,
+			lastModified: timestamp,
+			resourceCreatedAt: timestamp,
+			searchData: { name: "Van Gogh" },
+			deps: new Set([`${testRealmURL}fancy-person`]),
+			displayNames: [
+				"Fancy Person",
+				"Person",
+				"Card"
+			],
+			types: fancyPersonTypes,
+			iconHTML
+		});
+		let realmMeta = await fetchRealmMeta(adapter);
+		assert.strictEqual(realmMeta.rows.length, 0, "correct length of query result before indexing is done");
+		await batch.done();
+		realmMeta = await fetchRealmMeta(adapter);
+		assert.strictEqual(realmMeta.rows.length, 1, "correct length of query result after indexing is done");
+		let value = realmMeta.value;
+		assert.strictEqual(value.length, 2, "correct length of card type summary after indexing is done");
+		assert.deepEqual(value, [makeCardTypeSummary(`${testRealmURL}fancy-person/FancyPerson`, "Fancy Person", iconHTML, 1), makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1)], "correct card type summary after indexing is done");
+		batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		let resource3 = makeCardResource("3", "Van Gogh2", {
+			module: rri("./fancy-person"),
+			name: "FancyPerson"
+		});
+		await batch.invalidate([new URL(`${testRealmURL}3.json`)]);
+		timestamp = Date.now();
+		await batch.updateEntry(new URL(`${testRealmURL}3.json`), {
+			type: "instance",
+			resource: resource3,
+			lastModified: timestamp,
+			resourceCreatedAt: timestamp,
+			searchData: { name: "Van Gogh2" },
+			deps: new Set([`${testRealmURL}fancy-person`]),
+			displayNames: [
+				"Fancy Person",
+				"Person",
+				"Card"
+			],
+			types: fancyPersonTypes,
+			iconHTML
+		});
+		let resource4 = makeCardResource("4", "Mango", {
+			module: rri("./pet"),
+			name: "Pet"
+		});
+		await batch.invalidate([new URL(`${testRealmURL}4.json`)]);
+		timestamp = Date.now();
+		await batch.updateEntry(new URL(`${testRealmURL}4.json`), {
+			type: "instance",
+			resource: resource4,
+			lastModified: timestamp,
+			resourceCreatedAt: timestamp,
+			searchData: { name: "Mango" },
+			deps: new Set([`${testRealmURL}pet`]),
+			displayNames: ["Pet", "Card"],
+			types: petTypes,
+			iconHTML
+		});
+		await batch.done();
+		realmMeta = await fetchRealmMeta(adapter);
+		assert.strictEqual(realmMeta.rows.length, 1, "correct length of query result after indexing is done");
+		value = realmMeta.value;
+		assert.strictEqual(value.length, 3, "correct length of card type summary after indexing is done");
+		assert.deepEqual(value, [
+			makeCardTypeSummary(`${testRealmURL}fancy-person/FancyPerson`, "Fancy Person", iconHTML, 2),
+			makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1),
+			makeCardTypeSummary(`${testRealmURL}pet/Pet`, "Pet", iconHTML, 1)
+		], "correct card type summary after indexing is done");
+	});
+	(0, import_qunit.test)("a failure inside the swap rolls back every statement the swap made", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personRef = {
+			module: rri("./person"),
+			name: "Person"
+		};
+		let personTypes = internalKeysFor(virtualNetwork, personRef, baseCardRef);
+		await setupIndex(adapter);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await writeInstance(batch, {
+			id: "1",
+			name: "Mango",
+			adoptsFrom: personRef,
+			displayNames: ["Person", "Card"],
+			types: personTypes,
+			iconHTML
+		});
+		await adapter.execute(`CREATE TRIGGER index_writer_test_fail_swap
+       BEFORE INSERT ON realm_type_generations
+       BEGIN
+         SELECT RAISE(ABORT, 'injected index swap failure');
+       END`);
+		try {
+			await assert.rejects(batch.done(), "the swap fails at its last statement");
+		} finally {
+			await adapter.execute("DROP TRIGGER IF EXISTS index_writer_test_fail_swap");
+		}
+		let promoted = await adapter.execute(`SELECT url FROM boxel_index WHERE realm_url = $1`, { bind: [testRealmURL] });
+		assert.deepEqual(promoted, [], "no row reached boxel_index");
+		let generations = await adapter.execute(`SELECT current_generation FROM realm_generations WHERE realm_url = $1`, { bind: [testRealmURL] });
+		assert.deepEqual(generations, [{ current_generation: 1 }], "the realm generation did not advance");
+		assert.deepEqual((await fetchRealmMetaRows(adapter)).length, 0, "no realm_meta row was written");
+		await adapter.execute("BEGIN");
+		await adapter.execute("COMMIT");
+		assert.ok(true, "a new transaction starts cleanly after the rollback");
+	});
+	(0, import_qunit.test)("update realm meta carries forward the types a pass did not touch", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personRef = {
+			module: rri("./person"),
+			name: "Person"
+		};
+		let petRef = {
+			module: rri("./pet"),
+			name: "Pet"
+		};
+		let personTypes = internalKeysFor(virtualNetwork, personRef, baseCardRef);
+		let petTypes = internalKeysFor(virtualNetwork, petRef, baseCardRef);
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: makeCardResource("1", "Mango", personRef),
+			search_doc: { name: "Mango" },
+			display_names: ["Person"],
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			icon_html: iconHTML
+		}]);
+		await plantRealmMeta(adapter, 1, {
+			instances: [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 42)],
+			files: [makeCardTypeSummary(`${testRealmURL}markdown-file-def/MarkdownDef`, "Markdown", iconHTML, 7)]
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}2.json`)]);
+		await writeInstance(batch, {
+			id: "2",
+			name: "Ringo",
+			adoptsFrom: petRef,
+			displayNames: ["Pet", "Card"],
+			types: petTypes,
+			iconHTML
+		});
+		await batch.done();
+		let realmMeta = await fetchRealmMeta(adapter);
+		assert.deepEqual(realmMeta.value, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 42), makeCardTypeSummary(`${testRealmURL}pet/Pet`, "Pet", iconHTML, 1)], "Person keeps the entry the previous generation held and Pet is recomputed, both in display-name order");
+		assert.deepEqual(realmMeta.files, [makeCardTypeSummary(`${testRealmURL}markdown-file-def/MarkdownDef`, "Markdown", iconHTML, 7)], "the file arm carries forward too, on a pass that touched no file rows");
+	});
+	(0, import_qunit.test)("update realm meta rebuilds when the previous generation predates the partitioned shape", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personRef = {
+			module: rri("./person"),
+			name: "Person"
+		};
+		let petRef = {
+			module: rri("./pet"),
+			name: "Pet"
+		};
+		let personTypes = internalKeysFor(virtualNetwork, personRef, baseCardRef);
+		let petTypes = internalKeysFor(virtualNetwork, petRef, baseCardRef);
+		let markdownTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./markdown-file-def"),
+			name: "MarkdownDef"
+		}, {
+			module: rri("./card-api"),
+			name: "FileDef"
+		});
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: makeCardResource("1", "Mango", personRef),
+			search_doc: { name: "Mango" },
+			display_names: ["Person"],
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			icon_html: iconHTML
+		}, {
+			url: `${testRealmURL}notes/a.md`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "file",
+			search_doc: {
+				name: "a.md",
+				url: `${testRealmURL}notes/a.md`
+			},
+			display_names: ["Markdown", "File"],
+			types: markdownTypes,
+			icon_html: iconHTML
+		}]);
+		await plantRealmMeta(adapter, 1, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 42)]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}2.json`)]);
+		await writeInstance(batch, {
+			id: "2",
+			name: "Ringo",
+			adoptsFrom: petRef,
+			displayNames: ["Pet", "Card"],
+			types: petTypes,
+			iconHTML
+		});
+		await batch.done();
+		let realmMeta = await fetchRealmMeta(adapter);
+		assert.deepEqual(realmMeta.files, [makeCardTypeSummary(`${testRealmURL}markdown-file-def/MarkdownDef`, "Markdown", iconHTML, 1)], "the file arm the legacy shape never had is rebuilt rather than published empty");
+		assert.deepEqual(realmMeta.value, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1), makeCardTypeSummary(`${testRealmURL}pet/Pet`, "Pet", iconHTML, 1)], "the planted count is recomputed rather than carried, so the pass rebuilt");
+	});
+	(0, import_qunit.test)("update realm meta publishes the same value whether or not the pass could scope its rollup", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personRef = {
+			module: rri("./person"),
+			name: "Person"
+		};
+		let petRef = {
+			module: rri("./pet"),
+			name: "Pet"
+		};
+		let personaRef = {
+			module: rri("./persona"),
+			name: "Persona"
+		};
+		let namelessRef = {
+			module: rri("./nameless"),
+			name: "Nameless"
+		};
+		let personTypes = internalKeysFor(virtualNetwork, personRef, baseCardRef);
+		let petTypes = internalKeysFor(virtualNetwork, petRef, baseCardRef);
+		let personaTypes = internalKeysFor(virtualNetwork, personaRef, baseCardRef);
+		let namelessTypes = internalKeysFor(virtualNetwork, namelessRef, baseCardRef);
+		let markdownTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./markdown-file-def"),
+			name: "MarkdownDef"
+		}, {
+			module: rri("./card-api"),
+			name: "FileDef"
+		});
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				pristine_doc: makeCardResource("1", "Mango", personRef),
+				search_doc: { name: "Mango" },
+				display_names: ["Person"],
+				deps: [`${testRealmURL}person`],
+				types: personTypes,
+				icon_html: iconHTML
+			},
+			{
+				url: `${testRealmURL}3.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				pristine_doc: makeCardResource("3", "Vincent", personaRef),
+				search_doc: { name: "Vincent" },
+				display_names: ["Person"],
+				deps: [`${testRealmURL}persona`],
+				types: personaTypes,
+				icon_html: iconHTML
+			},
+			{
+				url: `${testRealmURL}4.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				pristine_doc: makeCardResource("4", "Anon", namelessRef),
+				search_doc: { name: "Anon" },
+				display_names: [],
+				deps: [`${testRealmURL}nameless`],
+				types: namelessTypes,
+				icon_html: iconHTML
+			},
+			{
+				url: `${testRealmURL}notes/a.md`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "file",
+				search_doc: {
+					name: "a.md",
+					url: `${testRealmURL}notes/a.md`
+				},
+				display_names: ["Markdown", "File"],
+				types: markdownTypes,
+				icon_html: iconHTML
+			}
+		]);
+		await plantRealmMeta(adapter, 1, {
+			instances: [
+				makeCardTypeSummary(`${testRealmURL}persona/Persona`, "Person", iconHTML, 1),
+				makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1),
+				makeCardTypeSummary(`${testRealmURL}nameless/Nameless`, null, iconHTML, 1)
+			],
+			files: [makeCardTypeSummary(`${testRealmURL}markdown-file-def/MarkdownDef`, "Markdown", iconHTML, 1)]
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}2.json`)]);
+		await writeInstance(batch, {
+			id: "2",
+			name: "Ringo",
+			adoptsFrom: petRef,
+			displayNames: ["Pet", "Card"],
+			types: petTypes,
+			iconHTML
+		});
+		await batch.done();
+		let scoped = await fetchRealmMeta(adapter);
+		batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await writeInstance(batch, {
+			id: "2",
+			name: "Ringo",
+			adoptsFrom: petRef,
+			displayNames: ["Pet", "Card"],
+			types: petTypes,
+			iconHTML
+		});
+		await batch.done();
+		let rebuilt = await fetchRealmMeta(adapter);
+		assert.deepEqual(scoped.value, rebuilt.value, "the instance summaries are identical");
+		assert.deepEqual(scoped.files, rebuilt.files, "the file summaries are identical");
+		assert.deepEqual(Object.fromEntries(scoped.value.map((s) => [s.code_ref, s.total])), {
+			[`${testRealmURL}person/Person`]: 1,
+			[`${testRealmURL}persona/Persona`]: 1,
+			[`${testRealmURL}nameless/Nameless`]: 1,
+			[`${testRealmURL}pet/Pet`]: 1
+		}, "and both describe the realm as it now stands");
+		assert.strictEqual(scoped.value[scoped.value.length - 1].code_ref, `${testRealmURL}nameless/Nameless`, "the unlabelled type sorts last under NULLS LAST");
+	});
+	(0, import_qunit.test)("update realm meta drops a type whose last instance the pass deleted", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personRef = {
+			module: rri("./person"),
+			name: "Person"
+		};
+		let petRef = {
+			module: rri("./pet"),
+			name: "Pet"
+		};
+		let personTypes = internalKeysFor(virtualNetwork, personRef, baseCardRef);
+		let petTypes = internalKeysFor(virtualNetwork, petRef, baseCardRef);
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: makeCardResource("1", "Mango", personRef),
+			search_doc: { name: "Mango" },
+			display_names: ["Person"],
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			icon_html: iconHTML
+		}, {
+			url: `${testRealmURL}2.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: makeCardResource("2", "Ringo", petRef),
+			search_doc: { name: "Ringo" },
+			display_names: ["Pet"],
+			deps: [`${testRealmURL}pet`],
+			types: petTypes,
+			icon_html: iconHTML
+		}]);
+		await plantRealmMeta(adapter, 1, {
+			instances: [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 42), makeCardTypeSummary(`${testRealmURL}pet/Pet`, "Pet", iconHTML, 1)],
+			files: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}2.json`)]);
+		await batch.done();
+		assert.deepEqual((await fetchRealmMeta(adapter)).value, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 42)], "the emptied type is dropped from the carried arm while the untouched one keeps the entry it had");
+	});
+	(0, import_qunit.test)("update realm meta moves a count when a card changes what it adopts from", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personRef = {
+			module: rri("./person"),
+			name: "Person"
+		};
+		let petRef = {
+			module: rri("./pet"),
+			name: "Pet"
+		};
+		let dogRef = {
+			module: rri("./dog"),
+			name: "Dog"
+		};
+		let personTypes = internalKeysFor(virtualNetwork, personRef, baseCardRef);
+		let petTypes = internalKeysFor(virtualNetwork, petRef, baseCardRef);
+		let dogTypes = internalKeysFor(virtualNetwork, dogRef, baseCardRef);
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: makeCardResource("1", "Mango", personRef),
+			search_doc: { name: "Mango" },
+			display_names: ["Person"],
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			icon_html: iconHTML
+		}, {
+			url: `${testRealmURL}3.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: makeCardResource("3", "Rex", dogRef),
+			search_doc: { name: "Rex" },
+			display_names: ["Dog"],
+			deps: [`${testRealmURL}dog`],
+			types: dogTypes,
+			icon_html: iconHTML
+		}]);
+		await plantRealmMeta(adapter, 1, {
+			instances: [makeCardTypeSummary(`${testRealmURL}dog/Dog`, "Dog", iconHTML, 42), makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1)],
+			files: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(`${testRealmURL}1.json`)]);
+		await writeInstance(batch, {
+			id: "1",
+			name: "Mango",
+			adoptsFrom: petRef,
+			displayNames: ["Pet", "Card"],
+			types: petTypes,
+			iconHTML
+		});
+		await batch.done();
+		assert.deepEqual((await fetchRealmMeta(adapter)).value, [makeCardTypeSummary(`${testRealmURL}dog/Dog`, "Dog", iconHTML, 42), makeCardTypeSummary(`${testRealmURL}pet/Pet`, "Pet", iconHTML, 1)], "the count moved onto the new type, the type it left is gone, and the type the pass never named was carried");
+	});
+	(0, import_qunit.test)("update realm meta partitions file rows into the files array", async function(assert) {
+		let iconHTML = "<svg>file icon</svg>";
+		let baseFileTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./card-api"),
+			name: "FileDef"
+		});
+		let markdownTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./markdown-file-def"),
+			name: "MarkdownDef"
+		}, {
+			module: rri("./card-api"),
+			name: "FileDef"
+		});
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				pristine_doc: makeCardResource("1", "Mango", {
+					module: rri("./person"),
+					name: "Person"
+				}),
+				search_doc: { name: "Mango" },
+				display_names: ["Person"],
+				deps: [`${testRealmURL}person`],
+				types: internalKeysFor(virtualNetwork, {
+					module: rri("./person"),
+					name: "Person"
+				}, baseCardRef),
+				icon_html: iconHTML
+			},
+			{
+				url: `${testRealmURL}notes/a.md`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "file",
+				search_doc: {
+					name: "a.md",
+					url: `${testRealmURL}notes/a.md`
+				},
+				display_names: ["Markdown", "File"],
+				types: markdownTypes,
+				icon_html: iconHTML
+			},
+			{
+				url: `${testRealmURL}notes/b.md`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "file",
+				search_doc: {
+					name: "b.md",
+					url: `${testRealmURL}notes/b.md`
+				},
+				display_names: ["Markdown", "File"],
+				types: markdownTypes,
+				icon_html: iconHTML
+			},
+			{
+				url: `${testRealmURL}misc/raw.bin`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "file",
+				search_doc: {
+					name: "raw.bin",
+					url: `${testRealmURL}misc/raw.bin`
+				},
+				display_names: ["File"],
+				types: baseFileTypes,
+				icon_html: iconHTML
+			}
+		]);
+		await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).done();
+		let realmMeta = await fetchRealmMeta(adapter);
+		assert.strictEqual(realmMeta.rows.length, 1, "one realm_meta row was written");
+		assert.deepEqual(realmMeta.value, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1)], "instance summaries only reflect CardDef rows");
+		assert.deepEqual(realmMeta.files, [makeCardTypeSummary(`${testRealmURL}card-api/FileDef`, "File", iconHTML, 1), makeCardTypeSummary(`${testRealmURL}markdown-file-def/MarkdownDef`, "Markdown", iconHTML, 2)], "file summaries collapse duplicates and live in their own arm");
+	});
+	(0, import_qunit.test)("update realm meta collapses rows with the same code_ref but mixed display_names", async function(assert) {
+		let iconHTML = "<svg>icon</svg>";
+		let markdownTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./markdown-file-def"),
+			name: "MarkdownDef"
+		}, {
+			module: rri("./card-api"),
+			name: "FileDef"
+		});
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}notes/new.md`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "file",
+			search_doc: {
+				name: "new.md",
+				url: `${testRealmURL}notes/new.md`
+			},
+			display_names: ["Markdown", "File"],
+			types: markdownTypes,
+			icon_html: iconHTML
+		}, {
+			url: `${testRealmURL}notes/old.md`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "file",
+			search_doc: {
+				name: "old.md",
+				url: `${testRealmURL}notes/old.md`
+			},
+			display_names: [],
+			types: markdownTypes,
+			icon_html: iconHTML
+		}]);
+		await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).done();
+		let realmMeta = await fetchRealmMeta(adapter);
+		assert.deepEqual(realmMeta.files, [makeCardTypeSummary(`${testRealmURL}markdown-file-def/MarkdownDef`, "Markdown", iconHTML, 2)], "one summary per code_ref, with the populated display_name picked over the empty one");
+	});
+	(0, import_qunit.test)("fetchCardTypeSummary returns the realm_meta row at realm_generations.current_generation", async function(assert) {
+		let iconHTML = "<svg>icon</svg>";
+		let personTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./person"),
+			name: "Person"
+		}, baseCardRef);
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: makeCardResource("1", "Mango", {
+				module: rri("./person"),
+				name: "Person"
+			}),
+			search_doc: { name: "Mango" },
+			display_names: ["Person"],
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			icon_html: iconHTML
+		}]);
+		await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).done();
+		await adapter.execute(`INSERT INTO realm_meta (realm_url, generation, value, indexed_at)
+       VALUES ($1, $2, $3, $4)`, { bind: [
+			testRealmURL,
+			999,
+			JSON.stringify([{
+				code_ref: `${testRealmURL}stale/Stale`,
+				display_name: "Stale",
+				total: 42,
+				icon_html: iconHTML
+			}]),
+			String(Date.now() - 1e3)
+		] });
+		let summary = await indexQueryEngine.fetchCardTypeSummary(new URL(testRealmURL));
+		assert.deepEqual(summary.instances.map((s) => s.code_ref), [`${testRealmURL}person/Person`], "fetchCardTypeSummary returns the row at realm_generations.current_generation even when a higher-numbered stale row is present");
+		assert.notOk(summary.instances.find((s) => s.display_name === "Stale"), "stale row contents do not leak through");
+	});
+	(0, import_qunit.test)("done() prunes realm_meta rows at any version, including ones higher than the current", async function(assert) {
+		let iconHTML = "<svg>icon</svg>";
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 0
+		}], []);
+		for (let version of [
+			50,
+			100,
+			200,
+			999
+		]) await adapter.execute(`INSERT INTO realm_meta (realm_url, generation, value, indexed_at)
+         VALUES ($1, $2, $3, $4)`, { bind: [
+			testRealmURL,
+			version,
+			JSON.stringify([{
+				code_ref: `${testRealmURL}stale-${version}/Stale`,
+				display_name: `Stale-${version}`,
+				total: version,
+				icon_html: iconHTML
+			}]),
+			String(Date.now() - version * 1e3)
+		] });
+		let rowsBefore = await adapter.execute(`SELECT generation FROM realm_meta WHERE realm_url = $1 ORDER BY generation`, { bind: [testRealmURL] });
+		assert.deepEqual(rowsBefore.map((r) => r.generation), [
+			50,
+			100,
+			200,
+			999
+		], "stale rows are seeded before the batch runs");
+		await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).done();
+		let rowsAfter = await adapter.execute(`SELECT generation FROM realm_meta WHERE realm_url = $1 ORDER BY generation`, { bind: [testRealmURL] });
+		assert.deepEqual(rowsAfter.map((r) => r.generation), [1], "pruneObsoleteEntries deletes every row that is not the current version, including higher-numbered stale ones");
+	});
+	(0, import_qunit.test)("update realm meta includes error entries with last known good state", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./person"),
+			name: "Person"
+		}, baseCardRef);
+		let personResource = makeCardResource("1", "Mango", {
+			module: rri("./person"),
+			name: "Person"
+		});
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			generation: 1,
+			realm_url: testRealmURL,
+			pristine_doc: personResource,
+			search_doc: { name: "Mango" },
+			display_names: [`Person`],
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			icon_html: iconHTML
+		}]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.updateEntry(new URL(`${testRealmURL}1.json`), {
+			type: "instance-error",
+			error: {
+				message: "test error",
+				status: 500,
+				additionalErrors: []
+			}
+		});
+		await batch.done();
+		let realmMeta = await fetchRealmMeta(adapter);
+		assert.strictEqual(realmMeta.rows.length, 1, "card type summary includes error entries");
+		let value = realmMeta.value;
+		assert.deepEqual(value, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1)], "card type summary uses last known good card type data");
+	});
+	(0, import_qunit.test)("resumes URLs already processed by a previous attempt of the same job", async function(assert) {
+		let url = `${testRealmURL}1.json`;
+		let lastModified = 17e8;
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], {
+			working: [{
+				url,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				staging_id: jobStagingId(42, 1),
+				last_modified: String(lastModified),
+				is_deleted: false,
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 2,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		});
+		assert.strictEqual(batch.resumedRows.size, 1, "resumed rows from prior attempt of same job_id are loaded");
+		assert.strictEqual(batch.resumedRows.get(url), lastModified, "last_modified value is preserved as a number");
+		assert.deepEqual(batch.invalidations, [url], "resumed URLs are pre-seeded into the invalidation set so done() promotes them");
+	});
+	(0, import_qunit.test)("does not resume rows with has_error=true so the retry can re-attempt them", async function(assert) {
+		let url = `${testRealmURL}errored.json`;
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], {
+			working: [{
+				url,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				staging_id: jobStagingId(42, 1),
+				last_modified: "1700000000",
+				is_deleted: false,
+				has_error: true,
+				error_doc: {
+					message: "transient",
+					status: 500,
+					additionalErrors: []
+				},
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 2,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		});
+		assert.strictEqual(batch.resumedRows.size, 0, "errored rows are not resumed — the retry exists to re-attempt them");
+		assert.deepEqual(batch.invalidations, [], "errored URLs are not pre-seeded into the invalidation set");
+	});
+	(0, import_qunit.test)("does not resume rows from a different job", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], {
+			working: [{
+				url: `${testRealmURL}from-other-job.json`,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 99,
+				staging_id: jobStagingId(99, 1),
+				last_modified: "1700000000",
+				is_deleted: false,
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 2,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		});
+		assert.strictEqual(batch.resumedRows.size, 0, "rows tagged with a different job_id are not resumed");
+	});
+	(0, import_qunit.test)("another pass's staged rows are invisible to this pass's discovery, dependency reads and summary, and survive its commit", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let personTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./person"),
+			name: "Person"
+		}, baseCardRef);
+		let petTypes = internalKeysFor(virtualNetwork, {
+			module: rri("./pet"),
+			name: "Pet"
+		}, baseCardRef);
+		let hubURL = `${testRealmURL}hub.json`;
+		let doomedURL = `${testRealmURL}doomed.json`;
+		let stagedURL = `${testRealmURL}staged-pet.json`;
+		let committedPerson = (url) => ({
+			url,
+			generation: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			deps: [`${testRealmURL}person`],
+			types: personTypes,
+			display_names: ["Person"],
+			icon_html: iconHTML
+		});
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], [committedPerson(hubURL), committedPerson(doomedURL)]);
+		let stageHub = async (stagingBatch, name) => {
+			let now = Date.now();
+			await stagingBatch.updateEntry(new URL(hubURL), {
+				type: "instance",
+				resource: makeCardResource("hub", name, {
+					module: rri("./person"),
+					name: "Person"
+				}),
+				lastModified: now,
+				resourceCreatedAt: now,
+				searchData: { name },
+				deps: new Set([`${testRealmURL}person`]),
+				displayNames: ["Person"],
+				types: personTypes,
+				iconHTML,
+				isolatedHtml: `<p>${name}</p>`
+			});
+		};
+		let peer = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 99,
+			reservationId: 1,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		});
+		await stageHub(peer, "Peer Hub");
+		await peer.invalidate([new URL(doomedURL)]);
+		let timestamp = Date.now();
+		await peer.updateEntry(new URL(stagedURL), {
+			type: "instance",
+			resource: makeCardResource("staged-pet", "Staged", {
+				module: rri("./pet"),
+				name: "Pet"
+			}),
+			lastModified: timestamp,
+			resourceCreatedAt: timestamp,
+			searchData: { name: "Staged" },
+			deps: new Set([hubURL]),
+			displayNames: ["Pet"],
+			types: petTypes,
+			iconHTML
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+		await batch.invalidate([new URL(hubURL)]);
+		assert.deepEqual(batch.invalidations, [hubURL], "the fan-out does not follow the peer's staged dependency edge");
+		assert.deepEqual((await batch.getDependencyRows([stagedURL, doomedURL])).map((row) => ({
+			url: row.url,
+			isDeleted: row.isDeleted
+		})), [{
+			url: doomedURL,
+			isDeleted: false
+		}], "dependency reads see the committed rows, not the peer's staged card or its tombstone");
+		assert.deepEqual(await batch.getOrderingDependencyRows([stagedURL]), [], "ordering reads do not see the peer's staged card");
+		await stageHub(batch, "Hub");
+		await batch.done();
+		assert.deepEqual((await fetchRealmMeta(adapter)).value, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 2)], "the published summary counts only committed cards: the peer's staged card and deletion are not in it");
+		let production = await adapter.execute(`SELECT url, is_deleted FROM boxel_index WHERE realm_url = $1 ORDER BY url COLLATE "POSIX"`, {
+			bind: [testRealmURL],
+			coerceTypes: { is_deleted: "BOOLEAN" }
+		});
+		assert.deepEqual(production.map((row) => [row.url, Boolean(row.is_deleted)]), [[doomedURL, false], [hubURL, false]], "the commit promotes none of the peer's other rows, and applies none of its deletions");
+		let hubVersions = async () => {
+			let [index] = await adapter.execute(`SELECT search_doc FROM boxel_index WHERE url = $1 AND type = 'instance'`, {
+				bind: [hubURL],
+				coerceTypes: { search_doc: "JSON" }
+			});
+			let [html] = await adapter.execute(`SELECT isolated_html FROM prerendered_html WHERE url = $1 AND type = 'instance'`, { bind: [hubURL] });
+			return {
+				index: index?.search_doc?.name,
+				html: html?.isolated_html
+			};
+		};
+		assert.deepEqual(await hubVersions(), {
+			index: "Hub",
+			html: "<p>Hub</p>"
+		}, "for a URL both passes staged, the commit promotes its own version on both channels, not the peer's");
+		let peerStaged = await adapter.execute(`SELECT url FROM boxel_index_pending WHERE staging_id = $1 ORDER BY url COLLATE "POSIX"`, { bind: [peer.stagingId] });
+		assert.deepEqual(peerStaged.map((row) => row.url), [
+			doomedURL,
+			hubURL,
+			stagedURL
+		], "the commit leaves the peer's staged rows in place");
+		await peer.done();
+		assert.deepEqual((await fetchRealmMeta(adapter)).value, [makeCardTypeSummary(`${testRealmURL}person/Person`, "Person", iconHTML, 1), makeCardTypeSummary(`${testRealmURL}pet/Pet`, "Pet", iconHTML, 1)], "the peer's own commit publishes what it staged");
+		assert.deepEqual(await hubVersions(), {
+			index: "Peer Hub",
+			html: "<p>Peer Hub</p>"
+		}, "the peer's commit promotes the peer's version of the hub");
+		let [doomed] = await adapter.execute(`SELECT is_deleted, types FROM boxel_index WHERE url = $1`, {
+			bind: [doomedURL],
+			coerceTypes: {
+				is_deleted: "BOOLEAN",
+				types: "JSON"
+			}
+		});
+		assert.true(doomed.is_deleted, "the peer's deletion lands with its commit");
+		assert.deepEqual(doomed.types, personTypes, "the promoted tombstone keeps the rest of the row it hides");
+	});
+	(0, import_qunit.test)("a commit clears ad-hoc staging idle past the abandonment window, and leaves recent staging alone", async function(assert) {
+		let iconHTML = "<svg>test icon</svg>";
+		let types = internalKeysFor(virtualNetwork, {
+			module: rri("./person"),
+			name: "Person"
+		}, baseCardRef);
+		let stageCard = async (id) => {
+			let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork);
+			await writeInstance(batch, {
+				id,
+				name: id,
+				adoptsFrom: {
+					module: rri("./person"),
+					name: "Person"
+				},
+				displayNames: ["Person"],
+				types,
+				iconHTML
+			});
+			return batch;
+		};
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], []);
+		let abandoned = await stageCard("abandoned");
+		let recent = await stageCard("recent");
+		let longAgo = Date.now() - 2880 * 60 * 1e3;
+		await adapter.execute(`UPDATE boxel_index_pending SET indexed_at = $1, diagnostics = NULL WHERE staging_id = $2`, { bind: [longAgo, abandoned.stagingId] });
+		await adapter.execute(`UPDATE prerendered_html_pending SET rendered_at = $1, diagnostics = NULL WHERE staging_id = $2`, { bind: [longAgo, abandoned.stagingId] });
+		let result = await (await stageCard("committed")).done();
+		let stagings = async (table) => (await adapter.execute(`SELECT DISTINCT staging_id FROM ${table} WHERE realm_url = $1`, { bind: [testRealmURL] })).map((row) => row.staging_id).sort();
+		assert.deepEqual(await stagings("boxel_index_pending"), [recent.stagingId], "the idle staging is cleared from the index channel; the recent one and the committed one are not left behind");
+		assert.deepEqual(await stagings("prerendered_html_pending"), [recent.stagingId], "and from the HTML channel");
+		assert.strictEqual(result.janitorStagingsCleared, 1, "the janitor counts the one staging it cleared");
+		assert.strictEqual(result.janitorRowsCleared, 2, "its index row and its HTML row");
+	});
+	(0, import_qunit.test)("forgetResumedRows drops a URL from resumedRows so future tombstoning is no longer guarded", async function(assert) {
+		let url = `${testRealmURL}1.json`;
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], {
+			working: [{
+				url,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				staging_id: jobStagingId(42, 1),
+				last_modified: "1700000000",
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 2,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		});
+		assert.true(batch.resumedRows.has(url), "precondition: row is initially resumed");
+		batch.forgetResumedRows([url]);
+		assert.false(batch.resumedRows.has(url), "after forgetResumedRows the URL is no longer protected");
+		batch.forgetResumedRows([`${testRealmURL}does-not-exist.json`]);
+		assert.strictEqual(batch.resumedRows.size, 0, "forgetResumedRows on a URL that is not present is a no-op");
+	});
+	(0, import_qunit.test)("done() promotes resumed rows even though they were never visited in this attempt", async function(assert) {
+		let url = `${testRealmURL}1.json`;
+		let resumedDoc = {
+			id: url,
+			type: "card",
+			attributes: { name: "Resumed" },
+			meta: { adoptsFrom: {
+				module: rri(`./person`),
+				name: "Person"
+			} }
+		};
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_generation: 1
+		}], {
+			working: [{
+				url,
+				generation: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				staging_id: jobStagingId(42, 1),
+				last_modified: "1700000000",
+				is_deleted: false,
+				has_error: false,
+				deps: [],
+				types: [],
+				pristine_doc: resumedDoc,
+				search_doc: { name: "Resumed" }
+			}],
+			production: []
+		});
+		await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 2,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		})).done();
+		let [promoted] = await adapter.execute(`SELECT pristine_doc, search_doc FROM boxel_index WHERE url = $1`, {
+			bind: [url],
+			coerceTypes: {
+				pristine_doc: "JSON",
+				search_doc: "JSON"
+			}
+		});
+		assert.deepEqual(promoted?.pristine_doc, resumedDoc, "resumed row was promoted to boxel_index by done()");
+		assert.deepEqual(promoted?.search_doc, { name: "Resumed" }, "resumed row search_doc landed in boxel_index");
+	});
+	(0, import_qunit.module)("getOrderingDependencyRows", function() {
+		const stagingJob = {
+			jobId: 7,
+			reservationId: 1,
+			priority: 0,
+			queueWaitMs: null,
+			concurrencyGroup: null,
+			laneFamily: null
+		};
+		(0, import_qunit.test)("returns production row when URL exists only in boxel_index", async function(assert) {
+			let url = `${testRealmURL}prod-only.json`;
+			let depUrl = `${testRealmURL}prod-only-dep.json`;
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], {
+				working: [],
+				production: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [depUrl],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, stagingJob)).getOrderingDependencyRows([url]);
+			assert.deepEqual(rows, [{
+				url,
+				type: "instance",
+				deps: [depUrl]
+			}], "returns the production row deps");
+		});
+		(0, import_qunit.test)("returns the staged row when URL exists only in boxel_index_pending and is not deleted", async function(assert) {
+			let url = `${testRealmURL}working-only.json`;
+			let depUrl = `${testRealmURL}working-only-dep.json`;
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], {
+				working: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					job_id: stagingJob.jobId,
+					staging_id: jobStagingId(stagingJob.jobId, stagingJob.reservationId),
+					is_deleted: false,
+					deps: [depUrl],
+					types: []
+				}],
+				production: []
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, stagingJob)).getOrderingDependencyRows([url]);
+			assert.deepEqual(rows, [{
+				url,
+				type: "instance",
+				deps: [depUrl]
+			}], "returns the working row deps");
+		});
+		(0, import_qunit.test)("working non-deleted wins over production when both exist", async function(assert) {
+			let url = `${testRealmURL}both.json`;
+			let workingDep = `${testRealmURL}working-dep.json`;
+			let productionDep = `${testRealmURL}production-dep.json`;
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], {
+				working: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					job_id: stagingJob.jobId,
+					staging_id: jobStagingId(stagingJob.jobId, stagingJob.reservationId),
+					is_deleted: false,
+					deps: [workingDep],
+					types: []
+				}],
+				production: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [productionDep],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, stagingJob)).getOrderingDependencyRows([url]);
+			assert.deepEqual(rows, [{
+				url,
+				type: "instance",
+				deps: [workingDep]
+			}], "working-non-deleted beat production");
+		});
+		(0, import_qunit.test)("production wins over deleted working row", async function(assert) {
+			let url = `${testRealmURL}deleted-working.json`;
+			let workingDep = `${testRealmURL}should-not-appear.json`;
+			let productionDep = `${testRealmURL}production-dep.json`;
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], {
+				working: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					job_id: stagingJob.jobId,
+					staging_id: jobStagingId(stagingJob.jobId, stagingJob.reservationId),
+					is_deleted: true,
+					deps: [workingDep],
+					types: []
+				}],
+				production: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [productionDep],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, stagingJob)).getOrderingDependencyRows([url]);
+			assert.deepEqual(rows, [{
+				url,
+				type: "instance",
+				deps: [productionDep]
+			}], "production picked when working row is deleted");
+		});
+		(0, import_qunit.test)("falls back to deleted working row when no production exists", async function(assert) {
+			let url = `${testRealmURL}deleted-only.json`;
+			let depUrl = `${testRealmURL}deleted-only-dep.json`;
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], {
+				working: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					job_id: stagingJob.jobId,
+					staging_id: jobStagingId(stagingJob.jobId, stagingJob.reservationId),
+					is_deleted: true,
+					deps: [depUrl],
+					types: []
+				}],
+				production: []
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, stagingJob)).getOrderingDependencyRows([url]);
+			assert.deepEqual(rows, [{
+				url,
+				type: "instance",
+				deps: [depUrl]
+			}], "returns deleted working row as last-resort fallback");
+		});
+		(0, import_qunit.test)("mixed input returns the correct provenance per URL", async function(assert) {
+			let workingOnlyUrl = `${testRealmURL}mixed-working.json`;
+			let workingOnlyDep = `${testRealmURL}mixed-working-dep.json`;
+			let productionOnlyUrl = `${testRealmURL}mixed-production.json`;
+			let productionOnlyDep = `${testRealmURL}mixed-production-dep.json`;
+			let bothUrl = `${testRealmURL}mixed-both.json`;
+			let bothWorkingDep = `${testRealmURL}mixed-both-working-dep.json`;
+			let bothProductionDep = `${testRealmURL}mixed-both-production-dep.json`;
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], {
+				working: [{
+					url: workingOnlyUrl,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					job_id: stagingJob.jobId,
+					staging_id: jobStagingId(stagingJob.jobId, stagingJob.reservationId),
+					is_deleted: false,
+					deps: [workingOnlyDep],
+					types: []
+				}, {
+					url: bothUrl,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					job_id: stagingJob.jobId,
+					staging_id: jobStagingId(stagingJob.jobId, stagingJob.reservationId),
+					is_deleted: false,
+					deps: [bothWorkingDep],
+					types: []
+				}],
+				production: [{
+					url: productionOnlyUrl,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [productionOnlyDep],
+					types: []
+				}, {
+					url: bothUrl,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [bothProductionDep],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, stagingJob)).getOrderingDependencyRows([
+				workingOnlyUrl,
+				productionOnlyUrl,
+				bothUrl
+			]);
+			let byUrl = new Map(rows.map((r) => [r.url, r]));
+			assert.deepEqual(byUrl.get(workingOnlyUrl), {
+				url: workingOnlyUrl,
+				type: "instance",
+				deps: [workingOnlyDep]
+			}, "working-only URL returns working deps");
+			assert.deepEqual(byUrl.get(productionOnlyUrl), {
+				url: productionOnlyUrl,
+				type: "instance",
+				deps: [productionOnlyDep]
+			}, "production-only URL returns production deps");
+			assert.deepEqual(byUrl.get(bothUrl), {
+				url: bothUrl,
+				type: "instance",
+				deps: [bothWorkingDep]
+			}, "URL present in both returns working deps (working wins)");
+			assert.strictEqual(rows.length, 3, "one row returned per requested URL");
+		});
+		(0, import_qunit.test)("projection excludes error_doc, has_error, and is_deleted", async function(assert) {
+			let url = `${testRealmURL}projection.json`;
+			await setupIndex(adapter, [{
+				realm_url: testRealmURL,
+				current_generation: 1
+			}], {
+				working: [{
+					url,
+					generation: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					job_id: stagingJob.jobId,
+					staging_id: jobStagingId(stagingJob.jobId, stagingJob.reservationId),
+					is_deleted: false,
+					has_error: true,
+					error_doc: {
+						id: url,
+						status: 500,
+						title: "kaboom",
+						message: "should not be returned",
+						additionalErrors: null
+					},
+					deps: [],
+					types: []
+				}],
+				production: []
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, stagingJob)).getOrderingDependencyRows([url]);
+			assert.strictEqual(rows.length, 1, "one row returned");
+			let row = rows[0];
+			assert.deepEqual(Object.keys(row).sort(), [
+				"deps",
+				"type",
+				"url"
+			], "row exposes only url, type, deps — no error_doc / has_error / is_deleted");
+		});
+	});
+});
+(0, import_qunit.module)("Unit | index-writer | error doc merge", function() {
+	function err(message, extra = {}) {
+		return {
+			message,
+			status: 500,
+			additionalErrors: null,
+			...extra
+		};
+	}
+	(0, import_qunit.test)("a higher-generation error doc supersedes a lower-generation one", function(assert) {
+		let recent = err("recent", {
+			id: "x",
+			additionalErrors: [err("recent-dep")]
+		});
+		let stale = err("stale", {
+			id: "x",
+			additionalErrors: [err("stale-dep")]
+		});
+		assert.strictEqual(mergeErrorsByGeneration(recent, 5, stale, 4).message, "recent", "the newer generation wins when it is the first argument");
+		assert.strictEqual(mergeErrorsByGeneration(stale, 4, recent, 5).message, "recent", "the newer generation wins when it is the second argument");
+		assert.deepEqual(mergeErrorsByGeneration(recent, 5, stale, 4).additionalErrors, [err("recent-dep")], "the stale document contributes nothing — it is not merged in");
+	});
+	(0, import_qunit.test)("equal-generation error docs merge their detail, keeping the primary message", function(assert) {
+		let merged = mergeErrorsByGeneration(err("primary message", {
+			id: "card",
+			deps: ["dep-a"],
+			additionalErrors: [err("existing-dep", { id: "existing" })]
+		}), 3, err("secondary message", {
+			id: "module",
+			deps: ["dep-b"],
+			additionalErrors: [err("missing middle-field", { id: "middle" })]
+		}), 3);
+		assert.strictEqual(merged.message, "primary message", "the primary envelope message is preserved");
+		let messages = (merged.additionalErrors ?? []).map((e) => e.message);
+		assert.ok(messages.includes("existing-dep"), "the primary's own additionalErrors are kept");
+		assert.ok(messages.includes("missing middle-field"), "the secondary's nested dependency detail is folded in flat");
+		assert.ok(messages.includes("secondary message"), "the secondary's own top-level error is folded in as a flat entry");
+		assert.deepEqual(merged.deps, ["dep-a", "dep-b"], "deps are unioned");
+	});
+	(0, import_qunit.test)("merging an error doc identical to the primary adds nothing", function(assert) {
+		let primary = err("same failure", {
+			id: "x",
+			status: 500
+		});
+		let secondary = err("same failure", {
+			id: "x",
+			status: 500
+		});
+		assert.strictEqual(mergeErrorDetail(primary, secondary).additionalErrors, null, "a secondary that matches the primary (id, message, status) is deduped away");
+	});
+	(0, import_qunit.test)("the secondary's nested detail is folded flat, not nested", function(assert) {
+		let merged = mergeErrorDetail(err("primary", { id: "p" }), err("secondary", {
+			id: "s",
+			additionalErrors: [err("leaf detail", { id: "leaf" })]
+		}));
+		assert.deepEqual((merged.additionalErrors ?? []).map((e) => e.message), ["secondary", "leaf detail"], "both the secondary envelope and its nested detail sit at the top level");
+		let secondaryEntry = (merged.additionalErrors ?? []).find((e) => e.id === "s");
+		assert.strictEqual(secondaryEntry.additionalErrors, null, "the folded secondary entry does not carry its own nested list");
+	});
+});
+//#endregion