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

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

@@ -1,2249 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Br as testRealmURL, Lr as testRRI, Qo as isFileDefInstance, Rc as Deferred, bt as buildQuerySearchURL, gi as SearchBoundError, hi as SEARCH_CONCURRENCY_CAP, mi as QUERY_FIELD_SEARCH_CONCURRENCY_CAP } from "./runtime-common-BTaLJEw-.js";
-import { T as rri } from "./paths-C9-NYXnM.js";
-import { D as baseRRI, O as baseRealm } from "./constants-Icc0nFW-.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 { t as SearchResource } from "./search-C8UKYVZ8.js";
-import { n as RealmService } from "./realm-CaK5mkT-.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-Dd8k0DNa.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);
-}
-async function waitForLiveRefresh(search, isRefreshed, expectation) {
-	let waitStart = performance.now();
-	try {
-		await waitUntil(isRefreshed, { timeout: 1e4 });
-	} catch (e) {
-		throw new Error(`live search did not reach ${expectation} ${Math.round(performance.now() - waitStart)} ms after the write; it holds ${JSON.stringify(search.instances.map((i) => i.id))}, isLoading=${search.isLoading}: ${e}`);
-	}
-}
-(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 waitForLiveRefresh(search, () => search.instances.length === 3, "3 instances");
-		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 waitForLiveRefresh(search, () => search.instances.length > initialCount, `more than ${initialCount} instances`);
-		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