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

package/bundled-test-harness/assets/search-entries-test-3DlqGPQq.js

@@ -0,0 +1,1486 @@
+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-FjsXmU7-.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