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

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

@@ -1,4380 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Br as testRealmURL, Co as SupportedMimeType, Lr as testRRI, l as internalKeyFor, tt as diffDoc, vc as init_md5_esm_bundler, xi as DEFAULT_ANONYMOUS_RATE_LIMIT, yc as md5 } from "./runtime-common-BTaLJEw-.js";
-import { T as rri, w as ri } from "./paths-C9-NYXnM.js";
-import { it as baseRealmRRI, q as skillCardRef, w as baseCardRef } from "./constants-Icc0nFW-.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-rPfzpIOU.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-Dd8k0DNa.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-Cc8uZunB.js";
-import { t as DateTimeField } from "./datetime-CaJus6ZL.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-import { t as NumberField } from "./number-BYHu62Pt.js";
-import { t as searchCardsForTest } from "./search-cards-DxcB56HL.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