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

package/bundled-test-harness/assets/search-test-BYpq32RM.js

@@ -0,0 +1,2241 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, Dr as testRRI, Ro as isFileDefInstance, Sc as Deferred, _t as buildQuerySearchURL, ai as SEARCH_CONCURRENCY_CAP, ii as QUERY_FIELD_SEARCH_CONCURRENCY_CAP, oi as SearchBoundError } from "./runtime-common-ClpqhbwG.js";
+import { y as rri } from "./paths-BYHDgqsT.js";
+import { D as baseRealm, E as baseRRI } from "./constants-CqKWhRfY.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { r as setOwner } from "./owner-CP0__uFm.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { Tn as destroy } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { ht as run } from "./service-LFpJ8EEP.js";
+import "./destroyable-mdLYRn_o.js";
+import { l as RealmService } from "./card-prerender-Dke537bN.js";
+import { t as SearchResource } from "./search-BkQYpQDY.js";
+import { M as waitUntil, T as settled } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/resources/search-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubRealmService = class extends RealmService {
+	realmOf(_input) {
+		return testRealmURL;
+	}
+};
+function getSearchResourceForTest(owner, args) {
+	return SearchResource.from(owner, args);
+}
+(0, import_qunit.module)(`Integration | search resource`, function(hooks) {
+	let loader;
+	let loaderService;
+	let storeService;
+	let realm;
+	let cardApi;
+	let string;
+	setupRenderingTest(hooks);
+	hooks.beforeEach(function() {
+		getOwner(this).register("service:realm", StubRealmService);
+		loaderService = getService("loader-service");
+		loader = loaderService.loader;
+		storeService = getService("store");
+	});
+	setupLocalIndexing(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(async function() {
+		cardApi = await loader.import("@cardstack/base/card-api");
+		string = await loader.import("@cardstack/base/string");
+		let { contains, field, CardDef, FieldDef, linksTo } = cardApi;
+		let { default: StringField } = string;
+		class PersonField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "lastName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
+		}
+		class Article extends CardDef {
+			static displayName = "Article";
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return contains(PersonField);
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		class Post extends CardDef {
+			static displayName = "Post";
+			static {
+				decorateFieldV2(this.prototype, "article", [field], function() {
+					return linksTo(Article);
+				});
+			}
+			#article = (initializeDeferredDecorator(this, "article"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+		}
+		class BlogPost extends Post {
+			static displayName = "BlogPost";
+			static {
+				decorateFieldV2(this.prototype, "article", [field], function() {
+					return linksTo(Article);
+				});
+			}
+			#article = (initializeDeferredDecorator(this, "article"), void 0);
+		}
+		class Book extends CardDef {
+			static displayName = "Book";
+			static {
+				decorateFieldV2(this.prototype, "author", [field], function() {
+					return contains(PersonField);
+				});
+			}
+			#author = (initializeDeferredDecorator(this, "author"), void 0);
+		}
+		const sampleCards = {
+			"card-1.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Card 1",
+					cardDescription: "Sample post",
+					author: {
+						firstName: "Cardy",
+						lastName: "Stackington Jr. III"
+					},
+					views: 0
+				},
+				meta: { adoptsFrom: {
+					module: testRRI("article"),
+					name: "Article"
+				} }
+			} },
+			"card-2.json": { data: {
+				type: "card",
+				attributes: {
+					author: {
+						firstName: "Cardy",
+						lastName: "Jones"
+					},
+					editions: 1,
+					pubDate: "2023-09-01"
+				},
+				meta: { adoptsFrom: {
+					module: testRRI("book"),
+					name: "Book"
+				} }
+			} },
+			"cards/1.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Card 1",
+					cardDescription: "Sample post",
+					author: {
+						firstName: "Carl",
+						lastName: "Stack",
+						posts: 1
+					},
+					createdAt: new Date(2022, 7, 1),
+					views: 10
+				},
+				meta: { adoptsFrom: {
+					module: testRRI("post"),
+					name: "Post"
+				} }
+			} },
+			"cards/2.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Card 2",
+					cardDescription: "Sample post",
+					author: {
+						firstName: "Carl",
+						lastName: "Deck",
+						posts: 3
+					},
+					createdAt: new Date(2022, 7, 22),
+					views: 5
+				},
+				meta: { adoptsFrom: {
+					module: testRRI("article"),
+					name: "Article"
+				} }
+			} },
+			"books/1.json": { data: {
+				type: "card",
+				attributes: {
+					author: {
+						firstName: "Mango",
+						lastName: "Abdel-Rahman"
+					},
+					editions: 1,
+					pubDate: "2022-07-01"
+				},
+				meta: { adoptsFrom: {
+					module: testRRI("book"),
+					name: "Book"
+				} }
+			} },
+			"books/2.json": { data: {
+				type: "card",
+				attributes: {
+					author: {
+						firstName: "Van Gogh",
+						lastName: "Abdel-Rahman"
+					},
+					editions: 0,
+					pubDate: "2023-08-01"
+				},
+				meta: { adoptsFrom: {
+					module: testRRI("book"),
+					name: "Book"
+				} }
+			} },
+			"books/3.json": { data: {
+				type: "card",
+				attributes: {
+					author: {
+						firstName: "Jackie",
+						lastName: "Aguilar"
+					},
+					editions: 2,
+					pubDate: "2022-08-01"
+				},
+				meta: { adoptsFrom: {
+					module: testRRI("book"),
+					name: "Book"
+				} }
+			} },
+			"spec-1.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Post",
+					cardDescription: "A card that represents a blog post",
+					specType: "card",
+					ref: {
+						module: testRRI("post"),
+						name: "Post"
+					}
+				},
+				meta: { adoptsFrom: {
+					module: baseRRI("spec"),
+					name: "Spec"
+				} }
+			} },
+			"spec-2.json": { data: {
+				type: "card",
+				attributes: {
+					cardTitle: "Article",
+					cardDescription: "A card that represents an online article ",
+					specType: "card",
+					ref: {
+						module: testRRI("article"),
+						name: "Article"
+					}
+				},
+				meta: { adoptsFrom: {
+					module: baseRRI("spec"),
+					name: "Spec"
+				} }
+			} }
+		};
+		await withCachedRealmSetup(async () => {
+			({realm} = await setupIntegrationTestRealm({
+				mockMatrixUtils,
+				contents: {
+					"person-field.gts": { PersonField },
+					"article.gts": { Article },
+					"blog-post.gts": { BlogPost },
+					"book.gts": { Book },
+					"post.gts": { Post },
+					...sampleCards,
+					"files/hello.txt": "Hello world",
+					"files/notes.txt": "Some notes"
+				}
+			}));
+		});
+	});
+	(0, import_qunit.test)(`can search for card instances by using the 'eq' filter`, async function(assert) {
+		let query = { filter: {
+			on: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			eq: { "author.lastName": "Jones" }
+		} };
+		let search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: false,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		assert.strictEqual(search.instances[0].id, `${testRealmURL}card-2`);
+		assert.strictEqual(search.instances[0].constructor.name, "Book");
+	});
+	(0, import_qunit.test)(`search is not re-run when query and realms are unchanged`, async function(assert) {
+		let realmServer = getService("realm-server");
+		let fetchCalls = 0;
+		let originalMaybeAuthedFetchForRealms = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+		realmServer.maybeAuthedFetchForRealms = async (...args) => {
+			fetchCalls++;
+			return await originalMaybeAuthedFetchForRealms(...args);
+		};
+		try {
+			let args = {
+				query: { filter: {
+					on: {
+						module: testRRI("book"),
+						name: "Book"
+					},
+					eq: { "author.lastName": "Jones" }
+				} },
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			};
+			let search = getSearchResourceForTest(loaderService, () => ({ named: args }));
+			await search.loaded;
+			assert.strictEqual(fetchCalls, 1, "initial search performed once");
+			search.modify([], args);
+			await settled();
+			assert.strictEqual(fetchCalls, 1, "search is not invoked again when query/realms are unchanged");
+		} finally {
+			realmServer.maybeAuthedFetchForRealms = originalMaybeAuthedFetchForRealms;
+		}
+	});
+	(0, import_qunit.test)(`a search the realm server sheds with 429 is retried after Retry-After`, async function(assert) {
+		let realmServer = getService("realm-server");
+		let fetchCalls = 0;
+		let originalMaybeAuthedFetchForRealms = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+		realmServer.maybeAuthedFetchForRealms = async (...args) => {
+			fetchCalls++;
+			if (fetchCalls === 1) return new Response(JSON.stringify({ errors: [{
+				status: "429",
+				title: "Too Many Requests",
+				message: "shed"
+			}] }), {
+				status: 429,
+				headers: {
+					"content-type": "application/vnd.card+json",
+					"retry-after": "0"
+				}
+			});
+			return await originalMaybeAuthedFetchForRealms(...args);
+		};
+		try {
+			let query = { filter: {
+				on: {
+					module: testRRI("book"),
+					name: "Book"
+				},
+				eq: { "author.lastName": "Jones" }
+			} };
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			assert.strictEqual(fetchCalls, 2, "the shed search was sent again");
+			assert.strictEqual(search.instances[0].id, `${testRealmURL}card-2`, "and the retry produced the result");
+		} finally {
+			realmServer.maybeAuthedFetchForRealms = originalMaybeAuthedFetchForRealms;
+		}
+	});
+	(0, import_qunit.test)(`a search the realm server answers with 401 is reauthenticated and replayed once`, async function(assert) {
+		let realmServer = getService("realm-server");
+		let network = getService("network");
+		await realmServer.login();
+		let rejectedToken = realmServer.token;
+		assert.ok(rejectedToken, "the search starts with a realm-server session");
+		let attempts = [];
+		let gate = async (request) => {
+			if (!new URL(request.url).pathname.endsWith("/_federated-search")) return null;
+			attempts.push(request.headers.get("Authorization"));
+			if (attempts.length === 1) return new Response(JSON.stringify({ errors: ["Unauthorized Request"] }), {
+				status: 401,
+				headers: { "content-type": "application/vnd.card+json" }
+			});
+			return null;
+		};
+		network.virtualNetwork.mount(gate, { prepend: true });
+		let reauthCalls = 0;
+		let reauthedFor = [];
+		let sessionDuringMint = [];
+		let originalReauthenticate = realmServer.reauthenticateRealmServer.bind(realmServer);
+		realmServer.reauthenticateRealmServer = async (rejectedToken) => {
+			reauthCalls++;
+			reauthedFor.push(rejectedToken);
+			let pending = originalReauthenticate(rejectedToken);
+			sessionDuringMint.push(realmServer.token);
+			return await pending;
+		};
+		try {
+			let query = { filter: {
+				on: {
+					module: testRRI("book"),
+					name: "Book"
+				},
+				eq: { "author.lastName": "Jones" }
+			} };
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			assert.strictEqual(attempts.length, 2, "the rejected search was sent again");
+			assert.strictEqual(reauthCalls, 1, "and exactly one session was minted to send it with");
+			assert.strictEqual(attempts[0], `Bearer ${rejectedToken}`, "the first attempt carried the token the server rejected");
+			assert.strictEqual(attempts[1], `Bearer ${realmServer.token}`, "and the replay carried the session the service now holds");
+			assert.deepEqual(reauthedFor, [rejectedToken], "the mint was told which session the server refused");
+			assert.deepEqual(sessionDuringMint, [rejectedToken], "and the service stayed logged in for the length of the mint, so a concurrent caller never sees an anonymous session");
+			assert.strictEqual(search.instances[0].id, `${testRealmURL}card-2`, "and the replay produced the result");
+		} finally {
+			realmServer.reauthenticateRealmServer = originalReauthenticate;
+			network.virtualNetwork.unmount(gate);
+		}
+	});
+	(0, import_qunit.test)(`a 401 the realm server repeats is surfaced rather than replayed forever`, async function(assert) {
+		let realmServer = getService("realm-server");
+		let network = getService("network");
+		await realmServer.login();
+		let attempts = 0;
+		let gate = async (request) => {
+			if (!new URL(request.url).pathname.endsWith("/_federated-search")) return null;
+			attempts++;
+			return new Response(JSON.stringify({ errors: ["Unauthorized Request"] }), {
+				status: 401,
+				headers: { "content-type": "application/vnd.card+json" }
+			});
+		};
+		network.virtualNetwork.mount(gate, { prepend: true });
+		try {
+			let query = { filter: {
+				on: {
+					module: testRRI("book"),
+					name: "Book"
+				},
+				eq: { "author.lastName": "Jones" }
+			} };
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			assert.strictEqual(attempts, 2, "the search was replayed once and then left alone");
+			assert.strictEqual(search.instances.length, 0, "and the still-refused search yields no results");
+		} finally {
+			network.virtualNetwork.unmount(gate);
+		}
+	});
+	(0, import_qunit.test)(`can perform a live search for cards`, async function(assert) {
+		let query = { filter: {
+			on: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			eq: { "author.lastName": "Abdel-Rahman" }
+		} };
+		let search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: true,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		assert.strictEqual(search.instances.length, 2);
+		assert.strictEqual(search.instances[0].id, `${testRealmURL}books/1`);
+		assert.strictEqual(search.instances[1].id, `${testRealmURL}books/2`);
+		await realm.write("books/3.json", JSON.stringify({ data: {
+			type: "card",
+			attributes: {
+				author: {
+					firstName: "Paper",
+					lastName: "Abdel-Rahman"
+				},
+				editions: 0,
+				pubDate: "2023-08-01"
+			},
+			meta: { adoptsFrom: {
+				module: testRRI("book"),
+				name: "Book"
+			} }
+		} }));
+		await waitUntil(() => search.instances.length === 3);
+		assert.strictEqual(search.instances.length, 3);
+		assert.strictEqual(search.instances[0].id, `${testRealmURL}books/1`);
+		assert.strictEqual(search.instances[1].id, `${testRealmURL}books/2`);
+		assert.strictEqual(search.instances[2].id, `${testRealmURL}books/3`);
+	});
+	(0, import_qunit.test)(`a live search of a realm named by a registered prefix re-runs on that realm's events`, async function(assert) {
+		let { virtualNetwork } = getService("network");
+		virtualNetwork.addRealmMapping("@test/mapped/", testRealmURL);
+		let messageService = getService("message-service");
+		let originalSubscribe = messageService.subscribe.bind(messageService);
+		let subscribedTo = [];
+		messageService.subscribe = (realmURL, cb) => {
+			subscribedTo.push(realmURL);
+			return originalSubscribe(realmURL, cb);
+		};
+		let originalSearchWithMeta = storeService.searchWithMeta.bind(storeService);
+		let searchedRealms = [];
+		storeService.searchWithMeta = async (query, realms, opts) => {
+			searchedRealms.push([...realms ?? []]);
+			return await originalSearchWithMeta(query, realms, opts);
+		};
+		try {
+			await getSearchResourceForTest(loaderService, () => ({ named: {
+				query: {},
+				realms: ["@test/mapped/"],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} })).loaded;
+			assert.true(subscribedTo.includes("@test/mapped/"), "the search subscribes by the spelling the caller used");
+			let runsBefore = searchedRealms.length;
+			assert.deepEqual(searchedRealms[runsBefore - 1], ["@test/mapped/"], "the search itself keeps the caller spelling");
+			await realm.write("books/3.json", JSON.stringify({ data: {
+				type: "card",
+				attributes: { author: {
+					firstName: "Paper",
+					lastName: "Abdel-Rahman"
+				} },
+				meta: { adoptsFrom: {
+					module: testRRI("book"),
+					name: "Book"
+				} }
+			} }));
+			await waitUntil(() => searchedRealms.length > runsBefore, { timeout: 1e4 });
+			assert.ok(true, "the realm's event re-ran the search");
+		} finally {
+			messageService.subscribe = originalSubscribe;
+			storeService.searchWithMeta = originalSearchWithMeta;
+			virtualNetwork.removeRealmMapping("@test/mapped/");
+		}
+	});
+	(0, import_qunit.test)(`a base realm card is merged and grouped whichever spelling names the base realm`, async function(assert) {
+		let spellings = [
+			baseRealm.url,
+			new URL(config.resolvedBaseRealmURL).href,
+			"@cardstack/base/"
+		];
+		for (let [index, spelling] of spellings.entries()) {
+			let title = `local-base-${index}-${Date.now()}`;
+			let query = { filter: {
+				on: {
+					module: baseRRI("card-api"),
+					name: "CardDef"
+				},
+				eq: { "cardInfo.name": title }
+			} };
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query,
+				realms: [spelling],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.deepEqual(search.instances, [], `${spelling}: the server returns nothing for the title`);
+			let local = await storeService.addWithoutPersisting({ data: {
+				type: "card",
+				id: `${baseRealm.url}cards/${title}`,
+				attributes: { cardInfo: { name: title } },
+				meta: { adoptsFrom: {
+					module: baseRRI("card-api"),
+					name: "CardDef"
+				} }
+			} });
+			await settled();
+			assert.strictEqual(String(local.id), `@cardstack/base/cards/${title}`, `${spelling}: the store names the card by prefix`);
+			assert.deepEqual(search.instances.map((instance) => instance.id), [local.id], `${spelling}: the local base card is merged`);
+			assert.deepEqual(search.instancesByRealm.map((group) => [group.realm, group.cards.map((card) => card.id)]), [[spelling, [local.id]]], `${spelling}: it is grouped under the realm as the caller named it`);
+		}
+	});
+	(0, import_qunit.test)(`a seed older than an event's generation is declined for a realm named by a registered prefix`, async function(assert) {
+		let { virtualNetwork } = getService("network");
+		virtualNetwork.addRealmMapping("@test/mapped/", testRealmURL);
+		let originalSearchWithMeta = storeService.searchWithMeta.bind(storeService);
+		let runs = 0;
+		storeService.searchWithMeta = async (query, realms, opts) => {
+			let result = await originalSearchWithMeta(query, realms, opts);
+			runs++;
+			return result;
+		};
+		try {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: {},
+				realms: ["@test/mapped/"],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			let runsBefore = runs;
+			getService("message-service").relayRealmEvent({
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${testRealmURL}books/1.json`],
+				generation: 10,
+				realmURL: testRealmURL
+			});
+			await waitUntil(() => runs > runsBefore, { timeout: 1e4 });
+			await settled();
+			let held = search.instances.map((instance) => instance.id);
+			let stale = await storeService.addWithoutPersisting(new cardApi.CardDef({ cardTitle: "Stale" }));
+			search.reseed({
+				cards: [stale],
+				identity: "stale-seed",
+				generation: 5,
+				realm: testRealmURL
+			});
+			await settled();
+			assert.deepEqual(search.instances.map((instance) => instance.id), held, "the stale seed does not replace the set the event refreshed");
+		} finally {
+			storeService.searchWithMeta = originalSearchWithMeta;
+			virtualNetwork.removeRealmMapping("@test/mapped/");
+		}
+	});
+	(0, import_qunit.test)(`a burst of realm events coalesces into a single live re-run`, async function(assert) {
+		let realmServer = getService("realm-server");
+		let fetchCalls = 0;
+		let originalMaybeAuthedFetchForRealms = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+		realmServer.maybeAuthedFetchForRealms = async (...args) => {
+			fetchCalls++;
+			return await originalMaybeAuthedFetchForRealms(...args);
+		};
+		try {
+			let query = { filter: {
+				on: {
+					module: testRRI("book"),
+					name: "Book"
+				},
+				eq: { "author.lastName": "Abdel-Rahman" }
+			} };
+			await getSearchResourceForTest(loaderService, () => ({ named: {
+				query,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} })).loaded;
+			let baseline = fetchCalls;
+			let messageService = getService("message-service");
+			for (let generation = 1; generation <= 5; generation++) messageService.relayRealmEvent({
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${testRealmURL}books/1.json`],
+				generation,
+				realmURL: testRealmURL
+			});
+			await settled();
+			assert.strictEqual(fetchCalls, baseline + 1, "five index events inside one window produce one search fetch");
+			messageService.relayRealmEvent({
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${testRealmURL}books/1.json`],
+				generation: 6,
+				realmURL: testRealmURL
+			});
+			await settled();
+			assert.strictEqual(fetchCalls, baseline + 2, "an event after the flush schedules its own re-run");
+		} finally {
+			realmServer.maybeAuthedFetchForRealms = originalMaybeAuthedFetchForRealms;
+		}
+	});
+	(0, import_qunit.test)(`a query change inside the window folds the pending re-run into it`, async function(assert) {
+		let realmServer = getService("realm-server");
+		let fetchCalls = 0;
+		let originalMaybeAuthedFetchForRealms = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+		realmServer.maybeAuthedFetchForRealms = async (...args) => {
+			fetchCalls++;
+			return await originalMaybeAuthedFetchForRealms(...args);
+		};
+		try {
+			let args = {
+				query: { filter: {
+					on: {
+						module: testRRI("book"),
+						name: "Book"
+					},
+					eq: { "author.lastName": "Abdel-Rahman" }
+				} },
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			};
+			let search = getSearchResourceForTest(loaderService, () => ({ named: args }));
+			await search.loaded;
+			let baseline = fetchCalls;
+			getService("message-service").relayRealmEvent({
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${testRealmURL}books/1.json`],
+				generation: 1,
+				realmURL: testRealmURL
+			});
+			search.modify([], {
+				...args,
+				query: { filter: {
+					on: {
+						module: testRRI("book"),
+						name: "Book"
+					},
+					eq: { "author.lastName": "Jones" }
+				} }
+			});
+			await settled();
+			assert.strictEqual(fetchCalls, baseline + 1, "the query change folds the armed flush into its own run; no redundant second search fires");
+		} finally {
+			realmServer.maybeAuthedFetchForRealms = originalMaybeAuthedFetchForRealms;
+		}
+	});
+	(0, import_qunit.module)("realm event type gating", function() {
+		const unrelatedType = `${testRealmURL}observation/Observation`;
+		const unrelatedURL = `${testRealmURL}observations/1`;
+		const unrelatedFileURL = `${unrelatedURL}.json`;
+		const bookType = `${testRealmURL}book/Book`;
+		const postType = `${testRealmURL}post/Post`;
+		const blogPostType = `${testRealmURL}blog-post/BlogPost`;
+		function relayIndexEvent(invalidatedTypes, invalidations = [unrelatedURL]) {
+			getService("message-service").relayRealmEvent({
+				eventName: "index",
+				indexType: "incremental",
+				invalidations,
+				...invalidatedTypes !== void 0 ? { invalidatedTypes } : {},
+				realmURL: testRealmURL
+			});
+		}
+		function relayPrerenderHtmlEvent(invalidations = [unrelatedFileURL], generation = 1) {
+			getService("message-service").relayRealmEvent({
+				eventName: "prerender_html",
+				invalidations,
+				generation,
+				realmURL: testRealmURL
+			});
+		}
+		function countingFetch() {
+			let realmServer = getService("realm-server");
+			let fetchCalls = 0;
+			let original = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+			realmServer.maybeAuthedFetchForRealms = async (...args) => {
+				fetchCalls++;
+				return await original(...args);
+			};
+			return {
+				count: () => fetchCalls,
+				restore: () => {
+					realmServer.maybeAuthedFetchForRealms = original;
+				}
+			};
+		}
+		function liveSearch(owner, query) {
+			return getSearchResourceForTest(loaderService, () => ({ named: {
+				query,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner
+			} }));
+		}
+		(0, import_qunit.test)("an index event that touched no anchored type does not re-run the query", async function(assert) {
+			let fetch = countingFetch();
+			try {
+				await liveSearch(this.owner, { filter: {
+					on: {
+						module: testRRI("book"),
+						name: "Book"
+					},
+					eq: {}
+				} }).loaded;
+				let baseline = fetch.count();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 1, "the first typed event re-runs while the anchors resolve");
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 1, "a write to a type the query is not anchored on is skipped");
+				relayIndexEvent([unrelatedType, bookType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 2, "an event naming the anchored type re-runs the query");
+				relayIndexEvent(void 0);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 3, "an event carrying no type information re-runs the query");
+			} finally {
+				fetch.restore();
+			}
+		});
+		(0, import_qunit.test)("a write to a subtype wakes a query anchored on its ancestor", async function(assert) {
+			let fetch = countingFetch();
+			try {
+				await liveSearch(this.owner, { filter: {
+					on: {
+						module: testRRI("post"),
+						name: "Post"
+					},
+					eq: {}
+				} }).loaded;
+				let baseline = fetch.count();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 1, "the anchors resolve and the second unrelated event is skipped");
+				relayIndexEvent([blogPostType, postType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 2, "a subtype write names the ancestor in its chain, so the query re-runs");
+			} finally {
+				fetch.restore();
+			}
+		});
+		(0, import_qunit.test)("a prerender_html event over rows an index event judged unrelated is skipped", async function(assert) {
+			let fetch = countingFetch();
+			try {
+				await liveSearch(this.owner, { filter: {
+					on: {
+						module: testRRI("book"),
+						name: "Book"
+					},
+					eq: {}
+				} }).loaded;
+				let baseline = fetch.count();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 1, "the index channel is gated once the anchors resolve");
+				relayPrerenderHtmlEvent([unrelatedFileURL]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 1, "the render of a row no index event tied to this query is skipped");
+				relayPrerenderHtmlEvent([`${testRealmURL}books/1.json`]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 2, "a render this query holds no verdict for re-runs it");
+			} finally {
+				fetch.restore();
+			}
+		});
+		(0, import_qunit.test)("an index event that could move a member withdraws its rows from the render gate", async function(assert) {
+			let fetch = countingFetch();
+			try {
+				await liveSearch(this.owner, { filter: {
+					on: {
+						module: testRRI("book"),
+						name: "Book"
+					},
+					eq: {}
+				} }).loaded;
+				let baseline = fetch.count();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				relayPrerenderHtmlEvent([unrelatedFileURL]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 1, "both channels are gated for a row judged unrelated");
+				relayIndexEvent([bookType], [unrelatedURL]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 2, "the re-typed row re-runs the query on the index channel");
+				relayPrerenderHtmlEvent([unrelatedFileURL]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 3, "and its render is no longer skipped");
+			} finally {
+				fetch.restore();
+			}
+		});
+		(0, import_qunit.test)("a query that admits a card of any type re-runs on every event", async function(assert) {
+			let fetch = countingFetch();
+			try {
+				await liveSearch(this.owner, { filter: { eq: { "author.lastName": "Abdel-Rahman" } } }).loaded;
+				let baseline = fetch.count();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 2, "an unanchored filter can gain a member of any type, so nothing is skipped");
+				relayPrerenderHtmlEvent([unrelatedFileURL]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 3, "and its renders are not skipped either");
+			} finally {
+				fetch.restore();
+			}
+		});
+		(0, import_qunit.test)("a query change re-resolves the anchors before they gate again", async function(assert) {
+			let fetch = countingFetch();
+			try {
+				let args = {
+					query: { filter: {
+						on: {
+							module: testRRI("book"),
+							name: "Book"
+						},
+						eq: {}
+					} },
+					realms: [testRealmURL],
+					isLive: true,
+					isAutoSaved: false,
+					storeService,
+					owner: this.owner
+				};
+				let search = getSearchResourceForTest(loaderService, () => ({ named: args }));
+				await search.loaded;
+				let baseline = fetch.count();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), baseline + 1, "the anchors resolve and the second event is skipped");
+				search.modify([], {
+					...args,
+					query: { filter: {
+						on: {
+							module: testRRI("post"),
+							name: "Post"
+						},
+						eq: {}
+					} }
+				});
+				await settled();
+				let afterChange = fetch.count();
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), afterChange + 1, "the first event after the change re-runs while the anchors re-resolve");
+				relayIndexEvent([unrelatedType]);
+				await settled();
+				assert.strictEqual(fetch.count(), afterChange + 1, "the re-resolved anchors gate again");
+				relayIndexEvent([postType]);
+				await settled();
+				assert.strictEqual(fetch.count(), afterChange + 2, "and they gate against the new query, not the old one");
+			} finally {
+				fetch.restore();
+			}
+		});
+	});
+	(0, import_qunit.test)(`cards in search results live update`, async function(assert) {
+		let query = { filter: {
+			on: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			eq: { "author.lastName": "Abdel-Rahman" }
+		} };
+		let search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: true,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		assert.strictEqual(search.instances.length, 2);
+		assert.strictEqual(search.instances[0].author.firstName, `Mango`);
+		await realm.write("books/1.json", JSON.stringify({ data: {
+			type: "card",
+			attributes: {
+				author: {
+					firstName: "Mang Mang",
+					lastName: "Abdel-Rahman"
+				},
+				editions: 0,
+				pubDate: "2023-08-01"
+			},
+			meta: { adoptsFrom: {
+				module: testRRI("book"),
+				name: "Book"
+			} }
+		} }));
+		await search.loaded;
+		await settled();
+		assert.strictEqual(search.instances.length, 2);
+		assert.strictEqual(search.instances[0].author.firstName, `Mang Mang`);
+	});
+	(0, import_qunit.test)(`can paginate search results and returns correct meta.page.total`, async function(assert) {
+		let query = {
+			filter: { type: {
+				module: testRRI("book"),
+				name: "Book"
+			} },
+			page: {
+				number: 0,
+				size: 2
+			},
+			sort: [{
+				by: "author.firstName",
+				on: {
+					module: testRRI("book"),
+					name: "Book"
+				},
+				direction: "asc"
+			}]
+		};
+		let search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: false,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		assert.strictEqual(search.instances.length, 2);
+		assert.strictEqual(search.meta.page?.total, 4, "meta.page.total shows total count across all pages");
+		query.page = {
+			number: 1,
+			size: 2
+		};
+		search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: false,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		assert.strictEqual(search.instances.length, 2);
+		assert.strictEqual(search.meta.page?.total, 4, "meta.page.total consistent across pages");
+		query.page = {
+			number: 2,
+			size: 2
+		};
+		search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: false,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		assert.strictEqual(search.instances.length, 0);
+		assert.strictEqual(search.meta.page?.total, 4, "meta.page.total remains correct on empty page");
+	});
+	(0, import_qunit.test)(`can search for file-meta instances using SearchResource`, async function(assert) {
+		let query = { filter: { type: {
+			module: baseRRI("card-api"),
+			name: "FileDef"
+		} } };
+		let search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: false,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		assert.ok(search.instances.length >= 2, "returns file-meta instances");
+		let ids = search.instances.map((i) => i.id);
+		assert.ok(ids.includes(rri(`${testRealmURL}files/hello.txt`)), "hello.txt is in results");
+		assert.ok(ids.includes(rri(`${testRealmURL}files/notes.txt`)), "notes.txt is in results");
+		for (let instance of search.instances) assert.ok(isFileDefInstance(instance), `${instance.id} is a FileDef instance`);
+	});
+	(0, import_qunit.test)(`can perform a live search for file-meta instances`, async function(assert) {
+		let query = { filter: { type: {
+			module: baseRRI("card-api"),
+			name: "FileDef"
+		} } };
+		let search = getSearchResourceForTest(loaderService, () => ({ named: {
+			query,
+			realms: [testRealmURL],
+			isLive: true,
+			isAutoSaved: false,
+			storeService,
+			owner: this.owner
+		} }));
+		await search.loaded;
+		let initialCount = search.instances.length;
+		assert.ok(initialCount >= 2, "initial results include file-meta instances");
+		await realm.write("files/new-file.txt", "New content");
+		await waitUntil(() => search.instances.length > initialCount);
+		let ids = search.instances.map((i) => i.id);
+		assert.ok(ids.includes(rri(`${testRealmURL}files/new-file.txt`)), "new file appears in live search results");
+		assert.ok(isFileDefInstance(search.instances.find((i) => i.id === `${testRealmURL}files/new-file.txt`)), "new file is a FileDef instance");
+	});
+	(0, import_qunit.module)(`in-flight search dedup`, function(innerHooks) {
+		let releaseFetch;
+		let fetchCalls;
+		let restoreFetch;
+		innerHooks.beforeEach(function() {
+			releaseFetch = new Deferred();
+			fetchCalls = 0;
+			let realmServer = getService("realm-server");
+			let original = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+			realmServer.maybeAuthedFetchForRealms = async (url, ...args) => {
+				if (typeof url === "string" && url.includes("_federated-search")) {
+					fetchCalls++;
+					await releaseFetch.promise;
+				}
+				return await original(url, ...args);
+			};
+			restoreFetch = () => {
+				realmServer.maybeAuthedFetchForRealms = original;
+			};
+		});
+		innerHooks.afterEach(function() {
+			try {
+				releaseFetch.fulfill();
+			} catch {}
+			restoreFetch?.();
+			restoreFetch = void 0;
+			globalThis.__boxelRenderContext = void 0;
+			storeService.clearInFlightSearch();
+		});
+		let bookQuery = { filter: {
+			on: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			eq: { "author.lastName": "Jones" }
+		} };
+		(0, import_qunit.test)(`concurrent same-key store.search calls share a single fetch when inside a prerender`, async function(assert) {
+			globalThis.__boxelRenderContext = true;
+			let p1 = storeService.search(bookQuery, [testRealmURL]);
+			let p2 = storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "second caller coalesces onto first in-flight fetch");
+			releaseFetch.fulfill();
+			let [r1, r2] = await Promise.all([p1, p2]);
+			assert.deepEqual(r1.map((i) => i.id ?? null), r2.map((i) => i.id ?? null), "both callers receive the same resolved instances");
+		});
+		(0, import_qunit.test)(`a realm named by a registered prefix coalesces with the same realm named by URL`, async function(assert) {
+			globalThis.__boxelRenderContext = true;
+			let { virtualNetwork } = getService("network");
+			virtualNetwork.addRealmMapping("@test/mapped/", testRealmURL);
+			try {
+				let p1 = storeService.search(bookQuery, ["@test/mapped/"]);
+				let p2 = storeService.search(bookQuery, [testRealmURL, "@test/mapped/"]);
+				assert.strictEqual(fetchCalls, 1, "both spellings key one in-flight fetch");
+				releaseFetch.fulfill();
+				await Promise.all([p1, p2]);
+			} finally {
+				virtualNetwork.removeRealmMapping("@test/mapped/");
+			}
+		});
+		(0, import_qunit.test)(`concurrent same-key store.search calls do NOT coalesce outside a prerender`, async function(assert) {
+			let p1 = storeService.search(bookQuery, [testRealmURL]);
+			let p2 = storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "both callers fire their own fetch outside the prerender gate");
+			releaseFetch.fulfill();
+			await Promise.all([p1, p2]);
+		});
+		(0, import_qunit.test)(`different queries produce different keys and run independently inside a prerender`, async function(assert) {
+			globalThis.__boxelRenderContext = true;
+			let otherQuery = { filter: {
+				on: {
+					module: testRRI("book"),
+					name: "Book"
+				},
+				eq: { "author.lastName": "Abdel-Rahman" }
+			} };
+			let p1 = storeService.search(bookQuery, [testRealmURL]);
+			let p2 = storeService.search(otherQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "different filters do not coalesce even inside a prerender");
+			releaseFetch.fulfill();
+			await Promise.all([p1, p2]);
+		});
+		(0, import_qunit.test)(`sequential same-key calls fall through after the first resolves (in-flight only, no resolved-doc cache)`, async function(assert) {
+			globalThis.__boxelRenderContext = true;
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "first call fetches once");
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "sequential same-key call re-fetches after the first resolves");
+		});
+		(0, import_qunit.test)(`clearInFlightSearch drops pending entries so new same-key callers re-fetch`, async function(assert) {
+			globalThis.__boxelRenderContext = true;
+			let p1 = storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "first fetch in-flight");
+			storeService.clearInFlightSearch();
+			let p2 = storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "post-clear same-key caller fires a fresh fetch");
+			releaseFetch.fulfill();
+			await Promise.all([p1, p2]);
+		});
+	});
+	(0, import_qunit.module)(`job-scoped resolved-doc search cache`, function(innerHooks) {
+		let releaseFetch;
+		let fetchCalls;
+		let restoreFetch;
+		innerHooks.beforeEach(function() {
+			releaseFetch = new Deferred();
+			fetchCalls = 0;
+			let realmServer = getService("realm-server");
+			let original = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+			realmServer.maybeAuthedFetchForRealms = async (url, ...args) => {
+				if (typeof url === "string" && url.includes("_federated-search")) {
+					fetchCalls++;
+					await releaseFetch.promise;
+				}
+				return await original(url, ...args);
+			};
+			restoreFetch = () => {
+				realmServer.maybeAuthedFetchForRealms = original;
+			};
+		});
+		innerHooks.afterEach(function() {
+			try {
+				releaseFetch.fulfill();
+			} catch {}
+			restoreFetch?.();
+			restoreFetch = void 0;
+			let g = globalThis;
+			g.__boxelRenderContext = void 0;
+			g.__boxelJobId = void 0;
+			g.__boxelRenderScope = void 0;
+			g.__boxelConsumingRealm = void 0;
+			storeService.clearInFlightSearch();
+			storeService.clearSearchCache();
+		});
+		let bookQuery = { filter: {
+			on: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			eq: { "author.lastName": "Jones" }
+		} };
+		function enterPrerender(jobId, consumingRealm) {
+			let g = globalThis;
+			g.__boxelRenderContext = true;
+			g.__boxelJobId = jobId;
+			g.__boxelConsumingRealm = consumingRealm;
+		}
+		(0, import_qunit.test)(`sequential same-key store.search calls hit the resolved-doc cache (one fetch total)`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			releaseFetch.fulfill();
+			let r1 = await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "first call populates cache");
+			let r2 = await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "second sequential same-key call serves from cache, no network");
+			assert.deepEqual(r1.map((i) => i.id ?? null), r2.map((i) => i.id ?? null), "cached doc returns the same instance set");
+		});
+		(0, import_qunit.test)(`a realm named by a registered prefix hits the same-realm cache of its URL`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			releaseFetch.fulfill();
+			let { virtualNetwork } = getService("network");
+			virtualNetwork.addRealmMapping("@test/mapped/", testRealmURL);
+			try {
+				await storeService.search(bookQuery, ["@test/mapped/"]);
+				await storeService.search(bookQuery, [testRealmURL]);
+				assert.strictEqual(fetchCalls, 1, "the second spelling is served from the first one's cache entry");
+			} finally {
+				virtualNetwork.removeRealmMapping("@test/mapped/");
+			}
+		});
+		(0, import_qunit.test)(`base named by its prefix hits the same-realm cache when the consuming realm is its alias`, async function(assert) {
+			enterPrerender("job-1", baseRealm.url);
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, ["@cardstack/base/"]);
+			await storeService.search(bookQuery, ["@cardstack/base/"]);
+			assert.strictEqual(fetchCalls, 1, "the second search is served from the first one's cache entry");
+		});
+		(0, import_qunit.test)(`cache bypasses outside a prerender (live SPA path)`, async function(assert) {
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "two sequential calls each fetch — no cache outside prerender");
+		});
+		(0, import_qunit.test)(`cache bypasses when __boxelJobId is unset (prerender with no job)`, async function(assert) {
+			let g = globalThis;
+			g.__boxelRenderContext = true;
+			g.__boxelConsumingRealm = testRealmURL;
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "sequential calls re-fetch when no jobId is on the page");
+		});
+		(0, import_qunit.test)(`cache bypasses cross-realm reads even inside a prerender`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL, "http://other-realm/data/"]);
+			await storeService.search(bookQuery, [testRealmURL, "http://other-realm/data/"]);
+			assert.strictEqual(fetchCalls, 2, "cross-realm reads bypass the same-realm cache");
+		});
+		(0, import_qunit.test)(`jobId change drops the cache (defensive clear at fetch-entry)`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "populates cache under job-1");
+			globalThis.__boxelJobId = "job-2";
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "cache entry from prior job is not served under new jobId");
+		});
+		(0, import_qunit.test)(`a render-scope change drops the cache while the job stays the same`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			let g = globalThis;
+			g.__boxelRenderScope = `${testRealmURL}@1`;
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "one scope serves repeats from cache");
+			g.__boxelRenderScope = `${testRealmURL}@1~1`;
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "an answer cached under the previous scope is not served under the new one");
+		});
+		(0, import_qunit.test)(`clearSearchCache drops cached entries so subsequent same-key calls re-fetch`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "first call populates cache");
+			storeService.clearSearchCache();
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "post-clear same-key caller re-fetches");
+		});
+		(0, import_qunit.test)(`cache hit short-circuits before the in-flight Map is consulted`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "first call populates cache");
+			let p1 = storeService.search(bookQuery, [testRealmURL]);
+			let p2 = storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "cache short-circuits both callers");
+			await Promise.all([p1, p2]);
+		});
+		(0, import_qunit.test)(`cache survives across renders within the same indexing job`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "first render populates cache");
+			storeService.clearInFlightSearch();
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "second render in the same job reuses the cached doc");
+		});
+		(0, import_qunit.test)(`clearSearchCache during an in-flight fetch suppresses the post-resolve populate`, async function(assert) {
+			enterPrerender("job-1", testRealmURL);
+			let p1 = storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 1, "first call entered the fetch");
+			storeService.clearSearchCache();
+			releaseFetch.fulfill();
+			await p1;
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "post-clear repopulate was suppressed; next call re-fetches");
+		});
+		(0, import_qunit.test)(`consumingRealm mismatch on a single-realm search bypasses the cache`, async function(assert) {
+			enterPrerender("job-1", "http://other-realm/data/");
+			releaseFetch.fulfill();
+			await storeService.search(bookQuery, [testRealmURL]);
+			await storeService.search(bookQuery, [testRealmURL]);
+			assert.strictEqual(fetchCalls, 2, "single-realm search against a non-consumingRealm is not cached");
+		});
+	});
+	(0, import_qunit.module)(`non-live SearchResource with seed (prerender query-field path)`, function(innerHooks) {
+		let releaseFetch;
+		let fetchCalls;
+		let restoreFetch;
+		innerHooks.beforeEach(function() {
+			releaseFetch = new Deferred();
+			fetchCalls = 0;
+			let realmServer = getService("realm-server");
+			let original = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+			realmServer.maybeAuthedFetchForRealms = async (url, ...args) => {
+				if (typeof url === "string" && url.includes("_federated-search")) {
+					fetchCalls++;
+					await releaseFetch.promise;
+				}
+				return await original(url, ...args);
+			};
+			restoreFetch = () => {
+				realmServer.maybeAuthedFetchForRealms = original;
+			};
+		});
+		innerHooks.afterEach(function() {
+			try {
+				releaseFetch.fulfill();
+			} catch {}
+			restoreFetch?.();
+			restoreFetch = void 0;
+			globalThis.__boxelRenderContext = void 0;
+			storeService.clearInFlightSearch();
+		});
+		let bookQuery = { filter: {
+			on: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			eq: { "author.lastName": "Abdel-Rahman" }
+		} };
+		async function buildSeed() {
+			releaseFetch.fulfill();
+			return {
+				cards: await storeService.search(bookQuery, [testRealmURL]),
+				searchURL: buildQuerySearchURL([testRealmURL], bookQuery)
+			};
+		}
+		(0, import_qunit.test)(`a seed that reports its count unknowable does not have one inferred from its rows`, async function(assert) {
+			let { cards, searchURL } = await buildSeed();
+			fetchCalls = 0;
+			globalThis.__boxelRenderContext = true;
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				seed: {
+					cards,
+					searchURL,
+					realms: [testRealmURL],
+					totalUnknown: true
+				},
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, cards.length, "the seeded rows are still held");
+			assert.strictEqual(search.totalMatchCount, void 0, "but no match count is reported");
+			assert.false(search.isPartial, "and no shortfall is claimed against a count nobody reported");
+		});
+		(0, import_qunit.test)(`a seed carrying a count larger than its rows reports the shortfall`, async function(assert) {
+			let { cards, searchURL } = await buildSeed();
+			fetchCalls = 0;
+			globalThis.__boxelRenderContext = true;
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				seed: {
+					cards,
+					searchURL,
+					realms: [testRealmURL],
+					meta: { page: { total: cards.length + 3 } }
+				},
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.totalMatchCount, cards.length + 3, "the seeded match count is reported as given");
+			assert.true(search.isPartial, "and the rows falling short of it is a shortfall");
+		});
+		(0, import_qunit.test)(`seed-only resolve: no fetch fires when isLive=false and a seed is present (prerender path)`, async function(assert) {
+			let { cards, searchURL } = await buildSeed();
+			fetchCalls = 0;
+			globalThis.__boxelRenderContext = true;
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				seed: {
+					cards,
+					searchURL,
+					realms: [testRealmURL]
+				},
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(fetchCalls, 0, "seed-only resolve: no _federated-search fetch fires");
+			assert.strictEqual(search.instances.length, cards.length, "resource exposes seed cards");
+			assert.deepEqual(search.instances.map((i) => i.id), cards.map((c) => c.id), "seed cards are returned in order");
+		});
+		(0, import_qunit.test)(`a seed carrying no meta infers the total from its rows`, async function(assert) {
+			let { cards, searchURL } = await buildSeed();
+			fetchCalls = 0;
+			globalThis.__boxelRenderContext = true;
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				seed: {
+					cards,
+					searchURL,
+					realms: [testRealmURL]
+				},
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.meta?.page?.total, cards.length, "nothing was withheld, so the rows in hand are the match count");
+			assert.notOk(search.meta?.incomplete, "and the result set is not labelled short");
+		});
+		(0, import_qunit.test)(`a seed labelled incomplete keeps the label, so its count reads as a floor`, async function(assert) {
+			let { cards, searchURL } = await buildSeed();
+			fetchCalls = 0;
+			globalThis.__boxelRenderContext = true;
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				seed: {
+					cards,
+					searchURL,
+					realms: [testRealmURL],
+					meta: {
+						page: { total: cards.length },
+						incomplete: true
+					},
+					queryErrors: [{
+						realm: "https://example.invalid/offline/",
+						type: "network",
+						message: "realm did not answer"
+					}]
+				},
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.true(search.meta?.incomplete, "the label survives seeding, so a consumer can tell the count is a floor");
+			assert.strictEqual(search.instances.length, cards.length, "the realms that answered still contribute their rows");
+		});
+		(0, import_qunit.test)(`a search that fails as a unit refuses to call its empty result a count`, async function(assert) {
+			releaseFetch.fulfill();
+			let realmServer = getService("realm-server");
+			realmServer.maybeAuthedFetchForRealms = async () => {
+				throw new Error("realm did not answer");
+			};
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, 0, "the failed search holds no rows");
+			assert.true(search.meta?.incomplete, "and labels the empty result set, so its zero is not read as a count");
+		});
+		(0, import_qunit.test)(`a live resource seeded with its document's answer subscribes without searching`, async function(assert) {
+			let { cards, searchURL } = await buildSeed();
+			fetchCalls = 0;
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				seed: {
+					cards,
+					searchURL,
+					realms: [testRealmURL]
+				},
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, cards.length, "the seed resolves the field to the set the document named");
+			assert.strictEqual(fetchCalls, 0, "and no search is issued to re-derive it");
+		});
+		(0, import_qunit.test)(`non-live with no seed still fetches (other non-live callers are unaffected)`, async function(assert) {
+			releaseFetch.fulfill();
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			assert.ok(fetchCalls >= 1, "non-live + no-seed callers still hit the network");
+			assert.strictEqual(search.instances.length, 2, "returns the books matching the query");
+		});
+		(0, import_qunit.test)(`empty unresolved seed still falls back to a fetch in prerender (cards=[], no searchURL)`, async function(assert) {
+			releaseFetch.fulfill();
+			globalThis.__boxelRenderContext = true;
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: bookQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				seed: {
+					cards: [],
+					realms: [testRealmURL]
+				},
+				owner: this.owner
+			} }));
+			await search.loaded;
+			assert.ok(fetchCalls >= 1, "empty unresolved seed in prerender falls back to fetch");
+			assert.strictEqual(search.instances.length, 2, "fallback fetch returns the books matching the query");
+		});
+	});
+	(0, import_qunit.module)(`client-side Store filtering step`, function(innerHooks) {
+		let fetchCalls;
+		let restoreFetch;
+		innerHooks.beforeEach(function() {
+			fetchCalls = 0;
+			let realmServer = getService("realm-server");
+			let original = realmServer.maybeAuthedFetchForRealms.bind(realmServer);
+			realmServer.maybeAuthedFetchForRealms = async (url, ...args) => {
+				if (typeof url === "string" && url.includes("_federated-search")) fetchCalls++;
+				return await original(url, ...args);
+			};
+			restoreFetch = () => {
+				realmServer.maybeAuthedFetchForRealms = original;
+			};
+		});
+		innerHooks.afterEach(function() {
+			restoreFetch?.();
+			restoreFetch = void 0;
+		});
+		const bookRef = {
+			module: testRRI("book"),
+			name: "Book"
+		};
+		let abdelRahmanQuery = { filter: {
+			on: bookRef,
+			eq: { "author.lastName": "Abdel-Rahman" }
+		} };
+		let aguilarQuery = { filter: {
+			on: bookRef,
+			eq: { "author.lastName": "Aguilar" }
+		} };
+		async function addBookCandidate(idPath, firstName, lastName) {
+			return await storeService.addWithoutPersisting({ data: {
+				type: "card",
+				id: `${testRealmURL}${idPath}`,
+				attributes: {
+					author: {
+						firstName,
+						lastName
+					},
+					editions: 0,
+					pubDate: "2024-01-01"
+				},
+				meta: { adoptsFrom: bookRef }
+			} });
+		}
+		(0, import_qunit.test)(`a locally added matching card appears in an eligible live search without a server round-trip`, async function(assert) {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, 2, "server returns the two matching books");
+			let fetchesBefore = fetchCalls;
+			await addBookCandidate("books/local-new", "Apple", "Abdel-Rahman");
+			await settled();
+			let ids = search.instances.map((i) => i.id);
+			assert.strictEqual(search.instances.length, 3, "the locally added matching card is merged into the result set");
+			assert.ok(ids.includes(rri(`${testRealmURL}books/local-new`)), "the new card appears in results");
+			assert.strictEqual(fetchCalls, fetchesBefore, "no _federated-search fetch fired for the client-side recompute");
+		});
+		(0, import_qunit.test)(`a surfaced candidate is not duplicated even though it is keyed by both local and remote id`, async function(assert) {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			let candidate = await addBookCandidate("books/dupe-check", "Apple", "Abdel-Rahman");
+			await settled();
+			let poolOccurrences = storeService.allCardInstances().filter((c) => c === candidate).length;
+			assert.strictEqual(poolOccurrences, 1, "the candidate appears exactly once in allCardInstances despite dual keying");
+			let ids = search.instances.map((i) => i.id);
+			assert.strictEqual(ids.length, new Set(ids).size, "the displayed result set has no duplicate ids");
+			assert.strictEqual(ids.filter((id) => id === rri(`${testRealmURL}books/dupe-check`)).length, 1, "the surfaced candidate is rendered exactly once");
+			assert.strictEqual(search.instances.length, 3, "two server books plus the single surfaced candidate");
+		});
+		(0, import_qunit.test)(`a server-returned card that no longer matches local state is removed`, async function(assert) {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, 2);
+			let book1 = storeService.peek(`${testRealmURL}books/1`);
+			book1.author.lastName = "Changed";
+			let ids = search.instances.map((i) => i.id);
+			assert.strictEqual(search.instances.length, 1, "the now-non-matching server card is removed");
+			assert.notOk(ids.includes(rri(`${testRealmURL}books/1`)), "books/1 dropped from results");
+		});
+		(0, import_qunit.test)(`editing a candidate toggles its membership reactively (recompute on Store mutation)`, async function(assert) {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, 2);
+			let candidate = await addBookCandidate("books/edit-me", "Switch", "Other");
+			await settled();
+			assert.strictEqual(search.instances.length, 2, "a candidate that does not match is not shown");
+			candidate.author.lastName = "Abdel-Rahman";
+			assert.strictEqual(search.instances.length, 3, "after editing to match, the candidate appears");
+			assert.ok(search.instances.map((i) => i.id).includes(rri(`${testRealmURL}books/edit-me`)));
+			candidate.author.lastName = "Other again";
+			assert.strictEqual(search.instances.length, 2, "after editing away from match, the candidate disappears");
+		});
+		(0, import_qunit.test)(`a merged candidate is reference-retained while displayed and released when it leaves`, async function(assert) {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			let candidate = await addBookCandidate("books/retained", "Apple", "Abdel-Rahman");
+			let candidateId = `${testRealmURL}books/retained`;
+			await settled();
+			assert.strictEqual(storeService.getReferenceCount(candidateId), 0, "a freshly hydrated candidate carries no reference before it is displayed");
+			assert.ok(search.instances.map((i) => i.id).includes(rri(candidateId)), "the candidate is displayed");
+			await settled();
+			assert.ok(storeService.getReferenceCount(candidateId) > 0, "a Store reference is retained while the candidate is displayed");
+			candidate.author.lastName = "Other";
+			assert.notOk(search.instances.map((i) => i.id).includes(rri(candidateId)), "the candidate leaves the result set");
+			await settled();
+			assert.strictEqual(storeService.getReferenceCount(candidateId), 0, "the reference is released once the candidate is no longer displayed");
+		});
+		(0, import_qunit.test)(`the merged set is ordered per the query sort`, async function(assert) {
+			let sortedQuery = {
+				filter: {
+					on: bookRef,
+					eq: { "author.lastName": "Abdel-Rahman" }
+				},
+				sort: [{
+					by: "author.firstName",
+					on: bookRef,
+					direction: "asc"
+				}]
+			};
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: sortedQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.deepEqual(search.instances.map((i) => i.id), [`${testRealmURL}books/1`, `${testRealmURL}books/2`]);
+			await addBookCandidate("books/apple", "Apple", "Abdel-Rahman");
+			await settled();
+			assert.deepEqual(search.instances.map((i) => i.id), [
+				`${testRealmURL}books/apple`,
+				`${testRealmURL}books/1`,
+				`${testRealmURL}books/2`
+			], "the candidate sorts into position by author.firstName");
+		});
+		(0, import_qunit.test)(`one-shot store.search never runs the client step (server-only)`, async function(assert) {
+			await addBookCandidate("books/local-only", "Local", "Abdel-Rahman");
+			let result = await storeService.search(abdelRahmanQuery, [testRealmURL]);
+			assert.notOk(result.map((c) => c.id).includes(`${testRealmURL}books/local-only`), "one-shot store.search ignores the local-only candidate");
+		});
+		(0, import_qunit.test)(`a non-live search is a server-only passthrough`, async function(assert) {
+			await addBookCandidate("books/passthrough", "Zoe", "Abdel-Rahman");
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: false,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, 2, "a non-live search ignores the local candidate");
+			assert.notOk(search.instances.map((i) => i.id).includes(rri(`${testRealmURL}books/passthrough`)));
+		});
+		(0, import_qunit.test)(`an incompletely-loaded (paginated) result set skips the client step`, async function(assert) {
+			let pagedQuery = {
+				filter: { type: bookRef },
+				page: {
+					number: 0,
+					size: 2
+				},
+				sort: [{
+					by: "author.firstName",
+					on: bookRef,
+					direction: "asc"
+				}]
+			};
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: pagedQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, 2, "first page holds 2");
+			assert.strictEqual(search.meta.page?.total, 4, "total is 4 across all pages — the loaded set is incomplete");
+			await addBookCandidate("books/paged-extra", "Aaa", "Zzz");
+			await settled();
+			assert.strictEqual(search.instances.length, 2, "an incomplete result set is not reconciled against the Store");
+			assert.notOk(search.instances.map((i) => i.id).includes(rri(`${testRealmURL}books/paged-extra`)));
+		});
+		(0, import_qunit.test)(`a non-client-evaluable filter (matches) forces server-only`, async function(assert) {
+			let matchesQuery = { filter: { matches: "Abdel-Rahman" } };
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: matchesQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			let serverIds = search.instances.map((i) => i.id);
+			await addBookCandidate("books/matches-extra", "Nope", "Abdel-Rahman");
+			await settled();
+			assert.ok(storeService.peek(`${testRealmURL}books/matches-extra`), "the candidate is hydrated in the Store");
+			assert.deepEqual(search.instances.map((i) => i.id), serverIds, "the displayed set stays equal to the server result — no candidate merged");
+			assert.notOk(search.instances.map((i) => i.id).includes(rri(`${testRealmURL}books/matches-extra`)), "the locally added candidate is not pulled into a matches search");
+		});
+		(0, import_qunit.test)(`a candidate evicted from the Store drops out of the displayed set on the next reactive pass`, async function(assert) {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			await addBookCandidate("books/will-evict", "Plum", "Abdel-Rahman");
+			await settled();
+			let candidateId = `${testRealmURL}books/will-evict`;
+			assert.ok(search.instances.map((i) => i.id).includes(rri(candidateId)), "the candidate is displayed before eviction");
+			let fetchesBefore = fetchCalls;
+			storeService.store.delete(candidateId);
+			await settled();
+			assert.notOk(search.instances.map((i) => i.id).includes(rri(candidateId)), "the candidate drops out after a Store eviction");
+			assert.strictEqual(fetchCalls, fetchesBefore, "no _federated-search fetch fired for the recompute");
+		});
+		(0, import_qunit.test)(`a candidate with an unresolvable predicate (unloaded linksTo) is not added`, async function(assert) {
+			let postRef = {
+				module: testRRI("post"),
+				name: "Post"
+			};
+			let query = { filter: {
+				on: postRef,
+				eq: { "article.cardTitle": "Any Title" }
+			} };
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			let serverIds = search.instances.map((i) => i.id);
+			await storeService.addWithoutPersisting({ data: {
+				type: "card",
+				id: `${testRealmURL}posts/unresolved`,
+				attributes: { cardTitle: "Lonely Post" },
+				relationships: { article: { links: { self: `${testRealmURL}does/not/exist` } } },
+				meta: { adoptsFrom: postRef }
+			} });
+			await settled();
+			assert.deepEqual(search.instances.map((i) => i.id), serverIds, "an unresolvable candidate does not enter the displayed set");
+			assert.notOk(search.instances.map((i) => i.id).includes(rri(`${testRealmURL}posts/unresolved`)), "the unresolvable candidate is absent");
+		});
+		(0, import_qunit.test)(`a Store candidate outside the query's target realm is not added`, async function(assert) {
+			let otherRealmURL = "https://other-realm.example/";
+			await storeService.addWithoutPersisting({ data: {
+				type: "card",
+				id: `${otherRealmURL}books/foreign`,
+				attributes: {
+					author: {
+						firstName: "Foreign",
+						lastName: "Abdel-Rahman"
+					},
+					editions: 0,
+					pubDate: "2024-01-01"
+				},
+				meta: { adoptsFrom: bookRef }
+			} });
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			let ids = search.instances.map((i) => i.id).map(String);
+			assert.strictEqual(search.instances.length, 2, "only the two in-realm matches are displayed");
+			assert.notOk(ids.some((id) => id.startsWith(otherRealmURL)), "the candidate outside [testRealmURL] is excluded");
+		});
+		(0, import_qunit.test)(`override authority: a server-card removal and a candidate add both reach the displayed set`, async function(assert) {
+			let search = getSearchResourceForTest(loaderService, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				storeService,
+				owner: this.owner
+			} }));
+			await search.loaded;
+			await settled();
+			assert.strictEqual(search.instances.length, 2);
+			let book1 = storeService.peek(`${testRealmURL}books/1`);
+			book1.author.lastName = "Changed";
+			await addBookCandidate("books/local-add", "Local", "Abdel-Rahman");
+			await settled();
+			let ids = search.instances.map((i) => i.id);
+			assert.strictEqual(search.instances.length, 2, "one server card dropped, one local candidate surfaced — same count, different members");
+			assert.notOk(ids.includes(rri(`${testRealmURL}books/1`)), "the now-non-matching server card is gone");
+			assert.ok(ids.includes(rri(`${testRealmURL}books/local-add`)), "the local-only matching candidate is present");
+		});
+		(0, import_qunit.test)("performThrottledSearch caps concurrent card searches at the configured limit", async function(assert) {
+			let inFlight = 0;
+			let maxInFlight = 0;
+			let started = 0;
+			let gates = [];
+			let count = SEARCH_CONCURRENCY_CAP + 2;
+			let makeRun = () => {
+				let gate = new Deferred();
+				gates.push(gate);
+				return async () => {
+					started++;
+					inFlight++;
+					maxInFlight = Math.max(maxInFlight, inFlight);
+					await gate.promise;
+					inFlight--;
+				};
+			};
+			let results = Array.from({ length: count }, () => storeService.performThrottledSearch(makeRun(), "card"));
+			try {
+				await waitUntil(() => started >= SEARCH_CONCURRENCY_CAP);
+				assert.strictEqual(maxInFlight, SEARCH_CONCURRENCY_CAP, "no more than the cap run at once");
+				assert.strictEqual(started, SEARCH_CONCURRENCY_CAP, "excess searches are queued, not started");
+			} finally {
+				for (let gate of gates) {
+					gate.fulfill();
+					await settled();
+				}
+				await Promise.all(results);
+			}
+			assert.strictEqual(maxInFlight, SEARCH_CONCURRENCY_CAP, "the cap held across the whole drain");
+			assert.strictEqual(started, count, "every queued search eventually ran (enqueue, not drop)");
+		});
+		(0, import_qunit.test)("a throttled search waits for a slot before it reaches the network; a host search does not", async function(assert) {
+			let cap = fillTheLane("query-field");
+			await waitUntil(cap.started, { timeout: 5e3 });
+			fetchCalls = 0;
+			let throttledDone = false;
+			let throttled = storeService.search(abdelRahmanQuery, [testRealmURL], { throttled: true }).then(() => {
+				throttledDone = true;
+			});
+			let hostDone = false;
+			let host = storeService.search(abdelRahmanQuery, [testRealmURL]).then(() => {
+				hostDone = true;
+			});
+			try {
+				await waitUntil(() => hostDone, { timeout: 5e3 });
+				assert.strictEqual(fetchCalls, 1, "the host search reached the network while every slot was taken");
+				assert.false(throttledDone, "the throttled search is still queued behind the full cap");
+			} finally {
+				await cap.release();
+			}
+			await throttled;
+			await host;
+			assert.true(throttledDone, "the throttled search ran once a slot freed");
+			assert.strictEqual(fetchCalls, 2, "it reached the network only after it had a slot");
+		});
+		(0, import_qunit.test)("a card search reaches the network while the query-field lane is full", async function(assert) {
+			let cap = fillTheLane("query-field");
+			await waitUntil(cap.started, { timeout: 5e3 });
+			fetchCalls = 0;
+			let queryFieldDone = false;
+			let queryField = storeService.search(abdelRahmanQuery, [testRealmURL], { throttled: true }).then(() => {
+				queryFieldDone = true;
+			});
+			let cardDone = false;
+			let card = storeService.search(abdelRahmanQuery, [testRealmURL], { cardInitiated: true }).then(() => {
+				cardDone = true;
+			});
+			try {
+				await waitUntil(() => cardDone, { timeout: 5e3 });
+				assert.strictEqual(fetchCalls, 1, "the card search reached the network past the queued fan-out");
+				assert.false(queryFieldDone, "the query-field search is still queued behind its own full lane");
+			} finally {
+				await cap.release();
+			}
+			await queryField;
+			await card;
+			assert.strictEqual(fetchCalls, 2, "the query-field search ran once its lane freed");
+		});
+		(0, import_qunit.test)("a query-field search reaches the network while the card lane is full", async function(assert) {
+			let cap = fillTheLane("card");
+			await waitUntil(cap.started, { timeout: 5e3 });
+			fetchCalls = 0;
+			let cardDone = false;
+			let card = storeService.search(abdelRahmanQuery, [testRealmURL], { cardInitiated: true }).then(() => {
+				cardDone = true;
+			});
+			let queryFieldDone = false;
+			let queryField = storeService.search(abdelRahmanQuery, [testRealmURL], { throttled: true }).then(() => {
+				queryFieldDone = true;
+			});
+			try {
+				await waitUntil(() => queryFieldDone, { timeout: 5e3 });
+				assert.strictEqual(fetchCalls, 1, "the query-field search reached the network past the queued card search");
+				assert.false(cardDone, "the card search is still queued behind its own full lane");
+			} finally {
+				await cap.release();
+			}
+			await card;
+			await queryField;
+			assert.strictEqual(fetchCalls, 2, "the card search ran once its lane freed");
+		});
+		(0, import_qunit.test)("a queued search whose consumer has gone away gives back its slot instead of fetching", async function(assert) {
+			let cap = fillTheLane("query-field");
+			await waitUntil(cap.started, { timeout: 5e3 });
+			fetchCalls = 0;
+			let obsolete = false;
+			let queued = storeService.searchWithMeta(abdelRahmanQuery, [testRealmURL], {
+				throttled: true,
+				isObsolete: () => obsolete
+			});
+			obsolete = true;
+			await cap.release();
+			let result = await queued;
+			assert.strictEqual(fetchCalls, 0, "the abandoned search never reached the network");
+			assert.deepEqual(result.instances, [], "it resolves empty for the caller that is no longer listening");
+			assert.strictEqual(result.meta.page?.total, 0, "and reports no count rather than a stale one");
+		});
+		function fillTheLane(lane) {
+			let laneCap = lane === "card" ? SEARCH_CONCURRENCY_CAP : QUERY_FIELD_SEARCH_CONCURRENCY_CAP;
+			let gates = [];
+			let occupied = 0;
+			let occupying = Array.from({ length: laneCap }, () => {
+				let gate = new Deferred();
+				gates.push(gate);
+				return storeService.performThrottledSearch(async () => {
+					occupied++;
+					await gate.promise;
+				}, lane);
+			});
+			return {
+				started: () => occupied >= laneCap,
+				release: async () => {
+					for (let gate of gates) try {
+						gate.fulfill();
+					} catch {}
+					await Promise.all(occupying);
+				}
+			};
+		}
+		function countThrottledRuns() {
+			let enqueued = 0;
+			let perform = storeService.performThrottledSearch.bind(storeService);
+			storeService.performThrottledSearch = (run, lane) => {
+				enqueued++;
+				return perform(run, lane);
+			};
+			return {
+				enqueued: () => enqueued,
+				restore: () => delete storeService.performThrottledSearch
+			};
+		}
+		(0, import_qunit.test)("a queued search superseded by a query change never sends the superseded query", async function(assert) {
+			let cap = fillTheLane("query-field");
+			await waitUntil(cap.started, { timeout: 5e3 });
+			let counter = countThrottledRuns();
+			fetchCalls = 0;
+			let args = {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				throttled: true,
+				storeService,
+				owner: this.owner
+			};
+			let search = getSearchResourceForTest(loaderService, () => ({ named: args }));
+			try {
+				search.isLoading;
+				await waitUntil(() => counter.enqueued() > 0, { timeout: 5e3 });
+				search.modify([], {
+					...args,
+					query: aguilarQuery
+				});
+				await waitUntil(() => counter.enqueued() > 1, { timeout: 5e3 });
+				await cap.release();
+				await settled();
+				assert.strictEqual(fetchCalls, 1, "only the surviving query reached the network");
+				assert.strictEqual(search.instances.length, 1, "the resource holds the surviving query's one match, not the superseded query's two");
+			} finally {
+				counter.restore();
+				await cap.release();
+			}
+		});
+		(0, import_qunit.test)("a queued search whose resource is destroyed never reaches the network", async function(assert) {
+			let cap = fillTheLane("query-field");
+			await waitUntil(cap.started, { timeout: 5e3 });
+			let counter = countThrottledRuns();
+			fetchCalls = 0;
+			let parent = {};
+			setOwner(parent, this.owner);
+			let search = getSearchResourceForTest(parent, () => ({ named: {
+				query: abdelRahmanQuery,
+				realms: [testRealmURL],
+				isLive: true,
+				isAutoSaved: false,
+				throttled: true,
+				storeService,
+				owner: this.owner
+			} }));
+			try {
+				search.isLoading;
+				await waitUntil(() => counter.enqueued() > 0, { timeout: 5e3 });
+				run(() => destroy(parent));
+				await cap.release();
+				await settled();
+				assert.strictEqual(fetchCalls, 0, "the destroyed resource never sent the search it had queued");
+			} finally {
+				counter.restore();
+				await cap.release();
+			}
+		});
+		(0, import_qunit.test)("a card-initiated search over the realms cap is rejected; the host is not", async function(assert) {
+			let query = { filter: { eq: {} } };
+			let realms = [
+				"http://r1/",
+				"http://r2/",
+				"http://r3/"
+			];
+			await assert.rejects(storeService.search(query, realms, { cardInitiated: true }), (e) => e instanceof SearchBoundError, "a card search over the realms cap throws a SearchBoundError");
+			let hostErr;
+			try {
+				await storeService.search(query, realms);
+			} catch (e) {
+				hostErr = e;
+			}
+			assert.false(hostErr instanceof SearchBoundError, "the host search is not subject to the realms cap");
+		});
+		(0, import_qunit.test)("a card-initiated search over the page cap is rejected", async function(assert) {
+			await assert.rejects(storeService.search({ page: { size: 1e3 } }, ["http://r1/"], { cardInitiated: true }), (e) => e instanceof SearchBoundError, "a card search over the page cap throws a SearchBoundError");
+		});
+		(0, import_qunit.test)("the card-facing store defaults a no-realm search to the current realm", async function(assert) {
+			let results = await storeService.cardFacingStore(() => void 0).search({ filter: { eq: {} } });
+			assert.deepEqual(results, [], "a no-realm search with no current realm is empty");
+			let bound = storeService.cardFacingStore(() => "http://current/");
+			await assert.rejects(bound.search({ filter: { eq: {} } }, [
+				"http://r1/",
+				"http://r2/",
+				"http://r3/"
+			]), (e) => e instanceof SearchBoundError, "the facade enforces the realms cap on an explicit list");
+		});
+		(0, import_qunit.test)("the card-facing store withholds the search methods that skip the caps", async function(assert) {
+			let cardStore = storeService.cardFacingStore(() => "http://current/");
+			for (let name of [
+				"searchWithMeta",
+				"searchEntries",
+				"getWithoutCache"
+			]) {
+				assert.strictEqual(typeof storeService[name], "function", `${name} is a real method on the store service`);
+				assert.strictEqual(cardStore[name], void 0, `${name} is not reachable through the card-facing store`);
+			}
+			for (let name of [
+				"save",
+				"create",
+				"add",
+				"addWithoutPersisting",
+				"addWithoutWaiting",
+				"peek",
+				"peekError",
+				"get",
+				"delete",
+				"patch",
+				"search",
+				"getSaveState"
+			]) assert.strictEqual(typeof cardStore[name], "function", `${name} is reachable through the card-facing store`);
+		});
+		(0, import_qunit.test)("the card-facing store gives no way back to the service and refuses writes", async function(assert) {
+			let cardStore = storeService.cardFacingStore(() => "http://current/");
+			let realGet = storeService.get;
+			let realSearch = storeService.search;
+			assert.strictEqual(cardStore.valueOf(), cardStore, "valueOf answers the facade, not the service");
+			assert.strictEqual(cardStore.valueOf().searchWithMeta, void 0, "so an uncapped sibling stays out of reach through it");
+			assert.strictEqual(String(cardStore), "[object Object]", "the facade still converts to a string");
+			assert.throws(() => {
+				cardStore.get = () => "replaced";
+			}, TypeError, "assigning a method through the facade is refused");
+			assert.throws(() => cardStore.__defineGetter__("search", () => "replaced"), TypeError, "defining a getter through the facade is refused");
+			assert.throws(() => Object.defineProperty(cardStore, "patch", { value: "replaced" }), TypeError, "defining a property on the facade is refused");
+			assert.throws(() => {
+				delete cardStore.search;
+			}, TypeError, "deleting a method through the facade is refused");
+			assert.strictEqual(storeService.get, realGet, "the service's get is untouched");
+			assert.strictEqual(storeService.search, realSearch, "the service's search is untouched");
+			for (let name of [
+				"get",
+				"search",
+				"patch"
+			]) assert.false(Object.prototype.hasOwnProperty.call(storeService, name), `nothing was installed as an own ${name} on the service`);
+		});
+	});
+});
+//#endregion