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

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

@@ -1,203 +0,0 @@
-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-Dd8k0DNa.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-9p1ZIDe-.js

@@ -1,459 +0,0 @@
-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-CoSr4EdS.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-Dd8k0DNa.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