@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

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

@@ -0,0 +1,1842 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Rr as CachingDefinitionLookup, X as IndexQueryEngine, Y as IndexWriter, Yn as testRRI, Z as coerceTypes, Zn as testRealmURL, la as ri, mi as baseCardRef, o as internalKeyFor, ua as rri, v as VirtualNetwork } from "./runtime-common-C7uLt5dN.js";
+import { T as getContext } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as setupTest } from "./dist-BsEojs3T.js";
+import { $ as setupIndex, S as makeRenderer, m as createPrerenderAuth, v as getDbAdapter } from "./mock-matrix-BhFWlMMr.js";
+import "./code-equality-assertion-BBezFT13.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 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)("can perform invalidations for a instance entry", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_version: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_version: 5
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}2.json`]
+			},
+			{
+				url: `${testRealmURL}2.json`,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}4.json`]
+			},
+			{
+				url: `${testRealmURL}3.json`,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}2.json`]
+			},
+			{
+				url: `${testRealmURL}4.json`,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				deps: []
+			},
+			{
+				url: `${testRealmURL}5.json`,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				deps: []
+			},
+			{
+				url: `${testRealmURL2}A.json`,
+				realm_version: 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_working WHERE realm_version = 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, realm_version, is_deleted FROM boxel_index_working WHERE realm_url != '${testRealmURL}'`, { coerceTypes: { is_deleted: "BOOLEAN" } });
+		assert.deepEqual(otherRealms, [{
+			url: `${testRealmURL2}A.json`,
+			realm_url: testRealmURL2,
+			realm_version: 5,
+			is_deleted: null
+		}], "the index entries from other realms are unchanged");
+		let realmVersions = await adapter.execute("select * from realm_versions ORDER BY realm_url COLLATE \"POSIX\"");
+		assert.deepEqual(realmVersions, [{
+			realm_url: `${testRealmURL}`,
+			current_version: 1
+		}, {
+			realm_url: `${testRealmURL2}`,
+			current_version: 5
+		}], "the \"production\" realm versions are correct");
+	});
+	(0, import_qunit.test)("can perform invalidations for a module change via instance deps", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_version: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_version: 5
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				file_alias: `${testRealmURL}1.json`,
+				type: "instance",
+				realm_version: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}employee`, `${testRealmURL}person`]
+			},
+			{
+				url: `${testRealmURL}2.json`,
+				file_alias: `${testRealmURL}2.json`,
+				type: "instance",
+				realm_version: 1,
+				realm_url: testRealmURL,
+				deps: [`${testRealmURL}1.json`]
+			},
+			{
+				url: `${testRealmURL}3.json`,
+				file_alias: `${testRealmURL}3.json`,
+				type: "instance",
+				realm_version: 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 don't cross realm boundaries", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_version: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_version: 5
+		}], [{
+			url: `${testRealmURL2}luke.json`,
+			file_alias: `${testRealmURL2}luke.json`,
+			type: "instance",
+			realm_version: 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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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 realm_version, 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, {
+			realm_version: 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 realm_version, pristine_doc, search_doc, deps, types FROM boxel_index_working WHERE url = $1`, {
+			bind: [`${testRealmURL}1.json`],
+			coerceTypes: {
+				pristine_doc: "JSON",
+				search_doc: "JSON",
+				deps: "JSON",
+				types: "JSON"
+			}
+		});
+		assert.deepEqual(wipVersion, {
+			realm_version: 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 realm_version, 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, {
+			realm_version: 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)("can copy index entries", async function(assert) {
+		let types = [{
+			module: rri(`./person`),
+			name: "Person"
+		}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL), virtualNetwork));
+		let destTypes = [{
+			module: rri(`./person`),
+			name: "Person"
+		}, baseCardRef].map((i) => internalKeyFor(i, new URL(testRealmURL2), 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_version: 1
+		}, {
+			realm_url: testRealmURL2,
+			current_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 1,
+			realm_url: testRealmURL,
+			type: "instance",
+			pristine_doc: resource,
+			search_doc: {
+				id: `${testRealmURL}1`,
+				name: "Mango",
+				friends: [{
+					id: `${testRealmURL}2`,
+					name: "Van Gogh"
+				}, {
+					id: `http://a-different-realm.com/hassan`,
+					name: "Hassan"
+				}]
+			},
+			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.split("/").pop()}</div>`])),
+			fitted_html: Object.fromEntries(types.map((type) => [type, `<div class="fitted">Fitted HTML for ${type.split("/").pop()}</div>`])),
+			isolated_html: `<div class="isolated">Isolated HTML</div>`,
+			atom_html: `<span class="atom">Atom HTML</span>`,
+			head_html: `<span class="head">Head HTML</span>`,
+			icon_html: "<svg>test icon</svg>"
+		}]);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL2), virtualNetwork);
+		await batch.copyFrom(new URL(testRealmURL));
+		await batch.done();
+		let results = await adapter.execute("SELECT * FROM boxel_index WHERE realm_url = $1 ORDER BY url COLLATE \"POSIX\"", {
+			coerceTypes,
+			bind: [testRealmURL2]
+		});
+		assert.strictEqual(results.length, 1, "correct number of items were copied");
+		let [copiedInstance] = results;
+		assert.ok(copiedInstance.indexed_at, "indexed_at was set");
+		delete copiedInstance.indexed_at;
+		assert.deepEqual(copiedInstance, {
+			url: `${testRealmURL2}1.json`,
+			file_alias: `${testRealmURL2}1`,
+			realm_version: 2,
+			realm_url: testRealmURL2,
+			type: "instance",
+			has_error: false,
+			pristine_doc: {
+				...resource,
+				id: rri(`${testRealmURL2}1`),
+				meta: {
+					...resource.meta,
+					realmURL: testRealmURL2
+				}
+			},
+			error_doc: null,
+			search_doc: {
+				id: `${testRealmURL2}1`,
+				name: "Mango",
+				friends: [{
+					id: `${testRealmURL2}2`,
+					name: "Van Gogh"
+				}, {
+					id: `http://a-different-realm.com/hassan`,
+					name: "Hassan"
+				}]
+			},
+			display_names: [`Person`],
+			deps: [`${testRealmURL2}person`],
+			last_known_good_deps: [`${testRealmURL2}person`],
+			types: destTypes,
+			last_modified: String(modified),
+			resource_created_at: String(modified),
+			embedded_html: Object.fromEntries(destTypes.map((type) => [type, `<div class="embedded">Embedded HTML for ${type.split("/").pop()}</div>`])),
+			fitted_html: Object.fromEntries(destTypes.map((type) => [type, `<div class="fitted">Fitted HTML for ${type.split("/").pop()}</div>`])),
+			isolated_html: `<div class="isolated">Isolated HTML</div>`,
+			atom_html: `<span class="atom">Atom HTML</span>`,
+			head_html: `<span class="head">Head HTML</span>`,
+			icon_html: "<svg>test icon</svg>",
+			markdown: null,
+			is_deleted: null,
+			diagnostics: null
+		}, "the copied instance is correct");
+	});
+	(0, import_qunit.test)("throws when copy source realm is not present on the realm server", async function(assert) {
+		assert.expect(1);
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL2,
+			current_version: 1
+		}], []);
+		let batch = await indexWriter.createBatch(new URL(testRealmURL2), virtualNetwork);
+		try {
+			await batch.copyFrom(new URL(testRealmURL));
+			throw new Error("Expected error to be thrown");
+		} catch (e) {
+			assert.strictEqual(e.message, `nothing to copy from ${testRealmURL} - this realm is not present on the realm server`, "the correct exception was thrown");
+		}
+	});
+	(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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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 realm_version = 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`,
+			realm_version: 2,
+			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,
+			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,
+			last_modified: String(modified),
+			resource_created_at: String(modified),
+			is_deleted: null,
+			icon_html: "<svg>test icon</svg>",
+			markdown: null
+		}, "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)("strips jsonb-illegal code points from error_doc and diagnostics on write", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_version: 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 realm_version = 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)("error entry does not include last known good state when not available", async function(assert) {
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_version: 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 realm_version = 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`,
+			realm_version: 2,
+			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,
+			embedded_html: null,
+			fitted_html: null,
+			isolated_html: null,
+			atom_html: null,
+			head_html: null,
+			last_modified: null,
+			resource_created_at: null,
+			is_deleted: false,
+			icon_html: null,
+			markdown: 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_version: 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 realm_version = 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_version: 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_version: 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`,
+			realm_version: 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`,
+				realmVersion: 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
+			});
+		} 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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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",
+			realmVersion: 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
+		});
+		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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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: []
+		});
+		let entry = await indexQueryEngine.getInstance(new URL(`${testRealmURL}1`), { useWorkInProgressIndex: true });
+		if (entry?.type === "instance") {
+			assert.ok(entry?.indexedAt, "the indexed_at field was set");
+			delete entry?.indexedAt;
+			assert.deepEqual(entry, {
+				type: "instance",
+				realmVersion: 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
+			});
+		} 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_version: 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`), { useWorkInProgressIndex: true });
+		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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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`,
+			realm_version: 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_version: 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_working WHERE realm_version = 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 realmVersions = await adapter.execute("select * from realm_versions ORDER BY realm_url COLLATE \"POSIX\"");
+		assert.deepEqual(realmVersions, [{
+			realm_url: `${testRealmURL}`,
+			current_version: 1
+		}], "the \"production\" realm versions 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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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)("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_version: 1
+		}], [
+			{
+				url: `${testRealmURL}1.json`,
+				realm_version: 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`,
+				realm_version: 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`,
+				realm_version: 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`,
+				realm_version: 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_version: 1
+		}], [{
+			url: `${testRealmURL}notes/new.md`,
+			realm_version: 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`,
+			realm_version: 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_versions.current_version", 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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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, realm_version, 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_versions.current_version 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_version: 0
+		}], []);
+		for (let version of [
+			50,
+			100,
+			200,
+			999
+		]) await adapter.execute(`INSERT INTO realm_meta (realm_url, realm_version, 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 realm_version FROM realm_meta WHERE realm_url = $1 ORDER BY realm_version`, { bind: [testRealmURL] });
+		assert.deepEqual(rowsBefore.map((r) => r.realm_version), [
+			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 realm_version FROM realm_meta WHERE realm_url = $1 ORDER BY realm_version`, { bind: [testRealmURL] });
+		assert.deepEqual(rowsAfter.map((r) => r.realm_version), [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_version: 1
+		}], [{
+			url: `${testRealmURL}1.json`,
+			realm_version: 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_version: 1
+		}], {
+			working: [{
+				url,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				last_modified: String(lastModified),
+				is_deleted: false,
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 1,
+			priority: 0
+		});
+		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_version: 1
+		}], {
+			working: [{
+				url,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				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: 1,
+			priority: 0
+		});
+		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_version: 1
+		}], {
+			working: [{
+				url: `${testRealmURL}from-other-job.json`,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 99,
+				last_modified: "1700000000",
+				is_deleted: false,
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 1,
+			priority: 0
+		});
+		assert.strictEqual(batch.resumedRows.size, 0, "rows tagged with a different job_id are not resumed");
+	});
+	(0, import_qunit.test)("working rows from another job are visible to dependency-walk queries but not to resumedRows", async function(assert) {
+		let otherUrl = `${testRealmURL}other-job-row.json`;
+		await setupIndex(adapter, [{
+			realm_url: testRealmURL,
+			current_version: 1
+		}], {
+			working: [{
+				url: otherUrl,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 99,
+				last_modified: "1700000000",
+				is_deleted: false,
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 1,
+			priority: 0
+		});
+		assert.strictEqual(batch.resumedRows.size, 0, "rows tagged with a different job_id are NOT in resumedRows");
+		let surviving = await adapter.execute("SELECT url FROM boxel_index_working WHERE realm_url = $1", { bind: [testRealmURL] });
+		assert.deepEqual(surviving.map((r) => r.url), [otherUrl], "cumulative working state is preserved (it is the source for reverse-deps walks)");
+	});
+	(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_version: 1
+		}], {
+			working: [{
+				url,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				last_modified: "1700000000",
+				deps: [],
+				types: []
+			}],
+			production: []
+		});
+		let batch = await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork, {
+			jobId: 42,
+			reservationId: 1,
+			priority: 0
+		});
+		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_version: 1
+		}], {
+			working: [{
+				url,
+				realm_version: 1,
+				realm_url: testRealmURL,
+				type: "instance",
+				job_id: 42,
+				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: 1,
+			priority: 0
+		})).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() {
+		(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_version: 1
+			}], {
+				working: [],
+				production: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [depUrl],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).getOrderingDependencyRows([url]);
+			assert.deepEqual(rows, [{
+				url,
+				type: "instance",
+				deps: [depUrl]
+			}], "returns the production row deps");
+		});
+		(0, import_qunit.test)("returns working row when URL exists only in boxel_index_working 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_version: 1
+			}], {
+				working: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					is_deleted: false,
+					deps: [depUrl],
+					types: []
+				}],
+				production: []
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).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_version: 1
+			}], {
+				working: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					is_deleted: false,
+					deps: [workingDep],
+					types: []
+				}],
+				production: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [productionDep],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).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_version: 1
+			}], {
+				working: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					is_deleted: true,
+					deps: [workingDep],
+					types: []
+				}],
+				production: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [productionDep],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).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_version: 1
+			}], {
+				working: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					is_deleted: true,
+					deps: [depUrl],
+					types: []
+				}],
+				production: []
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).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_version: 1
+			}], {
+				working: [{
+					url: workingOnlyUrl,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					is_deleted: false,
+					deps: [workingOnlyDep],
+					types: []
+				}, {
+					url: bothUrl,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					is_deleted: false,
+					deps: [bothWorkingDep],
+					types: []
+				}],
+				production: [{
+					url: productionOnlyUrl,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [productionOnlyDep],
+					types: []
+				}, {
+					url: bothUrl,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					deps: [bothProductionDep],
+					types: []
+				}]
+			});
+			let rows = await (await indexWriter.createBatch(new URL(testRealmURL), virtualNetwork)).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_version: 1
+			}], {
+				working: [{
+					url,
+					realm_version: 1,
+					realm_url: testRealmURL,
+					type: "instance",
+					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)).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");
+		});
+	});
+});
+//#endregion