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

package/bundled-test-harness/assets/search-entries-test-CE0B47pw.js

@@ -1,1486 +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, Lr as testRRI, lo as HtmlResourceType, po as htmlResourceId, so as EntryResourceType } from "./runtime-common-BTaLJEw-.js";
-import { r as setOwner } from "./owner-CP0__uFm.js";
-import { Tn as destroy, wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
-import "./destroyable-mdLYRn_o.js";
-import "./component-BJO47HTh.js";
-import { t as Component } from "./dist-CkA1rgqO.js";
-import { n as tracked } from "./tracking-800VJb8b.js";
-import "./template-factory-ds9s0u8l.js";
-import { t as templateOnly } from "./template-only-6nVzLWF-.js";
-import { n as knownFileMetaUrls, t as clearKnownFileMetaUrls } from "./known-file-meta-urls-BtSTkGnL.js";
-import { n as getSearchEntriesResource, t as SearchEntriesResource } from "./search-entries-0TMjLUAc.js";
-import { M as waitUntil, T as settled, h as render } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { A as field, a as CardDef, w as contains } from "./card-api-Cc8uZunB.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-//#region tests/integration/resources/search-entries-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var testRealm2URL = "http://test-realm/test2/";
-function getResourceForTest(parent, args) {
-	return SearchEntriesResource.from(parent, args);
-}
-(0, import_qunit.module)("Integration | search-entries resource", function(hooks) {
-	let loader;
-	let loaderService;
-	let storeService;
-	let realm;
-	let realm2;
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL, testRealm2URL],
-		autostart: true
-	});
-	let bookRef = {
-		module: testRRI("book"),
-		name: "Book"
-	};
-	hooks.beforeEach(async function() {
-		loaderService = getService("loader-service");
-		loader = loaderService.loader;
-		storeService = getService("store");
-		class Book extends CardDef {
-			static displayName = "Book";
-			static {
-				decorateFieldV2(this.prototype, "title", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#title = (initializeDeferredDecorator(this, "title"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "status", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#status = (initializeDeferredDecorator(this, "status"), void 0);
-		}
-		({realm} = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: testRealmURL,
-			contents: {
-				"book.gts": { Book },
-				"catalog.gts": { Book },
-				"books/1.json": new Book({
-					title: "Mango",
-					status: "ready"
-				}),
-				"books/2.json": new Book({
-					title: "Van Gogh",
-					status: "draft"
-				})
-			}
-		}));
-		({realm: realm2} = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: testRealm2URL,
-			contents: { "books/other.json": { data: {
-				type: "card",
-				attributes: {
-					title: "Paper",
-					status: "ready"
-				},
-				meta: { adoptsFrom: {
-					module: testRRI("book"),
-					name: "Book"
-				} }
-			} } }
-		}));
-	});
-	function bookDoc(title) {
-		return JSON.stringify({ data: {
-			type: "card",
-			attributes: {
-				title,
-				status: "ready"
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("book"),
-				name: "Book"
-			} }
-		} });
-	}
-	function fittedHtmlId(id) {
-		return htmlResourceId({
-			url: id,
-			format: "fitted",
-			renderType: bookRef
-		});
-	}
-	function entryResourceFor(spec) {
-		return {
-			type: EntryResourceType,
-			id: spec.id,
-			relationships: { html: { data: spec.htmlGen !== void 0 ? [{
-				type: HtmlResourceType,
-				id: fittedHtmlId(spec.id)
-			}] : [] } },
-			meta: { generation: spec.indexGen }
-		};
-	}
-	function htmlResourceFor(spec) {
-		return {
-			type: HtmlResourceType,
-			id: fittedHtmlId(spec.id),
-			attributes: {
-				html: spec.html ?? "<div>book</div>",
-				cardType: "Book",
-				format: "fitted",
-				renderType: bookRef
-			},
-			relationships: { styles: { data: spec.cssHref ? [{
-				type: "css",
-				id: `css-${spec.id}`
-			}] : [] } },
-			meta: { generation: spec.htmlGen }
-		};
-	}
-	function cssResourcesFor(specs) {
-		return specs.filter((spec) => spec.cssHref !== void 0).map((spec) => ({
-			type: "css",
-			id: `css-${spec.id}`,
-			attributes: { href: spec.cssHref }
-		}));
-	}
-	function entryCollectionDoc(specs) {
-		return {
-			data: specs.map(entryResourceFor),
-			included: specs.filter((spec) => spec.htmlGen !== void 0).map(htmlResourceFor),
-			meta: {
-				page: { total: specs.length },
-				htmlQuery: { eq: { format: "fitted" } }
-			}
-		};
-	}
-	function entrySingleDoc(spec) {
-		return {
-			data: entryResourceFor(spec),
-			included: spec.htmlGen !== void 0 ? [htmlResourceFor(spec), ...cssResourcesFor([spec])] : []
-		};
-	}
-	(0, import_qunit.test)("exposes entries joined from the wire document (default fieldset: html renderings)", async function(assert) {
-		let search = getResourceForTest(storeService, () => ({ named: { query: {
-			filter: { "item.on": bookRef },
-			realms: [testRealmURL]
-		} } }));
-		await search.loaded;
-		assert.strictEqual(search.entries.length, 2, "both books are returned");
-		assert.strictEqual(search.meta.page.total, 2);
-		assert.strictEqual(search.errors, void 0);
-		for (let entry of search.entries) {
-			assert.strictEqual(entry.realmUrl, testRealmURL);
-			assert.strictEqual(entry.html.length, 1, "the default htmlQuery selects the fitted rendering");
-			let [rendering] = entry.html;
-			assert.strictEqual(rendering.format, "fitted");
-			assert.strictEqual(rendering.cardType, "Book");
-			assert.false(rendering.isError);
-			assert.ok(rendering.html, "the rendering carries markup");
-			assert.strictEqual(entry.item, void 0, "an html-bearing entry has no item fallback");
-		}
-	});
-	(0, import_qunit.test)("a card-initiated no-realm search scopes to the default realm instead of fanning out", async function(assert) {
-		let search = getResourceForTest(storeService, () => ({ named: {
-			query: { filter: { "item.on": bookRef } },
-			cardInitiated: true,
-			getDefaultRealm: () => testRealmURL
-		} }));
-		await search.loaded;
-		assert.strictEqual(search.entries.length, 2, "only the two books in the default realm are returned");
-		assert.true(search.entries.every((entry) => entry.realmUrl === testRealmURL), "every result is from the default realm");
-		assert.false(search.entries.some((entry) => entry.realmUrl === testRealm2URL), "realm2 was never searched — no fan-out");
-	});
-	(0, import_qunit.test)("a card-initiated no-realm search with no resolvable default realm yields no results", async function(assert) {
-		let search = getResourceForTest(storeService, () => ({ named: {
-			query: { filter: { "item.on": bookRef } },
-			cardInitiated: true,
-			getDefaultRealm: () => void 0
-		} }));
-		await search.loaded;
-		assert.strictEqual(search.entries.length, 0, "no results, rather than a fan-out across all realms");
-	});
-	(0, import_qunit.test)("a host-owned no-realm search keeps the all-realms fallback", async function(assert) {
-		let search = getResourceForTest(storeService, () => ({ named: { query: { filter: { "item.on": bookRef } } } }));
-		await search.loaded;
-		assert.true(search.entries.some((entry) => entry.realmUrl === testRealmURL), "the default realm is searched");
-		assert.true(search.entries.some((entry) => entry.realmUrl === testRealm2URL), "realm2 is searched too — the all-realms fallback still fans out");
-	});
-	(0, import_qunit.test)("registers file result URLs so clicks/overlay classify them as files", async function(assert) {
-		let itemFileUrl = `${testRealmURL}notes.txt`;
-		let htmlFileUrl = `${testRealmURL}readme.md`;
-		let renderingId = htmlResourceId({
-			url: htmlFileUrl,
-			format: "fitted"
-		});
-		let doc = {
-			data: [{
-				type: EntryResourceType,
-				id: itemFileUrl,
-				relationships: { item: { data: {
-					type: "file-meta",
-					id: itemFileUrl
-				} } }
-			}, {
-				type: EntryResourceType,
-				id: htmlFileUrl,
-				relationships: { html: { data: [{
-					type: HtmlResourceType,
-					id: renderingId
-				}] } }
-			}],
-			included: [{
-				type: HtmlResourceType,
-				id: renderingId,
-				attributes: {
-					html: "<div>readme</div>",
-					cardType: "",
-					format: "fitted"
-				},
-				relationships: { styles: { data: [] } }
-			}],
-			meta: { page: { total: 2 } }
-		};
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async () => doc;
-		clearKnownFileMetaUrls();
-		try {
-			await getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			} } })).loaded;
-			assert.true(knownFileMetaUrls.has(itemFileUrl), "the item-only file row is registered");
-			assert.true(knownFileMetaUrls.has(htmlFileUrl), "the html-backed file row (no render type) is registered");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-			clearKnownFileMetaUrls();
-		}
-	});
-	(0, import_qunit.test)("exposes raw item serializations per the fieldset, without touching the store", async function(assert) {
-		let search = getResourceForTest(storeService, () => ({ named: { query: {
-			filter: { "item.on": bookRef },
-			fields: { entry: ["item"] },
-			realms: [testRealmURL]
-		} } }));
-		await search.loaded;
-		assert.strictEqual(search.entries.length, 2);
-		for (let entry of search.entries) {
-			assert.deepEqual(entry.html, [], "an item-only fieldset pins an empty html branch");
-			assert.ok(entry.item, "the raw serialization rides on the entry");
-			assert.strictEqual(entry.item.type, "card");
-			assert.strictEqual(storeService.peek(entry.id), void 0, "nothing is hydrated into the store");
-		}
-		assert.deepEqual(search.entries.map((entry) => entry.item.attributes?.title).sort(), ["Mango", "Van Gogh"]);
-	});
-	(0, import_qunit.test)("registers the in-flight search with the render store readiness signal during a prerender", async function(assert) {
-		let renderStore = getService("render-store");
-		let trackedLoads = [];
-		let originalTrackLoad = renderStore.trackLoad.bind(renderStore);
-		renderStore.trackLoad = (load) => {
-			trackedLoads.push(load);
-			originalTrackLoad(load);
-		};
-		let generationBefore = renderStore.loadGeneration;
-		globalThis.__boxelRenderContext = true;
-		try {
-			let search = getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			} } }));
-			let load = search.loaded;
-			assert.strictEqual(trackedLoads.length, 1, "the search registers exactly one load with the render store");
-			assert.strictEqual(trackedLoads[0], load, "the registered load is the in-flight search");
-			assert.true(renderStore.loadGeneration > generationBefore, "registering the search advances the render store load generation, so the settle loop waits for it");
-			await load;
-			assert.strictEqual(search.entries.length, 2, "the tracked load is the real search and it produced results");
-		} finally {
-			delete renderStore.trackLoad;
-			delete globalThis.__boxelRenderContext;
-		}
-	});
-	(0, import_qunit.test)("re-runs the search on an incremental index event", async function(assert) {
-		let search = getResourceForTest(storeService, () => ({ named: { query: {
-			filter: { "item.on": bookRef },
-			realms: [testRealmURL]
-		} } }));
-		await search.loaded;
-		assert.strictEqual(search.entries.length, 2);
-		await realm.write("books/3.json", bookDoc("Paper"));
-		await waitUntil(() => search.entries.length === 3, { timeout: 1e4 });
-		assert.ok(search.entries.find((entry) => entry.id === `${testRealmURL}books/3`), "the new book appears after the incremental index event");
-	});
-	(0, import_qunit.module)("index event type gating", function() {
-		const unrelatedType = "http://test-realm/test/observation/Observation";
-		function relayIndexEvent(invalidatedTypes) {
-			getService("message-service").relayRealmEvent({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [`${testRealmURL}observations/1.json`],
-				...invalidatedTypes !== void 0 ? { invalidatedTypes } : {},
-				realmURL: testRealmURL
-			});
-		}
-		function countingSearch() {
-			let searchCount = 0;
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return entryCollectionDoc([{
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: 1,
-					html: "<div>Mango</div>"
-				}]);
-			};
-			return () => searchCount;
-		}
-		(0, import_qunit.test)("an event that touched no anchored type does not re-run the query", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			let searchCount = countingSearch();
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount();
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 1, "the first typed event re-runs while the anchors resolve");
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 1, "a write to a type the query is not anchored on is skipped");
-				relayIndexEvent([unrelatedType, `${testRealmURL}book/Book`]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 2, "an event naming the anchored type re-runs the query");
-				relayIndexEvent();
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 3, "an event carrying no type information re-runs the query");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-			}
-		});
-		(0, import_qunit.test)("an anchor resolves through the module that defines the type, not only the one the query names", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			let searchCount = countingSearch();
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": {
-						module: testRRI("catalog"),
-						name: "Book"
-					} },
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount();
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 1, "the first typed event re-runs while the anchors resolve");
-				relayIndexEvent([`${testRealmURL}book/Book`]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 2, "an event naming the defining module re-runs a query anchored through the re-exporting one");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-			}
-		});
-		(0, import_qunit.test)("a loader replacement re-resolves the anchors before they gate again", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			let searchCount = countingSearch();
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount();
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 1, "the anchors resolve and the second event is skipped");
-				getService("loader-service").resetLoader({
-					clearFetchCache: true,
-					reason: "test",
-					codeChange: true
-				});
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 2, "the first event after the replacement re-runs while the anchors re-resolve");
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 2, "the re-resolved anchors gate again");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-			}
-		});
-		(0, import_qunit.test)("a query that admits an entry of any type re-runs on every event", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			let searchCount = countingSearch();
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { eq: { "item.status": "ready" } },
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount();
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				relayIndexEvent([unrelatedType]);
-				await settled();
-				assert.strictEqual(searchCount(), baseline + 2, "an unanchored filter can gain a member of any type, so nothing is skipped");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-			}
-		});
-	});
-	(0, import_qunit.test)("a burst of realm events coalesces into a single re-run", async function(assert) {
-		let searchCount = 0;
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async () => {
-			searchCount++;
-			return entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango</div>"
-			}]);
-		};
-		try {
-			await getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			} } })).loaded;
-			let baseline = searchCount;
-			let messageService = getService("message-service");
-			for (let i = 1; i <= 5; i++) messageService.relayRealmEvent({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [`${testRealmURL}books/${i}.json`],
-				realmURL: testRealmURL
-			});
-			await settled();
-			assert.strictEqual(searchCount, baseline + 1, "five index events inside one window produce one re-run");
-			messageService.relayRealmEvent({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [`${testRealmURL}books/1.json`],
-				realmURL: testRealmURL
-			});
-			await settled();
-			assert.strictEqual(searchCount, baseline + 2, "an event after the flush schedules its own re-run");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-		}
-	});
-	(0, import_qunit.test)("a query change inside the window cancels the armed re-run", async function(assert) {
-		let searchCount = 0;
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async () => {
-			searchCount++;
-			return entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango</div>"
-			}]);
-		};
-		try {
-			let search = getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			} } }));
-			await search.loaded;
-			let baseline = searchCount;
-			getService("message-service").relayRealmEvent({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [`${testRealmURL}books/1.json`],
-				realmURL: testRealmURL
-			});
-			search.modify([], { query: {
-				filter: {
-					"item.on": bookRef,
-					eq: { "item.status": "ready" }
-				},
-				realms: [testRealmURL]
-			} });
-			await settled();
-			assert.strictEqual(searchCount, baseline + 1, "the query change cancels the armed flush; only its own search runs");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-		}
-	});
-	(0, import_qunit.module)("prerender_html selective per-member refresh", function() {
-		function relayPrerenderHtml(invalidations, generation) {
-			getService("message-service").relayRealmEvent({
-				eventName: "prerender_html",
-				realmURL: testRealmURL,
-				generation,
-				invalidations
-			});
-		}
-		(0, import_qunit.test)("refreshes only the invalidated member via a card+html GET; no full re-query", async function(assert) {
-			let searchCount = 0;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return entryCollectionDoc([{
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: 1,
-					html: "<div>Mango v1</div>"
-				}, {
-					id: `${testRealmURL}books/2`,
-					indexGen: 1,
-					htmlGen: 1,
-					html: "<div>Van Gogh v1</div>"
-				}]);
-			};
-			let getCalls = [];
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async (url, opts) => {
-				getCalls.push({
-					url,
-					ifNoneMatch: opts.ifNoneMatch,
-					format: opts.format
-				});
-				return {
-					notModified: false,
-					doc: entrySingleDoc({
-						id: `${testRealmURL}books/1`,
-						indexGen: 1,
-						htmlGen: 2,
-						html: "<div>Mango v2</div>"
-					})
-				};
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				assert.strictEqual(search.entries.length, 2);
-				let book2Before = search.entries.find((entry) => entry.id === `${testRealmURL}books/2`);
-				let baseline = searchCount;
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => getCalls.length > 0, { timeout: 1e4 });
-				await settled();
-				assert.strictEqual(searchCount, baseline, "no whole-search re-query is issued");
-				assert.strictEqual(getCalls.length, 1, "exactly one card+html GET");
-				assert.strictEqual(getCalls[0].url, `${testRealmURL}books/1`);
-				assert.strictEqual(getCalls[0].ifNoneMatch, "\"1:1\"", "the held composite validator (index:html) is sent as If-None-Match");
-				assert.strictEqual(getCalls[0].format, "fitted");
-				assert.strictEqual(search.entries[0].html[0].html, "<div>Mango v2</div>", "the invalidated member swaps in the fresh HTML");
-				assert.strictEqual(search.entries.find((entry) => entry.id === `${testRealmURL}books/2`), book2Before, "the uninvalidated member keeps its identity");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("a member that comes back without the markup the search served it re-runs the whole search", async function(assert) {
-			let searchCount = 0;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return entryCollectionDoc([{
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: searchCount,
-					html: `<div>Mango v${searchCount}</div>`
-				}]);
-			};
-			let getCount = 0;
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return {
-					notModified: false,
-					doc: entrySingleDoc({
-						id: `${testRealmURL}books/1`,
-						indexGen: 1
-					})
-				};
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				let baseline = searchCount;
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => searchCount > baseline, { timeout: 1e4 });
-				await settled();
-				assert.strictEqual(getCount, 1, "the member was asked for first");
-				assert.strictEqual(search.entries[0].html[0]?.html, `<div>Mango v${searchCount}</div>`, "and the search’s own answer, with its markup, is what the member shows");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("a 304 keeps the current rendering and the member identity", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango v1</div>"
-			}]);
-			let getCount = 0;
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return { notModified: true };
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				let before = search.entries[0];
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => getCount > 0, { timeout: 1e4 });
-				await settled();
-				assert.strictEqual(getCount, 1, "the conditional GET was issued");
-				assert.strictEqual(search.entries[0], before, "a 304 leaves the member object untouched (a hydrated row stays live)");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("a member already at or above the event generation is not fetched", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 5,
-				htmlGen: 5,
-				html: "<div>Mango</div>"
-			}]);
-			let getCount = 0;
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return { notModified: true };
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				let before = search.entries[0];
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 5);
-				await settled();
-				assert.strictEqual(getCount, 0, "no GET is issued for a fresh member");
-				assert.strictEqual(search.entries[0], before, "the member is untouched");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("an event whose URLs are not in the visible set does no work", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango</div>"
-			}]);
-			let getCount = 0;
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return { notModified: true };
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				let before = search.entries[0];
-				relayPrerenderHtml([`${testRealmURL}books/999.json`], 9);
-				await settled();
-				assert.strictEqual(getCount, 0, "no GET for an unrelated invalidation");
-				assert.strictEqual(search.entries[0], before);
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("an empty-html member upgrades when its rendering lands", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 2
-			}]);
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			let capturedIfNoneMatch;
-			storeService.fetchCardEntry = async (_url, opts) => {
-				capturedIfNoneMatch = opts.ifNoneMatch;
-				return {
-					notModified: false,
-					doc: entrySingleDoc({
-						id: `${testRealmURL}books/1`,
-						indexGen: 2,
-						htmlGen: 2,
-						html: "<div>Mango</div>"
-					})
-				};
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				assert.deepEqual(search.entries[0].html, [], "no rendering initially");
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => search.entries[0]?.html.length === 1, { timeout: 1e4 });
-				assert.strictEqual(search.entries[0].html[0].html, "<div>Mango</div>");
-				assert.strictEqual(capturedIfNoneMatch, "\"2:none\"", "a member with no rendering sends the none-html validator");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("a full-text (matches) query re-runs in full instead of refreshing members", async function(assert) {
-			let searchCount = 0;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return entryCollectionDoc([{
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: 1,
-					html: "<div>Mango</div>"
-				}]);
-			};
-			let getCount = 0;
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return { notModified: true };
-			};
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: {
-						"item.on": bookRef,
-						matches: "mango"
-					},
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount;
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => searchCount > baseline, { timeout: 1e4 });
-				await settled();
-				assert.ok(searchCount > baseline, "a matches query re-runs the whole search (membership can change)");
-				assert.strictEqual(getCount, 0, "no per-member GET for a matches query");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("a failed member GET falls back to a full re-run", async function(assert) {
-			let searchCount = 0;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return entryCollectionDoc([{
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: 1,
-					html: "<div>Mango</div>"
-				}]);
-			};
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				throw new Error("boom");
-			};
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount;
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => searchCount > baseline, { timeout: 1e4 });
-				await settled();
-				assert.ok(searchCount > baseline, "a member the GET could not refresh triggers a coarse re-run");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("an item-only fieldset takes the coarse re-run — render errors can flip its membership", async function(assert) {
-			let itemOnlyDoc = {
-				data: [{
-					type: EntryResourceType,
-					id: `${testRealmURL}books/1`,
-					relationships: {},
-					meta: { generation: 1 }
-				}],
-				meta: { page: { total: 1 } }
-			};
-			let searchCount = 0;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return itemOnlyDoc;
-			};
-			let getCount = 0;
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return { notModified: true };
-			};
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					fields: { entry: ["item"] },
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount;
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => searchCount > baseline, { timeout: 1e4 });
-				await settled();
-				assert.ok(searchCount > baseline, "an item-only query re-runs the whole search on a prerender_html event");
-				assert.strictEqual(getCount, 0, "no per-member GET is attempted");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("coalesced events refresh the union of their members, each judged at its own generation", async function(assert) {
-			let book1 = `${testRealmURL}books/1`;
-			let book2 = `${testRealmURL}books/2`;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => entryCollectionDoc([{
-				id: book1,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango v1</div>"
-			}, {
-				id: book2,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Van Gogh v1</div>"
-			}]);
-			let getUrls = [];
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async (url) => {
-				getUrls.push(url);
-				if (getUrls.length === 1) return new Promise(() => {});
-				return {
-					notModified: false,
-					doc: entrySingleDoc({
-						id: url,
-						indexGen: 1,
-						htmlGen: url === book2 ? 3 : 2,
-						html: `<div>${url === book2 ? "Van Gogh" : "Mango"} v2</div>`
-					})
-				};
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => getUrls.length === 1, { timeout: 1e4 });
-				relayPrerenderHtml([`${testRealmURL}books/2.json`], 3);
-				await waitUntil(() => search.entries.find((e) => e.id === book1)?.htmlGeneration === 2 && search.entries.find((e) => e.id === book2)?.htmlGeneration === 3, { timeout: 1e4 });
-				await settled();
-				assert.deepEqual(getUrls.slice(1).sort(), [book1, book2], "the replacement run refreshes both events' members");
-				assert.strictEqual(search.entries.find((e) => e.id === book1)?.html[0]?.html, "<div>Mango v2</div>");
-				assert.strictEqual(search.entries.find((e) => e.id === book2)?.html[0]?.html, "<div>Van Gogh v2</div>");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("an index event on another realm mid-refresh does not drop the HTML update", async function(assert) {
-			let bookAId = `${testRealmURL}books/1`;
-			let bookBId = `${testRealm2URL}books/other`;
-			let staleDoc = entryCollectionDoc([{
-				id: bookAId,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango v1</div>"
-			}, {
-				id: bookBId,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Paper</div>"
-			}]);
-			let freshDoc = entryCollectionDoc([{
-				id: bookAId,
-				indexGen: 1,
-				htmlGen: 2,
-				html: "<div>Mango v2</div>"
-			}, {
-				id: bookBId,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Paper</div>"
-			}]);
-			let fetchedRealms = [];
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async (_query, realms) => {
-				fetchedRealms.push([...realms ?? []].sort());
-				return fetchedRealms.length === 1 ? staleDoc : freshDoc;
-			};
-			let getCount = 0;
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return new Promise(() => {});
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL, testRealm2URL]
-				} } }));
-				await search.loaded;
-				assert.strictEqual(search.entries.length, 2);
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => getCount > 0, { timeout: 1e4 });
-				getService("message-service").relayRealmEvent({
-					eventName: "index",
-					indexType: "incremental",
-					invalidations: [],
-					realmURL: testRealm2URL
-				});
-				await waitUntil(() => search.entries.find((e) => e.id === bookAId)?.htmlGeneration === 2, { timeout: 1e4 });
-				await settled();
-				assert.deepEqual(fetchedRealms[fetchedRealms.length - 1], [testRealmURL, testRealm2URL].sort(), "the coarse re-run covers the prerender event's realm too");
-				assert.strictEqual(search.entries.find((e) => e.id === bookAId)?.html[0]?.html, "<div>Mango v2</div>", "the invalidated member picked up the fresh HTML through the fold");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("a stylesheet-import failure during a member refresh degrades that entry to unstyled without a full re-run", async function(assert) {
-			let cssHref = `${testRealmURL}book.gts.deadbeef.glimmer-scoped.css`;
-			let searchCount = 0;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return entryCollectionDoc([{
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: 1,
-					html: "<div>Mango v1</div>"
-				}]);
-			};
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => ({
-				notModified: false,
-				doc: entrySingleDoc({
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: 2,
-					html: "<div>Mango v2</div>",
-					cssHref
-				})
-			});
-			let importCalls = [];
-			let stubbedLoader;
-			let originalImport;
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				let baseline = searchCount;
-				stubbedLoader = loaderService.loader;
-				originalImport = stubbedLoader.import.bind(stubbedLoader);
-				stubbedLoader.import = async (url) => {
-					importCalls.push(url);
-					if (url === cssHref) throw new Error("stylesheet fetch failed");
-					return originalImport(url);
-				};
-				relayPrerenderHtml([`${testRealmURL}books/1.json`], 2);
-				await waitUntil(() => search.entries[0]?.htmlGeneration === 2, { timeout: 1e4 });
-				await settled();
-				assert.true(importCalls.includes(cssHref), "the member refresh actually attempted the stylesheet import");
-				assert.strictEqual(searchCount, baseline, "a failed stylesheet import degrades the entry rather than triggering the coarse re-run");
-				assert.strictEqual(search.entries[0]?.htmlGeneration, 2, "the member's refresh is applied even though its stylesheet failed to load");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-				if (stubbedLoader && originalImport) stubbedLoader.import = originalImport;
-			}
-		});
-		(0, import_qunit.test)("a row whose only change is its generation stamps keeps identity and adopts the stamps", async function(assert) {
-			let docs = [entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango</div>"
-			}]), entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 2,
-				htmlGen: 2,
-				html: "<div>Mango</div>"
-			}])];
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => docs.shift() ?? docs[0];
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				let before = search.entries[0];
-				assert.strictEqual(before.htmlGeneration, 1);
-				getService("message-service").relayRealmEvent({
-					eventName: "index",
-					indexType: "incremental",
-					invalidations: [`${testRealmURL}books/1.json`],
-					realmURL: testRealmURL
-				});
-				await waitUntil(() => search.entries[0]?.htmlGeneration === 2, { timeout: 1e4 });
-				await settled();
-				assert.strictEqual(search.entries[0], before, "the content-unchanged row keeps its object identity");
-				assert.strictEqual(before.indexGeneration, 2, "the stamps are adopted");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-			}
-		});
-		(0, import_qunit.test)("clearing the query mid-refresh stops the remaining member GETs", async function(assert) {
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => entryCollectionDoc([{
-				id: `${testRealmURL}books/1`,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Mango</div>"
-			}, {
-				id: `${testRealmURL}books/2`,
-				indexGen: 1,
-				htmlGen: 1,
-				html: "<div>Van Gogh</div>"
-			}]);
-			let getCount = 0;
-			let releaseFirstGet;
-			let firstGet = new Promise((resolve) => releaseFirstGet = resolve);
-			let originalFetchCardEntry = storeService.fetchCardEntry.bind(storeService);
-			storeService.fetchCardEntry = async () => {
-				getCount++;
-				return firstGet;
-			};
-			try {
-				let search = getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } }));
-				await search.loaded;
-				relayPrerenderHtml([`${testRealmURL}books/1.json`, `${testRealmURL}books/2.json`], 2);
-				await waitUntil(() => getCount === 1, { timeout: 1e4 });
-				search.modify([], { query: void 0 });
-				releaseFirstGet({
-					notModified: false,
-					doc: entrySingleDoc({
-						id: `${testRealmURL}books/1`,
-						indexGen: 1,
-						htmlGen: 2,
-						html: "<div>Mango v2</div>"
-					})
-				});
-				await settled();
-				assert.strictEqual(getCount, 1, "no further member GET fires after the query is cleared");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-				storeService.fetchCardEntry = originalFetchCardEntry;
-			}
-		});
-		(0, import_qunit.test)("a non-incremental index event does not re-run the search", async function(assert) {
-			let searchCount = 0;
-			let originalSearchEntries = storeService.searchEntries.bind(storeService);
-			storeService.searchEntries = async () => {
-				searchCount++;
-				return entryCollectionDoc([{
-					id: `${testRealmURL}books/1`,
-					indexGen: 1,
-					htmlGen: 1,
-					html: "<div>Mango</div>"
-				}]);
-			};
-			try {
-				await getResourceForTest(storeService, () => ({ named: { query: {
-					filter: { "item.on": bookRef },
-					realms: [testRealmURL]
-				} } })).loaded;
-				let baseline = searchCount;
-				getService("message-service").relayRealmEvent({
-					eventName: "index",
-					indexType: "full",
-					realmURL: testRealmURL
-				});
-				await settled();
-				assert.strictEqual(searchCount, baseline, "a full (non-incremental) index event leaves the search alone");
-			} finally {
-				storeService.searchEntries = originalSearchEntries;
-			}
-		});
-		(0, import_qunit.test)("the real card+html GET round-trips and its ETag matches the reconstructed validator", async function(assert) {
-			let url = `${testRealmURL}books/1`;
-			let first = await storeService.fetchCardEntry(url, {
-				kind: "card",
-				format: "fitted"
-			});
-			assert.false(first.notModified, "the first GET returns the entry");
-			if (!first.notModified) {
-				let entry = first.doc.data;
-				assert.strictEqual(entry.id, url);
-				let htmlRef = entry.relationships.html?.data?.[0];
-				assert.ok(htmlRef, "the entry carries a rendering");
-				let htmlResource = first.doc.included?.find((resource) => resource.id === htmlRef.id);
-				assert.ok(htmlResource, "the rendering rides in included");
-				let indexGeneration = entry.meta?.generation;
-				let htmlGeneration = htmlResource?.meta?.generation;
-				let validator = `"${indexGeneration ?? 0}:${htmlGeneration ?? "none"}"`;
-				let second = await storeService.fetchCardEntry(url, {
-					kind: "card",
-					format: "fitted",
-					ifNoneMatch: validator
-				});
-				assert.true(second.notModified, "the reconstructed validator matches the server ETag, so the GET 304s");
-			}
-		});
-	});
-	(0, import_qunit.test)("an entry with an empty html array upgrades when its rendering lands on a later event", async function(assert) {
-		let entryURL = `${testRealmURL}books/1`;
-		let renderingId = htmlResourceId({
-			url: entryURL,
-			format: "fitted",
-			renderType: bookRef
-		});
-		let cssHref = `${testRealmURL}book.gts.abc123.glimmer-scoped.css`;
-		let unrenderedDoc = {
-			data: [{
-				type: EntryResourceType,
-				id: entryURL,
-				relationships: { html: { data: [] } }
-			}],
-			meta: { page: { total: 1 } }
-		};
-		let renderedDoc = {
-			data: [{
-				type: EntryResourceType,
-				id: entryURL,
-				relationships: { html: { data: [{
-					type: HtmlResourceType,
-					id: renderingId
-				}] } }
-			}],
-			included: [{
-				type: HtmlResourceType,
-				id: renderingId,
-				attributes: {
-					html: "<div>Mango</div>",
-					cardType: "Book",
-					format: "fitted",
-					renderType: bookRef
-				},
-				relationships: { styles: { data: [{
-					type: "css",
-					id: "deadbeef"
-				}] } }
-			}, {
-				type: "css",
-				id: "deadbeef",
-				attributes: { href: cssHref }
-			}],
-			meta: { page: { total: 1 } }
-		};
-		let docs = [
-			unrenderedDoc,
-			renderedDoc,
-			renderedDoc
-		];
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async () => docs.shift() ?? renderedDoc;
-		let originalImport = loader.import.bind(loader);
-		loader.import = async (url) => url === cssHref ? {} : originalImport(url);
-		try {
-			let search = getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			} } }));
-			await search.loaded;
-			assert.strictEqual(search.entries.length, 1);
-			assert.deepEqual(search.entries[0].html, [], "the entry matched but carries no rendering yet");
-			await realm.write("books/9.json", bookDoc("Trigger"));
-			await waitUntil(() => search.entries[0]?.html.length === 1, { timeout: 1e4 });
-			let [rendering] = search.entries[0].html;
-			assert.strictEqual(rendering.id, renderingId);
-			assert.strictEqual(rendering.html, "<div>Mango</div>");
-			assert.deepEqual(rendering.cssUrls, [cssHref], "the styles references resolve to the stylesheet hrefs");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-			loader.import = originalImport;
-		}
-	});
-	(0, import_qunit.test)("an incremental event refreshes only its own realm, leaving other realms untouched", async function(assert) {
-		let fetchedRealms = [];
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async (query, realms) => {
-			fetchedRealms.push(realms ?? []);
-			return await originalSearchEntries(query, realms);
-		};
-		try {
-			let search = getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL, testRealm2URL]
-			} } }));
-			await search.loaded;
-			assert.strictEqual(search.entries.length, 3, "both realms contribute entries");
-			let entriesBefore = [...search.entries];
-			let orderBefore = entriesBefore.map((entry) => entry.id);
-			let realm2EntryBefore = entriesBefore.find((entry) => entry.realmUrl === testRealm2URL);
-			assert.ok(realm2EntryBefore, "realm 2 contributed an entry");
-			await realm.write("books/3.json", bookDoc("Paper"));
-			await waitUntil(() => search.entries.length === 4, { timeout: 1e4 });
-			assert.deepEqual(fetchedRealms[fetchedRealms.length - 1], [testRealmURL], "the refresh fetch is scoped to the realm whose index moved");
-			assert.deepEqual(search.entries.map((entry) => entry.id), [...orderBefore, `${testRealmURL}books/3`], "surviving rows keep their positions; the new row appends");
-			let realm2EntryAfter = search.entries.find((entry) => entry.realmUrl === testRealm2URL);
-			assert.strictEqual(realm2EntryAfter, realm2EntryBefore, "realm 2's entry keeps its identity through realm 1's refresh");
-			for (let entryBefore of entriesBefore.filter((entry) => entry.realmUrl === testRealmURL)) assert.strictEqual(search.entries.find((entry) => entry.id === entryBefore.id), entryBefore, `unchanged refreshed row ${entryBefore.id} keeps its identity`);
-			assert.strictEqual(search.meta.page.total, 4);
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-		}
-	});
-	(0, import_qunit.test)("a paginated query takes a full re-run on an incremental event, keeping the server total", async function(assert) {
-		let fetchedRealms = [];
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async (query, realms) => {
-			fetchedRealms.push(realms ?? []);
-			return await originalSearchEntries(query, realms);
-		};
-		try {
-			let search = getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				page: { size: 2 },
-				realms: [testRealmURL, testRealm2URL]
-			} } }));
-			await search.loaded;
-			assert.strictEqual(search.entries.length, 3);
-			assert.strictEqual(search.meta.page.total, 3, "the server total spans all pages");
-			await realm.write("books/3.json", bookDoc("Paper"));
-			await waitUntil(() => search.meta.page.total === 4, { timeout: 1e4 });
-			assert.deepEqual(fetchedRealms[fetchedRealms.length - 1], [testRealmURL, testRealm2URL], "a paginated query re-fetches all realms — no realm-scoped splice");
-			assert.strictEqual(search.entries.length, 3, "realm 1's contribution stays page-limited");
-			assert.strictEqual(search.meta.page.total, 4, "the total stays server-accurate after the live update");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-		}
-	});
-	(0, import_qunit.test)("a realm named by a registered prefix is searched, tagged and refreshed by the spelling the caller used", async function(assert) {
-		let { virtualNetwork } = getService("network");
-		virtualNetwork.addRealmMapping("@test/mapped/", testRealm2URL);
-		let fetchedRealms = [];
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async (query, realms) => {
-			fetchedRealms.push(realms ?? []);
-			return await originalSearchEntries(query, realms);
-		};
-		try {
-			let search = getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL, "@test/mapped/"]
-			} } }));
-			await search.loaded;
-			assert.strictEqual(search.entries.length, 3, "both realms answer");
-			let realm1EntriesBefore = search.entries.filter((entry) => entry.realmUrl === testRealmURL);
-			assert.strictEqual(realm1EntriesBefore.length, 2);
-			assert.deepEqual(search.entries.filter((entry) => entry.realmUrl === "@test/mapped/").map((entry) => entry.id), [`${testRealm2URL}books/other`], "the prefixed realm's row carries the realm as the caller named it");
-			await realm2.write("books/another.json", bookDoc("Hassan"));
-			await waitUntil(() => search.entries.length === 4, { timeout: 1e4 });
-			assert.deepEqual(fetchedRealms[fetchedRealms.length - 1], ["@test/mapped/"], "the event on the backing realm refreshes that realm alone");
-			for (let entryBefore of realm1EntriesBefore) assert.strictEqual(search.entries.find((entry) => entry.id === entryBefore.id), entryBefore, `the other realm's row ${entryBefore.id} keeps its identity`);
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-			virtualNetwork.removeRealmMapping("@test/mapped/");
-		}
-	});
-	(0, import_qunit.test)("an event in realm 2 refreshes realm 2's rows", async function(assert) {
-		let search = getResourceForTest(storeService, () => ({ named: { query: {
-			filter: { "item.on": bookRef },
-			realms: [testRealmURL, testRealm2URL]
-		} } }));
-		await search.loaded;
-		assert.strictEqual(search.entries.length, 3);
-		await realm2.write("books/another.json", JSON.stringify({ data: {
-			type: "card",
-			attributes: {
-				title: "Hassan",
-				status: "ready"
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("book"),
-				name: "Book"
-			} }
-		} }));
-		await waitUntil(() => search.entries.length === 4, { timeout: 1e4 });
-		assert.ok(search.entries.find((entry) => entry.id === `${testRealm2URL}books/another`), "realm 2's new book appears");
-	});
-	(0, import_qunit.test)("does not re-fetch when the query is structurally unchanged", async function(assert) {
-		let fetchCount = 0;
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async (query, realms) => {
-			fetchCount++;
-			return await originalSearchEntries(query, realms);
-		};
-		try {
-			let query = {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			};
-			let search = getResourceForTest(storeService, () => ({ named: { query } }));
-			await search.loaded;
-			assert.strictEqual(fetchCount, 1, "initial search performed once");
-			search.modify([], { query: JSON.parse(JSON.stringify(query)) });
-			await settled();
-			assert.strictEqual(fetchCount, 1, "no re-fetch for a deep-equal query");
-			search.modify([], { query: {
-				filter: {
-					"item.on": bookRef,
-					eq: { "item.status": "ready" }
-				},
-				realms: [testRealmURL]
-			} });
-			await settled();
-			assert.strictEqual(fetchCount, 2, "a changed query re-runs the search");
-			assert.strictEqual(search.entries.length, 1, "the new query narrows the result set");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-		}
-	});
-	(0, import_qunit.test)("destroying the resource tears down its realm subscriptions", async function(assert) {
-		let fetchCount = 0;
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async (query, realms) => {
-			fetchCount++;
-			return await originalSearchEntries(query, realms);
-		};
-		try {
-			let parent = {};
-			setOwner(parent, this.owner);
-			await getResourceForTest(parent, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			} } })).loaded;
-			assert.strictEqual(fetchCount, 1);
-			destroy(parent);
-			await settled();
-			await realm.write("books/3.json", bookDoc("Paper"));
-			await settled();
-			assert.strictEqual(fetchCount, 1, "no fetch fires for a realm event after the resource is destroyed");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-		}
-	});
-	(0, import_qunit.test)("a failed fetch surfaces errors; a later successful run clears them", async function(assert) {
-		let failNext = true;
-		let originalSearchEntries = storeService.searchEntries.bind(storeService);
-		storeService.searchEntries = async (query, realms) => {
-			if (failNext) {
-				failNext = false;
-				let err = /* @__PURE__ */ new Error("search exploded");
-				err.status = 500;
-				throw err;
-			}
-			return await originalSearchEntries(query, realms);
-		};
-		try {
-			let search = getResourceForTest(storeService, () => ({ named: { query: {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			} } }));
-			await search.loaded;
-			assert.strictEqual(search.entries.length, 0);
-			assert.strictEqual(search.errors?.length, 1);
-			assert.strictEqual(search.errors?.[0].type, "instance-error");
-			assert.false(search.isLoading, "a failed run settles isLoading (no permanent \"Searching…\")");
-			await realm.write("books/3.json", bookDoc("Paper"));
-			await waitUntil(() => search.entries.length === 3, { timeout: 1e4 });
-			assert.strictEqual(search.errors, void 0, "a successful re-run clears the errors");
-		} finally {
-			storeService.searchEntries = originalSearchEntries;
-		}
-	});
-	(0, import_qunit.module)("rendered consumption", function() {
-		class QueryState {
-			static {
-				decorateFieldV2(this.prototype, "query", [tracked]);
-			}
-			#query = (initializeDeferredDecorator(this, "query"), void 0);
-		}
-		class Harness extends Component {
-			search = getSearchEntriesResource(this, () => this.args.state.query);
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "cYXtxh4U",
-					"block": "[[[10,0],[14,\"data-test-entry-count\",\"\"],[12],[1,[30,0,[\"search\",\"entries\",\"length\"]]],[13]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/resources/search-entries-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		(0, import_qunit.test)("a rendered consumer activates from an idle query and clears back to idle", async function(assert) {
-			let state = new QueryState();
-			await render(setComponentTemplate(templateFactory({
-				"id": "DewS/Yhh",
-				"block": "[[[8,[32,0],null,[[\"@state\"],[[32,1]]],null]],[],[]]",
-				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/resources/search-entries-test.gts",
-				"scope": () => [Harness, state],
-				"isStrictMode": true
-			}), templateOnly()));
-			assert.dom("[data-test-entry-count]").hasText("0", "an idle (undefined) query renders empty");
-			state.query = {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			};
-			await settled();
-			assert.dom("[data-test-entry-count]").hasText("2", "setting the query activates the search");
-			state.query = void 0;
-			await settled();
-			assert.dom("[data-test-entry-count]").hasText("0", "returning to idle clears the standing entries");
-			state.query = {
-				filter: {
-					"item.on": bookRef,
-					eq: { "item.status": "ready" }
-				},
-				realms: [testRealmURL]
-			};
-			await settled();
-			assert.dom("[data-test-entry-count]").hasText("1", "a fresh query after idle re-activates");
-		});
-		(0, import_qunit.test)("changing realms while entries are standing re-runs cleanly", async function(assert) {
-			let state = new QueryState();
-			state.query = {
-				filter: { "item.on": bookRef },
-				realms: [testRealmURL]
-			};
-			await render(setComponentTemplate(templateFactory({
-				"id": "DewS/Yhh",
-				"block": "[[[8,[32,0],null,[[\"@state\"],[[32,1]]],null]],[],[]]",
-				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/resources/search-entries-test.gts",
-				"scope": () => [Harness, state],
-				"isStrictMode": true
-			}), templateOnly()));
-			assert.dom("[data-test-entry-count]").hasText("2");
-			state.query = {
-				filter: { "item.on": bookRef },
-				realms: [testRealm2URL]
-			};
-			await settled();
-			assert.dom("[data-test-entry-count]").hasText("1", "only the new realm's entries remain after the re-run");
-		});
-	});
-});
-//#endregion