@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/realm-indexing-test-DSFn2F8F.js

@@ -0,0 +1,4380 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, Dr as testRRI, di as DEFAULT_ANONYMOUS_RATE_LIMIT, it as diffDoc, nc as init_md5_esm_bundler, rc as md5, u as internalKeyFor, uo as SupportedMimeType } from "./runtime-common-ClpqhbwG.js";
+import { v as ri, y as rri } from "./paths-BYHDgqsT.js";
+import { C as baseCardRef, J as skillCardRef, O as baseRealmRRI } from "./constants-CqKWhRfY.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { s as REALM_INDEX_BOILERPLATE_HTML } from "./card-prerender-Dke537bN.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, H as testModuleRealm, M as setupCardLogs, P as setupIntegrationTestRealm, V as testModuleRRI, d as cardInfo, lt as setupRenderingTest, p as cleanWhiteSpace, t as setupMockMatrix, x as getFileCreatedAt } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, H as linksTo, T as containsMany, U as linksToMany, a as CardDef, l as FieldDef, s as Component$1, w as contains } from "./card-api-Dzje0smT.js";
+import { t as DateTimeField } from "./datetime-BEbR9YgU.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+import { t as NumberField } from "./number-DZa-fHpu.js";
+import { t as searchCardsForTest } from "./search-cards-O_RNz8_i.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);
+}
+function expectSearchDoc(assert, actual, expected, message) {
+	assert.deepEqual(diffDoc(expected, actual ?? {}, false), [], message ?? "indexed search doc matches the searchable-driven generator");
+}
+(0, import_qunit.module)(`Integration | realm indexing`, function(hooks) {
+	setupRenderingTest(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/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: "@cardstack/base/card-api",
+				name: "CardDef"
+			} } } } }
+		});
+		let queryEngine = realm.realmIndexQueryEngine;
+		let { data: cards } = await searchCardsForTest(queryEngine, { filter: { type: baseCardRef } });
+		assert.deepEqual(cards, [{
+			id: testRRI("empty"),
+			type: "card",
+			attributes: {
+				cardInfo,
+				cardTitle: "Untitled Card",
+				cardDescription: null,
+				cardThumbnailURL: null
+			},
+			meta: {
+				adoptsFrom: {
+					module: rri("@cardstack/base/card-api"),
+					name: "CardDef"
+				},
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+					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(`${baseRealmRRI}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: "@cardstack/base/card-api",
+					name: "CardDef"
+				} } } },
+				"test2.json": { data: { meta: { adoptsFrom: {
+					module: "@cardstack/base/card-api",
+					name: "CardDef"
+				} } } },
+				"pet.gts": `
+          import { contains, field, CardDef } from "@cardstack/base/card-api";
+          import StringField from "@cardstack/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("@cardstack/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: `${testModuleRealm}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 === `${testRealmURL}Person/owner.json` || dep === `${testRealmURL}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(`${testModuleRealm}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` } } },
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}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: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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: `${testModuleRealm}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(`${testModuleRealm}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
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}pet`),
+						name: "Pet"
+					},
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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
+					},
+					meta: {
+						adoptsFrom: {
+							module: rri(`${testModuleRealm}pet`),
+							name: "Pet"
+						},
+						realmURL: ri("http://test-realm/test/"),
+						realmInfo: {
+							anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+							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: `${testModuleRealm}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(`${testModuleRealm}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: `${testModuleRealm}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: `${testModuleRealm}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: `${testModuleRealm}pet`,
+					name: "Pet"
+				} }
+			} } }
+		});
+		await realm.write("Pet/mango.json", JSON.stringify({ data: {
+			id: testRRI("Pet/mango"),
+			attributes: { firstName: "Van Gogh" },
+			meta: { adoptsFrom: {
+				module: rri(`${testModuleRealm}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: `${testModuleRealm}person`,
+						name: "Person"
+					} }
+				} },
+				"Pet/mango.json": { data: {
+					id: `${testRealmURL}Pet/mango`,
+					attributes: { firstName: "Mango" },
+					relationships: { owner: { links: { self: `../Person/owner` } } },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}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` } } },
+			meta: {
+				adoptsFrom: {
+					module: rri(`${testModuleRealm}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: {
+					anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+					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: `${testModuleRealm}person`,
+						name: "Person"
+					} }
+				} },
+				"Pet/mango.json": { data: {
+					id: `${testRealmURL}Pet/mango`,
+					attributes: { firstName: "Mango" },
+					relationships: { owner: { links: { self: `../Person/owner` } } },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}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` } } },
+			meta: {
+				adoptsFrom: {
+					module: rri(`${testModuleRealm}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: {
+					anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+					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(string_default);
+				});
+			}
+			#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: "@cardstack/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,
+					isFile: false,
+					cardThumbnailURL: null,
+					ref: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					},
+					containedExamples: [],
+					cardInfo
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("@cardstack/base/spec"),
+						name: "Spec"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}person-spec.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "person-spec.json"),
+					realmURL: testRealmURL,
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			expectSearchDoc(assert, (await indexer.instance(new URL(`${testRealmURL}person-spec`)))?.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,
+				fileExamples: null,
+				isCard: true,
+				isComponent: false,
+				isField: false,
+				isFile: false,
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					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(string_default);
+				});
+			}
+			#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: "@cardstack/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,
+					isFile: false,
+					cardThumbnailURL: null,
+					ref: {
+						module: `${testRealmURL}person`,
+						name: "Person"
+					},
+					containedExamples: [],
+					cardInfo
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri("@cardstack/base/spec"),
+						name: "Spec"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}person-spec.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "person-spec.json"),
+					realmURL: testRealmURL,
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			expectSearchDoc(assert, (await indexer.instance(new URL(`${testRealmURL}person-spec`)))?.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,
+				fileExamples: null,
+				isCard: true,
+				isComponent: false,
+				isField: false,
+				isFile: false,
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					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",
+						definition: null
+					}],
+					cardDescription: null,
+					instructions: "How to win friends and influence people",
+					cardThumbnailURL: null,
+					cardTitle: null,
+					cardInfo
+				},
+				meta: {
+					adoptsFrom: skillCardRef,
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}people-skill.json`),
+					resourceCreatedAt: await getFileCreatedAt(realm, "people-skill.json"),
+					realmURL: testRealmURL,
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						backgroundURL: null,
+						iconURL: null,
+						includePrerenderedDefaultRealmIndex: null,
+						lastPublishedAt: null,
+						name: "Unnamed Workspace",
+						publishable: null,
+						realmUserId: "@realm_server:localhost",
+						showAsCatalog: null,
+						visibility: "public"
+					}
+				}
+			});
+			expectSearchDoc(assert, (await indexer.instance(new URL(`${testRealmURL}people-skill`)))?.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",
+					definition: null
+				}],
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					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(string_default);
+					});
+				}
+				#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(string_default);
+					});
+				}
+				#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");
+					let errorDeps = entry.error.errorDetail.deps ?? [];
+					assert.ok(errorDeps.includes(`${testRealmURL}boom`), "error deps include the card's own module");
+					assert.ok(errorDeps.some((dep) => /@cardstack\/base\/default-templates\/embedded\.gts.*\.glimmer-scoped\.css$/.test(dep)), "error deps include transitive render dependencies (the full closure)");
+				} 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(`${testRealmURL}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(`${testRealmURL}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(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(`${testRealmURL}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(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(`${testRealmURL}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(string_default);
+				});
+			}
+			#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(`${testRealmURL}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"
+			},
+			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(string_default);
+				});
+			}
+			#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(`${testRealmURL}vangogh`)) ?? {};
+		expectSearchDoc(assert, searchDoc, {
+			_cardType: "Person",
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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(string_default);
+				});
+			}
+			#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(`${testRealmURL}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(string_default);
+				});
+			}
+			#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(`${testRealmURL}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(string_default);
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(`${testRealmURL}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
+          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)].sort(), [
+			`${testRealmURL}fancy-person/FancyPerson`,
+			`${testRealmURL}person/Person`,
+			cardDefRefURL
+		].sort(), "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
+        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
+        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(string_default);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(`${testRealmURL}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
+          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)].sort(), [
+			`${testRealmURL}fancy-person/FancyPerson`,
+			`${testRealmURL}person/Person`,
+			cardDefRefURL
+		].sort(), "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
+      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
+      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(string_default);
+				});
+			}
+			#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(string_default, { computeVia: function() {
+						return this.firstName;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+		}
+		class Appointment extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(string_default, { computeVia: function() {
+						return this.firstName;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardThumbnailURL", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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",
+						cardTitle: "Burcu"
+					}
+				},
+				cardDescription: "Dog",
+				cardThumbnailURL: `./jackie.jpg`,
+				cardInfo
+			});
+			assert.deepEqual(card.doc.data.relationships, { "appointment.contact.pet": { links: { self: `./mango` } } });
+		} 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: `${testModuleRealm}vendor`,
+						name: "Vendor"
+					} }
+				} },
+				"Chain/1.json": { data: {
+					id: `${testRealmURL}Chain/1`,
+					attributes: { name: "Ethereum Mainnet" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}chain`,
+						name: "Chain"
+					} }
+				} },
+				"Chain/2.json": { data: {
+					id: `${testRealmURL}Chain/2`,
+					attributes: { name: "Polygon" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}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` }
+					}
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}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: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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: `./1` },
+				attributes: {
+					name: "Ethereum Mainnet",
+					cardTitle: "Ethereum Mainnet",
+					chainId: 1,
+					cardDescription: `Chain 1`,
+					cardThumbnailURL: `Ethereum Mainnet-icon.png`,
+					cardInfo
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}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: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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: `./2` },
+				attributes: {
+					name: "Polygon",
+					cardTitle: "Polygon",
+					chainId: 137,
+					cardDescription: `Chain 137`,
+					cardThumbnailURL: `Polygon-icon.png`,
+					cardInfo
+				},
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}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: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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: `${testModuleRealm}card-with-error`,
+						name: "Boom"
+					} }
+				} },
+				"Person/owner.json": { data: {
+					id: `${testRealmURL}Person/owner`,
+					attributes: { firstName: "Hassan" },
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}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: `${testModuleRealm}person`,
+						name: "Person"
+					} }
+				} }
+			}
+		});
+		expectSearchDoc(assert, (await getInstance(realm, new URL(`${testRealmURL}Person/hassan`)))?.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",
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				theme: null
+			}
+		}, `search doc includes fullName field`);
+	});
+	(0, import_qunit.test)(`search doc includes a 'linksTo' field the render never loaded when it is searchable`, 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: `${testModuleRealm}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: `${testModuleRealm}post`,
+						name: "Post"
+					} }
+				} }
+			}
+		});
+		expectSearchDoc(assert, (await getInstance(realm, new URL(`${testRealmURL}Post/1`)))?.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,
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				theme: null
+			}
+		}, `post 1 search doc includes publication relationship`);
+		expectSearchDoc(assert, (await getInstance(realm, new URL(`${testRealmURL}Publication/pacific`)))?.searchDoc, {
+			_cardType: "Publication",
+			id: `${testRealmURL}Publication/pacific`,
+			cardTitle: "Pacific Weekly",
+			featuredPosts: [{
+				author: {
+					cardDescription: "Person",
+					fullName: " ",
+					cardTitle: " "
+				},
+				cardTheme: null,
+				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: " "
+				},
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				},
+				id: `${testRealmURL}Post/2`,
+				publication: { id: `${testRealmURL}Publication/pacific` },
+				cardTitle: "49 Shades of Mauve",
+				views: 24
+			}],
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				theme: null
+			}
+		}, `publication search doc includes featuredPosts relationship via its searchable annotation`);
+	});
+	(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(string_default);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "email", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default, { computeVia: function() {
+						return `${this.firstName ?? ""} ${this.lastName ?? ""}`;
+					} });
+				});
+			}
+			#fullName = (initializeDeferredDecorator(this, "fullName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default, { computeVia: function() {
+						return `${this.firstName ?? ""} ${this.lastName ?? ""}`;
+					} });
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(string_default, { computeVia: () => "Person" });
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+		}
+		class Post extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardDescription", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "venue", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#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(string_default);
+				});
+			}
+			#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(string_default, { computeVia: function() {
+						return this.venue;
+					} });
+				});
+			}
+			#cardDescription = (initializeDeferredDecorator(this, "cardDescription"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardThumbnailURL", [field], function() {
+					return contains(string_default, { 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: `${testModuleRealm}booking`,
+							name: "Booking"
+						}
+					},
+					meta: { adoptsFrom: {
+						module: "@cardstack/base/spec",
+						name: "Spec"
+					} }
+				} }
+			}
+		});
+		let entry = await getInstance(realm, new URL(`${testRealmURL}Spec/booking`));
+		expectSearchDoc(assert, entry?.searchDoc, {
+			_cardType: "Spec",
+			id: `${testRealmURL}Spec/booking`,
+			cardDescription: "Spec for Booking",
+			specType: "card",
+			moduleHref: `${testModuleRealm}booking`,
+			containedExamples: null,
+			linkedExamples: null,
+			fileExamples: null,
+			ref: `${testModuleRealm}booking/Booking`,
+			cardTitle: "Booking",
+			isCard: true,
+			isComponent: false,
+			isField: false,
+			isFile: false,
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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: {
+					"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"
+						}
+					}
+				},
+				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: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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: `./mango` },
+				attributes: {
+					cardDescription: null,
+					firstName: "Mango",
+					cardTitle: "Mango",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				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: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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: `./vanGogh` },
+				attributes: {
+					cardDescription: null,
+					firstName: "Van Gogh",
+					cardTitle: "Van Gogh",
+					cardThumbnailURL: null,
+					cardInfo
+				},
+				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: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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) expectSearchDoc(assert, hassanEntry.searchDoc, {
+			_cardType: "Pet Person",
+			id: `${testRealmURL}PetPerson/hassan`,
+			firstName: "Hassan",
+			pets: [{
+				id: `${testRealmURL}Pet/mango`,
+				firstName: "Mango",
+				owner: null,
+				cardTitle: "Mango",
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}, {
+				id: `${testRealmURL}Pet/vanGogh`,
+				firstName: "Van Gogh",
+				owner: null,
+				cardTitle: "Van Gogh",
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}],
+			friend: null,
+			cardTitle: "Hassan Pet Person",
+			cardDescription: "A person with pets",
+			cardThumbnailURL: null,
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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" },
+				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
+			},
+			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: {
+					anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+					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) expectSearchDoc(assert, 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,
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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: "@cardstack/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,
+				isFile: false,
+				cardInfo
+			},
+			meta: {
+				adoptsFrom: {
+					module: rri("@cardstack/base/spec"),
+					name: "Spec"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}pet-person-spec.json`),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+					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) expectSearchDoc(assert, entry.searchDoc, {
+			_cardType: "Spec",
+			id: `${testRealmURL}pet-person-spec`,
+			cardTitle: "PetPerson",
+			cardDescription: "Spec for PetPerson",
+			containedExamples: null,
+			linkedExamples: null,
+			fileExamples: null,
+			moduleHref: `${testModuleRealm}pet-person`,
+			ref: `${testModuleRealm}pet-person/PetPerson`,
+			specType: "card",
+			isCard: true,
+			isComponent: false,
+			isField: false,
+			isFile: false,
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				theme: null
+			}
+		});
+		else assert.ok(false, `could not find ${testRealmURL}pet-person-spec in the index`);
+	});
+	(0, import_qunit.test)("can index a card whose contained field has a query-backed link driven by a computed in that same field", async function(assert) {
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class Note extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "body", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#body = (initializeDeferredDecorator(this, "body"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "mentionedIds", [field], function() {
+					return containsMany(string_default, { computeVia: function() {
+						return (this.body ?? "").split(/\s+/).filter((word) => word.startsWith("@")).map((word) => `${testRealmURL}Pet/${word.slice(1)}`);
+					} });
+				});
+			}
+			#mentionedIds = (initializeDeferredDecorator(this, "mentionedIds"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "mentioned", [field], function() {
+					return linksToMany(() => Pet, { query: { filter: { in: { id: "$this.mentionedIds" } } } });
+				});
+			}
+			#mentioned = (initializeDeferredDecorator(this, "mentioned"), void 0);
+		}
+		class Post extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "note", [field], function() {
+					return contains(Note);
+				});
+			}
+			#note = (initializeDeferredDecorator(this, "note"), void 0);
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"test-cards.gts": {
+					Pet,
+					Note,
+					Post
+				},
+				"Pet/mango.json": { data: {
+					attributes: { name: "Mango" },
+					meta: { adoptsFrom: {
+						module: "../test-cards",
+						name: "Pet"
+					} }
+				} },
+				"post-1.json": { data: {
+					attributes: { note: { body: "hello @mango" } },
+					meta: { adoptsFrom: {
+						module: "./test-cards",
+						name: "Post"
+					} }
+				} }
+			}
+		});
+		let post = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}post-1`), { loadLinks: true });
+		if (post?.type === "doc") {
+			assert.deepEqual(post.doc.data.attributes?.note?.mentionedIds, [`${testRealmURL}Pet/mango`], "the computed declared inside the contained field is in the indexed document");
+			let mentioned = post.doc.data.relationships?.["note.mentioned"];
+			assert.ok(mentioned?.links?.search?.startsWith(`${testRealmURL}_search?`), `the query-backed link carries links.search (got ${JSON.stringify(mentioned?.links)})`);
+			assert.deepEqual(mentioned?.data, [{
+				type: "card",
+				id: `${testRealmURL}Pet/mango`
+			}], "the query resolved the mentioned card");
+		} else assert.ok(false, `search entry was an error: ${post?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("a computed linksToMany serializes into the indexed document", async function(assert) {
+		class Issue extends CardDef {
+			static displayName = "Issue";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+		}
+		class IssueTracker extends CardDef {
+			static displayName = "IssueTracker";
+			static {
+				decorateFieldV2(this.prototype, "directIssues", [field], function() {
+					return linksToMany(() => Issue);
+				});
+			}
+			#directIssues = (initializeDeferredDecorator(this, "directIssues"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "localCards", [field], function() {
+					return linksToMany(() => Issue, { computeVia: function() {
+						return this.directIssues;
+					} });
+				});
+			}
+			#localCards = (initializeDeferredDecorator(this, "localCards"), void 0);
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"test-cards.gts": {
+					Issue,
+					IssueTracker
+				},
+				"Issue/issue-1.json": { data: {
+					attributes: { title: "First" },
+					meta: { adoptsFrom: {
+						module: "../test-cards",
+						name: "Issue"
+					} }
+				} },
+				"Issue/issue-2.json": { data: {
+					attributes: { title: "Second" },
+					meta: { adoptsFrom: {
+						module: "../test-cards",
+						name: "Issue"
+					} }
+				} },
+				"Issue/issue-3.json": { data: {
+					attributes: { title: "Third" },
+					meta: { adoptsFrom: {
+						module: "../test-cards",
+						name: "Issue"
+					} }
+				} }
+			}
+		});
+		let issueIds = [
+			`${testRealmURL}Issue/issue-1`,
+			`${testRealmURL}Issue/issue-2`,
+			`${testRealmURL}Issue/issue-3`
+		];
+		await realm.write("board-1.json", JSON.stringify({ data: {
+			relationships: {
+				"directIssues.0": { links: { self: "./Issue/issue-1" } },
+				"directIssues.1": { links: { self: "./Issue/issue-2" } },
+				"directIssues.2": { links: { self: "./Issue/issue-3" } }
+			},
+			meta: { adoptsFrom: {
+				module: "./test-cards",
+				name: "IssueTracker"
+			} }
+		} }));
+		let board = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}board-1`), { loadLinks: true });
+		if (board?.type === "doc") {
+			let relationships = board.doc.data.relationships ?? {};
+			let linksFor = (prefix) => Object.keys(relationships).filter((key) => new RegExp(`^${prefix}\\.\\d+$`).test(key)).map((key) => relationships[key].links?.self).filter(Boolean).map((self) => new URL(self, `${testRealmURL}board-1`).href).sort();
+			assert.deepEqual(linksFor("directIssues"), issueIds, "the authored directIssues relationship serializes");
+			assert.deepEqual(linksFor("localCards"), issueIds, "the computed localCards relationship serializes");
+		} else assert.ok(false, `board search entry was an error: ${board?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("a computed link that resolves to nothing is omitted from the indexed document", async function(assert) {
+		class Tag extends CardDef {
+			static displayName = "Tag";
+			static {
+				decorateFieldV2(this.prototype, "label", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#label = (initializeDeferredDecorator(this, "label"), void 0);
+		}
+		class Board extends CardDef {
+			static displayName = "Board";
+			static {
+				decorateFieldV2(this.prototype, "tags", [field], function() {
+					return linksToMany(() => Tag);
+				});
+			}
+			#tags = (initializeDeferredDecorator(this, "tags"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "activeTags", [field], function() {
+					return linksToMany(() => Tag, { computeVia: function() {
+						return this.tags;
+					} });
+				});
+			}
+			#activeTags = (initializeDeferredDecorator(this, "activeTags"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "primaryTag", [field], function() {
+					return linksTo(() => Tag, { computeVia: function() {
+						return this.tags[0];
+					} });
+				});
+			}
+			#primaryTag = (initializeDeferredDecorator(this, "primaryTag"), void 0);
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: { "test-cards.gts": {
+				Tag,
+				Board
+			} }
+		});
+		await realm.write("board-empty.json", JSON.stringify({ data: { meta: { adoptsFrom: {
+			module: "./test-cards",
+			name: "Board"
+		} } } }));
+		let board = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}board-empty`), { loadLinks: true });
+		if (board?.type === "doc") assert.strictEqual(board.doc.data.relationships, void 0, "a card whose only links are empty computeds carries no relationships key (empty computeds omitted, the leftover `{}` stripped)");
+		else assert.ok(false, `board search entry was an error: ${board?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("a computed that reduces over a query-backed relationship is omitted from the indexed document", async function(assert) {
+		const issueRef = {
+			module: rri(`${testRealmURL}test-cards`),
+			name: "Issue"
+		};
+		class Issue extends CardDef {
+			static displayName = "Issue";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "project", [field], function() {
+					return linksTo(() => Project);
+				});
+			}
+			#project = (initializeDeferredDecorator(this, "project"), void 0);
+		}
+		class Project extends CardDef {
+			static displayName = "Project";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "issues", [field], function() {
+					return linksToMany(() => Issue, { query: { filter: {
+						on: issueRef,
+						eq: { "project.id": "$this.id" }
+					} } });
+				});
+			}
+			#issues = (initializeDeferredDecorator(this, "issues"), void 0);
+		}
+		class IssueTracker extends CardDef {
+			static displayName = "IssueTracker";
+			static {
+				decorateFieldV2(this.prototype, "project", [field], function() {
+					return linksTo(() => Project);
+				});
+			}
+			#project = (initializeDeferredDecorator(this, "project"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "directIssues", [field], function() {
+					return linksToMany(() => Issue);
+				});
+			}
+			#directIssues = (initializeDeferredDecorator(this, "directIssues"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "localCards", [field], function() {
+					return linksToMany(() => Issue, { computeVia: function() {
+						return this.directIssues;
+					} });
+				});
+			}
+			#localCards = (initializeDeferredDecorator(this, "localCards"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cards", [field], function() {
+					return linksToMany(() => Issue, { computeVia: function() {
+						return this.project?.issues;
+					} });
+				});
+			}
+			#cards = (initializeDeferredDecorator(this, "cards"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardCount", [field], function() {
+					return contains(NumberField, { computeVia: function() {
+						return this.cards.length;
+					} });
+				});
+			}
+			#cardCount = (initializeDeferredDecorator(this, "cardCount"), void 0);
+		}
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"test-cards.gts": {
+					Issue,
+					Project,
+					IssueTracker
+				},
+				"Project/proj-1.json": { data: {
+					attributes: { name: "Nexus" },
+					meta: { adoptsFrom: {
+						module: "../test-cards",
+						name: "Project"
+					} }
+				} },
+				"Issue/issue-1.json": { data: {
+					attributes: { title: "First" },
+					relationships: { project: { links: { self: "../Project/proj-1" } } },
+					meta: { adoptsFrom: {
+						module: "../test-cards",
+						name: "Issue"
+					} }
+				} },
+				"Issue/issue-2.json": { data: {
+					attributes: { title: "Second" },
+					relationships: { project: { links: { self: "../Project/proj-1" } } },
+					meta: { adoptsFrom: {
+						module: "../test-cards",
+						name: "Issue"
+					} }
+				} }
+			}
+		});
+		let issueIds = [`${testRealmURL}Issue/issue-1`, `${testRealmURL}Issue/issue-2`];
+		let project = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}Project/proj-1`), { loadLinks: true });
+		assert.deepEqual(project?.type === "doc" ? project.doc.data.relationships?.issues?.data?.map((d) => d.id).sort() : void 0, issueIds, "the query-backed Project.issues resolves both issues");
+		await realm.write("board-1.json", JSON.stringify({ data: {
+			relationships: {
+				project: { links: { self: "./Project/proj-1" } },
+				"directIssues.0": { links: { self: "./Issue/issue-1" } },
+				"directIssues.1": { links: { self: "./Issue/issue-2" } }
+			},
+			meta: { adoptsFrom: {
+				module: "./test-cards",
+				name: "IssueTracker"
+			} }
+		} }));
+		let board = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}board-1`), { loadLinks: true });
+		if (board?.type === "doc") {
+			let relationships = board.doc.data.relationships ?? {};
+			let linksFor = (prefix) => Object.keys(relationships).filter((key) => new RegExp(`^${prefix}\\.\\d+$`).test(key)).map((key) => relationships[key].links?.self).filter(Boolean).map((self) => new URL(self, `${testRealmURL}board-1`).href).sort();
+			assert.deepEqual(linksFor("localCards"), issueIds, "a computed over an authored link still serializes");
+			assert.deepEqual(linksFor("cards"), [], "a computed over a query-backed relationship is omitted");
+			assert.strictEqual(board.doc.data.attributes?.cardCount, void 0, "a contained computed reaching the query field through another computed is omitted");
+		} else assert.ok(false, `board search entry was an error: ${board?.error.errorDetail.message}`);
+	});
+	(0, import_qunit.test)("a query-backed field resolves references that live in another realm", async function(assert) {
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class Note extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "rawIds", [field], function() {
+					return containsMany(string_default);
+				});
+			}
+			#rawIds = (initializeDeferredDecorator(this, "rawIds"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "mentionedIds", [field], function() {
+					return containsMany(string_default, { computeVia: function() {
+						return this.rawIds ?? [];
+					} });
+				});
+			}
+			#mentionedIds = (initializeDeferredDecorator(this, "mentionedIds"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "mentioned", [field], function() {
+					return linksToMany(() => CardDef, { query: {
+						filter: { in: { id: "$this.mentionedIds" } },
+						realms: "$this.mentionedIds"
+					} });
+				});
+			}
+			#mentioned = (initializeDeferredDecorator(this, "mentioned"), void 0);
+		}
+		class Post extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "note", [field], function() {
+					return contains(Note);
+				});
+			}
+			#note = (initializeDeferredDecorator(this, "note"), void 0);
+		}
+		let otherRealmURL = "http://test-realm/other/";
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: otherRealmURL,
+			contents: {
+				"pet.gts": { Pet },
+				"Pet/mango.json": { data: {
+					attributes: { name: "Mango" },
+					meta: { adoptsFrom: {
+						module: "../pet",
+						name: "Pet"
+					} }
+				} }
+			}
+		});
+		let virtualNetwork = getService("network").virtualNetwork;
+		virtualNetwork.addRealmMapping("@other/cards/", otherRealmURL);
+		try {
+			let { realm } = await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				contents: {
+					"test-cards.gts": {
+						Post,
+						Note
+					},
+					"post-1.json": { data: {
+						attributes: { note: { rawIds: ["@other/cards/Pet/mango"] } },
+						meta: { adoptsFrom: {
+							module: "./test-cards",
+							name: "Post"
+						} }
+					} }
+				}
+			});
+			let post = await realm.realmIndexQueryEngine.cardDocument(new URL(`${testRealmURL}post-1`), { loadLinks: true });
+			if (post?.type === "doc") {
+				let mentioned = post.doc.data.relationships?.["note.mentioned"];
+				let searchURL = mentioned?.links?.search ?? "";
+				let namesOtherRealm = searchURL.includes(encodeURIComponent(otherRealmURL)) || searchURL.includes(otherRealmURL);
+				assert.ok(namesOtherRealm, `links.search names the other realm (got ${searchURL})`);
+				assert.deepEqual(mentioned?.data, [{
+					type: "card",
+					id: `${otherRealmURL}Pet/mango`
+				}], "the cross-realm reference resolved");
+			} else assert.ok(false, `search entry was an error: ${post?.error.errorDetail.message}`);
+		} finally {
+			virtualNetwork.removeRealmMapping("@other/cards/");
+		}
+	});
+	(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: `${testModuleRealm}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: `${testModuleRealm}friend`,
+						name: "Friend"
+					} }
+				} },
+				"Friend/vanGogh.json": { data: {
+					id: `${testRealmURL}Friend/vanGogh`,
+					attributes: {
+						firstName: "Van Gogh",
+						cardDescription: "Dog friend",
+						cardThumbnailURL: "van-gogh.jpg"
+					},
+					meta: { adoptsFrom: {
+						module: `${testModuleRealm}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` } } },
+			meta: {
+				adoptsFrom: {
+					module: rri(`${testModuleRealm}friend`),
+					name: "Friend"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+					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) expectSearchDoc(assert, 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` },
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			},
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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: `${testModuleRealm}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: `${testModuleRealm}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`
+					}
+				} },
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}friend`),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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`
+					}
+				} },
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}friend`),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/mango.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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) expectSearchDoc(assert, 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",
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			},
+			cardTitle: "Hassan",
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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`
+					}
+				} },
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}friend`),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/mango.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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`
+					}
+				} },
+				meta: {
+					adoptsFrom: {
+						module: rri(`${testModuleRealm}friend`),
+						name: "Friend"
+					},
+					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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) expectSearchDoc(assert, 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",
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			},
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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: `${testModuleRealm}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`
+				}
+			} },
+			meta: {
+				adoptsFrom: {
+					module: rri(`${testModuleRealm}friend`),
+					name: "Friend"
+				},
+				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Friend/hassan.json`),
+				realmURL: ri("http://test-realm/test/"),
+				realmInfo: {
+					anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+					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) expectSearchDoc(assert, hassanEntry.searchDoc, {
+			_cardType: "Friend",
+			id: `${testRealmURL}Friend/hassan`,
+			firstName: "Hassan",
+			cardDescription: "Dog owner",
+			friend: { id: `${testRealmURL}Friend/hassan` },
+			cardTitle: "Hassan",
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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
+						}
+					}
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${hassanID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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
+					}
+				} },
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${mangoID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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
+					}
+				} },
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${vanGoghID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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) expectSearchDoc(assert, hassanEntry.searchDoc, {
+			_cardType: "Friends",
+			id: hassanID,
+			firstName: "Hassan",
+			cardTitle: "Hassan",
+			friends: [{
+				id: mangoID,
+				firstName: "Mango",
+				cardTitle: "Mango",
+				friends: [{ id: hassanID }],
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}, {
+				id: vanGoghID,
+				firstName: "Van Gogh",
+				friends: [{ id: hassanID }],
+				cardTitle: "Van Gogh",
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}],
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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
+					}
+				} },
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${mangoID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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
+						}
+					}
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${hassanID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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
+					}
+				} },
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${vanGoghID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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) expectSearchDoc(assert, 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 }],
+					cardTheme: null,
+					cardInfo: {
+						cardThumbnail: null,
+						theme: null
+					}
+				}],
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}],
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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
+					}
+				} },
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${vanGoghID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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
+						}
+					}
+				},
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${hassanID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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
+					}
+				} },
+				meta: {
+					adoptsFrom: friendsRef,
+					lastModified: adapter.lastModifiedMap.get(`${mangoID}.json`),
+					realmURL: ri("http://test-realm/test/"),
+					realmInfo: {
+						anonymousRateLimitDefault: DEFAULT_ANONYMOUS_RATE_LIMIT,
+						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) expectSearchDoc(assert, vanGoghEntry.searchDoc, {
+			_cardType: "Friends",
+			id: vanGoghID,
+			firstName: "Van Gogh",
+			cardTitle: "Van Gogh",
+			friends: [{
+				id: hassanID,
+				firstName: "Hassan",
+				cardTitle: "Hassan",
+				friends: [{
+					cardTheme: null,
+					cardInfo: {
+						cardThumbnail: null,
+						theme: null
+					},
+					firstName: "Mango",
+					friends: [{ id: hassanID }],
+					id: mangoID,
+					cardTitle: "Mango"
+				}, { id: vanGoghID }],
+				cardTheme: null,
+				cardInfo: {
+					cardThumbnail: null,
+					theme: null
+				}
+			}],
+			cardTheme: null,
+			cardInfo: {
+				cardThumbnail: null,
+				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")), [
+			"@cardstack/base/card-api",
+			"@cardstack/base/number",
+			"@cardstack/base/searchable",
+			"@cardstack/base/string",
+			"https://localhost:4202/test/person",
+			"https://packages/@cardstack/boxel-host/commands/create-ai-assistant-room",
+			"https://packages/@cardstack/boxel-host/commands/send-ai-assistant-message",
+			"https://packages/@ember/component",
+			"https://packages/@ember/modifier",
+			"https://packages/@ember/template-factory"
+		].sort(), "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: `${baseRealmRRI}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")), [
+			"@cardstack/base/card-api",
+			"@cardstack/base/number",
+			"@cardstack/base/searchable",
+			"@cardstack/base/spec",
+			"@cardstack/base/string",
+			"https://localhost:4202/test/person",
+			"https://packages/@cardstack/boxel-host/commands/create-ai-assistant-room",
+			"https://packages/@cardstack/boxel-host/commands/send-ai-assistant-message",
+			"https://packages/@ember/component",
+			"https://packages/@ember/modifier",
+			"https://packages/@ember/template-factory"
+		].sort(), "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)("can ignore files listed in .boxelignore alongside .gitignore", async function(assert) {
+		let { realm } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"post.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"post.draft.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"scripts/tool.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"git-ignored.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				".gitignore": `
+git-ignored.json
+      `,
+				".boxelignore": `
+*.draft.json
+scripts/
+      `
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		for (let path of [
+			"post.draft",
+			"scripts/tool",
+			"git-ignored"
+		]) assert.strictEqual(await indexer.cardDocument(new URL(`${testRealmURL}${path}`)), void 0, `${path} is not indexed because it is ignored`);
+		assert.ok(await indexer.cardDocument(new URL(`${testRealmURL}post`)), "instance exists");
+	});
+	(0, import_qunit.test)("a from-scratch index removes the rows of a file that has since been ignored", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"post.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"draft.json": { data: { meta: { adoptsFrom: baseCardRef } } }
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		assert.ok(await indexer.cardDocument(new URL(`${testRealmURL}draft`)), "draft is indexed before it is ignored");
+		await adapter.write(".boxelignore", "draft.json\n");
+		await realm.fullIndex();
+		assert.strictEqual(await indexer.cardDocument(new URL(`${testRealmURL}draft`)), void 0, "draft is no longer indexed");
+		assert.ok(await indexer.cardDocument(new URL(`${testRealmURL}post`)), "post is still indexed");
+	});
+	(0, import_qunit.test)("a .boxelignore that lists itself keeps applying on every from-scratch index", async function(assert) {
+		let { realm, adapter } = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"post.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				"draft.json": { data: { meta: { adoptsFrom: baseCardRef } } },
+				".boxelignore": `
+.boxelignore
+draft.json
+      `
+			}
+		});
+		let indexer = realm.realmIndexQueryEngine;
+		for (let pass of [1, 2]) {
+			await new Promise((r) => setTimeout(r, 1e3));
+			await adapter.write("post.json", JSON.stringify({ data: { meta: { adoptsFrom: baseCardRef } } }));
+			await realm.fullIndex();
+			assert.strictEqual(await indexer.cardDocument(new URL(`${testRealmURL}draft`)), void 0, `draft is still ignored after from-scratch pass ${pass}`);
+		}
+	});
+	(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: "@cardstack/base/cards-grid",
+						name: "CardsGrid"
+					} }
+				} },
+				"realm.json": { data: {
+					type: "card",
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: "@cardstack/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: "@cardstack/base/cards-grid",
+						name: "CardsGrid"
+					} }
+				} },
+				"realm.json": { data: {
+					type: "card",
+					attributes: { includePrerenderedDefaultRealmIndex: true },
+					meta: { adoptsFrom: {
+						module: "@cardstack/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 default Workspace 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: "@cardstack/base/workspace",
+						name: "Workspace"
+					} }
+				} },
+				"realm.json": { data: {
+					type: "card",
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: "@cardstack/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 a Workspace-indexed realm has not opted in");
+	});
+	(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(string_default);
+				});
+			}
+			#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