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

package/bundled-test-harness/assets/query-fields-test-DQiMFRCe.js

@@ -0,0 +1,535 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, Or as testRealmInfo, Wn as APP_BOXEL_REALM_EVENT_TYPE, uo as SupportedMimeType } from "./runtime-common-ClpqhbwG.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { M as waitUntil, T as settled, a as find, d as click, i as findAll, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, O as saveCard, ct as setupApplicationTest, j as setupAcceptanceTestRealm, st as visitOperatorMode, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, C as card_api_exports, H as linksTo, U as linksToMany, a as CardDef, l as FieldDef, s as Component, w as contains } from "./card-api-Dzje0smT.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+//#region tests/acceptance/query-fields-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var QUERY_CARD_URL = `${testRealmURL}query-card`;
+var QUERY_CARD_2_URL = `${testRealmURL}query-card-2`;
+var QUERY_CARD_NESTED_URL = `${testRealmURL}query-card-nested`;
+var QUERY_CARD_MISSING_URL = `${testRealmURL}query-card-missing`;
+var TYPE_FILTER_CARD_URL = `${testRealmURL}type-filter-card`;
+(0, import_qunit.module)("Acceptance | Query Fields | host respects server-populated results", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: false
+	});
+	let loader;
+	let PersonClass;
+	hooks.beforeEach(async function() {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		PersonClass = Person;
+		class Animal extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class QueryLinksField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "favorite", [field], function() {
+					return linksTo(() => Person, { query: { filter: { eq: { name: "$this.cardTitle" } } } });
+				});
+			}
+			#favorite = (initializeDeferredDecorator(this, "favorite"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "matches", [field], function() {
+					return linksToMany(() => Person, { query: {
+						filter: { eq: { name: "$this.cardTitle" } },
+						page: {
+							size: 10,
+							number: 0
+						}
+					} });
+				});
+			}
+			#matches = (initializeDeferredDecorator(this, "matches"), void 0);
+		}
+		class QueryCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "favorite", [field], function() {
+					return linksTo(() => Person, { query: { filter: { eq: { name: "$this.cardTitle" } } } });
+				});
+			}
+			#favorite = (initializeDeferredDecorator(this, "favorite"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "matches", [field], function() {
+					return linksToMany(() => Person, { query: {
+						filter: { eq: { name: "$this.cardTitle" } },
+						page: {
+							size: 10,
+							number: 0
+						}
+					} });
+				});
+			}
+			#matches = (initializeDeferredDecorator(this, "matches"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "FShbkKU6",
+						"block": "[[[10,0],[14,\"data-test-inline-title\",\"\"],[12],[1,\"\\n  \"],[8,[30,1,[\"cardTitle\"]],null,[[\"@format\"],[\"edit\"]],null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,0],[14,\"data-test-favorite\",\"\"],[12],[1,\"\\n\"],[41,[30,2,[\"favorite\"]],[[[1,\"    \"],[1,[30,2,[\"favorite\",\"name\"]]],[1,\"\\n\"]],[]],null],[13],[1,\"\\n\"],[10,\"ul\"],[14,\"data-test-matches\",\"\"],[12],[1,\"\\n\"],[42,[28,[31,2],[[28,[31,2],[[30,2,[\"matches\"]]],null]],null],null,[[[1,\"    \"],[10,\"li\"],[14,\"data-test-match\",\"\"],[12],[1,[30,3,[\"name\"]]],[13],[1,\"\\n\"]],[3]],null],[13]],[\"@fields\",\"@model\",\"match\"],[\"if\",\"each\",\"-track-array\"]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/query-fields-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class QueryCardNested extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "queries", [field], function() {
+					return contains(QueryLinksField);
+				});
+			}
+			#queries = (initializeDeferredDecorator(this, "queries"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "6L1YN2D+",
+						"block": "[[[10,0],[14,\"data-test-inline-title\",\"\"],[12],[1,\"\\n  \"],[8,[30,1,[\"queries\",\"cardTitle\"]],null,[[\"@format\"],[\"edit\"]],null],[1,\"\\n\"],[13],[1,\"\\n\"],[10,0],[14,\"data-test-favorite\",\"\"],[12],[1,\"\\n\"],[41,[30,2,[\"queries\",\"favorite\"]],[[[1,\"    \"],[1,[30,2,[\"queries\",\"favorite\",\"name\"]]],[1,\"\\n\"]],[]],null],[13],[1,\"\\n\"],[10,\"ul\"],[14,\"data-test-matches\",\"\"],[12],[1,\"\\n\"],[42,[28,[31,2],[[28,[31,2],[[30,2,[\"queries\",\"matches\"]]],null]],null],null,[[[1,\"    \"],[10,\"li\"],[14,\"data-test-match\",\"\"],[12],[1,[30,3,[\"name\"]]],[13],[1,\"\\n\"]],[3]],null],[13]],[\"@fields\",\"@model\",\"match\"],[\"if\",\"each\",\"-track-array\"]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/query-fields-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		class TypeFilterCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "matches", [field], function() {
+					return linksToMany(() => Person, { query: { page: {
+						size: 10,
+						number: 0
+					} } });
+				});
+			}
+			#matches = (initializeDeferredDecorator(this, "matches"), void 0);
+			static isolated = class Isolated extends Component {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "AnzEqNR4",
+						"block": "[[[10,\"ul\"],[14,\"data-test-matches\",\"\"],[12],[1,\"\\n\"],[42,[28,[31,1],[[28,[31,1],[[30,1,[\"matches\"]]],null]],null],null,[[[1,\"    \"],[10,\"li\"],[14,\"data-test-match\",\"\"],[12],[1,[30,2,[\"name\"]]],[13],[1,\"\\n\"]],[2]],null],[13]],[\"@model\",\"match\"],[\"each\",\"-track-array\"]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/query-fields-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		await setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"query-card.gts": {
+					Person,
+					QueryCard,
+					Animal
+				},
+				"query-card-nested.gts": {
+					Person,
+					QueryCardNested,
+					QueryLinksField
+				},
+				"type-filter-card.gts": {
+					TypeFilterCard,
+					Person
+				},
+				"Person/target.json": new Person({ name: "Target" }),
+				"Person/not-target.json": new Person({ name: "Not Target" }),
+				"Animal/target.json": new Animal({ name: "Target" }),
+				"query-card.json": new QueryCard({ cardTitle: "Target" }),
+				"query-card-2.json": new QueryCard({ cardTitle: "Not Target" }),
+				"query-card-nested.json": new QueryCardNested({ queries: new QueryLinksField({ cardTitle: "Target" }) }),
+				"query-card-missing.json": new QueryCard({ cardTitle: "Missing" }),
+				"type-filter-card.json": new TypeFilterCard()
+			}
+		});
+		loader = getService("loader-service").loader;
+	});
+	(0, import_qunit.test)("host does not re-fetch query-backed relationships", async function(assert) {
+		assert.expect(9);
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			interceptedSearchRequests = [];
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			assert.strictEqual(interceptedSearchRequests.length, 0, "no search requests before editing");
+			let cardSelector = `[data-test-stack-card="${QUERY_CARD_URL}"]`;
+			assert.dom(cardSelector).exists("query card is open in operator mode");
+			await waitFor(`${cardSelector} [data-test-favorite]`);
+			assert.strictEqual(interceptedSearchRequests.length, 0, "no _federated-search requests were triggered while materializing query-backed relationships");
+			assert.dom(`${cardSelector} [data-test-favorite]`).includesText("Target", "linksTo query field was hydrated from server response");
+			let matchElements = findAll(`${cardSelector} [data-test-match]`);
+			assert.deepEqual(matchElements.map((el) => el.textContent?.trim()), ["Target"], "linksToMany query field was hydrated from server response");
+			assert.dom(cardSelector).includesText("Target", "rendered card displays data without re-fetching");
+			await click(`${cardSelector} [data-test-edit-button]`);
+			await waitFor(`${cardSelector} [data-test-card-format="edit"]`);
+			assert.dom(`${cardSelector} [data-test-links-to-editor="favorite"]`).doesNotExist("linksTo editor is hidden for query-backed field");
+			assert.dom(`${cardSelector} [data-test-add-new="favorite"]`).doesNotExist("add button is hidden for query-backed linksTo");
+			assert.dom(`${cardSelector} [data-test-links-to-many="matches"]`).doesNotExist("linksToMany editor is hidden for query-backed field");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("linksTo query field hydrates null without re-fetch when no result", async function(assert) {
+		assert.expect(4);
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_MISSING_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			let cardSelector = `[data-test-stack-card="${QUERY_CARD_MISSING_URL}"]`;
+			assert.dom(cardSelector).exists("query card with missing result is rendered");
+			await waitFor(`${cardSelector} [data-test-matches]`);
+			assert.strictEqual(interceptedSearchRequests.length, 0, "no search requests triggered when server returned null query relationship");
+			let favoriteText = findAll(`${cardSelector} [data-test-favorite]`)[0]?.textContent?.trim();
+			assert.strictEqual(favoriteText, "", "linksTo query field renders empty when no result is returned");
+			assert.strictEqual(findAll(`${cardSelector} [data-test-match]`).length, 0, "linksToMany query field renders empty when no results are returned");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("linksToMany query fields append new matches after realm invalidations", async function(assert) {
+		assert.expect(6);
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			let cardSelector = `[data-test-stack-card="${QUERY_CARD_URL}"]`;
+			assert.dom(cardSelector).exists("single query card is rendered");
+			await waitFor(`${cardSelector} [data-test-matches]`);
+			assert.strictEqual(findAll(`${cardSelector} [data-test-match]`).length, 1, "linksToMany field starts with one hydrated match");
+			assert.strictEqual(interceptedSearchRequests.length, 0, "no query runs while hydrating server-provided results");
+			let realmMatrixUsername = testRealmInfo.realmUserId;
+			let realmRoomId = mockMatrixUtils.getRoomIdForRealmAndUser(testRealmURL, "@testuser:localhost");
+			await saveCard(new PersonClass({ name: "Target" }), `${testRealmURL}Person/new-match`, loader);
+			mockMatrixUtils.simulateRemoteMessage(realmRoomId, realmMatrixUsername, {
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${testRealmURL}Person/new-match`],
+				realmURL: testRealmURL
+			}, { type: APP_BOXEL_REALM_EVENT_TYPE });
+			await settled();
+			assert.strictEqual(interceptedSearchRequests.length, 2, "realm invalidation triggers a refresh for each query-backed field");
+			assert.ok(interceptedSearchRequests[0].includes("_federated-search"), "query refresh targets the realm search endpoint");
+			assert.strictEqual(findAll(`${cardSelector} [data-test-match]`).length, 2, "linksToMany field shows the newly added match after refresh");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("query-backed relationships defined within FieldDef are hydrated without refetch", async function(assert) {
+		assert.expect(3);
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_NESTED_URL,
+				format: "isolated"
+			}]] });
+			let cardSelector = `[data-test-stack-card="${QUERY_CARD_NESTED_URL}"]`;
+			await waitFor(`${cardSelector} [data-test-matches]`);
+			assert.strictEqual(interceptedSearchRequests.length, 0, "no search requests triggered while hydrating nested query-backed relationships");
+			assert.dom(`${cardSelector} [data-test-favorite]`).includesText("Target", "nested linksTo query field hydrated from server response");
+			assert.deepEqual(findAll(`${cardSelector} [data-test-match]`).map((el) => el.textContent?.trim()), ["Target"], "nested linksToMany query field hydrated from server response");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("query fields do not respond to realm invalidations once garbage collected", async function(assert) {
+		assert.expect(3);
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_2_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			let store = getService("store");
+			store.store.sweep(card_api_exports);
+			store.store.sweep(card_api_exports);
+			await settled();
+			let realmMatrixUsername = testRealmInfo.realmUserId;
+			let realmRoomId = mockMatrixUtils.getRoomIdForRealmAndUser(testRealmURL, "@testuser:localhost");
+			await saveCard(new PersonClass({ name: "Not Target" }), `${testRealmURL}Person/new-match`, loader);
+			mockMatrixUtils.simulateRemoteMessage(realmRoomId, realmMatrixUsername, {
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${testRealmURL}Person/new-match`],
+				realmURL: testRealmURL
+			}, { type: APP_BOXEL_REALM_EVENT_TYPE });
+			await settled();
+			assert.strictEqual(interceptedSearchRequests.length, 2, "realm invalidation triggers a refresh for each query-backed field");
+			assert.ok(interceptedSearchRequests[0].includes("_federated-search"), "query refresh targets the realm search endpoint");
+			let cardSelector = `[data-test-stack-card="${QUERY_CARD_2_URL}"]`;
+			assert.strictEqual(findAll(`${cardSelector} [data-test-match]`).length, 2, "linksToMany field shows the newly added match after refresh");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("interpolated value in query fields triggers search refresh", async function(assert) {
+		await visitOperatorMode({ stacks: [[{
+			id: QUERY_CARD_URL,
+			format: "isolated"
+		}]] });
+		let cardSelector = `[data-test-stack-card="${QUERY_CARD_URL}"]`;
+		await waitFor(`${cardSelector} [data-test-matches]`);
+		let matchElements = findAll(`${cardSelector} [data-test-match]`);
+		assert.deepEqual(matchElements.map((el) => el.textContent?.trim()), ["Target"], "linksToMany query field was hydrated with initial value");
+		let titleElement = `${cardSelector} [data-test-inline-title] input`;
+		await waitFor(titleElement);
+		await fillIn(titleElement, "Not Target");
+		matchElements = findAll(`${cardSelector} [data-test-match]`);
+		assert.deepEqual(matchElements.map((el) => el.textContent?.trim()), ["Not Target"], "linksToMany query field was updated after changing the interpolated value");
+	});
+	(0, import_qunit.test)("saves omit query-backed relationships from JSON payload", async function(assert) {
+		let interceptedBody;
+		let network = getService("network");
+		let handler = async (request) => {
+			if (request.method === "PATCH" && request.url.endsWith("/query-card")) interceptedBody = await request.clone().json();
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_URL,
+				format: "isolated"
+			}]] });
+			await waitFor("[data-test-edit-button]");
+			await click("[data-test-edit-button]");
+			await fillIn("[data-test-field=\"cardTitle\"] input", "Not Target");
+			await waitUntil(() => {
+				return find("[data-test-last-saved]")?.textContent?.trim()?.startsWith("Saved") ?? false;
+			}, { timeoutMessage: "auto-save did not complete" });
+			assert.ok(interceptedBody, "captured auto-save payload");
+			let relationships = interceptedBody?.data?.relationships ?? {};
+			assert.notOk("favorite" in relationships, "linksTo query field was omitted from PATCH body");
+			assert.notOk("matches" in relationships, "linksToMany query field was omitted from PATCH body");
+			assert.notOk("matches.0" in relationships, "linksToMany query field was omitted from PATCH body");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("client falls back to live search when server-side cross-realm query has errors", async function(assert) {
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let cardJson = await (await network.virtualNetwork.fetch(new Request(QUERY_CARD_URL, { headers: { Accept: SupportedMimeType.CardJson } }))).json();
+		let fakeRemoteRealm = "https://unreachable-realm.example.com/";
+		let matchesRel = cardJson.data.relationships?.matches;
+		if (matchesRel) {
+			matchesRel.data = [];
+			matchesRel.meta = { errors: [{
+				realm: fakeRemoteRealm,
+				type: "fetch-error",
+				message: "Could not reach remote realm",
+				status: 502
+			}] };
+			for (let key of Object.keys(cardJson.data.relationships)) if (key.startsWith("matches.")) delete cardJson.data.relationships[key];
+		}
+		let modifiedBody = JSON.stringify(cardJson);
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			if (request.method === "GET" && request.url === QUERY_CARD_URL && request.headers.get("Accept")?.includes("card+json")) return new Response(modifiedBody, {
+				status: 200,
+				headers: new Headers({ "content-type": SupportedMimeType.CardJson })
+			});
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			let cardSelector = `[data-test-stack-card="${QUERY_CARD_URL}"]`;
+			assert.dom(cardSelector).exists("query card is rendered");
+			await waitFor(`${cardSelector} [data-test-matches]`);
+			assert.ok(interceptedSearchRequests.length > 0, "client-side _federated-search request was triggered as a fallback for the errored query field");
+			let matchElements = findAll(`${cardSelector} [data-test-match]`);
+			assert.deepEqual(matchElements.map((el) => el.textContent?.trim()), ["Target"], "linksToMany query field was populated via client-side fallback search");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("fallback search preserves the type filter from the query definition", async function(assert) {
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let cardJson = await (await network.virtualNetwork.fetch(new Request(QUERY_CARD_URL, { headers: { Accept: SupportedMimeType.CardJson } }))).json();
+		let fakeRemoteRealm = "https://unreachable-realm.example.com/";
+		let matchesRel = cardJson.data.relationships?.matches;
+		if (matchesRel) {
+			matchesRel.data = [];
+			matchesRel.meta = { errors: [{
+				realm: fakeRemoteRealm,
+				type: "fetch-error",
+				message: "Could not reach remote realm",
+				status: 502
+			}] };
+			for (let key of Object.keys(cardJson.data.relationships)) if (key.startsWith("matches.")) delete cardJson.data.relationships[key];
+		}
+		let modifiedBody = JSON.stringify(cardJson);
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			if (request.method === "GET" && request.url === QUERY_CARD_URL && request.headers.get("Accept")?.includes("card+json")) return new Response(modifiedBody, {
+				status: 200,
+				headers: new Headers({ "content-type": SupportedMimeType.CardJson })
+			});
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: QUERY_CARD_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			let cardSelector = `[data-test-stack-card="${QUERY_CARD_URL}"]`;
+			assert.dom(cardSelector).exists("query card is rendered");
+			await waitFor(`${cardSelector} [data-test-matches]`);
+			assert.ok(interceptedSearchRequests.length > 0, "client-side _federated-search request was triggered as a fallback");
+			let matchElements = findAll(`${cardSelector} [data-test-match]`);
+			assert.deepEqual(matchElements.map((el) => el.textContent?.trim()), ["Target"], "only Person cards appear — Animal/target with same name is excluded by the type filter");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("explicit CardTypeFilter hydrates from server without re-fetch", async function(assert) {
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: TYPE_FILTER_CARD_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			let cardSelector = `[data-test-stack-card="${TYPE_FILTER_CARD_URL}"]`;
+			assert.dom(cardSelector).exists("type-filter card is rendered");
+			await waitFor(`${cardSelector} [data-test-matches]`);
+			assert.strictEqual(interceptedSearchRequests.length, 0, "no _federated-search requests were triggered — server-populated results were used directly");
+			let matchNames = findAll(`${cardSelector} [data-test-match]`).map((el) => el.textContent?.trim()).sort();
+			assert.deepEqual(matchNames, ["Not Target", "Target"], "all Person cards are hydrated from server response — Animal/target is excluded by CardTypeFilter");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+	(0, import_qunit.test)("fallback search works with an explicit CardTypeFilter (no predicate)", async function(assert) {
+		let network = getService("network");
+		let interceptedSearchRequests = [];
+		let cardJson = await (await network.virtualNetwork.fetch(new Request(TYPE_FILTER_CARD_URL, { headers: { Accept: SupportedMimeType.CardJson } }))).json();
+		let fakeRemoteRealm = "https://unreachable-realm.example.com/";
+		let matchesRel = cardJson.data.relationships?.matches;
+		if (matchesRel) {
+			matchesRel.data = [];
+			matchesRel.meta = { errors: [{
+				realm: fakeRemoteRealm,
+				type: "fetch-error",
+				message: "Could not reach remote realm",
+				status: 502
+			}] };
+			for (let key of Object.keys(cardJson.data.relationships)) if (key.startsWith("matches.")) delete cardJson.data.relationships[key];
+		}
+		let modifiedBody = JSON.stringify(cardJson);
+		let handler = async (request) => {
+			if (new URL(request.url).pathname.endsWith("/_federated-search")) interceptedSearchRequests.push(request.url);
+			if (request.method === "GET" && request.url === TYPE_FILTER_CARD_URL && request.headers.get("Accept")?.includes("card+json")) return new Response(modifiedBody, {
+				status: 200,
+				headers: new Headers({ "content-type": SupportedMimeType.CardJson })
+			});
+			return null;
+		};
+		network.virtualNetwork.mount(handler, { prepend: true });
+		try {
+			await visitOperatorMode({ stacks: [[{
+				id: TYPE_FILTER_CARD_URL,
+				format: "isolated"
+			}]] });
+			await settled();
+			let cardSelector = `[data-test-stack-card="${TYPE_FILTER_CARD_URL}"]`;
+			assert.dom(cardSelector).exists("type-filter card is rendered");
+			await waitFor(`${cardSelector} [data-test-matches]`);
+			assert.ok(interceptedSearchRequests.length > 0, "client-side _federated-search request was triggered as a fallback");
+			let matchNames = findAll(`${cardSelector} [data-test-match]`).map((el) => el.textContent?.trim()).sort();
+			assert.deepEqual(matchNames, ["Not Target", "Target"], "all Person cards are returned by the type filter — Animal/target is excluded");
+		} finally {
+			network.virtualNetwork.unmount(handler);
+		}
+	});
+});
+//#endregion

package/bundled-test-harness/assets/rail-CNspDFyn.js

@@ -0,0 +1,44 @@
+import "./chunk-Rp0pCe6z.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory, S as on } from "./index-DaCZcoCY-CgzbilMy.js";
+import { i as fn } from "./helper-m6jA5HmU.js";
+import "./modifier-D0EP-FQ7.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+//#region ../choreo/src/film/rail.gts
+/** a chapter as a door on the rule */
+/**
+* THE FILM ON ONE LINE. A rule the width of the chapter strip, the run
+* so far filled in the accent, a dot on the head and the readout riding
+* it; the chapters are dots at the places they open, so the distance
+* between them is a fact and not a layout. The dots are the doors into
+* the chapters. The head's position is a custom property (`--cf-head`)
+* written by the film every frame, so nothing here re-renders on the
+* clock.
+*/
+var Rail = class extends Component {
+	atStyle = (m) => `left:calc(5px + ${m.at.toFixed(4)} * (100% - 10px))`;
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "Jg5NCXKZ",
+			"block": "[[[10,0],[14,0,\"cf-rail\"],[12],[1,\"\\n  \"],[10,1],[14,0,\"cf-rail-n\"],[12],[1,[30,1,[\"n\"]]],[13],[1,\"\\n  \"],[10,1],[14,0,\"cf-rail-t\"],[12],[1,[30,1,[\"title\"]]],[13],[1,\"\\n  \"],[10,1],[14,0,\"cf-years\"],[12],[1,\"\\n    \"],[10,\"i\"],[14,0,\"cf-years-rule\"],[14,\"aria-hidden\",\"true\"],[12],[13],[1,\"\\n    \"],[10,\"i\"],[14,0,\"cf-years-fill\"],[14,\"aria-hidden\",\"true\"],[12],[13],[1,\"\\n\"],[42,[28,[31,1],[[28,[31,1],[[30,2]],null]],null],null,[[[1,\"      \"],[11,\"button\"],[16,0,[29,[\"cf-years-ch \",[52,[30,3,[\"here\"]],\"is-here\"],\" \",[52,[30,3,[\"done\"]],\"is-done\"]]]],[16,5,[28,[30,0,[\"atStyle\"]],[[30,3]],null]],[16,\"title\",[29,[[30,3,[\"n\"]],\" \",[30,3,[\"title\"]],[52,[30,3,[\"label\"]],[28,[32,0],[\" · \",[30,3,[\"label\"]]],null]]]]],[24,4,\"button\"],[4,[32,1],[\"click\",[28,[32,2],[[30,4],[30,3,[\"head\"]]],null]],null],[12],[13],[1,\"\\n\"]],[3]],null],[41,[30,5],[[[1,\"      \"],[10,\"b\"],[14,0,\"cf-years-now\"],[14,\"aria-hidden\",\"true\"],[12],[1,[30,5]],[13],[1,\"\\n\"]],[]],[[[1,\"      \"],[10,\"b\"],[14,0,\"cf-years-now is-mute\"],[14,\"aria-hidden\",\"true\"],[12],[13],[1,\"\\n\"]],[]]],[41,[30,6],[[[1,\"      \"],[10,\"em\"],[14,0,\"cf-years-a\"],[14,\"aria-hidden\",\"true\"],[12],[1,[28,[32,3],[[30,6],0],null]],[13],[1,\"\\n      \"],[10,\"em\"],[14,0,\"cf-years-b\"],[14,\"aria-hidden\",\"true\"],[12],[1,[28,[32,3],[[30,6],1],null]],[13],[1,\"\\n\"]],[]],null],[1,\"  \"],[13],[1,\"\\n\"],[13]],[\"@chapter\",\"@marks\",\"m\",\"@pick\",\"@readout\",\"@labels\"],[\"each\",\"-track-array\",\"if\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/choreo/src/film/rail.gts",
+			"scope": () => [
+				concat,
+				on,
+				fn,
+				get
+			],
+			"isStrictMode": true
+		}), this);
+	}
+};
+function concat(...parts) {
+	return parts.map((p) => String(p ?? "")).join("");
+}
+function get(list, i) {
+	return list[i];
+}
+//#endregion
+export { Rail as t };

package/bundled-test-harness/assets/rail-D2YcQ0VP.js

@@ -0,0 +1,2 @@
+import { t as Rail } from "./rail-CNspDFyn.js";
+export { Rail };