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

package/bundled-test-harness/assets/operations-optimistic-test-KJLyzT8v.js

@@ -0,0 +1,203 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/operations-optimistic-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var loader;
+var operations;
+var REPORT_MODULE = `
+  import {
+    contains,
+    containsMany,
+    field,
+    CardDef,
+    Component,
+    FieldDef,
+  } from "@cardstack/base/card-api";
+  import StringField from "@cardstack/base/string";
+  import NumberField from "@cardstack/base/number";
+  import { operation, params, bxl } from "@cardstack/base/operations";
+
+  export class ReportComment extends FieldDef {
+    @field body = contains(StringField);
+  }
+
+  export class Report extends CardDef {
+    @field headline = contains(StringField);
+    @field status = contains(StringField);
+    @field comments = containsMany(ReportComment);
+    @field tally = contains(NumberField);
+    // A computed value. The realm answers a program reading one from its index
+    // overlay; nothing in the browser can, which is what makes an operation
+    // reading it ineligible rather than wrong.
+    @field shouted = contains(StringField, {
+      computeVia: function (this: Report) {
+        return (this.headline ?? '').toUpperCase();
+      },
+    });
+
+    @operation static addComment = {
+      base: 'transform',
+      params: { body: StringField },
+      append: { to: 'comments', value: { body: params('body') } },
+    };
+
+    @operation static escalate = {
+      base: 'transform',
+      set: { status: 'escalated' },
+    };
+
+    // Eligible on every other count, and refused because the author said so.
+    @operation static quietly = {
+      base: 'transform',
+      optimistic: false,
+      set: { status: 'quiet' },
+    };
+
+    // Reads a value the realm computes, which no local run can supply.
+    @operation static echoComputed = {
+      base: 'transform',
+      transformations: bxl\`.status = .shouted;\`,
+    };
+
+    static isolated = class Isolated extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+    static embedded = class Embedded extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+    static fitted = class Fitted extends Component<typeof this> {
+      <template><h1><@fields.headline /></h1></template>
+    }
+  }
+`;
+function reportRef() {
+	return {
+		module: `${testRealmURL}report`,
+		name: "Report"
+	};
+}
+function reportFile(headline) {
+	return { data: {
+		type: "card",
+		attributes: {
+			headline,
+			status: "open",
+			comments: [],
+			tally: 0
+		},
+		meta: { adoptsFrom: reportRef() }
+	} };
+}
+function realmContents() {
+	return {
+		"report.gts": REPORT_MODULE,
+		"report-applies.json": reportFile("Applies"),
+		"report-chains.json": reportFile("Chains"),
+		"report-opted-out.json": reportFile("Opted Out"),
+		"report-computed.json": reportFile("Computed"),
+		"report-agrees.json": reportFile("Agrees")
+	};
+}
+(0, import_qunit.module)("Integration | operations optimistic", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	setupCardLogs(hooks, async () => getService("loader-service").loader.import("@cardstack/base/card-api"));
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(async function() {
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: realmContents()
+		});
+		loader = getService("loader-service").loader;
+		({operations} = await loader.import("@cardstack/base/operations"));
+		await getService("realm").login(testRealmURL);
+		getService("operations");
+	});
+	async function cardAt(localPath) {
+		let url = `${testRealmURL}${localPath}`;
+		let store = getService("store");
+		store.addReference(url);
+		let instance = await store.get(url);
+		if (!instance || !("id" in instance)) throw new Error(`${localPath} did not load: ${JSON.stringify(instance)}`);
+		return instance;
+	}
+	function recordReads() {
+		let cardService = getService("card-service");
+		let reads = [];
+		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
+		cardService.fetchJSON = async (url, args) => {
+			if (!args?.method || args.method === "GET") reads.push(String(url));
+			return await originalFetchJSON(url, args);
+		};
+		return {
+			reads,
+			restore: () => {
+				delete cardService.fetchJSON;
+			}
+		};
+	}
+	async function storedAttributes(localPath) {
+		return (await getService("card-service").fetchJSON(`${testRealmURL}${localPath}`)).data.attributes;
+	}
+	(0, import_qunit.test)("an eligible transform leaves the card and the realm agreeing", async function(assert) {
+		let report = await cardAt("report-applies");
+		let recorder = recordReads();
+		let result;
+		try {
+			result = await operations(report).addComment({ body: "First comment." });
+			assert.deepEqual(recorder.reads.filter((url) => url.includes("report-applies")), [], "the card was never re-read, so nothing here came back from the realm");
+		} finally {
+			recorder.restore();
+		}
+		assert.strictEqual(report.comments[0].body, "First comment.", "with the payload the call supplied");
+		let stored = await storedAttributes("report-applies");
+		assert.strictEqual(stored.comments.length, 1, "and the realm stored exactly one comment, not two");
+		assert.strictEqual(stored.comments[0].body, "First comment.", "the same one — the local run and the realm ran the same program");
+		assert.ok(result.version, "the write reported the version it produced");
+	});
+	(0, import_qunit.test)("consecutive operations chain their versions and never re-read", async function(assert) {
+		let report = await cardAt("report-chains");
+		let recorder = recordReads();
+		try {
+			await operations(report).addComment({ body: "One." });
+			await operations(report).addComment({ body: "Two." });
+			assert.deepEqual(recorder.reads.filter((url) => url.includes("report-chains")), [], "neither operation re-read the card, because the realm confirmed both bases");
+		} finally {
+			recorder.restore();
+		}
+		assert.strictEqual(report.comments.length, 2, "the card carries both comments");
+		assert.deepEqual(report.comments.map((c) => c.body), ["One.", "Two."], "in the order they were asked for");
+		let stored = await storedAttributes("report-chains");
+		assert.deepEqual(stored.comments.map((c) => c.body), ["One.", "Two."], "and the realm holds exactly the same two — neither applied twice nor lost");
+	});
+	(0, import_qunit.test)("an operation the author opted out of is sent and awaited", async function(assert) {
+		let report = await cardAt("report-opted-out");
+		await operations(report).quietly();
+		assert.strictEqual(report.status, "open", "the local card is untouched by the call itself, since nothing was applied here");
+		let stored = await storedAttributes("report-opted-out");
+		assert.strictEqual(stored.status, "quiet", "and the write still lands, exactly as it did before this path existed");
+	});
+	(0, import_qunit.test)("an operation reading a computed value falls back rather than guessing", async function(assert) {
+		let report = await cardAt("report-computed");
+		await operations(report).echoComputed();
+		let stored = await storedAttributes("report-computed");
+		assert.strictEqual(stored.status, "COMPUTED", "the realm applied the program against the value only it can supply");
+		assert.notStrictEqual(report.status, null, "and the card never took the null a local run would have computed");
+	});
+	(0, import_qunit.test)("a declarative set applies locally and matches what the realm stores", async function(assert) {
+		let report = await cardAt("report-agrees");
+		await operations(report).escalate();
+		assert.strictEqual(report.status, "escalated", "the local card carries the new status");
+		let stored = await storedAttributes("report-agrees");
+		assert.strictEqual(stored.status, "escalated", "and so does the realm");
+		assert.strictEqual(stored.headline, "Agrees", "with nothing else disturbed");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/operations-query-test-J3HcnaoK.js

@@ -0,0 +1,459 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { n as decorateMethodV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL, Co as SupportedMimeType, Jo as isCardInstance, Lr as testRRI } from "./runtime-common-BTaLJEw-.js";
+import { h as GetCardContextName, i as CardSearchDefaultRealmContextName } from "./constants-Icc0nFW-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { n as getCardCollection } from "./card-collection-BQMglA2Y.js";
+import { n as getCard } from "./card-resource-9nZR8YyO.js";
+import { r as provide } from "./dist-Ble0L9o7.js";
+import { M as waitUntil, T as settled, h as render } from "./dist-BOAdzfkP.js";
+import { t as CardContextSearchResults } from "./card-context-search-results-KmkXJbmC.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix, vt as registerDefaultRoutes, yt as registerRealmServerRoute } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/operations-query-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealm2URL = "http://test-realm/test2/";
+var CALLER = "@testuser:localhost";
+var REPORT_MODULE = `
+  import {
+    contains,
+    field,
+    CardDef,
+    Component,
+  } from "@cardstack/base/card-api";
+  import StringField from "@cardstack/base/string";
+  import { operation, actor, params } from "@cardstack/base/operations";
+
+  export class Report extends CardDef {
+    @field headline = contains(StringField);
+    @field status = contains(StringField);
+    @field postedBy = contains(StringField);
+
+    @operation static openReports = {
+      base: 'query',
+      query: {
+        filter: { on: () => Report, eq: { status: 'open' } },
+        sort: [{ on: () => Report, by: 'headline', direction: 'asc' }],
+      },
+    };
+
+    @operation static myReports = {
+      base: 'query',
+      query: { filter: { on: () => Report, eq: { postedBy: actor() } } },
+    };
+
+    @operation static byStatus = {
+      base: 'query',
+      params: { status: StringField },
+      query: {
+        filter: { on: () => Report, eq: { status: params('status') } },
+      },
+    };
+
+    static isolated = class Isolated extends Component<typeof this> {
+      <template><h1 data-test-report><@fields.headline /></h1></template>
+    }
+    static embedded = class Embedded extends Component<typeof this> {
+      <template><h1 data-test-report><@fields.headline /></h1></template>
+    }
+    static fitted = class Fitted extends Component<typeof this> {
+      <template><h1 data-test-report><@fields.headline /></h1></template>
+    }
+  }
+`;
+var MEMO_MODULE = `
+  import { contains, field, CardDef } from "@cardstack/base/card-api";
+  import StringField from "@cardstack/base/string";
+
+  export class Memo extends CardDef {
+    @field body = contains(StringField);
+  }
+`;
+var STUDENT_MODULE = `
+  import { contains, field, CardDef } from "@cardstack/base/card-api";
+  import StringField from "@cardstack/base/string";
+
+  export class Student extends CardDef {
+    @field name = contains(StringField);
+  }
+`;
+var ROSTER_MODULE = `
+  import {
+    contains,
+    field,
+    linksToMany,
+    CardDef,
+  } from "@cardstack/base/card-api";
+  import StringField from "@cardstack/base/string";
+  import { operation } from "@cardstack/base/operations";
+  import { Student } from "./student";
+
+  export class Roster extends CardDef {
+    @field title = contains(StringField);
+    @field students = linksToMany(Student);
+
+    @operation static listNone = {
+      base: 'query',
+      query: { filter: { type: () => Roster } },
+      links: 'none',
+    };
+    @operation static listNoneDataOnly = {
+      base: 'query',
+      query: { filter: { type: () => Roster } },
+      links: 'none',
+      html: { fitted: 'unshareable', embedded: 'unshareable' },
+    };
+  }
+`;
+var ALGEBRA = `${testRealmURL}rosters/algebra`;
+var ADA = `${testRealmURL}students/ada`;
+var BEN = `${testRealmURL}students/ben`;
+function studentFile(name) {
+	return { data: {
+		type: "card",
+		attributes: { name },
+		meta: { adoptsFrom: {
+			module: testRRI("student"),
+			name: "Student"
+		} }
+	} };
+}
+function reportRef() {
+	return {
+		module: testRRI("report"),
+		name: "Report"
+	};
+}
+function reportFile(attributes) {
+	return { data: {
+		type: "card",
+		attributes: {
+			postedBy: CALLER,
+			...attributes
+		},
+		meta: { adoptsFrom: reportRef() }
+	} };
+}
+var CardSearchContext = class extends Component {
+	get getCardFn() {
+		return getCard;
+	}
+	static {
+		decorateMethodV2(this.prototype, "getCardFn", [provide(GetCardContextName)]);
+	}
+	get cardSearchDefaultRealm() {
+		return () => testRealmURL;
+	}
+	static {
+		decorateMethodV2(this.prototype, "cardSearchDefaultRealm", [provide(CardSearchDefaultRealmContextName)]);
+	}
+	get context() {
+		let store = getService("store");
+		return {
+			getCard,
+			getCards: store.getSearchResource.bind(store),
+			getCardCollection,
+			store,
+			searchResultsComponent: CardContextSearchResults
+		};
+	}
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "VjymkrAV",
+			"block": "[[[18,1,[[30,0,[\"context\"]]]]],[\"&default\"],[\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/operations-query-test.gts",
+			"isStrictMode": true
+		}), this);
+	}
+};
+(0, import_qunit.module)("Integration | operations query", function(hooks) {
+	let loader;
+	let operations;
+	let Report;
+	let realm;
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	setupCardLogs(hooks, async () => getService("loader-service").loader.import("@cardstack/base/card-api"));
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: CALLER,
+		activeRealms: [testRealmURL, testRealm2URL],
+		autostart: true
+	});
+	hooks.beforeEach(async function() {
+		({realm} = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealmURL,
+			contents: {
+				"report.gts": REPORT_MODULE,
+				"memo.gts": MEMO_MODULE,
+				"reports/open-1.json": reportFile({
+					headline: "Air quality",
+					status: "open"
+				}),
+				"reports/open-2.json": reportFile({
+					headline: "Boiler noise",
+					status: "open"
+				}),
+				"reports/closed.json": reportFile({
+					headline: "Closed one",
+					status: "closed"
+				}),
+				"reports/someone-elses.json": reportFile({
+					headline: "Not yours",
+					status: "open",
+					postedBy: "@someone-else:localhost"
+				}),
+				"student.gts": STUDENT_MODULE,
+				"roster.gts": ROSTER_MODULE,
+				"students/ada.json": studentFile("Ada"),
+				"students/ben.json": studentFile("Ben"),
+				"rosters/algebra.json": { data: {
+					type: "card",
+					attributes: { title: "Algebra" },
+					relationships: {
+						"students.0": { links: { self: "../students/ada" } },
+						"students.1": { links: { self: "../students/ben" } }
+					},
+					meta: { adoptsFrom: {
+						module: testRRI("roster"),
+						name: "Roster"
+					} }
+				} }
+			}
+		}));
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealm2URL,
+			contents: { "reports/elsewhere.json": reportFile({
+				headline: "Another realm",
+				status: "open"
+			}) }
+		});
+		loader = getService("loader-service").loader;
+		({operations} = await loader.import("@cardstack/base/operations"));
+		({Report} = await loader.import(`${testRealmURL}report`));
+		await getService("realm").login(testRealmURL);
+		getService("operations");
+	});
+	function saved(name) {
+		return operations(Report)[name];
+	}
+	async function settledEntries(search) {
+		await waitUntil(() => !search.isLoading, { timeout: 1e4 });
+		return search.entries.map((entry) => entry.id).sort();
+	}
+	(0, import_qunit.test)("a declared query answers the cards its filter matches", async function(assert) {
+		let reports = saved("openReports")();
+		assert.deepEqual(await settledEntries(reports), [
+			`${testRealmURL}reports/open-1`,
+			`${testRealmURL}reports/open-2`,
+			`${testRealmURL}reports/someone-elses`
+		], "every open report in the realm, and nothing the filter excludes");
+		assert.strictEqual(reports.meta.page.total, 3, "and the search reports what it found");
+	});
+	(0, import_qunit.test)("the caller is what a query compares against", async function(assert) {
+		let mine = saved("myReports")();
+		assert.deepEqual(await settledEntries(mine), [
+			`${testRealmURL}reports/closed`,
+			`${testRealmURL}reports/open-1`,
+			`${testRealmURL}reports/open-2`
+		], "the actor marker resolved to the signed-in user, so the report posted by somebody else is not a match");
+		assert.deepEqual(saved("myReports").query().filter, {
+			"item.on": reportRef(),
+			eq: { "item.postedBy": CALLER }
+		}, "which is what the query the search ran compares");
+	});
+	(0, import_qunit.test)("a payload fills the markers its declaration names", async function(assert) {
+		let closed = saved("byStatus")({ status: "closed" });
+		assert.deepEqual(await settledEntries(closed), [`${testRealmURL}reports/closed`], "the payload member the declaration names is what the filter compares against");
+	});
+	(0, import_qunit.test)("the wire query a call resolves to is the one the search component takes", async function(assert) {
+		let query = saved("openReports").query();
+		assert.deepEqual(query, {
+			filter: {
+				"item.on": reportRef(),
+				eq: { "item.status": "open" }
+			},
+			sort: [{
+				by: "item.headline",
+				"item.on": reportRef(),
+				direction: "asc"
+			}],
+			realms: [testRealmURL],
+			operation: "openReports",
+			on: reportRef()
+		}, "the classes became the type they name, the card-rooted query became the entry-addressed one, and the request names the operation the realm resolves it from");
+		await render(setComponentTemplate(templateFactory({
+			"id": "qY0oZ3So",
+			"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[30,1,[\"searchResultsComponent\"]],null,[[\"@query\",\"@mode\"],[[32,1],\"hover\"]],null],[1,\"\\n\"]],[1]]]]]],[\"context\"],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/operations-query-test.gts",
+			"scope": () => [CardSearchContext, query],
+			"isStrictMode": true
+		}), templateOnly()));
+		await waitUntil(() => Boolean(document.querySelector("[data-test-search-result]")));
+		assert.dom(`[data-test-search-result="${testRealmURL}reports/open-1"]`).exists("a card hands the resolved query over and renders the rows");
+		assert.dom(`[data-test-search-result="${testRealmURL}reports/closed"]`).doesNotExist("and the rows are the ones the saved search matched");
+	});
+	(0, import_qunit.test)("a search covers the realm holding its type until the call names others", async function(assert) {
+		let here = saved("openReports")();
+		assert.deepEqual(await settledEntries(here), [
+			`${testRealmURL}reports/open-1`,
+			`${testRealmURL}reports/open-2`,
+			`${testRealmURL}reports/someone-elses`
+		], "a declaration and a call that both named no realm search the one the type is defined in");
+		let across = saved("openReports")(void 0, { realms: [testRealmURL, testRealm2URL] });
+		assert.deepEqual(await settledEntries(across), [
+			`${testRealmURL}reports/open-1`,
+			`${testRealmURL}reports/open-2`,
+			`${testRealmURL}reports/someone-elses`,
+			`${testRealm2URL}reports/elsewhere`
+		], "and a call that names realms fans the same saved search out across them");
+	});
+	(0, import_qunit.test)("the search re-runs as the realms it covers index", async function(assert) {
+		let reports = saved("openReports")();
+		assert.strictEqual((await settledEntries(reports)).length, 3);
+		await realm.write("reports/open-3.json", JSON.stringify(reportFile({
+			headline: "Filed just now",
+			status: "open"
+		})));
+		await waitUntil(() => reports.entries.length === 4, { timeout: 1e4 });
+		assert.ok(reports.entries.find((entry) => entry.id === `${testRealmURL}reports/open-3`), "the report written after the search started joined it when the realm indexed it — a query is as fresh as the index");
+	});
+	(0, import_qunit.test)("a search the realm resolves by name re-runs on writes its own filter cannot see", async function(assert) {
+		let stale = {
+			...saved("openReports").query(),
+			filter: { "item.on": {
+				module: testRRI("memo"),
+				name: "Memo"
+			} }
+		};
+		let reports = getService("operations").search.entries(() => stale);
+		assert.strictEqual((await settledEntries(reports)).length, 3, "the realm answered with the open reports its declaration matches");
+		await realm.write("reports/closed-2.json", JSON.stringify(reportFile({
+			headline: "Closed again",
+			status: "closed"
+		})));
+		await settled();
+		assert.strictEqual((await settledEntries(reports)).length, 3, "a closed report is not one the realm’s declaration matches");
+		await realm.write("reports/open-4.json", JSON.stringify(reportFile({
+			headline: "Filed under a stale definition",
+			status: "open"
+		})));
+		await waitUntil(() => reports.entries.length === 4, { timeout: 1e4 });
+		assert.ok(reports.entries.find((entry) => entry.id === `${testRealmURL}reports/open-4`), "the report joined the search though the filter it carries could never match one");
+	});
+	(0, import_qunit.test)("a render its server pinned no actor on has no viewer, whatever sessions the tab holds", async function(assert) {
+		globalThis.__boxelPrerenderApp = true;
+		try {
+			assert.strictEqual(saved("myReports").query(), void 0, "the actor-scoped search answers no query, which the search surface reads as an idle search");
+			assert.ok(saved("openReports").query(), "and a saved search that does not read the caller is unaffected");
+		} finally {
+			delete globalThis.__boxelPrerenderApp;
+		}
+		assert.ok(saved("myReports").query(), "outside a render the same search resolves against the signed-in user");
+	});
+	(0, import_qunit.test)("a render a user asks for has that user as its viewer", async function(assert) {
+		globalThis.__boxelPrerenderApp = true;
+		globalThis.__boxelRenderActor = "@requester:localhost";
+		try {
+			assert.deepEqual(saved("myReports").query()?.filter, {
+				"item.on": reportRef(),
+				eq: { "item.postedBy": "@requester:localhost" }
+			}, "the actor-scoped search compares against the user the server pinned");
+		} finally {
+			delete globalThis.__boxelRenderActor;
+			delete globalThis.__boxelPrerenderApp;
+		}
+	});
+	(0, import_qunit.module)("a query declaring `none`", function() {
+		async function listNone() {
+			let { Roster } = await loader.import(`${testRealmURL}roster`);
+			return {
+				...operations(Roster).listNone.query(),
+				fields: { entry: ["html", "item"] }
+			};
+		}
+		function servedItem(doc, id) {
+			return doc.included?.find((resource) => resource.type === "card" && resource.id === id);
+		}
+		(0, import_qunit.test)("a row rendered through the search component leaves its card to load through its own read", async function(assert) {
+			let store = getService("store");
+			let query = await listNone();
+			let item = servedItem(await store.searchEntries(query, [testRealmURL]), ALGEBRA);
+			assert.strictEqual(item?.relationships, void 0, "the row arrives with its card’s relationships withheld");
+			assert.true(item?.meta?.relationshipsWithheld, "and says they were withheld");
+			await store.inflateSearchEntryItem(item);
+			assert.notOk(isCardInstance(store.peek(ALGEBRA)), "the store never deposits the row as the card’s instance");
+			await render(setComponentTemplate(templateFactory({
+				"id": "v3RGMQun",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[30,1,[\"searchResultsComponent\"]],null,[[\"@query\"],[[32,1]]],null],[1,\"\\n\"]],[1]]]]]],[\"context\"],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/operations-query-test.gts",
+				"scope": () => [CardSearchContext, query],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector(`[data-test-search-result="${ALGEBRA}"]`)));
+			await settled();
+			let roster = await store.get(ALGEBRA);
+			assert.true(isCardInstance(roster), "opened after its row rendered, the card loads");
+			assert.deepEqual(roster.students.map((student) => student.id), [ADA, BEN], "and carries the links its own read declares");
+		});
+		(0, import_qunit.test)("a row served with neither its markup nor its links renders the card loaded through its own read", async function(assert) {
+			let store = getService("store");
+			let { Roster } = await loader.import(`${testRealmURL}roster`);
+			let query = operations(Roster).listNoneDataOnly.query();
+			let served = await store.searchEntries(query, [testRealmURL]);
+			let entry = served.data.find((row) => row.id === ALGEBRA);
+			assert.strictEqual((entry?.relationships?.html?.data ?? []).length, 0, "the row arrives with no markup");
+			assert.true(servedItem(served, ALGEBRA)?.meta?.relationshipsWithheld, "and with its card’s relationships withheld");
+			assert.notOk(isCardInstance(store.peek(ALGEBRA)), "nothing has loaded the card yet");
+			await render(setComponentTemplate(templateFactory({
+				"id": "v3RGMQun",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[30,1,[\"searchResultsComponent\"]],null,[[\"@query\"],[[32,1]]],null],[1,\"\\n\"]],[1]]]]]],[\"context\"],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/operations-query-test.gts",
+				"scope": () => [CardSearchContext, query],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector(`[data-test-search-result="${ALGEBRA}"]`)));
+			await waitUntil(() => isCardInstance(store.peek(ALGEBRA)));
+			await settled();
+			assert.deepEqual(store.peek(ALGEBRA).students.map((student) => student.id), [ADA, BEN], "rendering the row loaded the card through its own read, with the links that read declares");
+		});
+		(0, import_qunit.test)("a row answered to the store’s search is loaded through its card’s own read", async function(assert) {
+			let store = getService("store");
+			let served = await store.searchEntries({
+				...await listNone(),
+				fields: { entry: ["item"] }
+			}, [testRealmURL]);
+			assert.true(servedItem(served, ALGEBRA)?.meta?.relationshipsWithheld, "the replayed row is one the realm served with its relationships withheld");
+			registerRealmServerRoute({
+				path: "/_federated-search",
+				handler: async () => new Response(JSON.stringify(served), {
+					status: 200,
+					headers: { "content-type": SupportedMimeType.CardJson }
+				})
+			});
+			try {
+				let results = await store.search({ filter: { type: {
+					module: testRRI("roster"),
+					name: "Roster"
+				} } }, [testRealmURL]);
+				assert.deepEqual(results.map((result) => result.id), [ALGEBRA], "the search answers with the card");
+				assert.deepEqual(results[0].students.map((student) => student.id), [ADA, BEN], "and the instance it answers with carries the links its own read declares");
+			} finally {
+				registerDefaultRoutes();
+			}
+		});
+	});
+	(0, import_qunit.test)("a saved search is invoked on the class that declares it", async function(assert) {
+		let card = await getService("store").get(`${testRealmURL}reports/open-1`);
+		await settled();
+		assert.strictEqual(operations(card).openReports, void 0, "a saved search reads a collection of a type, so one card carries no member for it");
+	});
+});
+//#endregion