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

package/bundled-test-harness/assets/realm-indexing-test-BQkX-Dat.js

@@ -0,0 +1,4018 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { It as SupportedMimeType, Mi as skillCardRef, Yn as testRRI, Zn as testRealmURL, la as ri, mi as baseCardRef, o as internalKeyFor, on as init_md5_esm_bundler, sn as md5, ua as rri, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { $n as setComponentTemplate } from "./service-DJ87xpDt.js";
+import { V as templateFactory } from "./index-DaCZcoCY-D2gI_aMw.js";
+import { a as REALM_INDEX_BOILERPLATE_HTML } from "./card-prerender-ClYlSOBU.js";
+import { o as Component } from "./dist-CXaz7pMY.js";
+import "./template-D3TMIrc1.js";
+import "./template-factory-DMEv2kVd.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, L as testModuleRRI, O as setupCardLogs, R as testModuleRealm, d as cardInfo, f as cleanWhiteSpace, j as setupLocalIndexing, rt as setupRenderingTest, t as setupMockMatrix, y as getFileCreatedAt } from "./mock-matrix-BhFWlMMr.js";
+import { G as contains, I as StringField, K as containsMany, O as NumberField, Q as field, a as CardDef, b as FieldDef, d as Component$1, lt as linksTo, m as DateTimeField, mt as setupBaseRealm } from "./base-realm-DpSTsZxD.js";
+//#region ../runtime-common/helpers/strip-scoped-css-attributes.ts
+init_md5_esm_bundler();
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+function stripScopedCSSAttributes(htmlString) {
+	return htmlString.replace(/ data-scopedcss-[0-9a-f]{10}-[0-9a-f]{10}/g, "");
+}
+//#endregion
+//#region tests/integration/realm-indexing-test.gts
+var loader;
+function unwrap(html) {
+	return html.trim().replace(/^<div ([^>]*>)/, "").trim().replace(/^<!---->/, "").replace(/<\/div>$/, "").trim();
+}
+function assertInnerHtmlMatches(assert, actual, expected, message) {
+	let cleanedActual = cleanWhiteSpace(stripScopedCSSAttributes(unwrap(actual)));
+	let cleanedExpected = cleanWhiteSpace(expected);
+	assert.strictEqual(cleanedActual, cleanedExpected, message);
+}
+(0, import_qunit.module)(`Integration | realm indexing`, function(hooks) {
+	setupRenderingTest(hooks);
+	setupBaseRealm(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks);
+	setupCardLogs(hooks, async () => await loader.import(`${baseRealm.url}card-api`));
+	async function getInstance(realm, url) {
+		let maybeInstance = await realm.realmIndexQueryEngine.instance(url);
+		if (maybeInstance?.type === "instance-error") return;
+		return maybeInstance;
+	}
+	(0, import_qunit.test)("full indexing discovers card instances", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "empty.json": { data: { meta: { adoptsFrom: {
+				module: "https://cardstack.com/base/card-api",
+				name: "CardDef"
+			} } } } }
+		});
+		let { data: cards } = await realm.realmIndexQueryEngine.searchCards({});
+		assert.deepEqual(cards, [{
+			id: testRRI("empty"),
+			type: "card",
+			attributes: {
+				cardInfo,
+				cardTitle: "Untitled Card",
+				cardDescription: null,
+				cardThumbnailURL: null
+			},
+			relationships: { "cardInfo.theme": { links: { self: null } } },
+			meta: {
+				adoptsFrom: {
+					module: rri("https://cardstack.com/base/card-api"),
+					name: "CardDef"
+				},
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					backgroundURL: null,
+					iconURL: null,
+					includePrerenderedDefaultRealmIndex: null,
+					lastPublishedAt: null,
+					name: "Unnamed Workspace",
+					publishable: null,
+					realmUserId: "@realm_server:localhost",
+					showAsCatalog: null,
+					visibility: "public"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}empty.json`),
+				resourceCreatedAt: await getFileCreatedAt(realm, "empty.json")
+			},
+			links: { self: `${testRealmURL}empty` }
+		}]);
+	});
+	(0, import_qunit.test)("indexing captures file meta content hash", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "notes.txt": "Hello from the test realm." }
+		});
+		await realm.fullIndex();
+		let { virtualNetwork } = getService("network");
+		let response = await virtualNetwork.fetch(new URL("notes.txt", testRealmURL), { headers: { Accept: SupportedMimeType.FileMeta } });
+		assert.true(response.ok, "file meta request succeeds");
+		let body = await response.json();
+		assert.strictEqual(body?.data?.type, "file-meta");
+		let contentHash = body?.data?.attributes?.contentHash;
+		let expectedHash = md5(new TextEncoder().encode("Hello from the test realm."));
+		assert.strictEqual(contentHash, expectedHash, "content hash is returned");
+	});
+	(0, import_qunit.test)("full indexing stores file entries with search doc and deps", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "notes.txt": "Hello from the test realm." }
+		});
+		await realm.fullIndex();
+		let fileURL = new URL("notes.txt", testRealmURL);
+		let fileEntry = await realm.realmIndexQueryEngine.file(fileURL);
+		assert.ok(fileEntry, "file entry exists");
+		assert.strictEqual(fileEntry?.type, "file");
+		assert.strictEqual(fileEntry?.searchDoc?.name, "notes.txt", "search doc includes name");
+		assert.strictEqual(fileEntry?.searchDoc?.contentType, "text/plain", "search doc includes contentType");
+		assert.strictEqual(fileEntry?.searchDoc?.contentHash, md5(new TextEncoder().encode("Hello from the test realm.")), "search doc includes contentHash");
+		assert.ok(fileEntry?.deps?.includes(`${baseRealm.url}file-api`), "deps include base file-api module");
+		let includesSelfFileDependency = fileEntry?.deps?.includes(fileURL.href);
+		assert.false(includesSelfFileDependency, "deps exclude self file URL");
+	});
+	(0, import_qunit.test)("full indexing skips over unchanged items in index", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"test1.json": { data: { meta: { adoptsFrom: {
+					module: "https://cardstack.com/base/card-api",
+					name: "CardDef"
+				} } } },
+				"test2.json": { data: { meta: { adoptsFrom: {
+					module: "https://cardstack.com/base/card-api",
+					name: "CardDef"
+				} } } },
+				"pet.gts": `
+          import { contains, field, CardDef } from "https://cardstack.com/base/card-api";
+          import StringField from "https://cardstack.com/base/string";
+
+          export class Pet extends CardDef {
+            @field firstName = contains(StringField);
+          }
+        `
+			}
+		});
+		assert.deepEqual(realm.realmIndexUpdater.stats, {
+			filesIndexed: 3,
+			fileErrors: 0,
+			instanceErrors: 0,
+			instancesIndexed: 2,
+			totalIndexEntries: 5
+		}, "indexer stats are correct");
+		await new Promise((r) => setTimeout(r, 1e3));
+		await adapter.write("test2.json", JSON.stringify({ data: {
+			attributes: { cardTitle: "test" },
+			meta: { adoptsFrom: {
+				module: rri("https://cardstack.com/base/card-api"),
+				name: "CardDef"
+			} }
+		} }));
+		await realm.fullIndex();
+		assert.deepEqual(realm.realmIndexUpdater.stats, {
+			filesIndexed: 1,
+			fileErrors: 0,
+			instanceErrors: 0,
+			instancesIndexed: 1,
+			totalIndexEntries: 5
+		}, "indexer stats are correct");
+	});
+	(0, import_qunit.test)("a card with a broken linksTo target indexes cleanly, and invalidation fan-out re-indexes it when the target is later created", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "Pet/mango.json": { data: {
+				id: `${testRealmURL}Pet/mango`,
+				attributes: { firstName: "Mango" },
+				relationships: { owner: { links: { self: `../Person/owner` } } },
+				meta: { adoptsFrom: {
+					module: "https://localhost:4202/test/pet",
+					name: "Pet"
+				} }
+			} } }
+		});
+		let queryEngine = realm.realmIndexQueryEngine;
+		{
+			let mango = await queryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+			if (mango?.type === "doc") {
+				let owner = mango.doc.data.relationships?.owner;
+				assert.strictEqual((Array.isArray(owner) ? owner[0] : owner)?.links?.self, `../Person/owner`, "broken owner reference is preserved on the wire so the consumer can render the placeholder");
+			} else assert.ok(false, `mango with a missing linksTo target indexes as a clean instance, got: ${mango?.error?.errorDetail.message}`);
+			let mangoInstance = await queryEngine.instance(new URL(`${testRealmURL}Pet/mango`));
+			assert.ok((mangoInstance?.deps ?? []).some((dep) => dep === `http://test-realm/test/Person/owner.json` || dep === `http://test-realm/test/Person/owner`), "deps include the unresolved owner link so invalidation can reach mango when the target is created");
+		}
+		await realm.write("Person/owner.json", JSON.stringify({ data: {
+			id: testRRI("Person/owner"),
+			attributes: { firstName: "Hassan" },
+			meta: { adoptsFrom: {
+				module: rri("https://localhost:4202/test/person"),
+				name: "Person"
+			} }
+		} }));
+		{
+			let mango = await queryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+			if (mango?.type === "doc") assert.deepEqual(mango.doc.data, {
+				id: testRRI("Pet/mango"),
+				type: "card",
+				links: { self: "./mango" },
+				attributes: {
+					cardDescription: null,
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					owner: { links: { self: `../Person/owner` } },
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://localhost:4202/test/pet"),
+						name: "Pet"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Pet/mango.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "Pet/mango.json"),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			else assert.ok(false, `search entry was an error: ${mango?.error.errorDetail.message}`);
+		}
+	});
+	(0, import_qunit.test)("can query the \"production\" index while performing indexing operations", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "Pet/mango.json": { data: {
+				id: `${testRealmURL}Pet/mango`,
+				attributes: { firstName: "Mango" },
+				meta: { adoptsFrom: {
+					module: "https://localhost:4202/test/pet",
+					name: "Pet"
+				} }
+			} } }
+		});
+		let queryEngine = realm.realmIndexQueryEngine;
+		let updateCard = realm.write("Pet/mango.json", JSON.stringify({ data: {
+			id: testRRI("Pet/mango"),
+			attributes: { firstName: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri("https://localhost:4202/test/pet"),
+				name: "Pet"
+			} }
+		} }));
+		let getCard = queryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+		let [_, entry] = await Promise.all([updateCard, getCard]);
+		if (entry?.type === "doc") {
+			delete entry.doc.data.meta.lastModified;
+			delete entry.doc.data.meta.resourceCreatedAt;
+			assert.deepEqual(entry.doc.data, {
+				id: testRRI("Pet/mango"),
+				type: "card",
+				links: { self: "./mango" },
+				attributes: {
+					cardDescription: null,
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					owner: { links: { self: null } },
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://localhost:4202/test/pet"),
+						name: "Pet"
+					},
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+		} else assert.ok(false, `search entry was an error: ${entry?.error.errorDetail.message}`);
+		{
+			let entry = await queryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+			if (entry?.type === "doc") {
+				delete entry.doc.data.meta.lastModified;
+				delete entry.doc.data.meta.resourceCreatedAt;
+				assert.deepEqual(entry.doc.data, {
+					id: testRRI("Pet/mango"),
+					type: "card",
+					links: { self: "./mango" },
+					attributes: {
+						cardDescription: null,
+						firstName: "Van Gogh",
+						cardTitle: "Van Gogh",
+						cardThumbnailURL: null,
+						cardInfo
+					},
+					relationships: {
+						owner: { links: { self: null } },
+						"cardInfo.theme": { links: { self: null } }
+					},
+					meta: {
+						adoptsFrom: {
+							module: rri("https://localhost:4202/test/pet"),
+							name: "Pet"
+						},
+						realmURL: ri("http://test-realm/test/"),
+						realmInfo: {
+							backgroundURL: null,
+							iconURL: null,
+							includePrerenderedDefaultRealmIndex: null,
+							lastPublishedAt: null,
+							name: "Unnamed Workspace",
+							publishable: null,
+							realmUserId: "@realm_server:localhost",
+							showAsCatalog: null,
+							visibility: "public"
+						}
+					}
+				});
+			} else assert.ok(false, `search entry was an error: ${entry?.error.errorDetail.message}`);
+		}
+	});
+	(0, import_qunit.test)("write with waitForIndex:false returns before indexing settles and incrementalIndexing() drains it", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "Pet/mango.json": { data: {
+				id: `${testRealmURL}Pet/mango`,
+				attributes: { firstName: "Mango" },
+				meta: { adoptsFrom: {
+					module: "https://localhost:4202/test/pet",
+					name: "Pet"
+				} }
+			} } }
+		});
+		let queryEngine = realm.realmIndexQueryEngine;
+		await realm.write("Pet/mango.json", JSON.stringify({ data: {
+			id: testRRI("Pet/mango"),
+			attributes: { firstName: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri("https://localhost:4202/test/pet"),
+				name: "Pet"
+			} }
+		} }), { waitForIndex: false });
+		let pendingIndex = realm.incrementalIndexing();
+		assert.notStrictEqual(pendingIndex, void 0, "indexing is still pending immediately after waitForIndex:false write");
+		await pendingIndex;
+		assert.strictEqual(realm.incrementalIndexing(), void 0, "incrementalIndexing() resolves to undefined once the deferred indexing settles");
+		let entry = await queryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+		if (entry?.type === "doc") assert.strictEqual(entry.doc.data.attributes?.firstName, "Van Gogh", "index reflects the deferred-indexed write after the drain");
+		else assert.ok(false, `search entry was an error: ${entry?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("HTTP DELETE +source returns before incremental indexing settles", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "Pet/mango.json": { data: {
+				id: `${testRealmURL}Pet/mango`,
+				attributes: { firstName: "Mango" },
+				meta: { adoptsFrom: {
+					module: "http://localhost:4202/test/pet",
+					name: "Pet"
+				} }
+			} } }
+		});
+		let queryEngine = realm.realmIndexQueryEngine;
+		await realm.incrementalIndexing();
+		assert.strictEqual(realm.incrementalIndexing(), void 0, "baseline: no pending indexing before DELETE");
+		let response = await realm.handle(new Request(`${testRealmURL}Pet/mango`, {
+			method: "DELETE",
+			headers: { Accept: "application/vnd.card+source" }
+		}));
+		if (!response) throw new Error("realm did not handle the DELETE");
+		assert.strictEqual(response.status, 204, "DELETE returns 204");
+		assert.strictEqual(await adapter.openFile("Pet/mango.json"), void 0, "file is gone from disk before indexing settles");
+		let pendingIndex = realm.incrementalIndexing();
+		assert.notStrictEqual(pendingIndex, void 0, "DELETE returned before deferred indexing settled");
+		await pendingIndex;
+		assert.strictEqual(realm.incrementalIndexing(), void 0, "incrementalIndexing() drains the deferred delete work");
+		let entry = await queryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+		assert.strictEqual(entry, void 0, "index reflects the deletion after the drain");
+	});
+	(0, import_qunit.test)("realm.delete() with default options (waitForIndex:true) awaits indexing inline", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "Pet/mango.json": { data: {
+				id: `${testRealmURL}Pet/mango`,
+				attributes: { firstName: "Mango" },
+				meta: { adoptsFrom: {
+					module: "http://localhost:4202/test/pet",
+					name: "Pet"
+				} }
+			} } }
+		});
+		await realm.incrementalIndexing();
+		await realm.delete("Pet/mango.json");
+		assert.strictEqual(realm.incrementalIndexing(), void 0, "no pending indexing remains after a default delete — the await happened inline");
+	});
+	(0, import_qunit.test)("write with default options (waitForIndex:true) awaits indexing inline", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "Pet/mango.json": { data: {
+				id: `${testRealmURL}Pet/mango`,
+				attributes: { firstName: "Mango" },
+				meta: { adoptsFrom: {
+					module: "https://localhost:4202/test/pet",
+					name: "Pet"
+				} }
+			} } }
+		});
+		await realm.write("Pet/mango.json", JSON.stringify({ data: {
+			id: testRRI("Pet/mango"),
+			attributes: { firstName: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri("https://localhost:4202/test/pet"),
+				name: "Pet"
+			} }
+		} }));
+		assert.strictEqual(realm.incrementalIndexing(), void 0, "no pending indexing remains after a default write — the await happened inline");
+	});
+	(0, import_qunit.test)("can index card with linkTo field", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Person/owner.json": { data: {
+					id: `${testRealmURL}Person/owner`,
+					attributes: { firstName: "Hassan" },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/person",
+						name: "Person"
+					} }
+				} },
+				"Pet/mango.json": { data: {
+					id: `${testRealmURL}Pet/mango`,
+					attributes: { firstName: "Mango" },
+					relationships: { owner: { links: { self: `../Person/owner` } } },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/pet",
+						name: "Pet"
+					} }
+				} }
+			}
+		});
+		let mango = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+		if (mango?.type === "doc") assert.deepEqual(mango.doc.data, {
+			id: testRRI("Pet/mango"),
+			type: "card",
+			links: { self: "./mango" },
+			attributes: {
+				cardDescription: null,
+				firstName: "Mango",
+				cardTitle: "Mango",
+				cardThumbnailURL: null,
+				cardInfo
+			},
+			relationships: {
+				owner: { links: { self: `../Person/owner` } },
+				"cardInfo.theme": { links: { self: null } }
+			},
+			meta: {
+				adoptsFrom: {
+					module: rri("https://localhost:4202/test/pet"),
+					name: "Pet"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Pet/mango.json`),
+				resourceCreatedAt: await getFileCreatedAt(realm, "Pet/mango.json"),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					backgroundURL: null,
+					iconURL: null,
+					includePrerenderedDefaultRealmIndex: null,
+					lastPublishedAt: null,
+					name: "Unnamed Workspace",
+					publishable: null,
+					realmUserId: "@realm_server:localhost",
+					showAsCatalog: null,
+					visibility: "public"
+				}
+			}
+		});
+		else assert.ok(false, `search entry was an error: ${mango?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("can index card with a relative linkTo field", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Person/owner.json": { data: {
+					id: `${testRealmURL}Person/owner`,
+					attributes: { firstName: "Hassan" },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/person",
+						name: "Person"
+					} }
+				} },
+				"Pet/mango.json": { data: {
+					id: `${testRealmURL}Pet/mango`,
+					attributes: { firstName: "Mango" },
+					relationships: { owner: { links: { self: `../Person/owner` } } },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/pet",
+						name: "Pet"
+					} }
+				} }
+			}
+		});
+		let mango = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}Pet/mango`));
+		if (mango?.type === "doc") assert.deepEqual(mango.doc.data, {
+			id: testRRI("Pet/mango"),
+			type: "card",
+			links: { self: "./mango" },
+			attributes: {
+				cardDescription: null,
+				firstName: "Mango",
+				cardTitle: "Mango",
+				cardThumbnailURL: null,
+				cardInfo
+			},
+			relationships: {
+				owner: { links: { self: `../Person/owner` } },
+				"cardInfo.theme": { links: { self: null } }
+			},
+			meta: {
+				adoptsFrom: {
+					module: rri("https://localhost:4202/test/pet"),
+					name: "Pet"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Pet/mango.json`),
+				resourceCreatedAt: await getFileCreatedAt(realm, "Pet/mango.json"),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					backgroundURL: null,
+					iconURL: null,
+					includePrerenderedDefaultRealmIndex: null,
+					lastPublishedAt: null,
+					name: "Unnamed Workspace",
+					publishable: null,
+					realmUserId: "@realm_server:localhost",
+					showAsCatalog: null,
+					visibility: "public"
+				}
+			}
+		});
+		else assert.ok(false, `search entry was an error: ${mango?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("relative code-ref fields are serialized as absolute URLs", async function(assert) {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		}
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"person-spec.json": { data: {
+					attributes: {
+						cardTitle: "Person Card",
+						cardDescription: "Spec for Person card",
+						specType: "card",
+						ref: {
+							module: `./person`,
+							name: "Person"
+						}
+					},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/spec",
+						name: "Spec"
+					} }
+				} }
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		let entry = await indexer.cardDocument(new URL(`${testRealmURL}person-spec`));
+		if (entry?.type === "doc") {
+			assert.deepEqual(entry.doc.data, {
+				id: testRRI("person-spec"),
+				type: "card",
+				links: { self: "./person-spec" },
+				attributes: {
+					cardTitle: "Person Card",
+					cardDescription: "Spec for Person card",
+					moduleHref: `${testRealmURL}person`,
+					readMe: null,
+					specType: "card",
+					isCard: true,
+					isComponent: false,
+					isField: false,
+					cardThumbnailURL: null,
+					ref: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					},
+					containedExamples: [],
+					cardInfo
+				},
+				relationships: {
+					"cardInfo.theme": { links: { self: null } },
+					linkedExamples: { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://cardstack.com/base/spec"),
+						name: "Spec"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}person-spec.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "person-spec.json"),
+					realmURL: testRealmURL,
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			let instance = await indexer.instance(new URL(`${testRealmURL}person-spec`));
+			assert.deepEqual(instance?.searchDoc, {
+				_cardType: "Spec",
+				cardDescription: "Spec for Person card",
+				id: `${testRealmURL}person-spec`,
+				specType: "card",
+				moduleHref: `${testRealmURL}person`,
+				ref: `${testRealmURL}person/Person`,
+				cardTitle: "Person Card",
+				containedExamples: null,
+				linkedExamples: null,
+				isCard: true,
+				isComponent: false,
+				isField: false,
+				cardInfo: { theme: null }
+			});
+		} else assert.ok(false, `search entry was an error: ${entry?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("absolute code-ref fields are preserved as absolute", async function(assert) {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		}
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"person-spec.json": { data: {
+					attributes: {
+						cardTitle: "Person Card",
+						cardDescription: "Spec for Person card",
+						specType: "card",
+						ref: {
+							module: `${testRealmURL}person`,
+							name: "Person"
+						}
+					},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/spec",
+						name: "Spec"
+					} }
+				} },
+				"people-skill.json": { data: {
+					attributes: {
+						instructions: "How to win friends and influence people",
+						commands: [{ codeRef: {
+							module: `@cardstack/boxel-host/commands/switch-submode`,
+							name: "default"
+						} }]
+					},
+					meta: { adoptsFrom: skillCardRef }
+				} }
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		let entry = await indexer.cardDocument(new URL(`${testRealmURL}person-spec`));
+		if (entry?.type === "doc") {
+			assert.deepEqual(entry.doc.data, {
+				id: testRRI("person-spec"),
+				type: "card",
+				links: { self: "./person-spec" },
+				attributes: {
+					cardTitle: "Person Card",
+					cardDescription: "Spec for Person card",
+					moduleHref: `${testRealmURL}person`,
+					readMe: null,
+					specType: "card",
+					isCard: true,
+					isComponent: false,
+					isField: false,
+					cardThumbnailURL: null,
+					ref: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					},
+					containedExamples: [],
+					cardInfo
+				},
+				relationships: {
+					"cardInfo.theme": { links: { self: null } },
+					linkedExamples: { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://cardstack.com/base/spec"),
+						name: "Spec"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}person-spec.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "person-spec.json"),
+					realmURL: testRealmURL,
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			let instance = await indexer.instance(new URL(`${testRealmURL}person-spec`));
+			assert.deepEqual(instance?.searchDoc, {
+				_cardType: "Spec",
+				cardDescription: "Spec for Person card",
+				id: `${testRealmURL}person-spec`,
+				specType: "card",
+				moduleHref: `${testRealmURL}person`,
+				ref: `${testRealmURL}person/Person`,
+				cardTitle: "Person Card",
+				containedExamples: null,
+				linkedExamples: null,
+				isCard: true,
+				isComponent: false,
+				isField: false,
+				cardInfo: { theme: null }
+			});
+		} else assert.ok(false, `search entry was an error: ${entry?.error.errorDetail.message}`);
+		entry = await indexer.cardDocument(new URL(`${testRealmURL}people-skill`));
+		if (entry?.type === "doc") {
+			assert.deepEqual(entry.doc.data, {
+				id: testRRI("people-skill"),
+				type: "card",
+				links: { self: "./people-skill" },
+				attributes: {
+					commands: [{
+						codeRef: {
+							module: "@cardstack/boxel-host/commands/switch-submode",
+							name: "default"
+						},
+						functionName: "switch-submode_dd88",
+						requiresApproval: false,
+						cardTitle: "Switch Submode"
+					}],
+					cardDescription: null,
+					instructions: "How to win friends and influence people",
+					cardThumbnailURL: null,
+					cardTitle: null,
+					cardInfo
+				},
+				relationships: { "cardInfo.theme": { links: { self: null } } },
+				meta: {
+					adoptsFrom: skillCardRef,
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}people-skill.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "people-skill.json"),
+					realmURL: testRealmURL,
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			let instance = await indexer.instance(new URL(`${testRealmURL}people-skill`));
+			assert.deepEqual(instance?.searchDoc, {
+				_cardType: "Skill",
+				id: `${testRealmURL}people-skill`,
+				instructions: "How to win friends and influence people",
+				commands: [{
+					codeRef: `@cardstack/boxel-host/commands/switch-submode/default`,
+					functionName: "switch-submode_dd88",
+					requiresApproval: false,
+					cardTitle: "Switch Submode"
+				}],
+				cardInfo: { theme: null }
+			});
+		} else assert.ok(false, `search entry was an error: ${entry?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("can recover from rendering a card that has a template error", async function(assert) {
+		{
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(StringField);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static isolated = class Isolated extends Component$1 {
+					static {
+						setComponentTemplate(templateFactory({
+							"id": "pbAMu5rb",
+							"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+							"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+							"isStrictMode": true
+						}), this);
+					}
+				};
+				static embedded = class Embedded extends Component$1 {
+					static {
+						setComponentTemplate(templateFactory({
+							"id": "455R5/G0",
+							"block": "[[[10,\"h1\"],[12],[1,\" Person Embedded Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+							"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+							"isStrictMode": true
+						}), this);
+					}
+				};
+				static fitted = class Fitted extends Component$1 {
+					static {
+						setComponentTemplate(templateFactory({
+							"id": "O3XcZBYx",
+							"block": "[[[10,\"h1\"],[12],[1,\" Person Fitted Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+							"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+							"isStrictMode": true
+						}), this);
+					}
+				};
+			}
+			class Boom extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(StringField);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static isolated = class Isolated extends Component$1 {
+					static {
+						setComponentTemplate(templateFactory({
+							"id": "KxUueTZn",
+							"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[1,[30,0,[\"boom\"]]],[13]],[\"@fields\"],[]]",
+							"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+							"isStrictMode": true
+						}), this);
+					}
+					get boom() {
+						throw new Error("intentional error");
+					}
+				};
+			}
+			let { realm } = await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				contents: {
+					"person.gts": { Person },
+					"boom.gts": { Boom },
+					"vangogh.json": { data: {
+						attributes: { firstName: "Van Gogh" },
+						meta: { adoptsFrom: {
+							module: `${testRealmURL}person`,
+							name: "Person"
+						} }
+					} },
+					"boom.json": { data: {
+						attributes: { firstName: "Boom!" },
+						meta: { adoptsFrom: {
+							module: "./boom",
+							name: "Boom"
+						} }
+					} }
+				}
+			});
+			let queryEngine = realm.realmIndexQueryEngine;
+			let realmIndexUpdater = realm.realmIndexUpdater;
+			{
+				let entry = await queryEngine.cardDocument(new URL(`${testRealmURL}boom`));
+				if (entry?.type === "error") {
+					assert.strictEqual(entry.error.errorDetail.message, "Encountered error rendering HTML for card: intentional error");
+					assert.deepEqual(entry.error.errorDetail.deps, [`${testRealmURL}boom`]);
+				} else assert.ok("false", "expected search entry to be an error document");
+			}
+			{
+				let entry = await queryEngine.cardDocument(new URL(`${testRealmURL}vangogh`));
+				if (entry?.type === "doc") {
+					assert.deepEqual(entry.doc.data.attributes?.firstName, "Van Gogh");
+					let { isolatedHtml, embeddedHtml, fittedHtml } = await getInstance(realm, new URL(`http://test-realm/test/vangogh`)) ?? {};
+					assertInnerHtmlMatches(assert, isolatedHtml, `<h1> Van Gogh </h1>`);
+					assertInnerHtmlMatches(assert, embeddedHtml[`${testRealmURL}person/Person`], `<h1> Person Embedded Card: Van Gogh </h1>`);
+					assertInnerHtmlMatches(assert, fittedHtml[`${testRealmURL}person/Person`], `<h1> Person Fitted Card: Van Gogh </h1>`);
+				} else assert.ok(false, `expected search entry to be a document but was: ${entry?.error.errorDetail.message}`);
+			}
+			await realmIndexUpdater.fullIndex();
+			{
+				let entry = await queryEngine.cardDocument(new URL(`${testRealmURL}vangogh`));
+				if (entry?.type === "doc") {
+					assert.deepEqual(entry.doc.data.attributes?.firstName, "Van Gogh");
+					let { isolatedHtml, embeddedHtml, fittedHtml } = await getInstance(realm, new URL(`http://test-realm/test/vangogh`)) ?? {};
+					assertInnerHtmlMatches(assert, isolatedHtml, `<h1> Van Gogh </h1>`);
+					assertInnerHtmlMatches(assert, embeddedHtml[`${testRealmURL}person/Person`], `<h1> Person Embedded Card: Van Gogh </h1>`);
+					assertInnerHtmlMatches(assert, fittedHtml[`${testRealmURL}person/Person`], `<h1> Person Fitted Card: Van Gogh </h1>`);
+				} else assert.ok(false, `expected search entry to be a document but was: ${entry?.error.errorDetail.message}`);
+			}
+		}
+	});
+	(0, import_qunit.test)("can recover from rendering a card that has a nested card with a template error", async function(assert) {
+		class Boom extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "KxUueTZn",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[1,[30,0,[\"boom\"]]],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+				get boom() {
+					throw new Error("intentional error");
+				}
+			};
+		}
+		class BoomPerson extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "boom", [field], function() {
+					return contains(Boom);
+				});
+			}
+			#boom = (initializeDeferredDecorator(this, "boom"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "boUjskQF",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13],[1,\"\\n\"],[10,\"h2\"],[12],[8,[30,1,[\"boom\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "pbAMu5rb",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "455R5/G0",
+						"block": "[[[10,\"h1\"],[12],[1,\" Person Embedded Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static fitted = class Fitted extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "O3XcZBYx",
+						"block": "[[[10,\"h1\"],[12],[1,\" Person Fitted Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"boom-person.gts": { BoomPerson },
+				"boom.gts": { Boom },
+				"person.gts": { Person },
+				"vangogh.json": { data: {
+					attributes: {
+						firstName: "Van Gogh",
+						boom: { firstName: "Mango" }
+					},
+					meta: { adoptsFrom: {
+						module: "./boom-person",
+						name: "BoomPerson"
+					} }
+				} },
+				"working-van-gogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		let entry = await indexer.cardDocument(new URL(`${testRealmURL}vangogh`));
+		if (entry?.type === "error") assert.strictEqual(entry.error.errorDetail.message, "Encountered error rendering HTML for card: intentional error");
+		else assert.ok("false", "expected search entry to be an error document");
+		await realm.reindex();
+		entry = await indexer.cardDocument(new URL(`${testRealmURL}working-van-gogh`));
+		if (entry?.type === "doc") {
+			assert.deepEqual(entry.doc.data.attributes?.firstName, "Van Gogh");
+			let { isolatedHtml, embeddedHtml, fittedHtml } = await getInstance(realm, new URL(`http://test-realm/test/working-van-gogh`)) ?? {};
+			assertInnerHtmlMatches(assert, isolatedHtml, `<h1> Van Gogh </h1>`);
+			assertInnerHtmlMatches(assert, embeddedHtml[`${testRealmURL}person/Person`], `<h1> Person Embedded Card: Van Gogh </h1>`);
+			assertInnerHtmlMatches(assert, fittedHtml[`${testRealmURL}person/Person`], `<h1> Person Fitted Card: Van Gogh </h1>`);
+		} else assert.ok(false, `expected search entry to be a document but was: ${entry?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("can recover from rendering a card that encounters a template error in its own custom component", async function(assert) {
+		class Custom extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "L1UHS+ps",
+					"block": "[[[1,[30,0,[\"boom\"]]]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+					"isStrictMode": true
+				}), this);
+			}
+			get boom() {
+				throw new Error("intentional error");
+			}
+		}
+		class CustomBoom extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "GCbWRRAT",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[8,[32,0],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"scope": () => [Custom],
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class BoomPerson2 extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "boom", [field], function() {
+					return contains(CustomBoom);
+				});
+			}
+			#boom = (initializeDeferredDecorator(this, "boom"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "boUjskQF",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13],[1,\"\\n\"],[10,\"h2\"],[12],[8,[30,1,[\"boom\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "pbAMu5rb",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "455R5/G0",
+						"block": "[[[10,\"h1\"],[12],[1,\" Person Embedded Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static fitted = class Fitted extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "O3XcZBYx",
+						"block": "[[[10,\"h1\"],[12],[1,\" Person Fitted Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"boom-person2.gts": { BoomPerson2 },
+				"custom-boom.gts": { CustomBoom },
+				"person.gts": { Person },
+				"vangogh.json": { data: {
+					attributes: {
+						firstName: "Van Gogh",
+						boom: { firstName: "Mango" }
+					},
+					meta: { adoptsFrom: {
+						module: "./boom-person2",
+						name: "BoomPerson2"
+					} }
+				} },
+				"working-vangogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		let entry = await indexer.cardDocument(new URL(`${testRealmURL}vangogh`));
+		if (entry?.type === "error") assert.strictEqual(entry.error.errorDetail.message, "Encountered error rendering HTML for card: intentional error");
+		else assert.ok("false", "expected search entry to be an error document");
+		await realm.reindex();
+		entry = await indexer.cardDocument(new URL(`${testRealmURL}working-vangogh`));
+		if (entry?.type === "doc") {
+			assert.deepEqual(entry.doc.data.attributes?.firstName, "Van Gogh");
+			let { isolatedHtml, embeddedHtml, fittedHtml } = await getInstance(realm, new URL(`http://test-realm/test/working-vangogh`)) ?? {};
+			assertInnerHtmlMatches(assert, isolatedHtml, `<h1> Van Gogh </h1>`);
+			assert.false(isolatedHtml.includes("id=\"ember"), `isolated HTML does not include ember ID's`);
+			assertInnerHtmlMatches(assert, embeddedHtml[`${testRealmURL}person/Person`], `<h1> Person Embedded Card: Van Gogh </h1>`);
+			assertInnerHtmlMatches(assert, fittedHtml[`${testRealmURL}person/Person`], `<h1> Person Fitted Card: Van Gogh </h1>`);
+			assert.false(Object.values(embeddedHtml).join("").includes("id=\"ember"), `embeddedHtml HTML does not include ember ID's`);
+			assert.false(Object.values(fittedHtml).join("").includes("id=\"ember"), `fittedHtml HTML does not include ember ID's`);
+		} else assert.ok(false, `expected search entry to be a document but was: ${entry?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("can incrementally index a card", async function(assert) {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "pbAMu5rb",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static atom = class Atom extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "MvjivV0J",
+						"block": "[[[10,0],[14,0,\"atom\"],[12],[1,[30,1,[\"firstName\"]]],[13]],[\"@model\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"vangogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `./person`,
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		await realm.write("vangogh.json", JSON.stringify({ data: {
+			id: testRRI("vangogh"),
+			attributes: { firstName: "Van Van" },
+			meta: { adoptsFrom: {
+				module: testRRI("person"),
+				name: "Person"
+			} }
+		} }));
+		let { instance } = await getInstance(realm, new URL(`http://test-realm/test/vangogh`)) ?? {};
+		assert.deepEqual(instance, {
+			id: testRRI("vangogh"),
+			type: "card",
+			attributes: {
+				cardInfo: {
+					summary: null,
+					notes: null,
+					cardThumbnailURL: null,
+					name: null
+				},
+				cardDescription: null,
+				firstName: "Van Van",
+				cardThumbnailURL: null,
+				cardTitle: "Untitled Card"
+			},
+			relationships: { "cardInfo.theme": { links: { self: null } } },
+			meta: {
+				adoptsFrom: {
+					module: rri(`./person`),
+					name: "Person"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}vangogh.json`),
+				resourceCreatedAt: await getFileCreatedAt(realm, "vangogh.json"),
+				realmURL: testRealmURL
+			}
+		}, "serialized instance is correct");
+	});
+	(0, import_qunit.test)("can capture search doc when indexing a card", async function(assert) {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "pbAMu5rb",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static atom = class Atom extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "MvjivV0J",
+						"block": "[[[10,0],[14,0,\"atom\"],[12],[1,[30,1,[\"firstName\"]]],[13]],[\"@model\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"vangogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		let { searchDoc } = await getInstance(realm, new URL(`http://test-realm/test/vangogh`)) ?? {};
+		assert.deepEqual(searchDoc, {
+			_cardType: "Person",
+			cardInfo: { theme: null },
+			firstName: "Van Gogh",
+			id: `${testRealmURL}vangogh`,
+			cardTitle: "Untitled Card"
+		}, "search doc is correct");
+	});
+	(0, import_qunit.test)("can capture atom html when indexing a card", async function(assert) {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "pbAMu5rb",
+						"block": "[[[10,\"h1\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static atom = class Atom extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "MvjivV0J",
+						"block": "[[[10,0],[14,0,\"atom\"],[12],[1,[30,1,[\"firstName\"]]],[13]],[\"@model\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"vangogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		let { atomHtml } = await getInstance(realm, new URL(`http://test-realm/test/vangogh`)) ?? {};
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(atomHtml)), cleanWhiteSpace(`<div class="atom">Van Gogh</div>`), "atom html is correct");
+		assert.false(atomHtml.includes("id=\"ember"), `atom HTML does not include ember ID's`);
+	});
+	(0, import_qunit.test)("can capture head html when indexing a card", async function(assert) {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static head = class Head extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "JVgzQi6M",
+						"block": "[[[10,\"title\"],[12],[1,[30,1,[\"firstName\"]]],[1,\"!\"],[13]],[\"@model\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"vangogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		let { headHtml } = await getInstance(realm, new URL(`http://test-realm/test/vangogh`)) ?? {};
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(headHtml)), cleanWhiteSpace(`<title>Van Gogh!</title>`), "head html is correct");
+	});
+	(0, import_qunit.test)(`can generate embedded HTML for instance's card class hierarchy`, async function(assert) {
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "455R5/G0",
+						"block": "[[[10,\"h1\"],[12],[1,\" Person Embedded Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class FancyPerson extends Person {
+			static displayName = "Fancy Person";
+			static {
+				decorateFieldV2(this.prototype, "favoriteColor", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#favoriteColor = (initializeDeferredDecorator(this, "favoriteColor"), void 0);
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "5nAE9D7f",
+						"block": "[[[10,\"h1\"],[12],[1,\"\\n  Fancy Person Embedded Card:\\n  \"],[8,[30,1,[\"firstName\"]],null,null,null],[1,\"\\n  -\\n  \"],[8,[30,1,[\"favoriteColor\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"fancy-person.gts": { FancyPerson },
+				"germaine.json": { data: {
+					attributes: {
+						firstName: "Germaine",
+						favoriteColor: "hot pink",
+						cardDescription: "Fancy Germaine"
+					},
+					meta: { adoptsFrom: {
+						module: "./fancy-person",
+						name: "FancyPerson"
+					} }
+				} }
+			}
+		});
+		let { embeddedHtml } = await getInstance(realm, new URL(`http://test-realm/test/germaine`)) ?? {};
+		assert.false(Object.values(embeddedHtml).join("").includes("id=\"ember"), `Embedded HTML does not include ember ID's`);
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(embeddedHtml[`${testRealmURL}fancy-person/FancyPerson`])), cleanWhiteSpace(`<div
+          class="ember-view boxel-card-container boxel-card-container--boundaries field-component-card embedded-format display-container-true"
+          data-boxel-card-container
+          data-test-boxel-card-container
+          style
+          data-boxel-card-id="http://test-realm/test/germaine"
+          data-boxel-card-format="embedded"
+          data-test-card="http://test-realm/test/germaine"
+          data-test-card-format="embedded"
+          data-test-field-component-card> <h1> Fancy Person Embedded Card: Germaine - hot pink </h1> </div>`), "default embedded HTML is correct");
+		let cardDefRefURL = internalKeyFor(baseCardRef, void 0, getService("network").virtualNetwork);
+		assert.deepEqual(Object.keys(embeddedHtml), [
+			`${testRealmURL}fancy-person/FancyPerson`,
+			`${testRealmURL}person/Person`,
+			cardDefRefURL
+		], "embedded class hierarchy is correct");
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(embeddedHtml[`${testRealmURL}person/Person`])), cleanWhiteSpace(`<div
+        class="ember-view boxel-card-container boxel-card-container--boundaries field-component-card embedded-format display-container-true"
+        data-boxel-card-container
+        data-test-boxel-card-container
+        style
+        data-boxel-card-id="http://test-realm/test/germaine"
+        data-boxel-card-format="embedded"
+        data-test-card="http://test-realm/test/germaine"
+        data-test-card-format="embedded"
+        data-test-field-component-card> <h1> Person Embedded Card: Germaine </h1> </div>`), `${testRealmURL}person/Person embedded HTML is correct`);
+		assert.false(embeddedHtml[`${testRealmURL}person/Person`].includes("id=\"ember"), `${testRealmURL}person/Person embedded HTML does not include ember ID's`);
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(embeddedHtml[cardDefRefURL])), cleanWhiteSpace(`<div
+        class="ember-view boxel-card-container boxel-card-container--boundaries field-component-card embedded-format display-container-true"
+        data-boxel-card-container
+        data-test-boxel-card-container
+        style
+        data-boxel-card-id="http://test-realm/test/germaine"
+        data-boxel-card-format="embedded"
+        data-test-card="http://test-realm/test/germaine"
+        data-test-card-format="embedded"
+        data-test-field-component-card>
+          <div class="embedded-template">
+            <div class="thumbnail-section">
+              <div class="card-thumbnail">
+                <div class="card-thumbnail-placeholder" data-test-card-thumbnail-placeholder></div>
+              </div>
+            </div>
+            <div class="info-section">
+              <h3 class="card-title" data-test-card-title>Untitled Fancy Person</h3>
+              <h4 class="card-display-name" data-test-card-display-name>
+                Fancy Person
+              </h4>
+            </div>
+            <div class="card-description" data-test-card-description>Fancy Germaine</div>
+          </div>
+        </div>
+      `), `${cardDefRefURL} embedded HTML is correct`);
+		assert.false(embeddedHtml[cardDefRefURL].includes("id=\"ember"), `${cardDefRefURL} fitted HTML does not include ember ID's`);
+	});
+	(0, import_qunit.test)(`can generate fitted HTML for instance's card class hierarchy`, async function(assert) {
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static fitted = class Fitted extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "O3XcZBYx",
+						"block": "[[[10,\"h1\"],[12],[1,\" Person Fitted Card: \"],[8,[30,1,[\"firstName\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class FancyPerson extends Person {
+			static displayName = "Fancy Person";
+			static {
+				decorateFieldV2(this.prototype, "favoriteColor", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#favoriteColor = (initializeDeferredDecorator(this, "favoriteColor"), void 0);
+			static fitted = class Fitted extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "Ea3TSKvz",
+						"block": "[[[10,\"h1\"],[12],[1,\"\\n  Fancy Person Fitted Card:\\n  \"],[8,[30,1,[\"firstName\"]],null,null,null],[1,\"\\n  -\\n  \"],[8,[30,1,[\"favoriteColor\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"fancy-person.gts": { FancyPerson },
+				"germaine.json": { data: {
+					attributes: {
+						firstName: "Germaine",
+						favoriteColor: "hot pink",
+						cardDescription: "Fancy Germaine"
+					},
+					meta: { adoptsFrom: {
+						module: "./fancy-person",
+						name: "FancyPerson"
+					} }
+				} }
+			}
+		});
+		let { embeddedHtml, fittedHtml } = await getInstance(realm, new URL(`http://test-realm/test/germaine`)) ?? {};
+		assert.false(Object.values(fittedHtml).join("").includes("id=\"ember"), `Fitted HTML does not include ember ID's`);
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(fittedHtml[`${testRealmURL}fancy-person/FancyPerson`])), cleanWhiteSpace(`<div
+          class="ember-view boxel-card-container boxel-card-container--boundaries field-component-card fitted-format display-container-true"
+          data-boxel-card-container
+          data-test-boxel-card-container
+          style
+          data-boxel-card-id="http://test-realm/test/germaine"
+          data-boxel-card-format="fitted"
+          data-test-card="http://test-realm/test/germaine"
+          data-test-card-format="fitted"
+          data-test-field-component-card> <h1> Fancy Person Fitted Card: Germaine - hot pink </h1> </div>`), "default fitted HTML is correct");
+		let cardDefRefURL = internalKeyFor(baseCardRef, void 0, getService("network").virtualNetwork);
+		assert.deepEqual(Object.keys(fittedHtml), [
+			`${testRealmURL}fancy-person/FancyPerson`,
+			`${testRealmURL}person/Person`,
+			cardDefRefURL
+		], "fitted class hierarchy is correct");
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(fittedHtml[`${testRealmURL}person/Person`])), cleanWhiteSpace(`<div
+      class="ember-view boxel-card-container boxel-card-container--boundaries field-component-card fitted-format display-container-true"
+      data-boxel-card-container
+      data-test-boxel-card-container
+      style
+      data-boxel-card-id="http://test-realm/test/germaine"
+      data-boxel-card-format="fitted"
+      data-test-card="http://test-realm/test/germaine"
+      data-test-card-format="fitted"
+      data-test-field-component-card> <h1> Person Fitted Card: Germaine </h1> </div>`), `${testRealmURL}person/Person fitted HTML is correct`);
+		assert.false(fittedHtml[`${testRealmURL}person/Person`].includes("id=\"ember"), `${testRealmURL}person/Person fitted HTML does not include ember ID's`);
+		assert.strictEqual(cleanWhiteSpace(stripScopedCSSAttributes(embeddedHtml[cardDefRefURL])), cleanWhiteSpace(`<div
+      class="ember-view boxel-card-container boxel-card-container--boundaries field-component-card embedded-format display-container-true"
+      data-boxel-card-container
+      data-test-boxel-card-container
+      style
+      data-boxel-card-id="http://test-realm/test/germaine"
+      data-boxel-card-format="embedded"
+      data-test-card="http://test-realm/test/germaine"
+      data-test-card-format="embedded"
+      data-test-field-component-card>
+        <div class="embedded-template">
+          <div class="thumbnail-section">
+            <div class="card-thumbnail">
+              <div class="card-thumbnail-placeholder" data-test-card-thumbnail-placeholder></div>
+            </div>
+          </div>
+          <div class="info-section">
+            <h3 class="card-title" data-test-card-title>Untitled Fancy Person</h3>
+            <h4 class="card-display-name" data-test-card-display-name> Fancy Person </h4>
+          </div>
+          <div class="card-description" data-test-card-description>Fancy Germaine</div>
+        </div>
+      </div>`), `${cardDefRefURL} embedded HTML is correct`);
+		assert.false(embeddedHtml[cardDefRefURL].includes("id=\"ember"), `${cardDefRefURL} embedded HTML does not include ember ID's`);
+	});
+	(0, import_qunit.test)("can index a card that has a cyclic relationship with the field of a card in its fields", async function(assert) {
+		class Person extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "pet", [field], function() {
+					return linksTo(() => PetCard);
+				});
+			}
+			#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.firstName;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+		}
+		class Appointment extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "contact", [field], function() {
+					return contains(Person);
+				});
+			}
+			#contact = (initializeDeferredDecorator(this, "contact"), void 0);
+		}
+		class PetCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "appointment", [field], function() {
+					return contains(Appointment);
+				});
+			}
+			#appointment = (initializeDeferredDecorator(this, "appointment"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.firstName;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardThumbnailURL", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardThumbnailURL = (initializeDeferredDecorator(this, "cardThumbnailURL"), void 0);
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person-card.gts": { Person },
+				"appointment.gts": { Appointment },
+				"pet-card.gts": { PetCard },
+				"jackie.json": { data: {
+					attributes: {
+						firstName: "Jackie",
+						appointment: {
+							cardTitle: "Vet visit",
+							contact: { firstName: "Burcu" }
+						},
+						cardDescription: "Dog",
+						cardThumbnailURL: "./jackie.jpg"
+					},
+					meta: { adoptsFrom: {
+						module: `./pet-card`,
+						name: "PetCard"
+					} },
+					relationships: { "appointment.contact.pet": { links: { self: `./mango` } } }
+				} },
+				"mango.json": { data: {
+					attributes: { firstName: "Mango" },
+					meta: { adoptsFrom: {
+						module: `./pet-card`,
+						name: "PetCard"
+					} }
+				} }
+			}
+		});
+		let card = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}jackie`));
+		if (card?.type === "doc") {
+			assert.deepEqual(card.doc.data.attributes, {
+				firstName: "Jackie",
+				cardTitle: "Jackie",
+				appointment: {
+					cardTitle: "Vet visit",
+					contact: { firstName: "Burcu" }
+				},
+				cardDescription: "Dog",
+				cardThumbnailURL: `./jackie.jpg`,
+				cardInfo
+			});
+			assert.deepEqual(card.doc.data.relationships, {
+				"appointment.contact.pet": { links: { self: `./mango` } },
+				"cardInfo.theme": { links: { self: null } }
+			});
+		} else assert.ok(false, `search entry was an error: ${card?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("can index a card with a containsMany composite containing a linkTo field", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Vendor/vendor1.json": { data: {
+					id: `${testRealmURL}Vendor/vendor1`,
+					attributes: {
+						name: "Acme Industries",
+						paymentMethods: [{
+							type: "crypto",
+							payment: { address: "0x1111" }
+						}, {
+							type: "crypto",
+							payment: { address: "0x2222" }
+						}]
+					},
+					relationships: {
+						"paymentMethods.0.payment.chain": { links: { self: `../Chain/1` } },
+						"paymentMethods.1.payment.chain": { links: { self: `../Chain/2` } }
+					},
+					meta: { adoptsFrom: {
+						module: `https://localhost:4202/test/vendor`,
+						name: "Vendor"
+					} }
+				} },
+				"Chain/1.json": { data: {
+					id: `${testRealmURL}Chain/1`,
+					attributes: { name: "Ethereum Mainnet" },
+					meta: { adoptsFrom: {
+						module: `https://localhost:4202/test/chain`,
+						name: "Chain"
+					} }
+				} },
+				"Chain/2.json": { data: {
+					id: `${testRealmURL}Chain/2`,
+					attributes: { name: "Polygon" },
+					meta: { adoptsFrom: {
+						module: `https://localhost:4202/test/chain`,
+						name: "Chain"
+					} }
+				} }
+			}
+		});
+		let vendor = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}Vendor/vendor1`), { loadLinks: true });
+		if (vendor?.type === "doc") assert.deepEqual(vendor.doc, {
+			data: {
+				id: testRRI("Vendor/vendor1"),
+				type: "card",
+				links: { self: "./vendor1" },
+				attributes: {
+					name: "Acme Industries",
+					cardTitle: "Acme Industries",
+					cardDescription: "Vendor",
+					cardThumbnailURL: null,
+					paymentMethods: [{
+						type: "crypto",
+						payment: { address: "0x1111" }
+					}, {
+						type: "crypto",
+						payment: { address: "0x2222" }
+					}],
+					cardInfo
+				},
+				relationships: {
+					"paymentMethods.0.payment.chain": {
+						data: {
+							id: `${testRealmURL}Chain/1`,
+							type: "card"
+						},
+						links: { self: `../Chain/1` }
+					},
+					"paymentMethods.1.payment.chain": {
+						data: {
+							id: `${testRealmURL}Chain/2`,
+							type: "card"
+						},
+						links: { self: `../Chain/2` }
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri(`https://localhost:4202/test/vendor`),
+						name: "Vendor"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Vendor/vendor1.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "Vendor/vendor1.json"),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			},
+			included: [{
+				id: testRRI("Chain/1"),
+				type: "card",
+				links: { self: `../Chain/1` },
+				attributes: {
+					name: "Ethereum Mainnet",
+					cardTitle: "Ethereum Mainnet",
+					chainId: 1,
+					cardDescription: `Chain 1`,
+					cardThumbnailURL: `Ethereum Mainnet-icon.png`,
+					cardInfo
+				},
+				relationships: { "cardInfo.theme": { links: { self: null } } },
+				meta: {
+					adoptsFrom: {
+						module: rri(`https://localhost:4202/test/chain`),
+						name: "Chain"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Chain/1.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "Chain/1.json"),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			}, {
+				id: testRRI("Chain/2"),
+				type: "card",
+				links: { self: `../Chain/2` },
+				attributes: {
+					name: "Polygon",
+					cardTitle: "Polygon",
+					chainId: 137,
+					cardDescription: `Chain 137`,
+					cardThumbnailURL: `Polygon-icon.png`,
+					cardInfo
+				},
+				relationships: { "cardInfo.theme": { links: { self: null } } },
+				meta: {
+					adoptsFrom: {
+						module: rri(`https://localhost:4202/test/chain`),
+						name: "Chain"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Chain/2.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "Chain/2.json"),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			}]
+		});
+		else assert.ok(false, `search entry was an error: ${vendor?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("can tolerate a card whose computed throws an exception", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Boom/boom.json": { data: {
+					id: `${testRealmURL}Boom/boom`,
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/card-with-error",
+						name: "Boom"
+					} }
+				} },
+				"Person/owner.json": { data: {
+					id: `${testRealmURL}Person/owner`,
+					attributes: { firstName: "Hassan" },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/person",
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}Boom/boom`));
+			if (card?.type === "error") assert.ok(card.error.errorDetail.message.includes("intentional error thrown"), "error doc includes raised error message");
+			else assert.ok(false, `expected search entry to be an error doc`);
+		}
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}Person/owner`));
+			if (card?.type === "doc") assert.strictEqual(card.doc.data.attributes?.firstName, "Hassan");
+			else assert.ok(false, `search entry was an error: ${card?.error.errorDetail.message}`);
+		}
+	});
+	(0, import_qunit.test)(`search doc includes 'contains' and used 'linksTo' fields, including contained computed fields`, async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Pet/mango.json": { data: {
+					attributes: { firstName: "Mango" },
+					relationships: { owner: { links: { self: `../Person/hassan` } } },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}pet`,
+						name: "Pet"
+					} }
+				} },
+				"Person/hassan.json": { data: {
+					id: `${testRealmURL}Person/hassan`,
+					attributes: {
+						firstName: "Hassan",
+						lastName: "Abdel-Rahman",
+						email: "hassan@cardstack.com",
+						posts: 100
+					},
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/person",
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		let entry = await getInstance(realm, new URL(`${testRealmURL}Person/hassan`));
+		assert.deepEqual(entry?.searchDoc, {
+			id: `${testRealmURL}Person/hassan`,
+			firstName: "Hassan",
+			lastName: "Abdel-Rahman",
+			email: "hassan@cardstack.com",
+			posts: 100,
+			cardTitle: "Hassan Abdel-Rahman",
+			cardDescription: "Person",
+			fullName: "Hassan Abdel-Rahman",
+			_cardType: "Person",
+			cardInfo: { theme: null }
+		}, `search doc includes fullName field`);
+	});
+	(0, import_qunit.test)(`search doc includes unused 'linksTo' field if isUsed option is set to true`, async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Publication/pacific.json": { data: {
+					id: `${testRealmURL}Publication/pacific`,
+					attributes: { cardTitle: "Pacific Weekly" },
+					relationships: {
+						"featuredPosts.0": { links: { self: `../Post/1` } },
+						"featuredPosts.1": { links: { self: `../Post/2` } }
+					},
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}publication`,
+						name: "Publication"
+					} }
+				} },
+				"Post/1.json": { data: {
+					id: `${testRealmURL}Post/1`,
+					attributes: {
+						cardTitle: "50 Ways to Leave Your Laptop",
+						views: 5
+					},
+					relationships: { publication: { links: { self: `../Publication/pacific` } } },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/post",
+						name: "Post"
+					} }
+				} },
+				"Post/2.json": { data: {
+					id: `${testRealmURL}Post/2`,
+					attributes: {
+						cardTitle: "49 Shades of Mauve",
+						views: 24
+					},
+					relationships: { publication: { links: { self: `../Publication/pacific` } } },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/post",
+						name: "Post"
+					} }
+				} }
+			}
+		});
+		let entry = await getInstance(realm, new URL(`${testRealmURL}Post/1`));
+		assert.deepEqual(entry?.searchDoc, {
+			_cardType: "Post",
+			author: {
+				cardDescription: "Person",
+				fullName: " ",
+				cardTitle: " "
+			},
+			id: `${testRealmURL}Post/1`,
+			cardTitle: "50 Ways to Leave Your Laptop",
+			publication: { id: `${testRealmURL}Publication/pacific` },
+			views: 5,
+			cardInfo: { theme: null }
+		}, `post 1 search doc includes publication relationship`);
+		let entry2 = await getInstance(realm, new URL(`${testRealmURL}Publication/pacific`));
+		assert.deepEqual(entry2?.searchDoc, {
+			_cardType: "Publication",
+			id: `${testRealmURL}Publication/pacific`,
+			cardTitle: "Pacific Weekly",
+			featuredPosts: [{
+				author: {
+					cardDescription: "Person",
+					fullName: " ",
+					cardTitle: " "
+				},
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				},
+				id: `${testRealmURL}Post/1`,
+				publication: { id: `${testRealmURL}Publication/pacific` },
+				cardTitle: "50 Ways to Leave Your Laptop",
+				views: 5
+			}, {
+				author: {
+					cardDescription: "Person",
+					fullName: " ",
+					cardTitle: " "
+				},
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				},
+				id: `${testRealmURL}Post/2`,
+				publication: { id: `${testRealmURL}Publication/pacific` },
+				cardTitle: "49 Shades of Mauve",
+				views: 24
+			}],
+			cardInfo: { theme: null }
+		}, `publication search doc includes featuredPosts relationship via isUsed=true`);
+	});
+	(0, import_qunit.test)("search doc normalizes containsMany composite fields", async function(assert) {
+		class Person extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "email", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#email = (initializeDeferredDecorator(this, "email"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "posts", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#posts = (initializeDeferredDecorator(this, "posts"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "fullName", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return `${this.firstName ?? ""} ${this.lastName ?? ""}`;
+					} });
+				});
+			}
+			#fullName = (initializeDeferredDecorator(this, "fullName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return `${this.firstName ?? ""} ${this.lastName ?? ""}`;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(StringField, { computeVia: () => "Person" });
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+		}
+		class Post extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return contains(Person);
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "views", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#views = (initializeDeferredDecorator(this, "views"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "createdAt", [field], function() {
+					return contains(DateTimeField);
+				});
+			}
+			#createdAt = (initializeDeferredDecorator(this, "createdAt"), void 0);
+		}
+		class Booking extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "venue", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#venue = (initializeDeferredDecorator(this, "venue"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "startTime", [field], function() {
+					return contains(DateTimeField);
+				});
+			}
+			#startTime = (initializeDeferredDecorator(this, "startTime"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "endTime", [field], function() {
+					return contains(DateTimeField);
+				});
+			}
+			#endTime = (initializeDeferredDecorator(this, "endTime"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "hosts", [field], function() {
+					return containsMany(Person);
+				});
+			}
+			#hosts = (initializeDeferredDecorator(this, "hosts"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "sponsors", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#sponsors = (initializeDeferredDecorator(this, "sponsors"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "posts", [field], function() {
+					return containsMany(Post);
+				});
+			}
+			#posts = (initializeDeferredDecorator(this, "posts"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(StringField, { computeVia: function() {
+						return this.venue;
+					} });
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardThumbnailURL", [field], function() {
+					return contains(StringField, { computeVia: () => null });
+				});
+			}
+			#cardThumbnailURL = (initializeDeferredDecorator(this, "cardThumbnailURL"), void 0);
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"booking.gts": { Booking },
+				"person.gts": { Person },
+				"post.gts": { Post },
+				"Spec/booking.json": { data: {
+					attributes: {
+						cardTitle: "Booking",
+						cardDescription: "Spec for Booking",
+						specType: "card",
+						ref: {
+							module: "https://localhost:4202/test/booking",
+							name: "Booking"
+						}
+					},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/spec",
+						name: "Spec"
+					} }
+				} }
+			}
+		});
+		let entry = await getInstance(realm, new URL(`${testRealmURL}Spec/booking`));
+		assert.deepEqual(entry?.searchDoc, {
+			_cardType: "Spec",
+			id: `${testRealmURL}Spec/booking`,
+			cardDescription: "Spec for Booking",
+			specType: "card",
+			moduleHref: "https://localhost:4202/test/booking",
+			containedExamples: null,
+			linkedExamples: null,
+			ref: "https://localhost:4202/test/booking/Booking",
+			cardTitle: "Booking",
+			isCard: true,
+			isComponent: false,
+			isField: false,
+			cardInfo: { theme: null }
+		});
+		structuredClone(entry?.searchDoc);
+	});
+	(0, import_qunit.test)("can index a card with linksToMany field", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Pet/vanGogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}pet`,
+						name: "Pet"
+					} }
+				} },
+				"PetPerson/hassan.json": { data: {
+					attributes: { firstName: "Hassan" },
+					relationships: {
+						"pets.0": { links: { self: `../Pet/mango` } },
+						"pets.1": { links: { self: `../Pet/vanGogh` } }
+					},
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}pet-person`,
+						name: "PetPerson"
+					} }
+				} },
+				"Pet/mango.json": { data: {
+					attributes: { firstName: "Mango" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}pet`,
+						name: "Pet"
+					} }
+				} }
+			}
+		});
+		let hassan = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}PetPerson/hassan`), { loadLinks: true });
+		if (hassan?.type === "doc") {
+			assert.deepEqual(hassan.doc.data, {
+				id: testRRI("PetPerson/hassan"),
+				type: "card",
+				links: { self: "./hassan" },
+				attributes: {
+					firstName: "Hassan",
+					cardTitle: "Hassan Pet Person",
+					cardDescription: "A person with pets",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					friend: { links: { self: null } },
+					"pets.0": {
+						links: { self: `../Pet/mango` },
+						data: {
+							id: `${testRealmURL}Pet/mango`,
+							type: "card"
+						}
+					},
+					"pets.1": {
+						links: { self: `../Pet/vanGogh` },
+						data: {
+							id: `${testRealmURL}Pet/vanGogh`,
+							type: "card"
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: testModuleRRI("pet-person"),
+						name: "PetPerson"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}PetPerson/hassan.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "PetPerson/hassan.json"),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			assert.deepEqual(hassan.doc.included, [{
+				id: testRRI("Pet/mango"),
+				type: "card",
+				links: { self: `../Pet/mango` },
+				attributes: {
+					cardDescription: null,
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					owner: { links: { self: null } },
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: testModuleRRI("pet"),
+						name: "Pet"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Pet/mango.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "Pet/mango.json"),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			}, {
+				id: testRRI("Pet/vanGogh"),
+				type: "card",
+				links: { self: `../Pet/vanGogh` },
+				attributes: {
+					cardDescription: null,
+					firstName: "Van Gogh",
+					cardTitle: "Van Gogh",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					owner: { links: { self: null } },
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: testModuleRRI("pet"),
+						name: "Pet"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Pet/vanGogh.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "Pet/vanGogh.json"),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			}]);
+		} else assert.ok(false, `search entry was an error: ${hassan?.error.errorDetail.message}`);
+		let hassanEntry = await getInstance(realm, new URL(`${testRealmURL}PetPerson/hassan`));
+		if (hassanEntry) assert.deepEqual(hassanEntry.searchDoc, {
+			_cardType: "Pet Person",
+			id: `${testRealmURL}PetPerson/hassan`,
+			firstName: "Hassan",
+			pets: [{
+				id: `${testRealmURL}Pet/mango`,
+				firstName: "Mango",
+				owner: null,
+				cardTitle: "Mango",
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}, {
+				id: `${testRealmURL}Pet/vanGogh`,
+				firstName: "Van Gogh",
+				owner: null,
+				cardTitle: "Van Gogh",
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}],
+			friend: null,
+			cardTitle: "Hassan Pet Person",
+			cardDescription: "A person with pets",
+			cardThumbnailURL: null,
+			cardInfo: { theme: null }
+		});
+		else assert.ok(false, `could not find ${testRealmURL}PetPerson/hassan in the index`);
+	});
+	(0, import_qunit.test)("can index a card with empty linksToMany field value", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "PetPerson/burcu.json": { data: {
+				attributes: { firstName: "Burcu" },
+				relationships: {
+					pets: { links: { self: null } },
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: { adoptsFrom: {
+					module: `${testModuleRealm}pet-person`,
+					name: "PetPerson"
+				} }
+			} } }
+		});
+		let card = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}PetPerson/burcu`), { loadLinks: true });
+		if (card?.type === "doc") assert.deepEqual(card.doc, { data: {
+			id: testRRI("PetPerson/burcu"),
+			type: "card",
+			links: { self: "./burcu" },
+			attributes: {
+				firstName: "Burcu",
+				cardTitle: "Burcu Pet Person",
+				cardDescription: "A person with pets",
+				cardThumbnailURL: null,
+				cardInfo
+			},
+			relationships: {
+				pets: { links: { self: null } },
+				friend: { links: { self: null } },
+				"cardInfo.theme": { links: { self: null } }
+			},
+			meta: {
+				adoptsFrom: {
+					module: testModuleRRI("pet-person"),
+					name: "PetPerson"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}PetPerson/burcu.json`),
+				resourceCreatedAt: await getFileCreatedAt(realm, "PetPerson/burcu.json"),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					backgroundURL: null,
+					iconURL: null,
+					includePrerenderedDefaultRealmIndex: null,
+					lastPublishedAt: null,
+					name: "Unnamed Workspace",
+					publishable: null,
+					realmUserId: "@realm_server:localhost",
+					showAsCatalog: null,
+					visibility: "public"
+				}
+			}
+		} });
+		else assert.ok(false, `search entry was an error: ${card?.error.errorDetail.message}`);
+		let entry = await getInstance(realm, new URL(`${testRealmURL}PetPerson/burcu`));
+		if (entry) assert.deepEqual(entry.searchDoc, {
+			_cardType: "Pet Person",
+			id: `${testRealmURL}PetPerson/burcu`,
+			firstName: "Burcu",
+			pets: null,
+			friend: null,
+			cardTitle: "Burcu Pet Person",
+			cardDescription: "A person with pets",
+			cardThumbnailURL: null,
+			cardInfo: { theme: null }
+		});
+		else assert.ok(false, `could not find ${testRealmURL}PetPerson/burcu in the index`);
+	});
+	(0, import_qunit.test)("can index a card that contains a field with a linksToMany field", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Pet/vanGogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}pet`,
+						name: "Pet"
+					} }
+				} },
+				"pet-person-spec.json": { data: {
+					attributes: {
+						cardTitle: "PetPerson",
+						cardDescription: "Spec for PetPerson",
+						specType: "card",
+						ref: {
+							module: `${testModuleRealm}pet-person`,
+							name: "PetPerson"
+						}
+					},
+					relationships: {},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/spec",
+						name: "Spec"
+					} }
+				} },
+				"Pet/mango.json": { data: {
+					attributes: { firstName: "Mango" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}pet`,
+						name: "Pet"
+					} }
+				} }
+			}
+		});
+		let spec = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}pet-person-spec`), { loadLinks: true });
+		if (spec?.type === "doc") assert.deepEqual(spec.doc.data, {
+			id: testRRI("pet-person-spec"),
+			type: "card",
+			links: { self: "./pet-person-spec" },
+			attributes: {
+				cardTitle: "PetPerson",
+				cardDescription: "Spec for PetPerson",
+				readMe: null,
+				cardThumbnailURL: null,
+				ref: {
+					module: `${testModuleRealm}pet-person`,
+					name: "PetPerson"
+				},
+				specType: "card",
+				moduleHref: `${testModuleRealm}pet-person`,
+				containedExamples: [],
+				isCard: true,
+				isComponent: false,
+				isField: false,
+				cardInfo
+			},
+			relationships: {
+				"cardInfo.theme": { links: { self: null } },
+				linkedExamples: { links: { self: null } }
+			},
+			meta: {
+				adoptsFrom: {
+					module: rri("https://cardstack.com/base/spec"),
+					name: "Spec"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}pet-person-spec.json`),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					backgroundURL: null,
+					iconURL: null,
+					includePrerenderedDefaultRealmIndex: null,
+					lastPublishedAt: null,
+					name: "Unnamed Workspace",
+					publishable: null,
+					realmUserId: "@realm_server:localhost",
+					showAsCatalog: null,
+					visibility: "public"
+				},
+				resourceCreatedAt: await getFileCreatedAt(realm, "pet-person-spec.json")
+			}
+		});
+		else assert.ok(false, `search entry was an error: ${spec?.error.errorDetail.message}`);
+		let entry = await getInstance(realm, new URL(`${testRealmURL}pet-person-spec`));
+		if (entry) assert.deepEqual(entry.searchDoc, {
+			_cardType: "Spec",
+			id: `${testRealmURL}pet-person-spec`,
+			cardTitle: "PetPerson",
+			cardDescription: "Spec for PetPerson",
+			containedExamples: null,
+			linkedExamples: null,
+			moduleHref: `${testModuleRealm}pet-person`,
+			ref: `${testModuleRealm}pet-person/PetPerson`,
+			specType: "card",
+			isCard: true,
+			isComponent: false,
+			isField: false,
+			cardInfo: { theme: null }
+		});
+		else assert.ok(false, `could not find ${testRealmURL}pet-person-spec in the index`);
+	});
+	(0, import_qunit.test)("can index a card that has nested linksTo fields", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Friend/hassan.json": { data: {
+					id: `${testRealmURL}Friend/hassan`,
+					attributes: {
+						firstName: "Hassan",
+						cardDescription: "Friend of dogs"
+					},
+					relationships: { friend: {
+						links: { self: `./mango` },
+						data: {
+							type: "card",
+							id: `${testRealmURL}Friend/mango`
+						}
+					} },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/friend",
+						name: "Friend"
+					} }
+				} },
+				"Friend/mango.json": { data: {
+					id: `${testRealmURL}Friend/mango`,
+					attributes: {
+						firstName: "Mango",
+						cardDescription: "Dog friend"
+					},
+					relationships: { friend: { links: { self: `./vanGogh` } } },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/friend",
+						name: "Friend"
+					} }
+				} },
+				"Friend/vanGogh.json": { data: {
+					id: `${testRealmURL}Friend/vanGogh`,
+					attributes: {
+						firstName: "Van Gogh",
+						cardDescription: "Dog friend",
+						cardThumbnailURL: "van-gogh.jpg"
+					},
+					relationships: { friend: { links: { self: null } } },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/friend",
+						name: "Friend"
+					} }
+				} }
+			}
+		});
+		let hassan = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}Friend/hassan`));
+		if (hassan?.type === "doc") assert.deepEqual(hassan.doc.data, {
+			id: testRRI("Friend/hassan"),
+			type: "card",
+			links: { self: "./hassan" },
+			attributes: {
+				firstName: "Hassan",
+				cardTitle: "Hassan",
+				cardDescription: "Friend of dogs",
+				cardThumbnailURL: null,
+				cardInfo
+			},
+			relationships: {
+				friend: { links: { self: `./mango` } },
+				"cardInfo.theme": { links: { self: null } }
+			},
+			meta: {
+				adoptsFrom: {
+					module: rri("https://localhost:4202/test/friend"),
+					name: "Friend"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					backgroundURL: null,
+					iconURL: null,
+					includePrerenderedDefaultRealmIndex: null,
+					lastPublishedAt: null,
+					name: "Unnamed Workspace",
+					publishable: null,
+					realmUserId: "@realm_server:localhost",
+					showAsCatalog: null,
+					visibility: "public"
+				},
+				resourceCreatedAt: await getFileCreatedAt(realm, "Friend/hassan.json")
+			}
+		});
+		else assert.ok(false, `search entry was an error: ${hassan?.error.errorDetail.message}`);
+		let hassanEntry = await getInstance(realm, new URL(`${testRealmURL}Friend/hassan`));
+		if (hassanEntry) assert.deepEqual(hassanEntry.searchDoc, {
+			_cardType: "Friend",
+			id: `${testRealmURL}Friend/hassan`,
+			firstName: "Hassan",
+			cardTitle: "Hassan",
+			cardDescription: "Friend of dogs",
+			friend: {
+				id: `${testRealmURL}Friend/mango`,
+				firstName: "Mango",
+				cardTitle: "Mango",
+				cardDescription: "Dog friend",
+				friend: { id: `${testRealmURL}Friend/vanGogh` },
+				cardInfo: { theme: null }
+			},
+			cardInfo: { theme: null }
+		});
+		else assert.ok(false, `could not find ${testRealmURL}Friend/hassan in the index`);
+	});
+	(0, import_qunit.test)("can index a field with a cycle in the linksTo field", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Friend/hassan.json": { data: {
+					id: `${testRealmURL}Friend/hassan`,
+					attributes: {
+						firstName: "Hassan",
+						cardDescription: "Dog owner"
+					},
+					relationships: { friend: { links: { self: `./mango` } } },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/friend",
+						name: "Friend"
+					} }
+				} },
+				"Friend/mango.json": { data: {
+					id: `${testRealmURL}Friend/mango`,
+					attributes: {
+						firstName: "Mango",
+						cardDescription: "Dog friend"
+					},
+					relationships: { friend: {
+						links: { self: `./hassan` },
+						data: {
+							type: "card",
+							id: `${testRealmURL}Friend/hassan`
+						}
+					} },
+					meta: { adoptsFrom: {
+						module: "https://localhost:4202/test/friend",
+						name: "Friend"
+					} }
+				} }
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		let hassan = await indexer.cardDocument(new URL(`${testRealmURL}Friend/hassan`), { loadLinks: true });
+		if (hassan?.type === "doc") assert.deepEqual(hassan.doc, {
+			data: {
+				id: testRRI("Friend/hassan"),
+				type: "card",
+				links: { self: "./hassan" },
+				attributes: {
+					firstName: "Hassan",
+					cardTitle: "Hassan",
+					cardDescription: "Dog owner",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					friend: {
+						links: { self: `./mango` },
+						data: {
+							type: "card",
+							id: `${testRealmURL}Friend/mango`
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://localhost:4202/test/friend"),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friend/hassan.json")
+				}
+			},
+			included: [{
+				id: testRRI("Friend/mango"),
+				type: "card",
+				links: { self: `./mango` },
+				attributes: {
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardDescription: "Dog friend",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					friend: {
+						links: { self: `./hassan` },
+						data: {
+							type: "card",
+							id: `${testRealmURL}Friend/hassan`
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://localhost:4202/test/friend"),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/mango.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friend/mango.json")
+				}
+			}]
+		});
+		else assert.ok(false, `search entry was an error: ${hassan?.error.errorDetail.message}`);
+		let hassanEntry = await getInstance(realm, new URL(`${testRealmURL}Friend/hassan`));
+		if (hassanEntry) assert.deepEqual(hassanEntry.searchDoc, {
+			_cardType: "Friend",
+			id: `${testRealmURL}Friend/hassan`,
+			firstName: "Hassan",
+			cardDescription: "Dog owner",
+			friend: {
+				id: `${testRealmURL}Friend/mango`,
+				firstName: "Mango",
+				cardTitle: "Mango",
+				friend: { id: `${testRealmURL}Friend/hassan` },
+				cardDescription: "Dog friend",
+				cardInfo: { theme: null }
+			},
+			cardTitle: "Hassan",
+			cardInfo: { theme: null }
+		});
+		else assert.ok(false, `could not find ${testRealmURL}Friend/hassan in the index`);
+		let mango = await indexer.cardDocument(new URL(`${testRealmURL}Friend/mango`), { loadLinks: true });
+		if (mango?.type === "doc") assert.deepEqual(mango.doc, {
+			data: {
+				id: testRRI("Friend/mango"),
+				type: "card",
+				links: { self: "./mango" },
+				attributes: {
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardDescription: "Dog friend",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					friend: {
+						links: { self: `./hassan` },
+						data: {
+							type: "card",
+							id: `${testRealmURL}Friend/hassan`
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://localhost:4202/test/friend"),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/mango.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friend/mango.json")
+				}
+			},
+			included: [{
+				id: testRRI("Friend/hassan"),
+				type: "card",
+				links: { self: `./hassan` },
+				attributes: {
+					firstName: "Hassan",
+					cardTitle: "Hassan",
+					cardDescription: "Dog owner",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					friend: {
+						links: { self: `./mango` },
+						data: {
+							type: "card",
+							id: `${testRealmURL}Friend/mango`
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("https://localhost:4202/test/friend"),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friend/hassan.json")
+				}
+			}]
+		});
+		else assert.ok(false, `search entry was an error: ${mango?.error.errorDetail.message}`);
+		let mangoEntry = await getInstance(realm, new URL(`${testRealmURL}Friend/mango`));
+		if (mangoEntry) assert.deepEqual(mangoEntry.searchDoc, {
+			_cardType: "Friend",
+			id: `${testRealmURL}Friend/mango`,
+			firstName: "Mango",
+			cardTitle: "Mango",
+			cardDescription: "Dog friend",
+			friend: {
+				id: `${testRealmURL}Friend/hassan`,
+				cardTitle: "Hassan",
+				firstName: "Hassan",
+				friend: { id: `${testRealmURL}Friend/mango` },
+				cardDescription: "Dog owner",
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			},
+			cardInfo: { theme: null }
+		});
+		else assert.ok(false, `could not find ${testRealmURL}Friend/mango in the index`);
+	});
+	(0, import_qunit.test)("can index a card that has a linksTo relationship to itself", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "Friend/hassan.json": { data: {
+				id: `${testRealmURL}Friend/hassan`,
+				attributes: {
+					firstName: "Hassan",
+					cardDescription: "Dog owner"
+				},
+				relationships: { friend: { links: { self: `./hassan` } } },
+				meta: { adoptsFrom: {
+					module: "https://localhost:4202/test/friend",
+					name: "Friend"
+				} }
+			} } }
+		});
+		let hassan = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}Friend/hassan`), { loadLinks: true });
+		if (hassan?.type === "doc") assert.deepEqual(hassan.doc, { data: {
+			id: testRRI("Friend/hassan"),
+			type: "card",
+			links: { self: "./hassan" },
+			attributes: {
+				firstName: "Hassan",
+				cardTitle: "Hassan",
+				cardDescription: "Dog owner",
+				cardThumbnailURL: null,
+				cardInfo
+			},
+			relationships: {
+				friend: {
+					links: { self: `./hassan` },
+					data: {
+						type: "card",
+						id: `${testRealmURL}Friend/hassan`
+					}
+				},
+				"cardInfo.theme": { links: { self: null } }
+			},
+			meta: {
+				adoptsFrom: {
+					module: rri("https://localhost:4202/test/friend"),
+					name: "Friend"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					backgroundURL: null,
+					iconURL: null,
+					includePrerenderedDefaultRealmIndex: null,
+					lastPublishedAt: null,
+					name: "Unnamed Workspace",
+					publishable: null,
+					realmUserId: "@realm_server:localhost",
+					showAsCatalog: null,
+					visibility: "public"
+				},
+				resourceCreatedAt: await getFileCreatedAt(realm, "Friend/hassan.json")
+			}
+		} });
+		else assert.ok(false, `search entry was an error: ${hassan?.error.errorDetail.message}`);
+		let hassanEntry = await getInstance(realm, new URL(`${testRealmURL}Friend/hassan`));
+		if (hassanEntry) assert.deepEqual(hassanEntry.searchDoc, {
+			_cardType: "Friend",
+			id: `${testRealmURL}Friend/hassan`,
+			firstName: "Hassan",
+			cardDescription: "Dog owner",
+			friend: { id: `${testRealmURL}Friend/hassan` },
+			cardTitle: "Hassan",
+			cardInfo: { theme: null }
+		});
+		else assert.ok(false, `could not find ${testRealmURL}Friend/hassan in the index`);
+	});
+	(0, import_qunit.test)("can index a field with a cycle in the linksToMany field", async function(assert) {
+		let hassanID = `${testRealmURL}Friends/hassan`;
+		let mangoID = `${testRealmURL}Friends/mango`;
+		let vanGoghID = `${testRealmURL}Friends/vanGogh`;
+		let friendsRef = {
+			module: testModuleRRI("friends"),
+			name: "Friends"
+		};
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"Friends/vanGogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					relationships: { "friends.0": {
+						links: { self: hassanID },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					} },
+					meta: { adoptsFrom: friendsRef }
+				} },
+				"Friends/hassan.json": { data: {
+					attributes: { firstName: "Hassan" },
+					relationships: {
+						"friends.0": {
+							links: { self: mangoID },
+							data: {
+								type: "card",
+								id: mangoID
+							}
+						},
+						"friends.1": {
+							links: { self: vanGoghID },
+							data: {
+								type: "card",
+								id: vanGoghID
+							}
+						}
+					},
+					meta: { adoptsFrom: friendsRef }
+				} },
+				"Friends/mango.json": { data: {
+					attributes: { firstName: "Mango" },
+					relationships: { "friends.0": {
+						links: { self: hassanID },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					} },
+					meta: { adoptsFrom: friendsRef }
+				} }
+			}
+		});
+		let queryEngine = realm.realmIndexQueryEngine;
+		let realmIndexUpdater = realm.realmIndexUpdater;
+		assert.deepEqual(realmIndexUpdater.stats, {
+			filesIndexed: 3,
+			fileErrors: 0,
+			instanceErrors: 0,
+			instancesIndexed: 3,
+			totalIndexEntries: 6
+		}, "instances are indexed without error");
+		let hassan = await queryEngine.cardDocument(new URL(hassanID), { loadLinks: true });
+		if (hassan?.type === "doc") {
+			assert.deepEqual(hassan.doc.data, {
+				id: rri(hassanID),
+				type: "card",
+				links: { self: "./hassan" },
+				attributes: {
+					firstName: "Hassan",
+					cardTitle: "Hassan",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./mango" },
+						data: {
+							type: "card",
+							id: mangoID
+						}
+					},
+					"friends.1": {
+						links: { self: "./vanGogh" },
+						data: {
+							type: "card",
+							id: vanGoghID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${hassanID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/hassan.json")
+				}
+			}, "hassan doc.data is correct");
+			assert.deepEqual(hassan.doc.included, [{
+				id: rri(mangoID),
+				type: "card",
+				links: { self: "./mango" },
+				attributes: {
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./hassan" },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${mangoID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/mango.json")
+				}
+			}, {
+				id: rri(vanGoghID),
+				type: "card",
+				links: { self: "./vanGogh" },
+				attributes: {
+					firstName: "Van Gogh",
+					cardTitle: "Van Gogh",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./hassan" },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${vanGoghID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/vanGogh.json")
+				}
+			}], "hassan doc.included is correct");
+		} else assert.ok(false, `search entry was an error: ${hassan?.error.errorDetail.message}`);
+		let hassanEntry = await getInstance(realm, new URL(hassanID));
+		if (hassanEntry) assert.deepEqual(hassanEntry.searchDoc, {
+			_cardType: "Friends",
+			id: hassanID,
+			firstName: "Hassan",
+			cardTitle: "Hassan",
+			friends: [{
+				id: mangoID,
+				firstName: "Mango",
+				cardTitle: "Mango",
+				friends: [{ id: hassanID }],
+				cardInfo: { theme: null }
+			}, {
+				id: vanGoghID,
+				firstName: "Van Gogh",
+				friends: [{ id: hassanID }],
+				cardTitle: "Van Gogh",
+				cardInfo: { theme: null }
+			}],
+			cardInfo: { theme: null }
+		}, "hassan searchData is correct");
+		else assert.ok(false, `could not find ${hassanID} in the index`);
+		let mango = await queryEngine.cardDocument(new URL(mangoID), { loadLinks: true });
+		if (mango?.type === "doc") {
+			assert.deepEqual(mango.doc.data, {
+				id: rri(mangoID),
+				type: "card",
+				links: { self: "./mango" },
+				attributes: {
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./hassan" },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${mangoID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/mango.json")
+				}
+			}, "mango doc.data is correct");
+			assert.deepEqual(mango.doc.included, [{
+				id: rri(hassanID),
+				type: "card",
+				links: { self: "./hassan" },
+				attributes: {
+					firstName: "Hassan",
+					cardTitle: "Hassan",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./mango" },
+						data: {
+							type: "card",
+							id: mangoID
+						}
+					},
+					"friends.1": {
+						links: { self: "./vanGogh" },
+						data: {
+							type: "card",
+							id: vanGoghID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${hassanID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/hassan.json")
+				}
+			}, {
+				id: rri(vanGoghID),
+				type: "card",
+				links: { self: "./vanGogh" },
+				attributes: {
+					firstName: "Van Gogh",
+					cardTitle: "Van Gogh",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./hassan" },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${vanGoghID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/vanGogh.json")
+				}
+			}], "mango doc.included is correct");
+		} else assert.ok(false, `search entry was an error: ${mango?.error.errorDetail.message}`);
+		let mangoEntry = await getInstance(realm, new URL(mangoID));
+		if (mangoEntry) assert.deepEqual(mangoEntry.searchDoc, {
+			_cardType: "Friends",
+			id: mangoID,
+			firstName: "Mango",
+			cardTitle: "Mango",
+			friends: [{
+				id: hassanID,
+				firstName: "Hassan",
+				cardTitle: "Hassan",
+				friends: [{ id: mangoID }, {
+					id: vanGoghID,
+					firstName: "Van Gogh",
+					cardTitle: "Van Gogh",
+					friends: [{ id: hassanID }],
+					cardInfo: { theme: null }
+				}],
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}],
+			cardInfo: { theme: null }
+		}, "mango searchData is correct");
+		else assert.ok(false, `could not find ${mangoID} in the index`);
+		let vanGogh = await queryEngine.cardDocument(new URL(vanGoghID), { loadLinks: true });
+		if (vanGogh?.type === "doc") {
+			assert.deepEqual(vanGogh.doc.data, {
+				id: rri(vanGoghID),
+				type: "card",
+				links: { self: "./vanGogh" },
+				attributes: {
+					firstName: "Van Gogh",
+					cardTitle: "Van Gogh",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./hassan" },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${vanGoghID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/vanGogh.json")
+				}
+			}, "vanGogh doc.data is correct");
+			assert.deepEqual(vanGogh.doc.included, [{
+				id: rri(hassanID),
+				type: "card",
+				links: { self: "./hassan" },
+				attributes: {
+					firstName: "Hassan",
+					cardTitle: "Hassan",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./mango" },
+						data: {
+							type: "card",
+							id: mangoID
+						}
+					},
+					"friends.1": {
+						links: { self: "./vanGogh" },
+						data: {
+							type: "card",
+							id: vanGoghID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${hassanID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/hassan.json")
+				}
+			}, {
+				id: rri(mangoID),
+				type: "card",
+				links: { self: "./mango" },
+				attributes: {
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardDescription: null,
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				relationships: {
+					"friends.0": {
+						links: { self: "./hassan" },
+						data: {
+							type: "card",
+							id: hassanID
+						}
+					},
+					"cardInfo.theme": { links: { self: null } }
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${mangoID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					},
+					resourceCreatedAt: await getFileCreatedAt(realm, "Friends/mango.json")
+				}
+			}], "vanGogh doc.included is correct");
+		} else assert.ok(false, `search entry was an error: ${vanGogh?.error.errorDetail.message}`);
+		let vanGoghEntry = await getInstance(realm, new URL(vanGoghID));
+		if (vanGoghEntry) assert.deepEqual(vanGoghEntry.searchDoc, {
+			_cardType: "Friends",
+			id: vanGoghID,
+			firstName: "Van Gogh",
+			cardTitle: "Van Gogh",
+			friends: [{
+				id: hassanID,
+				firstName: "Hassan",
+				cardTitle: "Hassan",
+				friends: [{
+					cardInfo: {
+						cardThumbnail: null,
+						theme: null
+					},
+					firstName: "Mango",
+					friends: [{ id: hassanID }],
+					id: mangoID,
+					cardTitle: "Mango"
+				}, { id: vanGoghID }],
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}],
+			cardInfo: { theme: null }
+		}, "vanGogh searchData is correct");
+		else assert.ok(false, `could not find ${vanGoghID} in the index`);
+	});
+	(0, import_qunit.test)("indexing identifies an instance's card references", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "person-1.json": { data: {
+				attributes: { firstName: "Mango" },
+				meta: { adoptsFrom: {
+					module: `${testModuleRealm}person`,
+					name: "Person"
+				} }
+			} } }
+		});
+		let refs = (await getInstance(realm, new URL(`${testRealmURL}person-1`)))?.deps;
+		assert.deepEqual(refs.sort().filter((ref) => !ref.includes("glimmer-scoped.css")), [
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/align-box-left-middle",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/align-left",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/arrow-left",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/bell",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/captions",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/clipboard-copy",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/code",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/eye",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/file",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/file-pencil",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/folder-pen",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/hash",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/image",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/import",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/letter-case",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/link",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/link-off",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/notepad-text",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/palette",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/rectangle-ellipsis",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/trash-2",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/wand",
+			"https://cardstack.com/base/-private",
+			"https://cardstack.com/base/card-api",
+			"https://cardstack.com/base/card-serialization",
+			"https://cardstack.com/base/contains-many-component",
+			"https://cardstack.com/base/default-templates/atom",
+			"https://cardstack.com/base/default-templates/broken-link-template",
+			"https://cardstack.com/base/default-templates/card-info",
+			"https://cardstack.com/base/default-templates/embedded",
+			"https://cardstack.com/base/default-templates/field-edit",
+			"https://cardstack.com/base/default-templates/file-def-edit",
+			"https://cardstack.com/base/default-templates/fitted",
+			"https://cardstack.com/base/default-templates/head",
+			"https://cardstack.com/base/default-templates/image-def-atom",
+			"https://cardstack.com/base/default-templates/image-def-embedded",
+			"https://cardstack.com/base/default-templates/image-def-fitted",
+			"https://cardstack.com/base/default-templates/image-def-isolated",
+			"https://cardstack.com/base/default-templates/isolated-and-edit",
+			"https://cardstack.com/base/default-templates/markdown",
+			"https://cardstack.com/base/default-templates/markdown-fallback",
+			"https://cardstack.com/base/default-templates/missing-template",
+			"https://cardstack.com/base/field-component",
+			"https://cardstack.com/base/field-support",
+			"https://cardstack.com/base/file-menu-items",
+			"https://cardstack.com/base/helpers/sanitized-html",
+			"https://cardstack.com/base/helpers/set-background-image",
+			"https://cardstack.com/base/links-to-editor",
+			"https://cardstack.com/base/links-to-many-component",
+			"https://cardstack.com/base/markdown-helpers",
+			"https://cardstack.com/base/menu-items",
+			"https://cardstack.com/base/number",
+			"https://cardstack.com/base/number/components/badge-counter",
+			"https://cardstack.com/base/number/components/badge-metric",
+			"https://cardstack.com/base/number/components/badge-notification",
+			"https://cardstack.com/base/number/components/gauge",
+			"https://cardstack.com/base/number/components/progress-bar",
+			"https://cardstack.com/base/number/components/progress-circle",
+			"https://cardstack.com/base/number/components/score",
+			"https://cardstack.com/base/number/components/stat",
+			"https://cardstack.com/base/number/util/index",
+			"https://cardstack.com/base/query-field-support",
+			"https://cardstack.com/base/shared-state",
+			"https://cardstack.com/base/string",
+			"https://cardstack.com/base/text-input-validator",
+			"https://cardstack.com/base/watched-array",
+			"https://localhost:4202/test/person",
+			"https://packages/@cardstack/boxel-host/commands/copy-and-edit",
+			"https://packages/@cardstack/boxel-host/commands/copy-card",
+			"https://packages/@cardstack/boxel-host/commands/copy-card-as-markdown",
+			"https://packages/@cardstack/boxel-host/commands/copy-file-to-realm",
+			"https://packages/@cardstack/boxel-host/commands/create-ai-assistant-room",
+			"https://packages/@cardstack/boxel-host/commands/generate-example-cards",
+			"https://packages/@cardstack/boxel-host/commands/open-create-listing-modal",
+			"https://packages/@cardstack/boxel-host/commands/open-in-interact-mode",
+			"https://packages/@cardstack/boxel-host/commands/patch-theme",
+			"https://packages/@cardstack/boxel-host/commands/populate-with-sample-data",
+			"https://packages/@cardstack/boxel-host/commands/send-ai-assistant-message",
+			"https://packages/@cardstack/boxel-host/commands/show-card",
+			"https://packages/@cardstack/boxel-host/commands/show-file",
+			"https://packages/@cardstack/boxel-host/commands/switch-submode",
+			"https://packages/@cardstack/boxel-ui/components",
+			"https://packages/@cardstack/boxel-ui/helpers",
+			"https://packages/@cardstack/boxel-ui/icons",
+			"https://packages/@cardstack/boxel-ui/modifiers",
+			"https://packages/@cardstack/runtime-common",
+			"https://packages/@cardstack/runtime-common/marked-sync",
+			"https://packages/@ember/component",
+			"https://packages/@ember/component/template-only",
+			"https://packages/@ember/helper",
+			"https://packages/@ember/modifier",
+			"https://packages/@ember/object",
+			"https://packages/@ember/object/internals",
+			"https://packages/@ember/runloop",
+			"https://packages/@ember/template",
+			"https://packages/@ember/template-factory",
+			"https://packages/@glimmer/component",
+			"https://packages/@glimmer/tracking",
+			"https://packages/ember-concurrency",
+			"https://packages/ember-concurrency/-private/async-arrow-runtime",
+			"https://packages/ember-css-url",
+			"https://packages/ember-modifier",
+			"https://packages/ember-provide-consume-context",
+			"https://packages/lodash",
+			"https://packages/super-fast-md5",
+			"https://packages/tracked-built-ins"
+		], "the card references for the instance are correct");
+	});
+	(0, import_qunit.test)("indexing identifies an instance's polymorphic contained references", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "spec-1.json": { data: {
+				attributes: {
+					cardTitle: "My Spec",
+					containedExamples: [{
+						firstName: "A",
+						lastName: "B"
+					}]
+				},
+				meta: {
+					adoptsFrom: {
+						module: `${baseRealm.url}spec`,
+						name: "Spec"
+					},
+					fields: { containedExamples: [{ adoptsFrom: {
+						module: `${testModuleRealm}person`,
+						name: "PersonField"
+					} }] }
+				}
+			} } }
+		});
+		let refs = (await getInstance(realm, new URL(`${realm.url}spec-1`)))?.deps;
+		assert.deepEqual(refs.sort().filter((ref) => !ref.includes("glimmer-scoped.css")), [
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/align-box-left-middle",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/align-left",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/apps",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/arrow-left",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/bell",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/book-open-text",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/box-model",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/captions",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/clipboard-copy",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/code",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/eye",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/file",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/file-pencil",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/folder-pen",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/git-branch",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/hash",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/image",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/import",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/layers-subtract",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/layout-list",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/letter-case",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/link",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/link-off",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/notepad-text",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/palette",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/rectangle-ellipsis",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/stack",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/toggle-left",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/trash-2",
+			"http://localhost:4206/@cardstack/boxel-icons/v1/icons/wand",
+			"https://cardstack.com/base/-private",
+			"https://cardstack.com/base/boolean",
+			"https://cardstack.com/base/card-api",
+			"https://cardstack.com/base/card-serialization",
+			"https://cardstack.com/base/code-ref",
+			"https://cardstack.com/base/contains-many-component",
+			"https://cardstack.com/base/default-templates/atom",
+			"https://cardstack.com/base/default-templates/broken-link-template",
+			"https://cardstack.com/base/default-templates/card-info",
+			"https://cardstack.com/base/default-templates/embedded",
+			"https://cardstack.com/base/default-templates/field-edit",
+			"https://cardstack.com/base/default-templates/file-def-edit",
+			"https://cardstack.com/base/default-templates/fitted",
+			"https://cardstack.com/base/default-templates/head",
+			"https://cardstack.com/base/default-templates/image-def-atom",
+			"https://cardstack.com/base/default-templates/image-def-embedded",
+			"https://cardstack.com/base/default-templates/image-def-fitted",
+			"https://cardstack.com/base/default-templates/image-def-isolated",
+			"https://cardstack.com/base/default-templates/isolated-and-edit",
+			"https://cardstack.com/base/default-templates/markdown",
+			"https://cardstack.com/base/default-templates/markdown-fallback",
+			"https://cardstack.com/base/default-templates/missing-template",
+			"https://cardstack.com/base/field-component",
+			"https://cardstack.com/base/field-support",
+			"https://cardstack.com/base/file-menu-items",
+			"https://cardstack.com/base/helpers/sanitized-html",
+			"https://cardstack.com/base/helpers/set-background-image",
+			"https://cardstack.com/base/links-to-editor",
+			"https://cardstack.com/base/links-to-many-component",
+			"https://cardstack.com/base/markdown",
+			"https://cardstack.com/base/markdown-helpers",
+			"https://cardstack.com/base/menu-items",
+			"https://cardstack.com/base/number",
+			"https://cardstack.com/base/number/components/badge-counter",
+			"https://cardstack.com/base/number/components/badge-metric",
+			"https://cardstack.com/base/number/components/badge-notification",
+			"https://cardstack.com/base/number/components/gauge",
+			"https://cardstack.com/base/number/components/progress-bar",
+			"https://cardstack.com/base/number/components/progress-circle",
+			"https://cardstack.com/base/number/components/score",
+			"https://cardstack.com/base/number/components/stat",
+			"https://cardstack.com/base/number/util/index",
+			"https://cardstack.com/base/query-field-support",
+			"https://cardstack.com/base/shared-state",
+			"https://cardstack.com/base/spec",
+			"https://cardstack.com/base/string",
+			"https://cardstack.com/base/text-input-validator",
+			"https://cardstack.com/base/watched-array",
+			"https://localhost:4202/test/person",
+			"https://packages/@cardstack/boxel-host/commands/copy-and-edit",
+			"https://packages/@cardstack/boxel-host/commands/copy-card",
+			"https://packages/@cardstack/boxel-host/commands/copy-card-as-markdown",
+			"https://packages/@cardstack/boxel-host/commands/copy-file-to-realm",
+			"https://packages/@cardstack/boxel-host/commands/create-ai-assistant-room",
+			"https://packages/@cardstack/boxel-host/commands/generate-example-cards",
+			"https://packages/@cardstack/boxel-host/commands/generate-readme-spec",
+			"https://packages/@cardstack/boxel-host/commands/open-create-listing-modal",
+			"https://packages/@cardstack/boxel-host/commands/open-in-interact-mode",
+			"https://packages/@cardstack/boxel-host/commands/patch-theme",
+			"https://packages/@cardstack/boxel-host/commands/populate-with-sample-data",
+			"https://packages/@cardstack/boxel-host/commands/send-ai-assistant-message",
+			"https://packages/@cardstack/boxel-host/commands/show-card",
+			"https://packages/@cardstack/boxel-host/commands/show-file",
+			"https://packages/@cardstack/boxel-host/commands/switch-submode",
+			"https://packages/@cardstack/boxel-ui/components",
+			"https://packages/@cardstack/boxel-ui/helpers",
+			"https://packages/@cardstack/boxel-ui/icons",
+			"https://packages/@cardstack/boxel-ui/modifiers",
+			"https://packages/@cardstack/runtime-common",
+			"https://packages/@cardstack/runtime-common/marked-sync",
+			"https://packages/@ember/component",
+			"https://packages/@ember/component/template-only",
+			"https://packages/@ember/helper",
+			"https://packages/@ember/modifier",
+			"https://packages/@ember/object",
+			"https://packages/@ember/object/internals",
+			"https://packages/@ember/runloop",
+			"https://packages/@ember/template",
+			"https://packages/@ember/template-factory",
+			"https://packages/@glimmer/component",
+			"https://packages/@glimmer/tracking",
+			"https://packages/ember-concurrency",
+			"https://packages/ember-concurrency/-private/async-arrow-runtime",
+			"https://packages/ember-css-url",
+			"https://packages/ember-modifier",
+			"https://packages/ember-provide-consume-context",
+			"https://packages/ember-resources",
+			"https://packages/lodash",
+			"https://packages/super-fast-md5",
+			"https://packages/tracked-built-ins"
+		], "the card references for the instance are correct");
+	});
+	(0, import_qunit.test)("search index does not contain entries that match patterns in ignore files", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"ignore-me-1.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"posts/nested.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"posts/please-ignore-me.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"posts/ignore-me-2.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				".git/should-not-index.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"post.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"dir/card.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				".gitignore": `
+ignore-me*.json
+dir/
+posts/please-ignore-me.json
+      `
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}posts/please-ignore-me`));
+			assert.deepEqual(card, void 0, "instance does not exist because file is ignored");
+		}
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}dir/card`));
+			assert.deepEqual(card, void 0, "instance does not exist because file is ignored");
+		}
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}ignore-me-1`));
+			assert.deepEqual(card, void 0, "instance does not exist because file is ignored");
+		}
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}posts/ignore-me-2`));
+			assert.deepEqual(card, void 0, "instance does not exist because file is ignored");
+		}
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}.git/should-not-index`));
+			assert.strictEqual(card, void 0, ".git directory entries are ignored");
+		}
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}post`));
+			assert.ok(card, "instance exists");
+		}
+		{
+			let card = await indexer.cardDocument(new URL(`${testRealmURL}posts/nested`));
+			assert.ok(card, "instance exists");
+		}
+	});
+	(0, import_qunit.test)("incremental indexing doesn't process ignored files", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"posts/ignore-me.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				".gitignore": `
+posts/ignore-me.json
+      `
+			}
+		});
+		let realmIndexUpdater = realm.realmIndexUpdater;
+		let queryEngine = realm.realmIndexQueryEngine;
+		await realmIndexUpdater.update([new URL(`${testRealmURL}posts/ignore-me.json`)]);
+		let instance = await queryEngine.cardDocument(new URL(`${testRealmURL}posts/ignore-me`));
+		assert.strictEqual(instance, void 0, "instance does not exist because file is ignored");
+		assert.strictEqual(realmIndexUpdater.stats.instancesIndexed, 0, "no instances were processed");
+	});
+	(0, import_qunit.test)("isolated HTML for the default CardsGrid realm-index card is replaced with the boilerplate when realm has not opted in", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"index.json": { data: {
+					type: "card",
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/cards-grid",
+						name: "CardsGrid"
+					} }
+				} },
+				"realm.json": { data: {
+					type: "card",
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/realm-config",
+						name: "RealmConfig"
+					} }
+				} }
+			}
+		});
+		let entry = await getInstance(realm, new URL(`${testRealmURL}index`));
+		assert.ok(entry, "realm index card is indexed");
+		assert.strictEqual(entry?.isolatedHtml, REALM_INDEX_BOILERPLATE_HTML, "isolated_html is the boilerplate constant when the realm has not opted in");
+		let embeddedHtml = entry?.embeddedHtml ?? {};
+		assert.ok(Object.keys(embeddedHtml).length > 0, "embedded HTML map is populated");
+		assert.ok(Object.values(embeddedHtml).every((html) => html.length > 0), "every embedded HTML entry has real content");
+		let fittedHtml = entry?.fittedHtml ?? {};
+		assert.ok(Object.keys(fittedHtml).length > 0, "fitted HTML map is populated");
+		assert.ok(Object.values(fittedHtml).every((html) => html.length > 0), "every fitted HTML entry has real content");
+	});
+	(0, import_qunit.test)("isolated HTML for the default CardsGrid realm-index card is rendered normally when realm has opted in", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"index.json": { data: {
+					type: "card",
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/cards-grid",
+						name: "CardsGrid"
+					} }
+				} },
+				"realm.json": { data: {
+					type: "card",
+					attributes: { includePrerenderedDefaultRealmIndex: true },
+					meta: { adoptsFrom: {
+						module: "https://cardstack.com/base/realm-config",
+						name: "RealmConfig"
+					} }
+				} }
+			}
+		});
+		let entry = await getInstance(realm, new URL(`${testRealmURL}index`));
+		assert.ok(entry, "realm index card is indexed");
+		assert.notStrictEqual(entry?.isolatedHtml, REALM_INDEX_BOILERPLATE_HTML, "isolated_html is not the boilerplate when the realm has opted in");
+		assert.ok(entry?.isolatedHtml, "isolated_html is set");
+		assert.ok((entry?.isolatedHtml ?? "").length > 0, "isolated_html has real content");
+	});
+	(0, import_qunit.test)("isolated HTML for a non-CardsGrid index card is rendered normally regardless of opt-in", async function(assert) {
+		class PlainHomePage extends CardDef {
+			static displayName = "Plain Home Page";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static isolated = class Isolated extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "WwNp1MCh",
+						"block": "[[[10,\"h1\"],[14,\"data-test-plain-home\",\"\"],[12],[8,[30,1,[\"title\"]],null,null,null],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-indexing-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"home.gts": { PlainHomePage },
+				"index.json": { data: {
+					type: "card",
+					attributes: { title: "Welcome" },
+					meta: { adoptsFrom: {
+						module: `${testRealmURL}home`,
+						name: "PlainHomePage"
+					} }
+				} }
+			}
+		});
+		let entry = await getInstance(realm, new URL(`${testRealmURL}index`));
+		assert.ok(entry, "realm index card is indexed");
+		assert.notStrictEqual(entry?.isolatedHtml, REALM_INDEX_BOILERPLATE_HTML, "isolated_html is not the boilerplate when the index is a non-CardsGrid card");
+		assertInnerHtmlMatches(assert, entry?.isolatedHtml, `<h1 data-test-plain-home> Welcome </h1>`);
+	});
+});
+//#endregion