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

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

@@ -1,3040 +0,0 @@
-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-Dd8k0DNa.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