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

package/bundled-test-harness/assets/store-test-D6PObxoD.js

@@ -1,3672 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Br as testRealmURL, Co as SupportedMimeType, Ec as CardError, Jo as isCardInstance, Lr as testRRI, Qo as isFileDefInstance, Rc as Deferred, Xn as APP_BOXEL_REALM_EVENT_TYPE } from "./runtime-common-BTaLJEw-.js";
-import { B as localId, G as realmURL, w as baseCardRef } from "./constants-Icc0nFW-.js";
-import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { r as service } from "./service-LFpJ8EEP.js";
-import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
-import "./component-BJO47HTh.js";
-import { t as Component } from "./dist-CkA1rgqO.js";
-import { n as tracked, t as cached } from "./tracking-800VJb8b.js";
-import "./template-factory-ds9s0u8l.js";
-import { n as getCardCollection } from "./card-collection-BQMglA2Y.js";
-import { n as getCard } from "./card-resource-9nZR8YyO.js";
-import { t as OperatorModeContainer } from "./container-Cqcwrd-m.js";
-import { M as waitUntil, T as settled, a as find, d as click, o as waitFor, r as typeIn } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { $ as withSavesHeldOpen, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, et as withSlowSave, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix, vt as registerDefaultRoutes, yt as registerRealmServerRoute } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { A as field, H as linksTo, U as linksToMany, a as CardDef, d as FileDef, s as Component$1, w as contains } from "./card-api-Cc8uZunB.js";
-import "./file-api-BsT3Q6C9.js";
-import { t as BooleanField } from "./boolean-Dk3JuO7r.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-import { n as renderComponent } from "./render-component-B15Z0e2v.js";
-//#region tests/integration/store-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-(0, import_qunit.module)("Integration | Store", function(hooks) {
-	setupRenderingTest(hooks);
-	setupOperatorModeStateCleanup(hooks);
-	let api;
-	let loader;
-	let loaderService;
-	let testRealm;
-	let testRealmAdapter;
-	let storeService;
-	let operatorModeStateService;
-	let cardStore;
-	let PersonDef;
-	let BoomPersonDef;
-	let EmployeeDef;
-	let ManagerDef;
-	let realmService;
-	setupLocalIndexing(hooks);
-	setupRealmCacheTeardown(hooks);
-	setupOnSave(hooks);
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL],
-		autostart: true
-	});
-	function forceGC() {
-		cardStore.sweep(api);
-		cardStore.sweep(api);
-	}
-	function setCardInOperatorModeState(cardURL, format = "isolated") {
-		operatorModeStateService.restore({ stacks: cardURL ? [[{
-			id: cardURL,
-			format
-		}]] : [[]] });
-	}
-	const noop = () => {};
-	async function writePerson(path, name) {
-		await testRealm.write(path, JSON.stringify({ data: {
-			attributes: { name },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-	}
-	function interceptRealmEvents() {
-		let messageService = getService("message-service");
-		let deliver = messageService.relayRealmEvent.bind(messageService);
-		let captured = [];
-		messageService.relayRealmEvent = (event) => {
-			captured.push(event);
-		};
-		function find(url) {
-			return captured.find((event) => event.eventName === "index" && event.indexType === "incremental" && event.invalidations.includes(url));
-		}
-		return {
-			deliver,
-			async nextEventFor(url) {
-				await waitUntil(() => find(url) !== void 0, {
-					timeout: 1e4,
-					timeoutMessage: `the realm broadcast no incremental index event naming ${url}; observed events: ${JSON.stringify(captured)}`
-				});
-				let event = find(url);
-				captured.length = 0;
-				return event;
-			},
-			restore() {
-				messageService.relayRealmEvent = deliver;
-			}
-		};
-	}
-	function countCardReads(pathFragment) {
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		let count = 0;
-		cardService.fetchJSON = async (fetchUrl, args) => {
-			if (String(fetchUrl).includes(pathFragment) && (args?.method ?? "GET") === "GET") count++;
-			return originalFetchJSON(fetchUrl, args);
-		};
-		return {
-			get count() {
-				return count;
-			},
-			stop() {
-				delete cardService.fetchJSON;
-			}
-		};
-	}
-	function withholdSource(pathFragment) {
-		let loadCardDocument = cardStore.loadCardDocument.bind(cardStore);
-		cardStore.loadCardDocument = async (url, opts) => {
-			if (url.includes(pathFragment)) return new CardError(`${url} is withheld by this test`, { status: 404 });
-			return loadCardDocument(url, opts);
-		};
-	}
-	hooks.afterEach(function() {
-		if (cardStore) delete cardStore.loadCardDocument;
-	});
-	async function settleCardRender(assert, id, selector, opts) {
-		let start = performance.now();
-		await settled();
-		let elapsedMs = Math.round(performance.now() - start);
-		if (!find(selector)) {
-			let held = storeService.peek(id, { type: opts?.type });
-			let error = storeService.peekError(id, { type: opts?.type });
-			console.error([
-				`[card-render-diag] ${selector} is not rendered after settled() (${elapsedMs}ms)`,
-				`reference count: ${storeService.getReferenceCount(id)}`,
-				`peek: ${held === void 0 ? "<nothing>" : isCardInstance(held) || isFileDefInstance(held) ? `instance ${held.id}` : `error ${JSON.stringify(held)}`}`,
-				`peekError: ${error ? JSON.stringify(error) : "<none>"}`
-			].join("\n"));
-		} else if (elapsedMs > 1e3) console.warn(`[card-render-diag] ${selector} took ${elapsedMs}ms to load and render`);
-		assert.dom(selector).exists(`${id} is rendered`);
-	}
-	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);
-			static {
-				decorateFieldV2(this.prototype, "hasError", [field], function() {
-					return contains(BooleanField);
-				});
-			}
-			#hasError = (initializeDeferredDecorator(this, "hasError"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "bestFriend", [field], function() {
-					return linksTo(() => Person);
-				});
-			}
-			#bestFriend = (initializeDeferredDecorator(this, "bestFriend"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "friends", [field], function() {
-					return linksToMany(() => Person);
-				});
-			}
-			#friends = (initializeDeferredDecorator(this, "friends"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "boom", [field], function() {
-					return contains(string_default, { computeVia: function() {
-						if (this.hasError) throw new Error("intentional error thrown");
-						return "boom";
-					} });
-				});
-			}
-			#boom = (initializeDeferredDecorator(this, "boom"), void 0);
-		}
-		PersonDef = Person;
-		class BoomPerson extends CardDef {
-			static displayName = "Boom Person";
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-			static isolated = class Isolated extends Component$1 {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "I6b4/CsV",
-						"block": "[[[1,\"Hello\\n\"],[8,[30,1,[\"name\"]],null,null,null],[1,\"!\\n\"],[1,[30,0,[\"boom\"]]]],[\"@fields\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-				boom = () => intentionallyNotDefined();
-			};
-		}
-		BoomPersonDef = BoomPerson;
-		class Employee extends CardDef {
-			static displayName = "Employee";
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-			static isolated = class Isolated extends Component$1 {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "TyvrA1L5",
-						"block": "[[[10,0],[14,\"data-test-employee-badge\",\"\"],[12],[1,\"Employee: \"],[8,[30,1,[\"name\"]],null,null,null],[13]],[\"@fields\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-			};
-		}
-		EmployeeDef = Employee;
-		class Manager extends Employee {
-			static displayName = "Manager";
-			static isolated = class Isolated extends Component$1 {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "3Gw4m0Y6",
-						"block": "[[[10,0],[14,\"data-test-manager-badge\",\"\"],[12],[1,\"Manager: \"],[8,[30,1,[\"name\"]],null,null,null],[13]],[\"@fields\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-			};
-		}
-		ManagerDef = Manager;
-		loaderService = getService("loader-service");
-		loader = loaderService.loader;
-		api = await loader.import("@cardstack/base/card-api");
-		storeService = getService("store");
-		operatorModeStateService = getService("operator-mode-state-service");
-		cardStore = storeService.store;
-		realmService = getService("realm");
-		await withCachedRealmSetup(async () => {
-			({adapter: testRealmAdapter, realm: testRealm} = await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				contents: {
-					"person.gts": { Person },
-					"boom-person.gts": { BoomPerson },
-					"employee.gts": { Employee },
-					"manager.gts": { Manager },
-					"Person/hassan.json": new Person({ name: "Hassan" }),
-					"Person/jade.json": new Person({ name: "Jade" }),
-					"Person/queenzy.json": new Person({ name: "Queenzy" }),
-					"Person/germaine.json": new Person({ name: "Germaine" }),
-					"Person/boris.json": new Person({ name: "Boris" })
-				}
-			}));
-		});
-		await realmService.login(testRealmURL);
-	});
-	hooks.afterEach(function() {
-		getService("network").virtualNetwork.removeRealmMapping("@test-prefix/");
-	});
-	(0, import_qunit.test)("can peek a card instance", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let instance = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.true(isCardInstance(instance), "peeked item is a card instance");
-	});
-	(0, import_qunit.test)("can peek a card by local id", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let instanceA = storeService.peek(`${testRealmURL}Person/hassan`);
-		let instanceB = storeService.peek(instanceA[localId]);
-		assert.true(isCardInstance(instanceB), "peeked item is a card instance");
-		assert.strictEqual(instanceA, instanceB, "the same instance is returned by both remote ID and local ID");
-	});
-	(0, import_qunit.test)("can peek a card error when no stale instance exists", async function(assert) {
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: {
-				name: "Hassan",
-				hasError: true
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let error = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.false(isCardInstance(error), "error is not a card instance");
-		assert.ok(error.message.includes("intentional error thrown"), "error message is correct");
-	});
-	(0, import_qunit.test)("peek returns a stale instance when the server state reflects an error", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: {
-				name: "Hassan",
-				hasError: true
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await waitUntil(() => storeService.peekError(`${testRealmURL}Person/hassan`));
-		let staleInstance = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.true(isCardInstance(staleInstance), "the peek-ed instance is not an error");
-	});
-	(0, import_qunit.test)("peek for an uncached returns undefined", async function(assert) {
-		let instance = storeService.peek(`${testRealmURL}Person/does-not-exist`);
-		assert.strictEqual(instance, void 0, "instance is undefined");
-	});
-	(0, import_qunit.test)("can use registered prefix ids across store APIs", async function(assert) {
-		getService("network").virtualNetwork.addRealmMapping("@test-prefix/", testRealmURL);
-		storeService.addReference("@test-prefix/Person/hassan");
-		await storeService.flush();
-		let byPrefix = storeService.peek("@test-prefix/Person/hassan");
-		let byUrl = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.true(isCardInstance(byPrefix), "prefix id resolves to a card");
-		assert.strictEqual(byPrefix, byUrl, "prefix id and resolved URL return the same instance");
-		assert.strictEqual(storeService.getReferenceCount("@test-prefix/Person/hassan"), 1, "prefix id and resolved URL share a single reference count");
-		assert.strictEqual(storeService.getReferenceCount(`${testRealmURL}Person/hassan`), 1, "resolved URL sees the same reference count");
-		storeService.dropReference("@test-prefix/Person/hassan");
-		assert.strictEqual(storeService.getReferenceCount(`${testRealmURL}Person/hassan`), 0, "dropping a prefix reference clears the resolved URL reference count");
-		let countsDuringSave;
-		this.onSave((url) => {
-			if (url.href === `${testRealmURL}Person/hassan`) countsDuringSave = {
-				url: storeService.getReferenceCount(`${testRealmURL}Person/hassan`),
-				prefix: storeService.getReferenceCount("@test-prefix/Person/hassan")
-			};
-		});
-		storeService.save("@test-prefix/Person/hassan");
-		await settled();
-		let saveError = storeService.getSaveState(byPrefix[localId])?.lastSaveError;
-		assert.strictEqual(saveError, void 0, `save() persists the card${saveError ? `: ${saveError instanceof Error ? saveError.message : JSON.stringify(saveError)}` : ""}`);
-		assert.deepEqual(countsDuringSave, {
-			url: 1,
-			prefix: 1
-		}, "save() holds exactly one reference while it runs, read the same through the prefix id and the resolved URL");
-		assert.strictEqual(storeService.getReferenceCount("@test-prefix/Person/hassan"), 0, "save() releases its hold once it lands");
-		storeService.addReference("@test-prefix/Person/boris");
-		await storeService.flush();
-		await storeService.delete("@test-prefix/Person/boris");
-		assert.strictEqual(storeService.peek("@test-prefix/Person/boris"), void 0, "delete() clears the prefix-form card identity from the store");
-		assert.strictEqual(storeService.peek(`${testRealmURL}Person/boris`), void 0, "delete() clears the resolved card identity from the store");
-		let file = await testRealmAdapter.openFile(`Person/boris.json`);
-		assert.strictEqual(file, void 0, "delete() removes the remote card");
-	});
-	(0, import_qunit.test)("deleting a linked target rewrites a loaded consumer linksTo slot to a broken-link sentinel", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		storeService.addReference(`${testRealmURL}Person/boris`);
-		await storeService.flush();
-		let hassan = storeService.peek(`${testRealmURL}Person/hassan`);
-		hassan.bestFriend = storeService.peek(`${testRealmURL}Person/boris`);
-		await settled();
-		assert.strictEqual(api.getRelationshipMembershipState(hassan, "bestFriend").membership[0].kind, "present", "the consumer link resolves to the target before the delete");
-		await storeService.delete(`${testRealmURL}Person/boris`);
-		let after = api.getRelationshipMembershipState(hassan, "bestFriend").membership[0];
-		assert.strictEqual(after.kind, "not-found", "deleting the target rewrites the consumer slot to a broken-link sentinel without a reload");
-		assert.strictEqual(after.reference, `${testRealmURL}Person/boris`, "the sentinel preserves the deleted target reference for the placeholder");
-	});
-	(0, import_qunit.test)("deleting a linked target rewrites only the matching element of a loaded consumer linksToMany slot", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		storeService.addReference(`${testRealmURL}Person/boris`);
-		storeService.addReference(`${testRealmURL}Person/jade`);
-		await storeService.flush();
-		let hassan = storeService.peek(`${testRealmURL}Person/hassan`);
-		let boris = storeService.peek(`${testRealmURL}Person/boris`);
-		hassan.friends = [storeService.peek(`${testRealmURL}Person/jade`), boris];
-		await settled();
-		let before = api.getRelationshipMembershipState(hassan, "friends").membership;
-		assert.deepEqual(before.map((s) => s.kind), ["present", "present"], "both linksToMany elements resolve before the delete");
-		await storeService.delete(`${testRealmURL}Person/boris`);
-		let after = api.getRelationshipMembershipState(hassan, "friends").membership;
-		let borisEntry = after.find((s) => s.reference === `${testRealmURL}Person/boris`);
-		let jadeEntry = after.find((s) => s.reference === `${testRealmURL}Person/jade`);
-		assert.strictEqual(borisEntry?.kind, "not-found", "the deleted element becomes a broken-link sentinel");
-		assert.strictEqual(jadeEntry?.kind, "present", "the surviving element is left untouched");
-	});
-	(0, import_qunit.test)("peekError returns the server state error when a stale instance exists", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: {
-				name: "Hassan",
-				hasError: true
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await waitUntil(() => storeService.peekError(`${testRealmURL}Person/hassan`));
-		let error = storeService.peekError(`${testRealmURL}Person/hassan`);
-		assert.false(isCardInstance(error), "error is not a card instance");
-		assert.ok(error.message.includes("intentional error thrown"), "error message is correct");
-	});
-	(0, import_qunit.test)("can add reference to a card url", async function(assert) {
-		let instance = storeService.peek(`${testRealmURL}hassan`);
-		assert.strictEqual(instance, void 0, "instance is not in store yet");
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		instance = storeService.peek(`${testRealmURL}Person/hassan`);
-		if (isCardInstance(instance)) assert.strictEqual(instance.name, "Hassan", "instance is cached in store");
-		else assert.ok(false, `expected instance to be a card:${JSON.stringify(instance, null, 2)}`);
-		forceGC();
-		instance = storeService.peek(`${testRealmURL}Person/hassan`);
-		if (isCardInstance(instance)) assert.strictEqual(instance.name, "Hassan", "instance is cached in store after GC");
-		else assert.ok(false, `expected instance to be a card:${JSON.stringify(instance, null, 2)} after GC`);
-	});
-	(0, import_qunit.test)("can add reference to a local id", async function(assert) {
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutPersisting(instance);
-		storeService.addReference(instance[localId]);
-		forceGC();
-		let peekedInstance = storeService.peek(instance[localId]);
-		assert.strictEqual(peekedInstance, instance, "instance is not garbage collected");
-	});
-	(0, import_qunit.test)("a render-context load does not set up the autosave change subscription", async function(assert) {
-		let cardService = getService("card-service");
-		let originalGetAPI = cardService.getAPI.bind(cardService);
-		let realApi = await originalGetAPI();
-		let trueSubscribe = realApi.subscribeToChanges;
-		let subscribeCount = 0;
-		cardService.getAPI = async () => new Proxy(realApi, { get(target, prop, receiver) {
-			if (prop === "subscribeToChanges") return (...args) => {
-				subscribeCount++;
-				return trueSubscribe(...args);
-			};
-			return Reflect.get(target, prop, receiver);
-		} });
-		try {
-			await storeService.addWithoutPersisting(new PersonDef({ name: "Mango" }));
-			assert.true(subscribeCount > 0, "the live store subscribes a loaded instance for autosave");
-			subscribeCount = 0;
-			globalThis.__boxelRenderContext = true;
-			await getService("render-store").addWithoutPersisting(new PersonDef({ name: "Van Gogh" }));
-			assert.strictEqual(subscribeCount, 0, "the render store does not subscribe a loaded instance for autosave");
-		} finally {
-			cardService.getAPI = originalGetAPI;
-			delete globalThis.__boxelRenderContext;
-		}
-	});
-	(0, import_qunit.test)("a card render absorbs a blocked write, a headless command reports it", async function(assert) {
-		globalThis.__boxelPrerenderApp = true;
-		try {
-			let rendered = new PersonDef({ name: "Andrea" });
-			assert.strictEqual(await storeService.add(rendered), rendered, "a render keeps the instance rather than failing");
-			globalThis.__boxelHeadlessCommand = true;
-			await assert.rejects(storeService.add(new PersonDef({ name: "Van Gogh" })), /persistence block still raised/, "a command reports the blocked write");
-			let ephemeral = new PersonDef({ name: "Mango" });
-			assert.strictEqual(await storeService.addWithoutPersisting(ephemeral), ephemeral, "a memory-only add is served as asked");
-		} finally {
-			delete globalThis.__boxelHeadlessCommand;
-			delete globalThis.__boxelPrerenderApp;
-		}
-	});
-	(0, import_qunit.test)("restoring sessions from storage skips the re-walk when the session blob is unchanged", function(assert) {
-		let walks = 0;
-		let originalGetOrCreate = realmService.getOrCreateRealmResource.bind(realmService);
-		realmService.getOrCreateRealmResource = (...args) => {
-			walks++;
-			return originalGetOrCreate(...args);
-		};
-		try {
-			realmService.lastRestoredSessionsString = void 0;
-			let before = walks;
-			realmService.restoreSessionsFromStorage();
-			assert.true(walks - before > 0, "the first restore walks the stored sessions");
-			before = walks;
-			realmService.restoreSessionsFromStorage();
-			assert.strictEqual(walks - before, 0, "a restore with an unchanged blob does not re-walk");
-			realmService.lastRestoredSessionsString = "stale-sentinel";
-			before = walks;
-			realmService.restoreSessionsFromStorage();
-			assert.true(walks - before > 0, "a restore re-walks once the stored blob no longer matches the memo");
-		} finally {
-			realmService.getOrCreateRealmResource = originalGetOrCreate;
-		}
-	});
-	(0, import_qunit.test)("getFields is memoized per instance in the render context and invalidates as the instance grows", function(assert) {
-		let person = new PersonDef({ name: "Mango" });
-		try {
-			globalThis.__boxelRenderContext = true;
-			let first = api.getFields(person, { usedLinksToFieldsOnly: true });
-			let second = api.getFields(person, { usedLinksToFieldsOnly: true });
-			assert.strictEqual(first, second, "a repeat call in the render context returns the memoized field map");
-			assert.notOk("bestFriend" in first, "an unused linksTo field is absent before it is populated");
-			person.bestFriend = new PersonDef({ name: "Van Gogh" });
-			let third = api.getFields(person, { usedLinksToFieldsOnly: true });
-			assert.notStrictEqual(third, first, "growing the instance invalidates the memo");
-			assert.ok("bestFriend" in third, "the now-used linksTo field appears after the bucket grows");
-			delete globalThis.__boxelRenderContext;
-			let live1 = api.getFields(person, { usedLinksToFieldsOnly: true });
-			let live2 = api.getFields(person, { usedLinksToFieldsOnly: true });
-			assert.notStrictEqual(live1, live2, "the live app always gets a fresh field map");
-		} finally {
-			delete globalThis.__boxelRenderContext;
-		}
-	});
-	(0, import_qunit.test)("can drop reference to a card url", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let instance = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.ok(instance, "instance is in store");
-		storeService.dropReference(`${testRealmURL}Person/hassan`);
-		forceGC();
-		assert.strictEqual(storeService.peek(`${testRealmURL}Person/hassan`), void 0, "instance has been garbage collected from the store");
-	});
-	(0, import_qunit.test)("can drop reference to a local id", async function(assert) {
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutPersisting(instance);
-		storeService.addReference(instance[localId]);
-		storeService.dropReference(instance[localId]);
-		forceGC();
-		let peekedInstance = storeService.peek(instance[localId]);
-		assert.strictEqual(peekedInstance, void 0, "instance is garbage collected");
-	});
-	(0, import_qunit.test)("file-meta instance is retained when referenced", async function(assert) {
-		await testRealm.write("hero.png", "mock hero image");
-		let fileUrl = `${testRealmURL}hero.png`;
-		let fileInstance = await storeService.get(fileUrl, { type: "file-meta" });
-		assert.ok(fileInstance, "file meta instance is loaded");
-		assert.ok(fileInstance.constructor?.isFileDef, "file meta instance is a FileDef");
-		storeService.addReference(fileUrl);
-		forceGC();
-		let peekedInstance = cardStore.getFileMeta(fileUrl);
-		assert.strictEqual(peekedInstance, fileInstance, "file meta instance is retained after GC with reference");
-	});
-	(0, import_qunit.test)("file-meta instance is garbage collected when references drop", async function(assert) {
-		await testRealm.write("hero.png", "mock hero image");
-		let fileUrl = `${testRealmURL}hero.png`;
-		await storeService.get(fileUrl, { type: "file-meta" });
-		storeService.addReference(fileUrl);
-		storeService.dropReference(fileUrl);
-		forceGC();
-		assert.strictEqual(cardStore.getFileMeta(fileUrl), void 0, "file meta instance is garbage collected after reference drop");
-	});
-	(0, import_qunit.test)("realm subscription is removed when file-meta reference count drops to zero", async function(assert) {
-		await testRealm.write("hero.png", "mock hero image");
-		let fileUrl = `${testRealmURL}hero.png`;
-		let subscriptions = storeService.subscriptions;
-		assert.false(subscriptions.has(testRealmURL), "realm is not subscribed before adding file-meta reference");
-		storeService.addReference(fileUrl, { type: "file-meta" });
-		assert.true(subscriptions.has(testRealmURL), "realm subscription is created for file-meta reference");
-		storeService.dropReference(fileUrl);
-		assert.false(subscriptions.has(testRealmURL), "realm subscription is removed when file-meta reference reaches zero");
-	});
-	(0, import_qunit.test)("add stores FileDef dependencies", async function(assert) {
-		class FileCard extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "attachment", [field], function() {
-					return linksTo(FileDef);
-				});
-			}
-			#attachment = (initializeDeferredDecorator(this, "attachment"), void 0);
-		}
-		let fileUrl = `${testRealmURL}hero.png`;
-		let fileDef = new FileDef({
-			id: fileUrl,
-			sourceUrl: fileUrl,
-			url: fileUrl,
-			name: "hero.png",
-			contentType: "image/png"
-		});
-		let card = new FileCard({ attachment: fileDef });
-		await storeService.addWithoutPersisting(card);
-		assert.strictEqual(storeService.peek(fileUrl, { type: "file-meta" }), fileDef, "file meta dependency is cached in file-meta store");
-	});
-	(0, import_qunit.test)("card read of a binary file URL is rerouted to file-meta", async function(assert) {
-		await testRealm.write("hero.png", "mock hero image");
-		let fileUrl = `${testRealmURL}hero.png`;
-		let result = await storeService.get(fileUrl);
-		assert.ok(result.constructor?.isFileDef, "card read returns a FileDef via the safety-net reroute");
-		let fileInstance = await storeService.get(fileUrl, { type: "file-meta" });
-		assert.ok(fileInstance.constructor?.isFileDef, "file-meta read returns a FileDef");
-		assert.strictEqual(storeService.peekError(fileUrl), void 0, "no error cached on the card bucket");
-		assert.strictEqual(storeService.peekError(fileUrl, { type: "file-meta" }), void 0, "no error cached on the file-meta bucket");
-	});
-	(0, import_qunit.test)("a file the realm does not hold is reported as a missing file", async function(assert) {
-		let missingFileUrl = `${testRealmURL}missing.png`;
-		let error = await storeService.get(missingFileUrl, { type: "file-meta" });
-		assert.strictEqual(error.status, 404, "the error carries the HTTP status");
-		assert.strictEqual(error.title, "File Not Found", "a missing file is titled as a missing file, not a missing card");
-		assert.strictEqual(error.message, `The file ${missingFileUrl} does not exist`, "the message names a file, not a card");
-	});
-	(0, import_qunit.test)("garbage collects cards that only consume each other", async function(assert) {
-		let alpha = new PersonDef({ name: "Alpha" });
-		let beta = new PersonDef({ name: "Beta" });
-		alpha.bestFriend = beta;
-		beta.bestFriend = alpha;
-		await storeService.addWithoutPersisting(alpha);
-		await storeService.addWithoutPersisting(beta);
-		assert.strictEqual(storeService.peek(alpha[localId]), alpha, "alpha is present before GC");
-		assert.strictEqual(storeService.peek(beta[localId]), beta, "beta is present before GC");
-		forceGC();
-		assert.strictEqual(storeService.peek(alpha[localId]), void 0, "alpha is garbage collected");
-		assert.strictEqual(storeService.peek(beta[localId]), void 0, "beta is garbage collected");
-	});
-	(0, import_qunit.test)("can manually save an instance", async function(assert) {
-		assert.expect(2);
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		this.onSave((url, doc) => {
-			assert.strictEqual(url.href, `${testRealmURL}Person/hassan`, "the saved card id is correct");
-			assert.strictEqual(doc.data.attributes?.name, "Hassan", "save data is correct");
-		});
-		storeService.save(`${testRealmURL}Person/hassan`);
-	});
-	(0, import_qunit.test)("can create an instance", async function(assert) {
-		let url = await storeService.create({ data: {
-			attributes: { name: "Andrea" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} });
-		assert.strictEqual(typeof url, "string", "received a url for new instance");
-		let instance = storeService.peek(url);
-		assert.strictEqual(instance.id, url);
-		assert.strictEqual(instance.name, "Andrea");
-		let file = await testRealmAdapter.openFile(`${instance.id.substring(testRealmURL.length)}.json`);
-		assert.ok(file, "file exists");
-		let fileJSON = JSON.parse(file.content);
-		assert.strictEqual(fileJSON.data.attributes.name, "Andrea", "file exists");
-	});
-	(0, import_qunit.test)("can handle card error when creating an instance", async function(assert) {
-		let error = await storeService.create({ data: {
-			attributes: {
-				name: "Andrea",
-				hasError: true
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} });
-		assert.strictEqual(typeof error, "object", "received a error for new instance");
-		assert.ok(error.message.includes("intentional error thrown", "the error message is correct"));
-	});
-	(0, import_qunit.test)("can handle a rendering card error when creating an instance", async function(assert) {
-		let instance = new BoomPersonDef({ name: "Andrea" });
-		let error = await storeService.add(instance, { realm: testRealmURL });
-		storeService.addReference(instance[localId]);
-		await storeService.flush();
-		let stale = storeService.peek(instance[localId]);
-		if (isCardInstance(stale)) assert.strictEqual(stale.name, "Andrea", "the stale card state is correct");
-		else assert.ok(false, `expected an instance but got a card error: "${stale.message}"`);
-		let peekedError = storeService.peekError(instance[localId]);
-		assert.strictEqual(peekedError, error, "the output of store.add is the peek-ed error");
-		if (!isCardInstance(error)) {
-			assert.strictEqual(error.id, instance[localId], "the error doc id is the local id of the instance");
-			assert.ok(error.message.includes("intentionallyNotDefined is not defined"));
-			loaderService.resetLoader();
-			await testRealm.write(`boom-person.gts`, `
-        import { contains, field, CardDef, Component, StringField } from '@cardstack/base/card-api';
-
-        export class BoomPerson extends CardDef {
-          static displayName = 'Boom Person';
-          @field name = contains(StringField);
-          static isolated = class Isolated extends Component<typeof this> {
-            <template>
-              Hello
-              <@fields.firstName />!
-            </template>
-          };
-        }
-      `.trim());
-			await waitUntil(() => !storeService.peekError(instance[localId]), { timeout: 5e3 });
-			await waitUntil(() => {
-				let card = storeService.peek(instance[localId]);
-				return Boolean(card && isCardInstance(card));
-			}, { timeout: 5e3 });
-			let peek = storeService.peek(instance[localId]);
-			assert.strictEqual(peek.name, "Andrea", "peek-ed value has been updated to be the fixed card instance");
-		} else assert.ok(false, "expected a card error but got a running instance");
-	});
-	(0, import_qunit.test)("can add a running instance to the store", async function(assert) {
-		assert.expect(5);
-		this.onSave((_, doc) => {
-			assert.strictEqual(doc.data.attributes?.name, "Andrea", "card data is correct");
-		});
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.add(instance);
-		assert.ok(instance.id, "instance has been assigned remote id");
-		let peekedInstance = storeService.peek(instance.id);
-		assert.strictEqual(instance, peekedInstance, "instance is the same");
-		let file = await testRealmAdapter.openFile(`${instance.id.substring(testRealmURL.length)}.json`);
-		assert.ok(file, "file exists");
-		let fileJSON = JSON.parse(file.content);
-		assert.strictEqual(fileJSON.data.attributes.name, "Andrea", "file exists");
-	});
-	(0, import_qunit.test)("add() does not persist an existing card when the realm is read-only", async function(assert) {
-		storeService.realm.permissions = () => ({
-			get canRead() {
-				return true;
-			},
-			get canWrite() {
-				return false;
-			}
-		});
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		let writes = [];
-		this.onSave((url) => writes.push(url.href));
-		instance.name = "Hassan Updated";
-		let result = await storeService.add(instance);
-		await settled();
-		assert.deepEqual(writes, [], "no write is attempted without permission");
-		assert.true(isCardInstance(result), "add() still resolves with the instance rather than a permission error");
-		let file = await testRealmAdapter.openFile("Person/hassan.json");
-		assert.strictEqual(JSON.parse(file.content).data.attributes.name, "Hassan", "the durable document is untouched");
-	});
-	(0, import_qunit.test)("add() reports its save in the card save state", async function(assert) {
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		instance.name = "Hassan Updated";
-		await storeService.add(instance);
-		let saveState = storeService.getSaveState(instance.id);
-		assert.false(saveState.hasUnsavedChanges, "the card no longer reports unsaved changes");
-		assert.ok(saveState.lastSaved, "lastSaved reflects the add()-driven save");
-		assert.strictEqual(saveState.lastSaveError, void 0, "no save error is reported");
-		assert.false(saveState.isSaving, "the save is no longer in flight");
-	});
-	(0, import_qunit.test)("add() records a persistence failure in the card save state", async function(assert) {
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		instance.name = "Hassan Updated";
-		let store = storeService;
-		store.saveCardDocument = async () => {
-			throw new Error("intentional persistence failure");
-		};
-		try {
-			await storeService.add(instance);
-		} finally {
-			delete store.saveCardDocument;
-		}
-		let saveState = storeService.getSaveState(instance.id);
-		assert.ok(saveState.lastSaveError, "the failure is visible to the save indicator, not only to the caller");
-		assert.false(saveState.isSaving, "the save is no longer in flight");
-	});
-	(0, import_qunit.test)("add() awaits durable persistence for an existing card", async function(assert) {
-		let queenzy = await storeService.get(`${testRealmURL}Person/queenzy`);
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		instance.name = "Hassan Updated";
-		instance.bestFriend = queenzy;
-		let result = await storeService.add(instance);
-		assert.true(isCardInstance(result), "add() resolves with the card instance");
-		let file = await testRealmAdapter.openFile("Person/hassan.json");
-		let fileJSON = JSON.parse(file.content);
-		assert.strictEqual(fileJSON.data.attributes.name, "Hassan Updated", "the scalar mutation is durable as soon as add() resolves");
-		assert.ok(fileJSON.data.relationships.bestFriend.links.self.endsWith("queenzy"), "the link mutation is durable as soon as add() resolves");
-	});
-	(0, import_qunit.test)("add() stays pending until an existing card is durably persisted", async function(assert) {
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		instance.name = "Hassan Updated";
-		let store = storeService;
-		let gate = new Deferred();
-		let originalPersist = store.persistAndUpdate;
-		store.persistAndUpdate = async (...args) => {
-			await gate.promise;
-			return await originalPersist.call(store, ...args);
-		};
-		try {
-			let resolved = false;
-			let addPromise = storeService.add(instance).then((r) => {
-				resolved = true;
-				return r;
-			});
-			for (let i = 0; i < 10; i++) await Promise.resolve();
-			assert.false(resolved, "add() has not resolved while persistence is gated");
-			gate.fulfill();
-			await addPromise;
-			assert.true(resolved, "add() resolves once persistence completes");
-		} finally {
-			delete store.persistAndUpdate;
-		}
-		let file = await testRealmAdapter.openFile("Person/hassan.json");
-		assert.strictEqual(JSON.parse(file.content).data.attributes.name, "Hassan Updated", "the mutation is durably persisted");
-	});
-	(0, import_qunit.test)("add() surfaces persistence failures for an existing card", async function(assert) {
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		instance.name = "Hassan Updated";
-		let store = storeService;
-		store.saveCardDocument = async () => {
-			throw new Error("intentional persistence failure");
-		};
-		let result;
-		try {
-			result = await storeService.add(instance);
-		} finally {
-			delete store.saveCardDocument;
-		}
-		assert.false(isCardInstance(result), "add() resolves with a card error rather than the instance when persistence fails");
-		assert.ok(result.message.includes("intentional persistence failure"), "the persistence error propagates to the caller instead of being swallowed");
-	});
-	(0, import_qunit.test)("can add a serialized instance to the store", async function(assert) {
-		assert.expect(6);
-		this.onSave((_, doc) => {
-			assert.strictEqual(doc.data.attributes?.name, "Andrea", "card data is correct");
-		});
-		let instance = await storeService.add({ data: {
-			attributes: { name: "Andrea" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} });
-		assert.ok(instance.id, "instance has been assigned remote id");
-		let peekedInstance = storeService.peek(instance.id);
-		assert.strictEqual(instance, peekedInstance, "instance is the same");
-		assert.strictEqual(instance.name, "Andrea", "instance data is correct");
-		let file = await testRealmAdapter.openFile(`${instance.id.substring(testRealmURL.length)}.json`);
-		assert.ok(file, "file exists");
-		let fileJSON = JSON.parse(file.content);
-		assert.strictEqual(fileJSON.data.attributes.name, "Andrea", "file exists");
-	});
-	(0, import_qunit.test)("can skip saving when adding to the store", async function(assert) {
-		assert.expect(3);
-		this.onSave(() => {
-			assert.ok(false, "save should not happen");
-		});
-		let instance = await storeService.addWithoutPersisting({ data: {
-			attributes: { name: "Andrea" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }, {});
-		assert.strictEqual(instance.id, void 0, "instance has NOT been assigned remote id");
-		let peekedInstance = storeService.peek(instance[localId]);
-		assert.strictEqual(instance, peekedInstance, "instance is the same");
-		assert.strictEqual(instance.name, "Andrea", "instance data is correct");
-	});
-	(0, import_qunit.test)("can skip waiting for the save when adding to the store", async function(assert) {
-		assert.expect(6);
-		let didSave = false;
-		this.onSave((_, doc) => {
-			didSave = true;
-			assert.strictEqual(doc.data.attributes?.name, "Andrea", "card data is correct");
-		});
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutWaiting(instance);
-		assert.false(didSave, "the instance has not saved yet");
-		await waitUntil(() => didSave, { timeout: 1e4 });
-		assert.ok(instance.id, "instance has been assigned remote id");
-		let peekedInstance = storeService.peek(instance.id);
-		assert.strictEqual(instance, peekedInstance, "instance is the same");
-		let file = await testRealmAdapter.openFile(`${instance.id.substring(testRealmURL.length)}.json`);
-		assert.ok(file, "file exists");
-		let fileJSON = JSON.parse(file.content);
-		assert.strictEqual(fileJSON.data.attributes.name, "Andrea", "file exists");
-	});
-	(0, import_qunit.test)("can set realmURL when adding to the store", async function(assert) {
-		let instance = new PersonDef({ name: "Andrea" });
-		assert.strictEqual(instance[realmURL]?.href, void 0, "realmURL meta is not set on the instance");
-		await storeService.addWithoutPersisting(instance, { realm: testRealmURL });
-		assert.strictEqual(instance[realmURL]?.href, testRealmURL, "realmURL meta was set on the instance");
-	});
-	(0, import_qunit.test)("can add linked cards to the store when adding a card", async function(assert) {
-		let wu = new PersonDef({ name: "Wu" });
-		let michael = new PersonDef({ name: "Michael" });
-		let lin = new PersonDef({
-			name: "Lin",
-			bestFriend: wu,
-			friends: [michael]
-		});
-		await storeService.addWithoutPersisting(lin);
-		let peekedMichael = storeService.peek(michael[localId]);
-		assert.strictEqual(peekedMichael, michael, "michael instance added to store");
-		let peekedWu = storeService.peek(wu[localId]);
-		assert.strictEqual(peekedWu, wu, "wu instance added to store");
-	});
-	(0, import_qunit.test)("can reject a card added to the store that has a conflicting local ID for a given URL", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let doc = { data: {
-			type: "card",
-			id: testRRI("Person/hassan"),
-			attributes: { name: "Hassan" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} };
-		let conflictingInstance = await api.createFromSerialized(doc.data, doc, void 0);
-		try {
-			await storeService.addWithoutPersisting(conflictingInstance);
-			throw new Error("expected exception to be thrown");
-		} catch (err) {
-			assert.ok(err.message.includes("has conflicting instance id in store"), "the expected error was thrown");
-		}
-	});
-	(0, import_qunit.test)("added instance that was previously not saved will begin to auto save after being added", async function(assert) {
-		assert.expect(2);
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.add(instance);
-		this.onSave((url, doc) => {
-			assert.strictEqual(url.href, instance.id, "the instance URL is correct");
-			assert.strictEqual(doc.data.attributes?.name, "Air", "card data is correct");
-		});
-		instance.name = "Air";
-	});
-	(0, import_qunit.test)("an instance will auto save when its data changes", async function(assert) {
-		assert.expect(2);
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		this.onSave((url, doc) => {
-			assert.strictEqual(url.href, instance.id, "the instance URL is correct");
-			assert.strictEqual(doc.data.attributes?.name, "Paper", "card data is correct");
-		});
-		instance.name = "Paper";
-	});
-	(0, import_qunit.test)("an unsaved instance will auto save when its data changes", async function(assert) {
-		assert.expect(2);
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutPersisting(instance);
-		this.onSave((url, doc) => {
-			assert.strictEqual(url.href.split("/").pop(), instance[localId], "the new card url ends with the local id");
-			assert.strictEqual(doc.data.attributes?.name, "Air", "card data is correct");
-		});
-		instance.name = "Air";
-	});
-	(0, import_qunit.test)("an instance will NOT auto save when its data changes, if the user does not have write permissions", async function(assert) {
-		storeService.realm.permissions = () => ({
-			get canRead() {
-				return true;
-			},
-			get canWrite() {
-				return false;
-			}
-		});
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		this.onSave(() => {
-			assert.ok(false, "should not save");
-		});
-		instance.name = "Paper";
-		assert.strictEqual(instance.name, "Paper");
-		let id = instance.id;
-		assert.deepEqual(storeService.getSaveState(id), {
-			hasUnsavedChanges: true,
-			isSaving: false,
-			lastSaveError: void 0,
-			lastSaved: void 0,
-			lastSavedErrorMsg: void 0
-		});
-	});
-	(0, import_qunit.test)("an instance can debounce auto saves", async function(assert) {
-		assert.expect(5);
-		setCardInOperatorModeState(`${testRealmURL}Person/hassan`, "edit");
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		let nameInput = `[data-test-stack-card="${testRealmURL}Person/hassan"] [data-test-field="name"] input`;
-		let typedSoFar = () => find(nameInput)?.value;
-		let typedWhenIssued = [];
-		let saveLog = [];
-		let saveTrace = () => `saves so far: ${saveLog.join(" | ")}`;
-		let saveCount = 0;
-		this.onSave((url, doc) => {
-			saveCount++;
-			let savedName = doc.data?.attributes?.name;
-			saveLog.push(`#${saveCount} issuedAfter=${JSON.stringify(typedWhenIssued[saveCount - 1])} saved=${JSON.stringify(savedName)}`);
-			assert.strictEqual(url.href, `${testRealmURL}Person/hassan`, "correct document is saved");
-			switch (saveCount) {
-				case 1:
-					assert.strictEqual(savedName, "Hassan ", `the initial instance mutation event is saved (${saveTrace()})`);
-					break;
-				case 2:
-					assert.strictEqual(savedName, "Hassan Paper", `the final instance mutation event is saved (${saveTrace()})`);
-					break;
-				default: assert.ok(false, `unexpected number of saves: ${saveCount} (${saveTrace()})`);
-			}
-		});
-		await withSavesHeldOpen(async (release) => {
-			let keystrokes = typeIn(nameInput, " Paper");
-			keystrokes.catch(() => {});
-			try {
-				await Promise.race([keystrokes, waitUntil(() => typedSoFar() === "Hassan Paper", { timeout: 3e3 })]);
-			} catch (err) {
-				throw new Error(`the keystrokes did not land, input holds ${JSON.stringify(typedSoFar())} (${saveTrace()})`, { cause: err });
-			}
-			release();
-			await keystrokes;
-		}, { onSaveIssued: () => typedWhenIssued.push(typedSoFar()) });
-		assert.strictEqual(saveCount, 2, `the number of auto-saves is correct (${saveTrace()})`);
-	});
-	(0, import_qunit.test)("a non-immediate auto save stays in flight for the save-indicator floor", async function(assert) {
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		let id = instance.id;
-		let store = storeService;
-		let originalPersist = store.persistAndUpdate;
-		store.persistAndUpdate = async () => instance;
-		try {
-			let startedAt = Date.now();
-			instance.name = "Paper";
-			await waitUntil(() => storeService.getSaveState(id)?.lastSaved, { timeout: 5e3 });
-			let heldMs = Date.now() - startedAt;
-			assert.ok(heldMs >= 500, `the save is held in flight for the floor (held ${heldMs}ms)`);
-		} finally {
-			store.persistAndUpdate = originalPersist;
-		}
-	});
-	(0, import_qunit.test)("getSaveState works for initially unsaved instance", async function(assert) {
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutPersisting(instance);
-		assert.strictEqual(storeService.getSaveState(instance[localId]), void 0, "save state is undefined");
-		instance.name = "Air";
-		assert.true(storeService.getSaveState(instance[localId])?.hasUnsavedChanges, "hasUnsavedChanges state is correct");
-		await waitUntil(() => storeService.getSaveState(instance[localId])?.isSaving, { timeout: 1e4 });
-		await waitUntil(() => storeService.getSaveState(instance[localId])?.lastSaved, { timeout: 1e4 });
-		assert.false(storeService.getSaveState(instance[localId])?.isSaving, "isSaving state is correct");
-		assert.false(storeService.getSaveState(instance.id)?.isSaving, "isSaving state is correct (by remote id)");
-		assert.ok(storeService.getSaveState(instance.id)?.lastSaved, "lastSaved state is correct (by remote id)");
-	});
-	(0, import_qunit.test)("can capture error when auto saving", async function(assert) {
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		try {
-			globalThis.__emulateServerPatchFailure = true;
-			instance.hasError = true;
-			await waitUntil(() => storeService.getSaveState(`${testRealmURL}Person/hassan`)?.lastSaveError, { timeout: 1e4 });
-			let saveState = storeService.getSaveState(`${testRealmURL}Person/hassan`);
-			assert.ok(saveState.lastSavedErrorMsg?.includes("intentional error thrown"), "error message is correct");
-		} finally {
-			delete globalThis.__emulateServerPatchFailure;
-		}
-	});
-	(0, import_qunit.module)("auto save waits for edits to pause", function(hooks) {
-		let saves;
-		let originalQuietPeriodMs;
-		let originalMaxWaitMs;
-		function recordSave(url, doc) {
-			saves.push({
-				url: url.href,
-				name: doc.data?.attributes?.name
-			});
-		}
-		hooks.beforeEach(function() {
-			saves = [];
-			this.onSave(recordSave);
-			let environment = getService("environment-service");
-			originalQuietPeriodMs = environment.autoSaveQuietPeriodMs;
-			originalMaxWaitMs = environment.autoSaveMaxWaitMs;
-			setAutoSaveTiming(NEVER, NEVER);
-		});
-		hooks.afterEach(function() {
-			let environment = getService("environment-service");
-			environment.autoSaveQuietPeriodMs = originalQuietPeriodMs;
-			environment.autoSaveMaxWaitMs = originalMaxWaitMs;
-		});
-		function setAutoSaveTiming(quietPeriodMs, maxWaitMs) {
-			let environment = getService("environment-service");
-			environment.autoSaveQuietPeriodMs = quietPeriodMs;
-			environment.autoSaveMaxWaitMs = maxWaitMs;
-		}
-		const NEVER = 10 * 6e4;
-		function pause(ms) {
-			return new Promise((resolve) => setTimeout(resolve, ms));
-		}
-		async function waitForSaves(count, message) {
-			try {
-				await waitUntil(() => saves.length >= count, { timeout: 5e3 });
-			} catch (err) {
-				throw new Error(`${message}: expected ${count} save(s), saw ${JSON.stringify(saves)}`, { cause: err });
-			}
-		}
-		function recordWrites(onWrite) {
-			let virtualNetwork = getService("network").virtualNetwork;
-			let originalFetch = virtualNetwork.fetch;
-			let writes = [];
-			virtualNetwork.fetch = async (input, init) => {
-				let request = input instanceof Request ? input : void 0;
-				let method = init?.method ?? request?.method ?? "GET";
-				if (method === "PATCH" || method === "POST") {
-					let url = request?.url ?? String(input);
-					writes.push({
-						url,
-						keepalive: init?.keepalive ?? request?.keepalive ?? false
-					});
-					onWrite?.(url);
-				}
-				return await originalFetch.call(virtualNetwork, input, init);
-			};
-			return {
-				writes,
-				restore: () => virtualNetwork.fetch = originalFetch
-			};
-		}
-		function hidePage() {
-			Object.defineProperty(document, "visibilityState", {
-				configurable: true,
-				get: () => "hidden"
-			});
-			try {
-				document.dispatchEvent(new Event("visibilitychange"));
-			} finally {
-				delete document.visibilityState;
-			}
-		}
-		(0, import_qunit.test)("edits are saved once, after they pause", async function(assert) {
-			setAutoSaveTiming(300, NEVER);
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			for (let name of [
-				"H",
-				"Ha",
-				"Has",
-				"Hass",
-				"Hassa"
-			]) {
-				instance.name = name;
-				await pause(50);
-			}
-			assert.strictEqual(saves.length, 0, "nothing is saved while editing");
-			let saveState = storeService.getSaveState(id);
-			assert.true(saveState.hasUnsavedChanges, "the card has unsaved changes");
-			assert.false(saveState.isSaving, "the card is not saving yet");
-			assert.strictEqual(saveState.lastSavedErrorMsg, "Unsaved changes", "the indicator reports unsaved changes");
-			await waitForSaves(1, "the edits are saved once they pause");
-			await storeService.flushSaves();
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Hassa"
-			}], "one save carries the last edit");
-			assert.false(storeService.getSaveState(id).hasUnsavedChanges, "nothing is left unsaved");
-			assert.ok(storeService.getSaveState(id).lastSavedErrorMsg?.startsWith("Saved"), "the indicator reports the save");
-		});
-		(0, import_qunit.test)("editing without a pause is saved at the maximum wait", async function(assert) {
-			setAutoSaveTiming(300, 600);
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			let maxWaitMs = 600;
-			let edits = 30;
-			let startedAt = Date.now();
-			let timeline = [];
-			this.onSave((url, doc) => {
-				recordSave(url, doc);
-				timeline.push(`saved@${Date.now() - startedAt}`);
-			});
-			let { writes, restore } = recordWrites((url) => timeline.push(`${url === id ? "sent" : `sent ${url}`}@${Date.now() - startedAt}`));
-			let editingMs;
-			let sentWhileEditing;
-			try {
-				for (let i = 1; i <= edits; i++) {
-					instance.name = `Hassan ${i}`;
-					await pause(100);
-				}
-				editingMs = Date.now() - startedAt;
-				sentWhileEditing = writes.filter((w) => w.url === id).length;
-				timeline.push(`editing-ended@${editingMs}`);
-				await storeService.flushSaves();
-			} finally {
-				restore();
-			}
-			assert.ok(sentWhileEditing >= 1, `edits are saved while editing goes on (${sentWhileEditing} sent; ${timeline.join(", ")})`);
-			let bound = Math.ceil(editingMs / maxWaitMs) + 1;
-			assert.ok(saves.length <= bound, `${edits} edits over ${editingMs}ms take at most ${bound} saves (${saves.length} saved; ${timeline.join(", ")})`);
-			assert.ok(saves.length < edits / 3, `${edits} edits take far fewer saves than edits (${saves.length} saved; ${timeline.join(", ")})`);
-			assert.strictEqual(saves[saves.length - 1]?.name, `Hassan ${edits}`, "the last save carries the last edit");
-		});
-		(0, import_qunit.test)("an edit made while its save runs stays unsaved until the next save", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			await withSavesHeldOpen(async (release) => {
-				instance.name = "Paper";
-				document.body.dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
-				await waitUntil(() => storeService.getSaveState(id)?.isSaving);
-				instance.name = "Paper Hassan";
-				release();
-				await waitUntil(() => !storeService.getSaveState(id)?.isSaving);
-				let saveState = storeService.getSaveState(id);
-				assert.true(saveState.hasUnsavedChanges, "the edit made during the save is still unsaved");
-				assert.strictEqual(saveState.lastSavedErrorMsg, "Unsaved changes", "the indicator does not report the edit as saved");
-			});
-			await storeService.flushSaves();
-			assert.deepEqual(saves.map((s) => s.name), ["Paper", "Paper Hassan"], "both edits are saved, in order");
-			assert.false(storeService.getSaveState(id).hasUnsavedChanges);
-		});
-		(0, import_qunit.test)("a pending save is sent when the last reference to its card is dropped", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			storeService.addReference(id);
-			await storeService.flush();
-			let instance = storeService.peek(id);
-			instance.name = "Paper";
-			storeService.dropReference(id);
-			await waitForSaves(1, "dropping the last reference sends the save");
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-			await storeService.flushSaves();
-			assert.strictEqual(storeService.getReferenceCount(id), 0, "the save's hold on the card is released once it lands");
-		});
-		(0, import_qunit.test)("a pending save is not sent early while something still shows its card", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			storeService.addReference(id);
-			storeService.addReference(id);
-			await storeService.flush();
-			let instance = storeService.peek(id);
-			instance.name = "Paper";
-			storeService.dropReference(id);
-			await pause(1e3);
-			assert.strictEqual(saves.length, 0, "the save keeps waiting");
-			storeService.dropReference(id);
-			await waitForSaves(1, "dropping the last reference sends the save");
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-		});
-		(0, import_qunit.test)("garbage collection keeps a card whose save is pending", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let controlId = `${testRealmURL}Person/jade`;
-			let instance = await storeService.get(id);
-			let control = await storeService.get(controlId);
-			assert.strictEqual(storeService.getReferenceCount(id), 0);
-			assert.strictEqual(storeService.getReferenceCount(controlId), 0);
-			instance.name = "Paper";
-			forceGC();
-			assert.strictEqual(storeService.peek(controlId), void 0, "an unreferenced card without a pending save is collected");
-			assert.notStrictEqual(control, void 0);
-			assert.strictEqual(storeService.peek(id), instance, "the card with a pending save is kept");
-			await storeService.flushSaves();
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-		});
-		(0, import_qunit.test)("flushSaves sends pending saves and waits for them", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			instance.name = "Paper";
-			await storeService.flushSaves();
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-			assert.false(storeService.hasUnsavedEdits);
-		});
-		(0, import_qunit.test)("ending the session drops saves still waiting for typing to pause", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			instance.name = "Paper";
-			storeService.resetState();
-			storeService._onSave(recordSave);
-			await pause(1e3);
-			assert.deepEqual(saves, [], "nothing is written after the session ends");
-			assert.false(storeService.hasUnsavedEdits, "nothing is left pending");
-		});
-		(0, import_qunit.test)("a save queued behind a running one does not write once the session ends", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			await withSavesHeldOpen(async (release) => {
-				instance.name = "Paper";
-				storeService.flushSaves();
-				await waitUntil(() => storeService.getSaveState(id)?.isSaving);
-				instance.name = "Paper Hassan";
-				storeService.flushSaves();
-				storeService.resetState();
-				storeService._onSave(recordSave);
-				release();
-				await waitUntil(() => !storeService.hasUnsavedEdits, { timeout: 5e3 });
-			});
-			assert.deepEqual(saves.map((s) => s.name), ["Paper"], "only the save that started before the session ended is written");
-		});
-		(0, import_qunit.test)("logout saves pending edits before the session ends", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			instance.name = "Paper";
-			let matrixService = getService("matrix-service");
-			let originalClearAuth = matrixService.clearAuth;
-			let originalResetState = matrixService.resetState;
-			let savedWhenAuthCleared;
-			matrixService.clearAuth = () => {
-				savedWhenAuthCleared = [...saves];
-				throw new Error("stop logout here");
-			};
-			matrixService.resetState = () => {};
-			try {
-				await matrixService.logout({ skipIndexTransition: true });
-			} finally {
-				matrixService.clearAuth = originalClearAuth;
-				matrixService.resetState = originalResetState;
-			}
-			assert.deepEqual(savedWhenAuthCleared, [{
-				url: id,
-				name: "Paper"
-			}], "the edit is saved before auth is cleared");
-		});
-		(0, import_qunit.test)("resetting the store cache sends pending saves", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			instance.name = "Paper";
-			storeService.resetCache();
-			await waitForSaves(1, "the reset sends the save");
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-			await storeService.flushSaves();
-		});
-		(0, import_qunit.test)("hiding the page sends pending saves as requests that outlive the page", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			instance.name = "Paper";
-			let { writes, restore } = recordWrites();
-			try {
-				hidePage();
-				await waitForSaves(1, "hiding the page sends the save");
-			} finally {
-				restore();
-			}
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-			assert.deepEqual(writes, [{
-				url: id,
-				keepalive: true
-			}]);
-		});
-		(0, import_qunit.test)("pagehide sends pending saves as requests that outlive the page", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			instance.name = "Paper";
-			let { writes, restore } = recordWrites();
-			try {
-				window.dispatchEvent(new PageTransitionEvent("pagehide"));
-				await waitForSaves(1, "pagehide sends the save");
-				await storeService.flushSaves();
-			} finally {
-				restore();
-			}
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-			assert.deepEqual(writes, [{
-				url: id,
-				keepalive: true
-			}]);
-		});
-		(0, import_qunit.test)("saves past the keepalive budget are still sent, without keepalive", async function(assert) {
-			let ids = [`${testRealmURL}Person/hassan`, `${testRealmURL}Person/jade`];
-			let longName = "x".repeat(4e4);
-			for (let id of ids) {
-				let instance = await storeService.get(id);
-				instance.name = longName;
-			}
-			let { writes, restore } = recordWrites();
-			try {
-				window.dispatchEvent(new PageTransitionEvent("pagehide"));
-				await waitForSaves(2, "pagehide sends both saves");
-				await storeService.flushSaves();
-			} finally {
-				restore();
-			}
-			assert.deepEqual(saves.map((s) => s.url).sort(), [...ids].sort(), "both cards are saved");
-			assert.deepEqual(writes.map((w) => w.keepalive).sort(), [false, true], "one save fits the budget and the other is sent as an ordinary request");
-		});
-		(0, import_qunit.test)("an edit after a flush gives up still waits for typing to pause", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let jade = `${testRealmURL}Person/jade`;
-			let instance = await storeService.get(id);
-			let other = await storeService.get(jade);
-			await withSavesHeldOpen(async (release) => {
-				instance.name = "Paper";
-				await storeService.flushSaves({ timeoutMs: 100 });
-				assert.true(storeService.hasUnsavedEdits, "the held save is running");
-				other.name = "Jade Paper";
-				release();
-				await waitUntil(() => saves.length === 1, { timeout: 5e3 });
-				await pause(500);
-			});
-			assert.deepEqual(saves.map((s) => s.name), ["Paper"], "the later edit is not sent when the flush's save lands");
-			await storeService.flushSaves();
-			assert.deepEqual(saves.map((s) => s.name), ["Paper", "Jade Paper"]);
-		});
-		(0, import_qunit.test)("focus leaving a field sends pending saves", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			let instance = await storeService.get(id);
-			instance.name = "Paper";
-			document.body.dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
-			await waitForSaves(1, "focus leaving sends the save");
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Paper"
-			}]);
-		});
-		(0, import_qunit.test)("closing a card in the stack sends the save its edit is waiting on", async function(assert) {
-			let id = `${testRealmURL}Person/hassan`;
-			setCardInOperatorModeState(id, "edit");
-			await renderComponent(class TestDriver extends Component {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "ZD1xwmB+",
-						"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-						"scope": () => [OperatorModeContainer, noop],
-						"isStrictMode": true
-					}), this);
-				}
-			});
-			let input = find(`[data-test-stack-card="${id}"] [data-test-field="name"] input`);
-			input.value = "Hassan Paper";
-			input.dispatchEvent(new Event("input", { bubbles: true }));
-			assert.strictEqual(saves.length, 0, "the edit waits to be saved");
-			let closed = click(`[data-test-stack-card="${id}"] [data-test-close-button]`);
-			await waitForSaves(1, "closing the card sends the save");
-			await closed;
-			assert.deepEqual(saves, [{
-				url: id,
-				name: "Hassan Paper"
-			}]);
-		});
-	});
-	(0, import_qunit.test)("can delete card from the store", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/boris`);
-		await storeService.flush();
-		let instance = storeService.peek(`${testRealmURL}Person/boris`);
-		await storeService.delete(`${testRealmURL}Person/boris`);
-		assert.strictEqual(storeService.peek(instance.id), void 0, "the instance is no longer in the store");
-		assert.strictEqual(storeService.peek(instance[localId]), void 0, "the instance is no longer in the store (via local id)");
-		let file = await testRealmAdapter.openFile(`Person/boris.json`);
-		assert.strictEqual(file, void 0, "file no longer exists");
-	});
-	(0, import_qunit.test)("subscribeToCardInvalidation fires the callback when the card is deleted", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/boris`);
-		await storeService.flush();
-		let fired = 0;
-		let unsubscribe = storeService.subscribeToCardInvalidation(`${testRealmURL}Person/boris`, () => {
-			fired += 1;
-		});
-		await storeService.delete(`${testRealmURL}Person/boris`);
-		assert.strictEqual(fired, 1, "the invalidation subscriber fires exactly once on delete");
-		unsubscribe();
-	});
-	(0, import_qunit.test)("subscribeToCardInvalidation unsubscribe stops firing the callback", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/boris`);
-		await storeService.flush();
-		let fired = 0;
-		storeService.subscribeToCardInvalidation(`${testRealmURL}Person/boris`, () => {
-			fired += 1;
-		})();
-		await storeService.delete(`${testRealmURL}Person/boris`);
-		assert.strictEqual(fired, 0, "no callbacks fire after unsubscribe");
-	});
-	(0, import_qunit.test)("a synchronously throwing invalidation subscriber does not break siblings", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/boris`);
-		await storeService.flush();
-		let originalError = console.error;
-		let captured = [];
-		console.error = (...args) => {
-			if (typeof args[0] === "string" && args[0].includes("card invalidation subscriber")) captured.push(args);
-			else originalError(...args);
-		};
-		let secondFired = 0;
-		let unsubscribeA = storeService.subscribeToCardInvalidation(`${testRealmURL}Person/boris`, () => {
-			throw new Error("intentional sync throw from invalidation subscriber");
-		});
-		let unsubscribeB = storeService.subscribeToCardInvalidation(`${testRealmURL}Person/boris`, () => {
-			secondFired += 1;
-		});
-		try {
-			await storeService.delete(`${testRealmURL}Person/boris`);
-			assert.strictEqual(secondFired, 1, "the second subscriber still runs after the first one throws");
-			assert.strictEqual(captured.length, 1, "the synchronous throw is reported via console.error exactly once");
-		} finally {
-			unsubscribeA();
-			unsubscribeB();
-			console.error = originalError;
-		}
-	});
-	(0, import_qunit.test)("an async-rejecting invalidation subscriber does not break siblings and does not surface as an unhandled rejection", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/boris`);
-		await storeService.flush();
-		let originalError = console.error;
-		let captured = [];
-		console.error = (...args) => {
-			if (typeof args[0] === "string" && args[0].includes("card invalidation subscriber")) captured.push(args);
-			else originalError(...args);
-		};
-		let secondFired = 0;
-		let unsubscribeA = storeService.subscribeToCardInvalidation(`${testRealmURL}Person/boris`, async () => {
-			await Promise.resolve();
-			throw new Error("intentional async rejection from invalidation subscriber");
-		});
-		let unsubscribeB = storeService.subscribeToCardInvalidation(`${testRealmURL}Person/boris`, () => {
-			secondFired += 1;
-		});
-		try {
-			await storeService.delete(`${testRealmURL}Person/boris`);
-			await settled();
-			assert.strictEqual(secondFired, 1, "the second subscriber still runs alongside the async-rejecting one");
-			assert.strictEqual(captured.length, 1, "the async rejection is reported via console.error exactly once");
-		} finally {
-			unsubscribeA();
-			unsubscribeB();
-			console.error = originalError;
-		}
-	});
-	(0, import_qunit.test)("can patch an instance", async function(assert) {
-		let instance = await storeService.patch(`${testRealmURL}Person/hassan`, {
-			attributes: { name: "Hassan Updated" },
-			relationships: {
-				bestFriend: { links: { self: `${testRealmURL}Person/jade` } },
-				"friends.0": { links: { self: `${testRealmURL}Person/germaine` } }
-			}
-		});
-		let peekedInstance = storeService.peek(`${testRealmURL}Person/hassan`);
-		let jade = storeService.peek(`${testRealmURL}Person/jade`);
-		let germaine = storeService.peek(`${testRealmURL}Person/germaine`);
-		assert.strictEqual(peekedInstance, instance, "the patched instance is in the store");
-		assert.ok(isCardInstance(jade), "jade is in the store");
-		assert.ok(isCardInstance(germaine), "germaine is in the store");
-		assert.strictEqual(instance.name, "Hassan Updated", "the contains field was patched");
-		assert.strictEqual(instance.bestFriend, jade, "the linksTo field was patched");
-		assert.deepEqual(instance.friends, [germaine], "the linksToMany field was patched");
-	});
-	(0, import_qunit.test)("a patch that gives a primitive field an object replaces its value", async function(assert) {
-		await testRealm.write("Settings/one.json", JSON.stringify({ data: {
-			type: "card",
-			attributes: {
-				cardInfo: {
-					name: "Settings",
-					summary: "Kept"
-				},
-				config: {
-					approver: "@mae:localhost",
-					retired: true
-				}
-			},
-			meta: { adoptsFrom: {
-				module: "@cardstack/base/realm-config",
-				name: "RealmConfig"
-			} }
-		} }));
-		let id = `${testRealmURL}Settings/one`;
-		let instance = await storeService.patch(id, { attributes: {
-			cardInfo: { name: "Renamed" },
-			config: { approvers: "@mae:localhost" }
-		} });
-		assert.deepEqual(instance.config, { approvers: "@mae:localhost" }, "the instance holds the map the patch sent");
-		let file = await testRealmAdapter.openFile("Settings/one.json");
-		let { attributes } = JSON.parse(file.content).data;
-		assert.deepEqual(attributes.config, { approvers: "@mae:localhost" }, "and so does the saved file, without the renamed or dropped keys");
-		assert.strictEqual(attributes.cardInfo.summary, "Kept", "the compound field keeps the nested value the patch leaves out");
-	});
-	(0, import_qunit.test)("resolving a linksTo lazily issues no save", async function(assert) {
-		let hassanId = `${testRealmURL}Person/hassan`;
-		await testRealm.write("Person/ghost-friend.json", JSON.stringify({ data: {
-			attributes: { name: "Ghost" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Hassan" },
-			relationships: { bestFriend: { links: { self: `${testRealmURL}Person/ghost-friend` } } },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let cardService = getService("card-service");
-		let fetchJSON = cardService.fetchJSON.bind(cardService);
-		let intercepted = 0;
-		cardService.fetchJSON = async (url, args) => {
-			let doc = await fetchJSON(url, args);
-			if (String(url).replace(/\.json$/, "") === hassanId) {
-				intercepted++;
-				delete doc?.included;
-			}
-			return doc;
-		};
-		let saved = [];
-		this.onSave((url) => {
-			saved.push(url.href);
-		});
-		try {
-			let instance = await storeService.get(hassanId);
-			assert.ok(intercepted > 0, "the card fetch was intercepted");
-			assert.strictEqual(instance.bestFriend, void 0, "the link is not loaded yet, so reading it takes the lazy path");
-			await storeService.flush();
-			await settled();
-			assert.strictEqual(instance.bestFriend?.name, "Ghost", "the lazy load resolved the target and assigned it to the field");
-			assert.deepEqual(saved, [], "no save was issued while loading");
-		} finally {
-			cardService.fetchJSON = fetchJSON;
-		}
-	});
-	(0, import_qunit.test)("resolving a linksToMany lazily issues no save", async function(assert) {
-		let hassanId = `${testRealmURL}Person/hassan`;
-		await testRealm.write("Person/ghost-friend.json", JSON.stringify({ data: {
-			attributes: { name: "Ghost" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Hassan" },
-			relationships: { "friends.0": { links: { self: `${testRealmURL}Person/ghost-friend` } } },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let cardService = getService("card-service");
-		let fetchJSON = cardService.fetchJSON.bind(cardService);
-		let intercepted = 0;
-		cardService.fetchJSON = async (url, args) => {
-			let doc = await fetchJSON(url, args);
-			if (String(url).replace(/\.json$/, "") === hassanId) {
-				intercepted++;
-				delete doc?.included;
-			}
-			return doc;
-		};
-		let saved = [];
-		this.onSave((url) => {
-			saved.push(url.href);
-		});
-		try {
-			let instance = await storeService.get(hassanId);
-			assert.ok(intercepted > 0, "the card fetch was intercepted");
-			assert.deepEqual(instance.friends.map((f) => f?.name), [void 0], "the element is not loaded yet, so reading it takes the lazy path");
-			await storeService.flush();
-			await settled();
-			assert.deepEqual(instance.friends.map((f) => f?.name), ["Ghost"], "the lazy load resolved the target into its slot");
-			assert.deepEqual(saved, [], "no save was issued while loading");
-		} finally {
-			cardService.fetchJSON = fetchJSON;
-		}
-	});
-	(0, import_qunit.test)("a concurrent field write during store.patch is not clobbered by the patch’s stale snapshot", async function(assert) {
-		let targetId = `${testRealmURL}Person/hassan`;
-		let instance = await storeService.get(targetId);
-		let gate = new Deferred();
-		let enteredGate = new Deferred();
-		let originalLoadPatchedInstances = storeService.loadPatchedInstances;
-		storeService.loadPatchedInstances = async function(...args) {
-			let result = await originalLoadPatchedInstances.apply(this, args);
-			enteredGate.fulfill();
-			await gate.promise;
-			return result;
-		};
-		try {
-			let patchPromise = storeService.patch(targetId, { relationships: { bestFriend: { links: { self: `${testRealmURL}Person/jade` } } } });
-			await enteredGate.promise;
-			instance.name = "Race Winner";
-			gate.fulfill();
-			await patchPromise;
-		} finally {
-			storeService.loadPatchedInstances = originalLoadPatchedInstances;
-		}
-		assert.strictEqual(instance.name, "Race Winner", "the concurrent field write is not clobbered by the patch's stale snapshot");
-		assert.strictEqual(instance.bestFriend?.id, `${testRealmURL}Person/jade`, "the patch itself was still applied");
-	});
-	(0, import_qunit.test)("a create gives the instance a remote identity the rest of the store can use", async function(assert) {
-		let instance = new PersonDef({ name: "Sequence" });
-		let instanceLocalId = instance[localId];
-		let subscriptions = storeService.subscriptions;
-		assert.false(subscriptions.has(testRealmURL), "the realm is not subscribed before the create");
-		let result = await storeService.persistAndUpdate(instance);
-		assert.true(isCardInstance(result), "the create resolved to the instance");
-		assert.ok(instance.id?.startsWith(testRealmURL), "the instance took a remote id in the realm");
-		assert.strictEqual(storeService.peek(instanceLocalId), instance, "the local id still resolves to this instance");
-		assert.strictEqual(storeService.peek(instance.id), instance, "the remote id resolves to the same instance");
-		assert.true(subscriptions.has(testRealmURL), "the store is listening for the realm's index events");
-		let cardPath = `${instance.id.substring(testRealmURL.length)}.json`;
-		assert.ok(await testRealmAdapter.openFile(cardPath), "the realm holds the created card");
-		instance.name = "Sequence Edited";
-		await waitUntil(() => storeService.getSaveState(instanceLocalId)?.lastSaved, { timeout: 1e4 });
-		await settled();
-		let file = await testRealmAdapter.openFile(cardPath);
-		assert.strictEqual(JSON.parse(file.content).data.attributes.name, "Sequence Edited", "an edit after the create autosaves to the realm");
-	});
-	(0, import_qunit.test)("a small new card saves even when its resident linked graph would overflow the size limit if inlined", async function(assert) {
-		let environmentService = getService("environment-service");
-		let originalMaxSize = environmentService.cardSizeLimitBytes;
-		try {
-			let bigFriend = new PersonDef({ name: "x".repeat(6e3) });
-			let savedFriend = await storeService.persistAndUpdate(bigFriend);
-			assert.true(isCardInstance(savedFriend), "the large linked card saved");
-			environmentService.cardSizeLimitBytes = 2500;
-			let instance = new PersonDef({ name: "Small" });
-			instance.bestFriend = bigFriend;
-			let result = await storeService.persistAndUpdate(instance);
-			assert.true(isCardInstance(result), "a new card whose own document is under the limit saves regardless of how large a graph it links to — the check measures what the realm stores, not the tab's loaded `included`");
-			let cardPath = `${instance.id.substring(testRealmURL.length)}.json`;
-			assert.ok(await testRealmAdapter.openFile(cardPath), "the realm holds the created card");
-		} finally {
-			environmentService.cardSizeLimitBytes = originalMaxSize;
-		}
-	});
-	(0, import_qunit.test)("includedScope controls which link targets the serializer builds", async function(assert) {
-		let cardService = getService("card-service");
-		let api = await cardService.getAPI();
-		let saved = new PersonDef({ name: "Saved" });
-		await storeService.persistAndUpdate(saved);
-		let unsaved = new PersonDef({ name: "Unsaved" });
-		let instance = new PersonDef({ name: "Consumer" });
-		instance.bestFriend = saved;
-		instance.friends = [unsaved];
-		let all = api.serializeCard(instance, {
-			useAbsoluteURL: true,
-			includedScope: "all"
-		});
-		assert.ok((all.included ?? []).find((r) => r.id === saved.id), "'all' serializes saved targets into included");
-		assert.ok((all.included ?? []).find((r) => r.lid === unsaved[localId]), "'all' serializes local targets into included");
-		let local = api.serializeCard(instance, {
-			useAbsoluteURL: true,
-			includedScope: "local"
-		});
-		assert.notOk((local.included ?? []).find((r) => r.id === saved.id), "'local' does not serialize saved targets");
-		assert.ok((local.included ?? []).find((r) => r.lid === unsaved[localId]), "'local' serializes local targets — the write's co-creation manifest");
-		let none = api.serializeCard(instance, {
-			useAbsoluteURL: true,
-			includedScope: "none"
-		});
-		assert.strictEqual(none.included, void 0, "'none' builds no included at all");
-		assert.deepEqual(local.data, all.data, "'local' leaves the primary resource identical to 'all'");
-		assert.deepEqual(none.data, all.data, "'none' leaves the primary resource identical to 'all'");
-		let viaCardService = await cardService.serializeCard(instance, {
-			useAbsoluteURL: true,
-			withLocalResourcesIncluded: true
-		});
-		assert.deepEqual(viaCardService, local, "withLocalResourcesIncluded serializes at the 'local' scope");
-	});
-	(0, import_qunit.test)("an oversized unsaved link created alongside a card still fails the size check", async function(assert) {
-		let environmentService = getService("environment-service");
-		let originalMaxSize = environmentService.cardSizeLimitBytes;
-		try {
-			environmentService.cardSizeLimitBytes = 2500;
-			let bigUnsaved = new PersonDef({ name: "x".repeat(6e3) });
-			let instance = new PersonDef({ name: "Small" });
-			instance.bestFriend = bigUnsaved;
-			let result = await storeService.persistAndUpdate(instance);
-			assert.false(isCardInstance(result), "the save is refused: the unsaved link is co-created as its own file and is over the ceiling");
-			assert.ok(String(result?.message).includes("exceeds maximum allowed size"), `the error names the size limit (got: ${result?.message})`);
-		} finally {
-			environmentService.cardSizeLimitBytes = originalMaxSize;
-		}
-	});
-	(0, import_qunit.test)("a save overlapping a create PATCHes instead of issuing a second POST", async function(assert) {
-		let instance = new PersonDef({ name: "Overlap" });
-		await storeService.addWithoutPersisting(instance);
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		let methods = [];
-		let reachedPost = new Deferred();
-		let releasePost = new Deferred();
-		cardService.fetchJSON = async (url, args) => {
-			if (args?.method !== "POST" && args?.method !== "PATCH") return originalFetchJSON(url, args);
-			methods.push(args.method);
-			if (args.method === "POST") {
-				reachedPost.fulfill();
-				await releasePost.promise;
-			}
-			return originalFetchJSON(url, args);
-		};
-		try {
-			let creating = storeService.persistAndUpdate(instance);
-			let reachedPostFirst = await Promise.race([reachedPost.promise.then(() => true), creating.then(() => false)]);
-			assert.true(reachedPostFirst, `the create reached its POST (resolved early as: ${JSON.stringify(await Promise.race([creating, Promise.resolve("still in flight")]))})`);
-			let overlapping = storeService.persistAndUpdate(instance);
-			releasePost.fulfill();
-			await Promise.all([creating, overlapping]);
-		} finally {
-			releasePost.fulfill();
-			delete cardService.fetchJSON;
-		}
-		await settled();
-		assert.deepEqual(methods, ["POST", "PATCH"], "the overlapping save waited for the remote id and updated the created card");
-		assert.ok(await testRealmAdapter.openFile(`${instance.id.substring(testRealmURL.length)}.json`), "the realm holds the created card");
-	});
-	function holdCreateResponse(held, opts) {
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		let writes = [];
-		let stored = new Deferred();
-		let release = new Deferred();
-		cardService.fetchJSON = async (url, args) => {
-			if (args?.method !== "POST" && args?.method !== "PATCH") return originalFetchJSON(url, args);
-			let body = JSON.parse(args.body);
-			writes.push({
-				method: args.method,
-				body
-			});
-			if (args.method !== "POST" || body.data.lid !== held[localId]) return originalFetchJSON(url, args);
-			let response = await originalFetchJSON(url, args);
-			stored.fulfill();
-			await release.promise;
-			if (opts?.fail) throw new Error("the create response never arrived");
-			return response;
-		};
-		return {
-			writes,
-			stored: stored.promise,
-			release: () => release.fulfill(),
-			restore() {
-				release.fulfill();
-				delete cardService.fetchJSON;
-			}
-		};
-	}
-	function includedLids(body) {
-		return (body.included ?? []).flatMap((resource) => "lid" in resource && resource.lid ? [resource.lid] : []);
-	}
-	(0, import_qunit.test)("a save does not send a linked card whose create is still in flight as a card to create", async function(assert) {
-		let friend = new PersonDef({ name: "Friend" });
-		await storeService.addWithoutPersisting(friend);
-		let person = new PersonDef({ name: "Person" });
-		person.bestFriend = friend;
-		await storeService.addWithoutPersisting(person);
-		let hold = holdCreateResponse(friend);
-		let personResult;
-		try {
-			let creatingFriend = storeService.persistAndUpdate(friend);
-			await hold.stored;
-			let savingPerson = storeService.persistAndUpdate(person);
-			let personSettledWhileFriendHeld = await Promise.race([savingPerson.then(() => true), new Promise((r) => setTimeout(() => r(false), 500))]);
-			assert.false(personSettledWhileFriendHeld, "the save waits while the linked card's create is unanswered");
-			assert.deepEqual(hold.writes.map((w) => w.method), ["POST"], "nothing but the linked card's own create went out while it was unanswered");
-			hold.release();
-			[, personResult] = await Promise.all([creatingFriend, savingPerson]);
-		} finally {
-			hold.restore();
-		}
-		await settled();
-		assert.true(isCardInstance(personResult), `the save succeeded (resolved as: ${JSON.stringify(personResult)})`);
-		let personWrite = hold.writes.find((w) => w.body.data.lid === person[localId]);
-		assert.ok(personWrite, "the card linking to it was saved");
-		assert.deepEqual(includedLids(personWrite.body), [], "the save carried no card to create");
-		assert.strictEqual(personWrite.body.data.relationships?.bestFriend?.links?.self, friend.id, "the save linked to the id the realm assigned the linked card");
-		let file = await testRealmAdapter.openFile(`${person.id.substring(testRealmURL.length)}.json`);
-		assert.ok(file, "the realm holds the saved card");
-	});
-	(0, import_qunit.test)("a save started in the same turn as a linked card's create does not send that card again", async function(assert) {
-		let friend = new PersonDef({ name: "Friend" });
-		await storeService.addWithoutPersisting(friend);
-		let person = new PersonDef({ name: "Person" });
-		person.bestFriend = friend;
-		await storeService.addWithoutPersisting(person);
-		let hold = holdCreateResponse(friend);
-		let results;
-		try {
-			let creatingFriend = storeService.persistAndUpdate(friend);
-			let savingPerson = storeService.persistAndUpdate(person);
-			await hold.stored;
-			hold.release();
-			results = await Promise.all([creatingFriend, savingPerson]);
-		} finally {
-			hold.restore();
-		}
-		await settled();
-		assert.true(results.every((r) => isCardInstance(r)), `both saves succeeded (resolved as: ${JSON.stringify(results)})`);
-		assert.deepEqual(hold.writes.map((w) => includedLids(w.body)), [[], []], "neither request carried a card to create besides its own");
-	});
-	(0, import_qunit.test)("a save still creates a linked card that was never saved alongside it", async function(assert) {
-		let friend = new PersonDef({ name: "Friend" });
-		let person = new PersonDef({ name: "Person" });
-		person.bestFriend = friend;
-		await storeService.addWithoutPersisting(person);
-		let hold = holdCreateResponse(friend);
-		let personResult;
-		try {
-			personResult = await storeService.persistAndUpdate(person);
-		} finally {
-			hold.restore();
-		}
-		await settled();
-		assert.true(isCardInstance(personResult), `the save succeeded (resolved as: ${JSON.stringify(personResult)})`);
-		assert.deepEqual(hold.writes.map((w) => includedLids(w.body)), [[friend[localId]]], "one request carried the unsaved linked card as a card to create");
-		let personFile = await testRealmAdapter.openFile(`${person.id.substring(testRealmURL.length)}.json`);
-		let friendPath = JSON.parse(personFile.content).data.relationships.bestFriend.links.self;
-		assert.ok(await testRealmAdapter.openFile(`${new URL(friendPath, person.id).href.substring(testRealmURL.length)}.json`), "the realm holds the linked card, created with the save");
-	});
-	(0, import_qunit.test)("a save waiting on a linked card whose create fails does not hang", async function(assert) {
-		let friend = new PersonDef({ name: "Friend" });
-		await storeService.addWithoutPersisting(friend);
-		let person = new PersonDef({ name: "Person" });
-		person.bestFriend = friend;
-		await storeService.addWithoutPersisting(person);
-		let hold = holdCreateResponse(friend, { fail: true });
-		let friendResult;
-		let personResult;
-		try {
-			let creatingFriend = storeService.persistAndUpdate(friend);
-			await hold.stored;
-			let savingPerson = storeService.persistAndUpdate(person);
-			let personSettledWhileFriendHeld = await Promise.race([savingPerson.then(() => true), new Promise((r) => setTimeout(() => r(false), 500))]);
-			assert.false(personSettledWhileFriendHeld, "the save waits while the linked card's create is unanswered");
-			assert.deepEqual(hold.writes.map((w) => w.method), ["POST"], "nothing but the linked card's own create went out while it was unanswered");
-			hold.release();
-			[friendResult, personResult] = await Promise.all([creatingFriend, savingPerson]);
-		} finally {
-			hold.restore();
-		}
-		await settled();
-		assert.false(isCardInstance(friendResult), "the linked card's create reported its failure");
-		assert.true(isCardInstance(personResult), `the save answered, linked to the already-stored card (resolved as: ${JSON.stringify(personResult)})`);
-		assert.deepEqual(includedLids(hold.writes.find((w) => w.body.data.lid === person[localId]).body), [friend[localId]], "with no create left on the wire, the save sent the linked card as a card to create");
-	});
-	(0, import_qunit.test)("loads FileDef links from included resources", async function(assert) {
-		await testRealm.writeMany(new Map([
-			["gallery.gts", `
-            import { CardDef, field, linksTo, linksToMany } from "@cardstack/base/card-api";
-            import { FileDef } from "@cardstack/base/file-api";
-
-            export class Gallery extends CardDef {
-              @field hero = linksTo(FileDef);
-              @field attachments = linksToMany(FileDef);
-            }
-          `],
-			["Gallery/hero.json", JSON.stringify({
-				data: {
-					attributes: { cardInfo: {} },
-					relationships: {
-						hero: {
-							links: { self: `${testRealmURL}hero.png` },
-							data: {
-								type: "file-meta",
-								id: `${testRealmURL}hero.png`
-							}
-						},
-						"attachments.0": {
-							links: { self: `${testRealmURL}first.png` },
-							data: {
-								type: "file-meta",
-								id: `${testRealmURL}first.png`
-							}
-						},
-						"attachments.1": {
-							links: { self: `${testRealmURL}second.png` },
-							data: {
-								type: "file-meta",
-								id: `${testRealmURL}second.png`
-							}
-						}
-					},
-					meta: { adoptsFrom: {
-						module: testRRI("gallery"),
-						name: "Gallery"
-					} }
-				},
-				included: [
-					{
-						type: "file-meta",
-						id: `${testRealmURL}hero.png`,
-						attributes: {
-							name: "hero.png",
-							url: `${testRealmURL}hero.png`,
-							sourceUrl: `${testRealmURL}hero.png`,
-							contentType: "image/png"
-						},
-						meta: { adoptsFrom: {
-							module: "@cardstack/base/card-api",
-							name: "FileDef"
-						} }
-					},
-					{
-						type: "file-meta",
-						id: `${testRealmURL}first.png`,
-						attributes: {
-							name: "first.png",
-							url: `${testRealmURL}first.png`,
-							sourceUrl: `${testRealmURL}first.png`,
-							contentType: "image/png"
-						},
-						meta: { adoptsFrom: {
-							module: "@cardstack/base/card-api",
-							name: "FileDef"
-						} }
-					},
-					{
-						type: "file-meta",
-						id: `${testRealmURL}second.png`,
-						attributes: {
-							name: "second.png",
-							url: `${testRealmURL}second.png`,
-							sourceUrl: `${testRealmURL}second.png`,
-							contentType: "image/png"
-						},
-						meta: { adoptsFrom: {
-							module: "@cardstack/base/card-api",
-							name: "FileDef"
-						} }
-					}
-				]
-			})],
-			["hero.png", "mock hero image"],
-			["first.png", "mock first image"],
-			["second.png", "mock second image"]
-		]));
-		let gallery = await storeService.get(`${testRealmURL}Gallery/hero`);
-		assert.ok(gallery.hero, "hero is loaded from included resources");
-		assert.strictEqual(gallery.hero?.id, `${testRealmURL}hero.png`, "hero FileDef has id set from file meta");
-		assert.strictEqual(gallery.hero?.name, "hero.png", "hero FileDef uses file meta name");
-		assert.strictEqual(gallery.hero?.url, `${testRealmURL}hero.png`, "hero FileDef uses file meta url");
-		let attachments = gallery.attachments ?? [];
-		assert.strictEqual(attachments.length, 2, "attachments are loaded from included resources");
-		assert.strictEqual(attachments[0]?.id, `${testRealmURL}first.png`, "first attachment has id set from file meta");
-		assert.strictEqual(attachments[0]?.name, "first.png", "first attachment uses file meta name");
-		assert.strictEqual(attachments[1]?.id, `${testRealmURL}second.png`, "second attachment has id set from file meta");
-		assert.strictEqual(attachments[1]?.name, "second.png", "second attachment uses file meta name");
-	});
-	(0, import_qunit.test)("uses cached FileDef for links.self when field expects FileDef", async function(assert) {
-		await testRealm.writeMany(new Map([
-			["gallery.gts", `
-            import { CardDef, field, linksTo } from "@cardstack/base/card-api";
-            import { FileDef } from "@cardstack/base/file-api";
-
-            export class Gallery extends CardDef {
-              @field hero = linksTo(FileDef);
-            }
-          `],
-			["Gallery/cached.json", JSON.stringify({ data: {
-				attributes: { cardInfo: {} },
-				relationships: { hero: {
-					links: { self: `${testRealmURL}hero.png` },
-					data: {
-						type: "file-meta",
-						id: `${testRealmURL}hero.png`
-					}
-				} },
-				meta: { adoptsFrom: {
-					module: testRRI("gallery"),
-					name: "Gallery"
-				} }
-			} })],
-			["hero.png", "mock hero image"]
-		]));
-		let cachedFile = await storeService.get(`${testRealmURL}hero.png`, { type: "file-meta" });
-		let gallery = await storeService.get(`${testRealmURL}Gallery/cached`);
-		assert.strictEqual(gallery.hero, cachedFile, "links.self resolves to cached FileDef for FileDef fields");
-	});
-	(0, import_qunit.test)("can skip waiting for the save when patching an instance", async function(assert) {
-		assert.expect(4);
-		let targetId = `${testRealmURL}Person/hassan`;
-		let instance = await storeService.get(targetId);
-		let didSave = false;
-		this.onSave((url, doc) => {
-			if (url.href === targetId) {
-				didSave = true;
-				assert.strictEqual(doc.data.attributes?.name, "Hassan Updated", "patched data is persisted");
-			}
-		});
-		await storeService.patch(targetId, { attributes: { name: "Hassan Updated" } }, { doNotWaitForPersist: true });
-		assert.strictEqual(instance.name, "Hassan Updated", "local instance updated immediately");
-		assert.false(didSave, "instance has not been persisted yet");
-		await waitUntil(() => didSave, { timeout: 1e4 });
-		let file = await testRealmAdapter.openFile("Person/hassan.json");
-		assert.strictEqual(JSON.parse(file.content).data.attributes.name, "Hassan Updated", "remote document reflects patch after persistence completes");
-	});
-	(0, import_qunit.test)("can patch an unsaved instance", async function(assert) {
-		let instance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutPersisting(instance, { realm: testRealmURL });
-		await storeService.patch(instance[localId], {
-			attributes: { name: "Andrea Updated" },
-			relationships: {
-				bestFriend: { links: { self: `${testRealmURL}Person/queenzy` } },
-				"friends.0": { links: { self: `${testRealmURL}Person/germaine` } }
-			}
-		});
-		let peekedInstance = storeService.peek(instance[localId]);
-		let queenzy = storeService.peek(`${testRealmURL}Person/queenzy`);
-		let germaine = storeService.peek(`${testRealmURL}Person/germaine`);
-		assert.strictEqual(peekedInstance, instance, "the patched instance is in the store");
-		assert.ok(isCardInstance(queenzy), "queenzy is in the store");
-		assert.ok(isCardInstance(germaine), "germaine is in the store");
-		assert.strictEqual(instance[realmURL]?.href, testRealmURL, "the realm config on the instance is preserved");
-		assert.strictEqual(instance.name, "Andrea Updated", "the contains field was patched");
-		assert.strictEqual(instance.bestFriend, queenzy, "the linksTo field was patched");
-		assert.deepEqual(instance.friends, [germaine], "the linksToMany field was patched");
-		await waitUntil(() => instance.id, { timeoutMessage: "waiting for instance to get assigned an id" });
-		assert.ok(instance.id, "instance was assigned a remote id");
-	});
-	(0, import_qunit.test)("can skip save when patching an instance", async function(assert) {
-		this.onSave(() => {
-			assert.ok(false, "should not save");
-		});
-		let instance = await storeService.patch(`${testRealmURL}Person/hassan`, {
-			attributes: { name: "Hassan Updated" },
-			relationships: {
-				bestFriend: { links: { self: `${testRealmURL}Person/jade` } },
-				"friends.0": { links: { self: `${testRealmURL}Person/germaine` } }
-			}
-		}, { doNotPersist: true });
-		let peekedInstance = storeService.peek(`${testRealmURL}Person/hassan`);
-		let jade = storeService.peek(`${testRealmURL}Person/jade`);
-		let germaine = storeService.peek(`${testRealmURL}Person/germaine`);
-		assert.strictEqual(peekedInstance, instance, "the patched instance is in the store");
-		assert.ok(isCardInstance(jade), "jade is in the store");
-		assert.ok(isCardInstance(germaine), "germaine is in the store");
-		assert.strictEqual(instance.name, "Hassan Updated", "the contains field was patched");
-		assert.strictEqual(instance.bestFriend, jade, "the linksTo field was patched");
-		assert.deepEqual(instance.friends, [germaine], "the linksToMany field was patched");
-	});
-	(0, import_qunit.test)("can search", async function(assert) {
-		let results = await storeService.search({ filter: {
-			on: {
-				module: testRRI("person"),
-				name: "Person"
-			},
-			eq: { name: "Hassan" }
-		} }, [testRealmURL]);
-		assert.strictEqual(results.length, 1, "the correct number of results are returned");
-		assert.strictEqual(results[0].id, `${testRealmURL}Person/hassan`, "the result is correct");
-	});
-	function overrideSearchWith(doc) {
-		registerRealmServerRoute({
-			path: "/_federated-search",
-			handler: async () => new Response(JSON.stringify(doc), {
-				status: 200,
-				headers: { "content-type": SupportedMimeType.CardJson }
-			})
-		});
-	}
-	function htmlOnlyEntryDoc(id, opts) {
-		let htmlId = opts?.isFileMeta ? `${id}#fitted` : `${id}#fitted#${testRealmURL}person/Person`;
-		return {
-			data: [{
-				type: "entry",
-				id,
-				relationships: { html: { data: [{
-					type: "html",
-					id: htmlId
-				}] } }
-			}],
-			included: [{
-				type: "html",
-				id: htmlId,
-				attributes: {
-					html: "<div>prerendered</div>",
-					cardType: "Person",
-					format: "fitted"
-				},
-				relationships: { styles: { data: [] } }
-			}],
-			meta: { page: { total: 1 } }
-		};
-	}
-	let personQuery = { filter: {
-		on: {
-			module: testRRI("person"),
-			name: "Person"
-		},
-		eq: { name: "Hassan" }
-	} };
-	(0, import_qunit.test)("a search result with no item serialization is not deposited into the Store", async function(assert) {
-		let id = `${testRealmURL}Person/html-only`;
-		overrideSearchWith(htmlOnlyEntryDoc(id));
-		try {
-			let results = await storeService.search(personQuery, [testRealmURL]);
-			assert.strictEqual(results.length, 0, "the html-only entry is not returned as a hydrated instance");
-			assert.notOk(isCardInstance(storeService.peek(id)), "the html-only entry is not deposited in the Store");
-		} finally {
-			registerDefaultRoutes();
-		}
-	});
-	(0, import_qunit.test)("a search result with no item serialization leaves a resident full instance untouched", async function(assert) {
-		let id = `${testRealmURL}Person/hassan`;
-		storeService.addReference(id);
-		await storeService.flush();
-		let before = storeService.peek(id);
-		assert.true(isCardInstance(before), "the full instance is resident before the search");
-		overrideSearchWith(htmlOnlyEntryDoc(id));
-		try {
-			let results = await storeService.search(personQuery, [testRealmURL]);
-			assert.strictEqual(results.length, 0, "an entry with no serialization contributes no instance");
-			let after = storeService.peek(id);
-			assert.strictEqual(after, before, "the html-only entry left the resident full instance untouched");
-			assert.true(isCardInstance(after), "still a full card instance");
-		} finally {
-			registerDefaultRoutes();
-		}
-	});
-	(0, import_qunit.test)("a file-meta search result with no item serialization leaves a resident FileDef untouched", async function(assert) {
-		await testRealm.write("hero.png", "mock hero image");
-		let fileUrl = `${testRealmURL}hero.png`;
-		let before = await storeService.get(fileUrl, { type: "file-meta" });
-		storeService.addReference(fileUrl, { type: "file-meta" });
-		assert.true(before?.constructor?.isFileDef, "the live FileDef is resident before the search");
-		overrideSearchWith(htmlOnlyEntryDoc(fileUrl, { isFileMeta: true }));
-		try {
-			let results = await storeService.search(personQuery, [testRealmURL]);
-			assert.strictEqual(results.length, 0, "an entry with no serialization contributes no instance");
-			assert.true(storeService.peek(fileUrl, { type: "file-meta" })?.constructor?.isFileDef, "the resident live FileDef is untouched");
-			assert.ok(Object.is(storeService.peek(fileUrl, { type: "file-meta" }), before), "still the same resident FileDef");
-		} finally {
-			storeService.dropReference(fileUrl);
-			registerDefaultRoutes();
-		}
-	});
-	(0, import_qunit.test)("an instance live updates from indexing events for an instance update", async function(assert) {
-		assert.expect(2);
-		let url = `${testRealmURL}Person/hassan`;
-		let didSave = false;
-		this.onSave(() => {
-			didSave = true;
-		});
-		setCardInOperatorModeState(url);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		let events = interceptRealmEvents();
-		try {
-			await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-				attributes: { name: "Hassan updated" },
-				meta: { adoptsFrom: {
-					module: testRRI("person"),
-					name: "Person"
-				} }
-			} }));
-			let event = await events.nextEventFor(url);
-			events.deliver(event);
-			await settled();
-		} finally {
-			events.restore();
-		}
-		await storeService.flushSaves();
-		assert.dom("[data-test-stack-card] [data-test-field=\"name\"]").containsText("Hassan updated", "card live updated");
-		assert.false(didSave, "indexing updates do not auto save instances");
-	});
-	(0, import_qunit.test)("an instance live updates from indexing events for a code update", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/hassan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		let instance = await storeService.get(`${testRealmURL}Person/hassan`);
-		await testRealm.write(`person.gts`, `
-      import { contains, field, Component, CardDef, } from '@cardstack/base/card-api';
-      import StringField from '@cardstack/base/string';
-
-      export class Person extends CardDef {
-        @field name = contains(StringField);
-        static isolated = class Isolated extends Component<typeof this> {
-          <template>
-            <div test-update>Hello</div>
-            <@fields.firstName />
-          </template>
-        };
-      }`.trim());
-		await waitFor("[test-update]", { timeout: 5e3 });
-		assert.dom("[test-update]").containsText("Hello", "the instance rendered with the new code");
-		let newInstance = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.notStrictEqual(instance[localId], newInstance[localId], "the updated instance is a different object than the original instance");
-	});
-	(0, import_qunit.test)("an instance live updates to a new type when its adoptsFrom changes", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/hassan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		let original = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.true(original instanceof PersonDef, "the card starts out as a Person");
-		assert.dom("[data-test-employee-badge]").doesNotExist();
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Hassan" },
-			meta: { adoptsFrom: {
-				module: testRRI("employee"),
-				name: "Employee"
-			} }
-		} }));
-		await waitUntil(() => storeService.peek(`${testRealmURL}Person/hassan`) instanceof EmployeeDef, { timeout: 5e3 });
-		let reloaded = storeService.peek(`${testRealmURL}Person/hassan`);
-		assert.true(reloaded instanceof EmployeeDef, "the store now holds an Employee instance for the same id");
-		await waitFor("[data-test-employee-badge]", { timeout: 5e3 });
-		assert.dom("[data-test-employee-badge]").containsText("Employee: Hassan", "the card re-rendered using the new type");
-	});
-	(0, import_qunit.test)("an instance rebuilds when its adoptsFrom changes to an ancestor type", async function(assert) {
-		await testRealm.write("Manager/m1.json", JSON.stringify({ data: {
-			attributes: { name: "Hassan" },
-			meta: { adoptsFrom: {
-				module: testRRI("manager"),
-				name: "Manager"
-			} }
-		} }));
-		setCardInOperatorModeState(`${testRealmURL}Manager/m1`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-manager-badge]");
-		let original = storeService.peek(`${testRealmURL}Manager/m1`);
-		assert.true(original instanceof ManagerDef, "the card starts as a Manager");
-		await testRealm.write("Manager/m1.json", JSON.stringify({ data: {
-			attributes: { name: "Hassan" },
-			meta: { adoptsFrom: {
-				module: testRRI("employee"),
-				name: "Employee"
-			} }
-		} }));
-		await waitUntil(() => {
-			let c = storeService.peek(`${testRealmURL}Manager/m1`);
-			return c instanceof EmployeeDef && !(c instanceof ManagerDef);
-		}, { timeout: 5e3 });
-		await waitFor("[data-test-employee-badge]", { timeout: 5e3 });
-		assert.dom("[data-test-employee-badge]").containsText("Employee: Hassan", "rebuilt as the ancestor type");
-		assert.dom("[data-test-manager-badge]").doesNotExist("no longer rendered as the Manager subclass");
-	});
-	(0, import_qunit.test)("an instance can live update thru an error state", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/hassan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: {
-				name: "Hassan",
-				hasError: true
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await settled();
-		assert.dom("[data-test-card-error]").exists("the card error is shown");
-		assert.dom("[data-test-error-message]").containsText("intentional error thrown");
-		await click("[data-test-toggle-details]");
-		assert.dom("[data-test-error-details]").includesText("Stack trace: Error: Encountered error rendering HTML");
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: {
-				name: "Hassan",
-				hasError: false
-			},
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await settled();
-		assert.dom("[data-test-card-error]").doesNotExist("the error is dismissed");
-		assert.dom("[data-test-stack-card] [data-test-field=\"name\"]").containsText("Hassan", "card is still rendered");
-	});
-	(0, import_qunit.test)("a card the realm has not indexed renders from its source, with its computed fields, and takes the indexed state once indexing lands", async function(assert) {
-		let url = `${testRealmURL}Person/unindexed`;
-		await testRealmAdapter.write("Person/unindexed.json", JSON.stringify({ data: {
-			attributes: { name: "Unindexed" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		setCardInOperatorModeState(url);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await settleCardRender(assert, url, `[data-stack-card="${url}"] [data-test-field="name"]`);
-		assert.dom("[data-test-card-awaiting-index]").doesNotExist("no placeholder stands in for a card whose source is there");
-		assert.dom(`[data-stack-card="${url}"] [data-test-field="name"]`).containsText("Unindexed", "the card renders from its source");
-		let instance = storeService.peek(url);
-		assert.true(isCardInstance(instance), "the store holds a running card");
-		assert.strictEqual(instance.boom, "boom", "its computed field evaluates in the tab");
-		await writePerson("Person/unindexed.json", "Indexed Person");
-		await settled();
-		assert.dom(`[data-stack-card="${url}"] [data-test-field="name"]`).containsText("Indexed Person", "the index event brings the indexed state");
-		assert.strictEqual(storeService.peek(url), instance, "into the same instance, so nothing the user holds is swapped out");
-	});
-	(0, import_qunit.test)("a full reindex re-reads a card built from its source in place", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let url = `${testRealmURL}Person/from-source`;
-		await testRealmAdapter.write("Person/from-source.json", JSON.stringify({ data: {
-			attributes: { name: "From Source" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let instance = await storeService.get(url);
-		assert.true(isCardInstance(instance), "the read returns a running card rather than a placeholder");
-		assert.strictEqual(storeService.peekError(url), void 0, "and records no error for it");
-		let events = interceptRealmEvents();
-		try {
-			await writePerson("Person/from-source.json", "From Source Indexed");
-			events.deliver({
-				eventName: "index",
-				indexType: "full",
-				realmURL: testRealmURL
-			});
-			await settled();
-		} finally {
-			events.restore();
-		}
-		assert.strictEqual(storeService.peek(url), instance, "the same instance is still the one the store hands out");
-		assert.strictEqual(instance.name, "From Source Indexed", "and it now holds the indexed state");
-	});
-	(0, import_qunit.test)("a read that reports the index state answers awaiting-index without changing what other reads of the card get", async function(assert) {
-		async function writeUnindexed(path, name) {
-			await testRealmAdapter.write(path, JSON.stringify({ data: {
-				attributes: { name },
-				meta: { adoptsFrom: {
-					module: testRRI("person"),
-					name: "Person"
-				} }
-			} }));
-		}
-		let readFirst = `${testRealmURL}Person/report-first`;
-		await writeUnindexed("Person/report-first.json", "Report First");
-		let reported = await storeService.getWithoutCache(readFirst);
-		assert.true(reported.awaitingIndex, "the index-state read reports the card as awaiting index");
-		assert.strictEqual(storeService.peekError(readFirst), void 0, "and records nothing in the store");
-		assert.true(isCardInstance(await storeService.get(readFirst)), "so opening the card afterwards still builds it from its source");
-		let openedFirst = `${testRealmURL}Person/opened-first`;
-		await writeUnindexed("Person/opened-first.json", "Opened First");
-		let opened = await storeService.get(openedFirst);
-		assert.true(isCardInstance(opened), "the opened card is running");
-		reported = await storeService.getWithoutCache(openedFirst);
-		assert.true(reported.awaitingIndex, "the index-state read is not handed the card built from source");
-		assert.strictEqual(storeService.peek(openedFirst), opened, "and the running card stays in place");
-		let concurrent = `${testRealmURL}Person/concurrent`;
-		await writeUnindexed("Person/concurrent.json", "Concurrent");
-		let [got, reportedConcurrently] = await Promise.all([storeService.get(concurrent), storeService.getWithoutCache(concurrent)]);
-		assert.true(isCardInstance(got), "the plain read gets the card");
-		assert.true(reportedConcurrently.awaitingIndex, "the index-state read gets the awaiting-index answer");
-	});
-	(0, import_qunit.test)("a read that reports the index state is not handed a card still being built from its source", async function(assert) {
-		let url = `${testRealmURL}Person/half-built`;
-		await testRealmAdapter.write("Person/half-built.json", JSON.stringify({ data: {
-			attributes: { name: "Half Built" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let reachedBuilt = new Deferred();
-		let releaseBuilt = new Deferred();
-		let service = storeService;
-		let createFromSerialized = service.createFromSerialized.bind(service);
-		service.createFromSerialized = async (resource, ...rest) => {
-			let instance = await createFromSerialized(resource, ...rest);
-			if (String(resource?.id ?? "").includes("Person/half-built")) {
-				reachedBuilt.fulfill();
-				await releaseBuilt.promise;
-			}
-			return instance;
-		};
-		let reported;
-		let opening;
-		try {
-			opening = storeService.get(url);
-			await reachedBuilt.promise;
-			assert.true(isCardInstance(storeService.peek(url)), "the card being built is already in the identity map");
-			reported = await storeService.getWithoutCache(url);
-		} finally {
-			releaseBuilt.fulfill();
-			delete service.createFromSerialized;
-		}
-		assert.true(reported?.awaitingIndex, "the index-state read gets the awaiting-index answer, not the card being built");
-		assert.true(isCardInstance(await opening), "and the read that was building the card still gets it");
-	});
-	(0, import_qunit.test)("an index event that lands while a card is being built from its source re-reads it once it is built", async function(assert) {
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let url = `${testRealmURL}Person/source-racing`;
-		await testRealmAdapter.write("Person/source-racing.json", JSON.stringify({ data: {
-			attributes: { name: "Source Racing" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let reachedSource = new Deferred();
-		let releaseSource = new Deferred();
-		let loadCardDocument = cardStore.loadCardDocument.bind(cardStore);
-		cardStore.loadCardDocument = async (sourceURL, opts) => {
-			let doc = await loadCardDocument(sourceURL, opts);
-			if (sourceURL.includes("Person/source-racing")) {
-				reachedSource.fulfill();
-				await releaseSource.promise;
-			}
-			return doc;
-		};
-		let events = interceptRealmEvents();
-		try {
-			let reading = storeService.get(url);
-			await reachedSource.promise;
-			await writePerson("Person/source-racing.json", "Source Racing Person");
-			events.deliver({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [url],
-				realmURL: testRealmURL
-			});
-			releaseSource.fulfill();
-			await reading;
-			await settled();
-		} finally {
-			releaseSource.fulfill();
-			delete cardStore.loadCardDocument;
-			events.restore();
-		}
-		assert.strictEqual(storeService.peek(url)?.name, "Source Racing Person", "the store re-reads the card rather than keeping the source it read before the write");
-	});
-	(0, import_qunit.test)("a card the realm has not indexed and whose source cannot be read shows as being prepared, then renders once indexing lands", async function(assert) {
-		withholdSource("Person/pending");
-		await testRealmAdapter.write("Person/pending.json", JSON.stringify({ data: {
-			attributes: { name: "Pending" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		setCardInOperatorModeState(`${testRealmURL}Person/pending`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		await waitFor("[data-test-card-awaiting-index]");
-		assert.dom("[data-test-card-awaiting-index]").containsText("Preparing this card", "the card reads as on its way rather than missing");
-		assert.dom("[data-test-card-error]").doesNotExist("no card error is reported");
-		await testRealm.write("Person/pending.json", JSON.stringify({ data: {
-			attributes: { name: "Pending Person" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await settled();
-		let id = `${testRealmURL}Person/pending`;
-		if (document.querySelector("[data-test-card-awaiting-index]")) {
-			let realmEvents = mockMatrixUtils.getRoomIds().flatMap((roomId) => mockMatrixUtils.getRoomEvents(roomId)).filter((event) => event.type === APP_BOXEL_REALM_EVENT_TYPE).sort((a, b) => a.origin_server_ts - b.origin_server_ts).slice(-5).map((event) => event.content);
-			console.warn(`[awaiting-index-placeholder flake-probe] placeholder still shown after settled(). store error=${JSON.stringify(storeService.peekError(id) ?? null)}; store holds instance=${isCardInstance(storeService.peek(id))}; last realm events in mock homeserver=${JSON.stringify(realmEvents)}.`);
-		}
-		assert.dom("[data-test-card-awaiting-index]").doesNotExist("the placeholder is gone once the card is indexed");
-		assert.dom(`[data-stack-card="${testRealmURL}Person/pending"] [data-test-field="name"]`).containsText("Pending Person", "the real card takes over once it is indexed");
-	});
-	(0, import_qunit.test)("an index event that lands while the first read is in flight still resolves the placeholder", async function(assert) {
-		withholdSource("Person/racing");
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		await testRealmAdapter.write("Person/racing.json", JSON.stringify({ data: {
-			attributes: { name: "Racing" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		let reached404 = new Deferred();
-		let release404 = new Deferred();
-		cardService.fetchJSON = async (url, args) => {
-			if (!String(url).includes("Person/racing")) return originalFetchJSON(url, args);
-			try {
-				return await originalFetchJSON(url, args);
-			} catch (err) {
-				reached404.fulfill();
-				await release404.promise;
-				throw err;
-			}
-		};
-		let messageService = getService("message-service");
-		let deliverRealmEvents = messageService.relayRealmEvent.bind(messageService);
-		messageService.relayRealmEvent = () => {};
-		try {
-			let reading = storeService.get(`${testRealmURL}Person/racing`);
-			await reached404.promise;
-			await testRealm.write("Person/racing.json", JSON.stringify({ data: {
-				attributes: { name: "Racing Person" },
-				meta: { adoptsFrom: {
-					module: testRRI("person"),
-					name: "Person"
-				} }
-			} }));
-			deliverRealmEvents({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [`${testRealmURL}Person/racing`],
-				realmURL: testRealmURL
-			});
-			release404.fulfill();
-			await reading;
-			await settled();
-		} finally {
-			release404.fulfill();
-			delete cardService.fetchJSON;
-			messageService.relayRealmEvent = deliverRealmEvents;
-		}
-		let instance = storeService.peek(`${testRealmURL}Person/racing`);
-		assert.true(isCardInstance(instance), "the store holds the card rather than the stale placeholder");
-		assert.strictEqual(instance.name, "Racing Person", "and it is the indexed state");
-	});
-	(0, import_qunit.test)("a full reindex resolves a placeholder even though it names no cards", async function(assert) {
-		withholdSource("Person/swept");
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		await testRealmAdapter.write("Person/swept.json", JSON.stringify({ data: {
-			attributes: { name: "Swept" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let placeholder = await storeService.get(`${testRealmURL}Person/swept`);
-		assert.true(placeholder.awaitingIndex, "the read leaves an awaiting-index placeholder");
-		let messageService = getService("message-service");
-		let deliverRealmEvents = messageService.relayRealmEvent.bind(messageService);
-		messageService.relayRealmEvent = () => {};
-		try {
-			await testRealm.write("Person/swept.json", JSON.stringify({ data: {
-				attributes: { name: "Swept Person" },
-				meta: { adoptsFrom: {
-					module: testRRI("person"),
-					name: "Person"
-				} }
-			} }));
-			deliverRealmEvents({
-				eventName: "index",
-				indexType: "full",
-				realmURL: testRealmURL
-			});
-			await settled();
-		} finally {
-			messageService.relayRealmEvent = deliverRealmEvents;
-		}
-		let instance = storeService.peek(`${testRealmURL}Person/swept`);
-		assert.true(isCardInstance(instance), "the sweep replaced the placeholder with the card");
-		assert.strictEqual(instance.name, "Swept Person", "and it is the indexed state");
-	});
-	(0, import_qunit.test)("a reload that 404s while the row is being rebuilt keeps the card instead of deleting it", async function(assert) {
-		let url = `${testRealmURL}Person/rebuilt`;
-		await testRealm.write("Person/rebuilt.json", JSON.stringify({ data: {
-			attributes: { name: "Rebuilt" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		storeService.addReference(url);
-		await storeService.flush();
-		assert.true(isCardInstance(storeService.peek(url)), "the card starts out loaded");
-		let messageService = getService("message-service");
-		let deliverRealmEvents = messageService.relayRealmEvent.bind(messageService);
-		messageService.relayRealmEvent = () => {};
-		try {
-			await testRealm.delete("Person/rebuilt.json");
-			await testRealmAdapter.write("Person/rebuilt.json", JSON.stringify({ data: {
-				attributes: { name: "Rebuilt" },
-				meta: { adoptsFrom: {
-					module: testRRI("person"),
-					name: "Person"
-				} }
-			} }));
-			deliverRealmEvents({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [url],
-				realmURL: testRealmURL
-			});
-			await settled();
-		} finally {
-			messageService.relayRealmEvent = deliverRealmEvents;
-		}
-		assert.true(isCardInstance(storeService.peek(url)), "the card is still in the store — nothing was deleted");
-		assert.strictEqual(storeService.peekError(url), void 0, "and it is left alone rather than covered by a placeholder");
-	});
-	(0, import_qunit.test)("a card already running in the store is never displaced by the awaiting-index placeholder", async function(assert) {
-		let instance = await storeService.add(new PersonDef({ name: "Brand New" }));
-		let url = instance.id;
-		assert.ok(url, "the new card was assigned a remote id");
-		let messageService = getService("message-service");
-		let deliverRealmEvents = messageService.relayRealmEvent.bind(messageService);
-		messageService.relayRealmEvent = () => {};
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		cardService.fetchJSON = async (fetchUrl, args) => {
-			if (String(fetchUrl).includes(url)) {
-				let err = /* @__PURE__ */ new Error("awaiting index");
-				err.status = 404;
-				err.responseText = JSON.stringify({ errors: [{
-					id: url,
-					status: 404,
-					title: "Not Found",
-					message: `${url} has not finished indexing`,
-					isCardError: true,
-					awaitingIndex: true,
-					additionalErrors: null
-				}] });
-				throw err;
-			}
-			return originalFetchJSON(fetchUrl, args);
-		};
-		try {
-			deliverRealmEvents({
-				eventName: "index",
-				indexType: "incremental",
-				invalidations: [url],
-				realmURL: testRealmURL
-			});
-			await settled();
-		} finally {
-			delete cardService.fetchJSON;
-			messageService.relayRealmEvent = deliverRealmEvents;
-		}
-		assert.strictEqual(storeService.peek(url), instance, "the running instance is still the one the store hands out");
-		assert.strictEqual(storeService.peekError(url), void 0, "no placeholder stands in front of it");
-		assert.ok(storeService.getSaveState(url), "and it is still autosaving, so the user can keep editing");
-	});
-	(0, import_qunit.test)("a full reindex resolves a placeholder whose read was still in flight when it landed", async function(assert) {
-		withholdSource("Person/swept-inflight");
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		await testRealmAdapter.write("Person/swept-inflight.json", JSON.stringify({ data: {
-			attributes: { name: "Swept In Flight" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		let url = `${testRealmURL}Person/swept-inflight`;
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		let reached404 = new Deferred();
-		let release404 = new Deferred();
-		cardService.fetchJSON = async (fetchUrl, args) => {
-			if (!String(fetchUrl).includes("Person/swept-inflight")) return originalFetchJSON(fetchUrl, args);
-			try {
-				return await originalFetchJSON(fetchUrl, args);
-			} catch (err) {
-				reached404.fulfill();
-				await release404.promise;
-				throw err;
-			}
-		};
-		let messageService = getService("message-service");
-		let deliverRealmEvents = messageService.relayRealmEvent.bind(messageService);
-		messageService.relayRealmEvent = () => {};
-		try {
-			let reading = storeService.get(url);
-			await reached404.promise;
-			await testRealm.write("Person/swept-inflight.json", JSON.stringify({ data: {
-				attributes: { name: "Swept In Flight Person" },
-				meta: { adoptsFrom: {
-					module: testRRI("person"),
-					name: "Person"
-				} }
-			} }));
-			deliverRealmEvents({
-				eventName: "index",
-				indexType: "full",
-				realmURL: testRealmURL
-			});
-			release404.fulfill();
-			await reading;
-			await settled();
-		} finally {
-			release404.fulfill();
-			delete cardService.fetchJSON;
-			messageService.relayRealmEvent = deliverRealmEvents;
-		}
-		let instance = storeService.peek(url);
-		assert.true(isCardInstance(instance), "the card takes over rather than the placeholder being stranded");
-		assert.strictEqual(instance.name, "Swept In Flight Person", "and it is the indexed state");
-	});
-	(0, import_qunit.test)("a duplicate incremental event does not reload a card the store already holds at that generation", async function(assert) {
-		let url = `${testRealmURL}Person/echoed`;
-		let events = interceptRealmEvents();
-		let reads;
-		try {
-			await writePerson("Person/echoed.json", "Echoed");
-			await events.nextEventFor(url);
-			storeService.addReference(url);
-			await storeService.flush();
-			await writePerson("Person/echoed.json", "Echoed Again");
-			let event = await events.nextEventFor(url);
-			assert.strictEqual(typeof event.generation, "number", "the realm reported the generation its pass committed");
-			let { versions: _versions, ...onGeneration } = event;
-			reads = countCardReads("Person/echoed");
-			events.deliver(onGeneration);
-			await settled();
-			assert.strictEqual(reads.count, 1, "the event is acted on once");
-			assert.strictEqual(storeService.peek(url).name, "Echoed Again", "and the store holds what the pass wrote");
-			events.deliver(onGeneration);
-			await settled();
-			assert.strictEqual(reads.count, 1, "the same event delivered a second time is a no-op");
-			let { generation: _generation, ...withoutGeneration } = onGeneration;
-			events.deliver(withoutGeneration);
-			await settled();
-			assert.strictEqual(reads.count, 2, "while an otherwise identical event carrying no generation does reload");
-		} finally {
-			reads?.stop();
-			events.restore();
-		}
-	});
-	(0, import_qunit.test)("a duplicate arriving while the first reload is still in flight is coalesced into it", async function(assert) {
-		let url = `${testRealmURL}Person/coalesced`;
-		let events = interceptRealmEvents();
-		let reads;
-		try {
-			await writePerson("Person/coalesced.json", "Coalesced");
-			await events.nextEventFor(url);
-			storeService.addReference(url);
-			await storeService.flush();
-			await writePerson("Person/coalesced.json", "Coalesced Again");
-			let event = await events.nextEventFor(url);
-			reads = countCardReads("Person/coalesced");
-			events.deliver(event);
-			events.deliver(event);
-			await settled();
-			assert.strictEqual(reads.count, 1, "the duplicate is answered by the reload already in flight");
-			assert.strictEqual(storeService.peek(url).name, "Coalesced Again", "and that reload still brought the state the pass wrote");
-			let { generation: _generation, versions: _versions, ...bare } = event;
-			events.deliver(bare);
-			events.deliver(bare);
-			await settled();
-			assert.strictEqual(reads.count, 3, "while a pair carrying neither member reloads twice");
-		} finally {
-			reads?.stop();
-			events.restore();
-		}
-	});
-	(0, import_qunit.test)("an incremental event overtaken by a newer one does not reload", async function(assert) {
-		let url = `${testRealmURL}Person/overtaken`;
-		let events = interceptRealmEvents();
-		let reads;
-		try {
-			await writePerson("Person/overtaken.json", "Overtaken");
-			await events.nextEventFor(url);
-			storeService.addReference(url);
-			await storeService.flush();
-			await writePerson("Person/overtaken.json", "Second");
-			let earlier = await events.nextEventFor(url);
-			await writePerson("Person/overtaken.json", "Third");
-			let later = await events.nextEventFor(url);
-			assert.true(later.generation > earlier.generation, "the two passes are ordered by generation");
-			reads = countCardReads("Person/overtaken");
-			events.deliver(later);
-			await settled();
-			assert.strictEqual(reads.count, 1, "the newer event is acted on");
-			assert.strictEqual(storeService.peek(url).name, "Third", "and the store holds the state that pass wrote");
-			events.deliver(earlier);
-			await settled();
-			assert.strictEqual(reads.count, 1, "the older event arriving after it is ignored");
-		} finally {
-			reads?.stop();
-			events.restore();
-		}
-	});
-	(0, import_qunit.test)("a write's echo is recognized by its version once the request id has aged out of this client's memory", async function(assert) {
-		let url = `${testRealmURL}Person/aged-out`;
-		let events = interceptRealmEvents();
-		let reads;
-		try {
-			await writePerson("Person/aged-out.json", "Aged Out");
-			await events.nextEventFor(url);
-			storeService.addReference(url);
-			await storeService.flush();
-			let instance = storeService.peek(url);
-			instance.name = "Aged Out Edit";
-			storeService.save(url);
-			await settled();
-			let event = await events.nextEventFor(url);
-			assert.true(event.generation > api.getCardMeta(instance, "generation"), "the event names a generation past the one the store holds");
-			assert.strictEqual(api.getCardMeta(instance, "version"), event.versions?.[url], "and the store recorded the version its own write returned");
-			let agedOut = {
-				...event,
-				clientRequestId: "instance:aged-out-of-this-clients-memory"
-			};
-			reads = countCardReads("Person/aged-out");
-			events.deliver(agedOut);
-			await settled();
-			assert.strictEqual(reads.count, 0, "the echo of our own write is not read back");
-			assert.strictEqual(storeService.peek(url).name, "Aged Out Edit", "and the edit stands");
-			let { versions: _versions, ...withoutVersions } = agedOut;
-			events.deliver(withoutVersions);
-			await settled();
-			assert.strictEqual(reads.count, 1, "while the same event without the map does reload");
-		} finally {
-			reads?.stop();
-			events.restore();
-		}
-	});
-	(0, import_qunit.test)("a reload still in flight when the store is reset leaves the replacement identity map alone", async function(assert) {
-		let url = `${testRealmURL}Person/reset-mid-reload`;
-		let events = interceptRealmEvents();
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		let readHeld = new Deferred();
-		let releaseRead = new Deferred();
-		let holding = false;
-		try {
-			await writePerson("Person/reset-mid-reload.json", "Before Reset");
-			await events.nextEventFor(url);
-			storeService.addReference(url);
-			await storeService.flush();
-			let preReset = storeService.peek(url);
-			await writePerson("Person/reset-mid-reload.json", "After Reset");
-			let event = await events.nextEventFor(url);
-			holding = true;
-			cardService.fetchJSON = async (fetchUrl, args) => {
-				if (holding && String(fetchUrl).includes("Person/reset-mid-reload") && (args?.method ?? "GET") === "GET") {
-					holding = false;
-					readHeld.fulfill();
-					await releaseRead.promise;
-				}
-				return originalFetchJSON(fetchUrl, args);
-			};
-			events.deliver(event);
-			await readHeld.promise;
-			storeService.resetCache();
-			let replacement = await storeService.get(url);
-			assert.notStrictEqual(replacement[localId], preReset[localId], "the replacement identity map loads its own instance of the card");
-			releaseRead.fulfill();
-			await settled();
-			assert.strictEqual(storeService.peek(url), replacement, "the resumed reload leaves the replacement instance in place");
-			assert.strictEqual(storeService.peekError(url)?.message, void 0, "and records no error for the card");
-			assert.strictEqual(replacement.name, "After Reset", "the replacement holds the state the realm wrote");
-		} finally {
-			releaseRead.fulfill();
-			delete cardService.fetchJSON;
-			events.restore();
-		}
-	});
-	(0, import_qunit.test)("a reload still in flight when a code change resets identity in place leaves the re-established instance alone", async function(assert) {
-		let url = `${testRealmURL}Person/code-change-mid-reload`;
-		let events = interceptRealmEvents();
-		let cardService = getService("card-service");
-		let originalFetchJSON = cardService.fetchJSON.bind(cardService);
-		let readHeld = new Deferred();
-		let releaseRead = new Deferred();
-		let holding = false;
-		try {
-			await writePerson("Person/code-change-mid-reload.json", "Before Reset");
-			await events.nextEventFor(url);
-			storeService.addReference(url);
-			await storeService.flush();
-			let preReset = storeService.peek(url);
-			await writePerson("Person/code-change-mid-reload.json", "After Reset");
-			let event = await events.nextEventFor(url);
-			holding = true;
-			cardService.fetchJSON = async (fetchUrl, args) => {
-				if (holding && String(fetchUrl).includes("Person/code-change-mid-reload") && (args?.method ?? "GET") === "GET") {
-					holding = false;
-					readHeld.fulfill();
-					await releaseRead.promise;
-				}
-				return originalFetchJSON(fetchUrl, args);
-			};
-			events.deliver(event);
-			await readHeld.promise;
-			storeService.refreshReferencesForCodeChange("test code change");
-			let reestablished = await storeService.get(url);
-			assert.strictEqual(storeService.peek(url), reestablished, "the store holds the instance the code change re-established");
-			assert.notStrictEqual(reestablished[localId], preReset[localId], "the code change re-establishes the card as a fresh instance");
-			releaseRead.fulfill();
-			await settled();
-			assert.strictEqual(storeService.peek(url), reestablished, "the resumed reload leaves the re-established instance in place");
-			assert.strictEqual(storeService.peekError(url)?.message, void 0, "and records no error for the card");
-			assert.strictEqual(reestablished.name, "After Reset", "the re-established instance holds the state the realm wrote");
-		} finally {
-			releaseRead.fulfill();
-			delete cardService.fetchJSON;
-			events.restore();
-		}
-	});
-	async function holdIndexQueue() {
-		let { queue } = getService("queue");
-		let started = new Deferred();
-		let release = new Deferred();
-		queue.register("hold-index-queue", async () => {
-			started.fulfill();
-			await release.promise;
-			return null;
-		});
-		let holder = await queue.publish({
-			jobType: "hold-index-queue",
-			concurrencyGroup: null,
-			timeout: 30,
-			args: null
-		});
-		await started.promise;
-		let pendingCallers = () => queue.jobs.filter((job) => job.jobType === "incremental-index").flatMap((job) => (job.args?.coalescedCallers ?? []).map((caller) => caller.clientRequestId));
-		let published = [];
-		let arrivals = [];
-		let heldAt = performance.now();
-		let publish = queue.publish.bind(queue);
-		queue.publish = async (args) => {
-			let job = await publish(args);
-			published.push({
-				jobType: args.jobType,
-				at: Math.round(performance.now() - heldAt)
-			});
-			for (let arrival of [...arrivals]) if (arrival.ready()) {
-				arrivals.splice(arrivals.indexOf(arrival), 1);
-				arrival.deferred.fulfill();
-			}
-			return job;
-		};
-		let callersArrive = async (description, ready) => {
-			if (ready(pendingCallers())) return;
-			let deferred = new Deferred();
-			let arrival = {
-				ready: () => ready(pendingCallers()),
-				deferred
-			};
-			arrivals.push(arrival);
-			let guard = setTimeout(() => {
-				arrivals.splice(arrivals.indexOf(arrival), 1);
-				deferred.reject(/* @__PURE__ */ new Error(`the held index pass never had ${description}: callers=${JSON.stringify(pendingCallers())} publishes=${JSON.stringify(published)}`));
-			}, 2e4);
-			try {
-				await deferred.promise;
-			} finally {
-				clearTimeout(guard);
-			}
-		};
-		return {
-			holder,
-			release,
-			pendingCallers,
-			callersArrive
-		};
-	}
-	(0, import_qunit.test)("this client's own write, announced under another writer's id in a pass they shared, is not read back", async function(assert) {
-		let mine = `${testRealmURL}Person/shared-mine`;
-		let theirs = `${testRealmURL}Person/shared-theirs`;
-		let events = interceptRealmEvents();
-		let reads;
-		let theirReads;
-		let hold;
-		try {
-			await writePerson("Person/shared-mine.json", "Mine");
-			await events.nextEventFor(mine);
-			await writePerson("Person/shared-theirs.json", "Theirs");
-			await events.nextEventFor(theirs);
-			storeService.addReference(mine);
-			storeService.addReference(theirs);
-			await storeService.flush();
-			hold = await holdIndexQueue();
-			let theirWrite = testRealm.write("Person/shared-theirs.json", JSON.stringify({ data: {
-				attributes: { name: "Theirs Edited" },
-				meta: { adoptsFrom: {
-					module: testRRI("person"),
-					name: "Person"
-				} }
-			} }), { clientRequestId: "instance:another-tab" });
-			await hold.callersArrive("the other writer's write", (callers) => callers.includes("instance:another-tab"));
-			let instance = storeService.peek(mine);
-			instance.name = "Mine Edited";
-			let ownSave = storeService.save(mine);
-			await hold.callersArrive("this client's save", (callers) => callers.length === 2);
-			hold.release.fulfill();
-			await Promise.all([
-				theirWrite,
-				ownSave,
-				hold.holder.done
-			]);
-			await settled();
-			let event = await events.nextEventFor(mine);
-			assert.strictEqual(event.clientRequestId, "instance:another-tab", "the pass is announced under the other writer's id");
-			assert.deepEqual([...event.invalidations].sort(), [mine, theirs].sort(), "and it carries both writes");
-			assert.strictEqual(event.coalescedWrites?.length, 2, "with both writers among its coalesced writes");
-			reads = countCardReads("Person/shared-mine");
-			theirReads = countCardReads("Person/shared-theirs");
-			events.deliver(event);
-			await settled();
-			assert.strictEqual(reads.count, 0, "the card this client wrote is not read back");
-			assert.strictEqual(storeService.peek(mine).name, "Mine Edited", "and its edit stands");
-			assert.strictEqual(theirReads.count, 1, "while the card the other writer changed is");
-			assert.strictEqual(storeService.peek(theirs).name, "Theirs Edited", "and the store holds what that writer wrote");
-			let { coalescedWrites: _coalescedWrites, ...announcedAlone } = event;
-			events.deliver(announcedAlone);
-			await settled();
-			assert.strictEqual(reads.count, 1, "while the same event without its coalesced writes reads it back");
-		} finally {
-			hold?.release.fulfill();
-			reads?.stop();
-			theirReads?.stop();
-			events.restore();
-		}
-	});
-	(0, import_qunit.test)("an instance can be restored after a loader reset", async function(assert) {
-		setCardInOperatorModeState(`${testRealmURL}Person/hassan`);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		assert.dom(`[data-stack-card="${testRealmURL}Person/hassan"] [data-test-field="name"]`).containsText("Hassan", "the card data is correct");
-		await testRealm.write(`foo.gts`, `
-        import { contains, CardDef } from '@cardstack/base/card-api';
-        export class Foo extends CardDef {}
-      `.trim());
-		await waitFor("[data-test-stack-item-loading-card]", {
-			count: 0,
-			timeout: 5e3
-		});
-		assert.dom("[data-test-stack-item-loading-card]").doesNotExist("loading state is not displayed");
-		assert.dom(`[data-stack-card="${testRealmURL}Person/hassan"] [data-test-field="name"]`).containsText("Hassan", "the card data is correct");
-	});
-	(0, import_qunit.test)("an instance that started out with a local ID can be restored after a loader reset", async function(assert) {
-		let newInstance = new PersonDef({ name: "Andrea" });
-		await storeService.add(newInstance, { realm: testRealmURL });
-		setCardInOperatorModeState(newInstance[localId]);
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		assert.dom(`[data-stack-card="${newInstance.id}"] [data-test-field="name"]`).containsText("Andrea", "the card data is correct");
-		await testRealm.write(`foo.gts`, `
-        import { contains, CardDef } from '@cardstack/base/card-api';
-        export class Foo extends CardDef {}
-      `.trim());
-		await waitFor("[data-test-stack-item-loading-card]", {
-			count: 0,
-			timeout: 5e3
-		});
-		assert.dom("[data-test-stack-item-loading-card]").doesNotExist("loading state is not displayed");
-		assert.dom(`[data-stack-card="${newInstance.id}"] [data-test-field="name"]`).containsText("Andrea", "the card data is correct");
-	});
-	(0, import_qunit.test)("an unsaved instance live updates when realm event matching local ID is received", async function(assert) {
-		let newInstance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutPersisting(newInstance);
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let instance = storeService.peek(`${testRealmURL}Person/hassan`);
-		instance.friends = [newInstance];
-		await waitUntil(() => newInstance.id, { timeout: 5e3 });
-		assert.strictEqual(newInstance.id.split("/").pop(), newInstance[localId], "the new instance was live updated with a remote id");
-	});
-	(0, import_qunit.test)("an unsaved instance will auto save after it has been assigned a remote ID", async function(assert) {
-		assert.expect(2);
-		let newInstance = new PersonDef({ name: "Andrea" });
-		await storeService.addWithoutPersisting(newInstance);
-		storeService.addReference(`${testRealmURL}Person/hassan`);
-		await storeService.flush();
-		let instance = storeService.peek(`${testRealmURL}Person/hassan`);
-		instance.friends = [newInstance];
-		await waitUntil(() => newInstance.id, { timeout: 5e3 });
-		this.onSave((url, doc) => {
-			if (url.href === newInstance.id) {
-				assert.strictEqual(url.href, newInstance.id, "the save url is correct");
-				assert.strictEqual(doc.data.attributes?.name, "Air", "card data is correct");
-			}
-		});
-		newInstance.name = "Air";
-	});
-	(0, import_qunit.test)("reference count is balanced when used with CardResource that is destroyed", async function(assert) {
-		class Driver {
-			static {
-				decorateFieldV2(this.prototype, "showComponent", [tracked], function() {
-					return false;
-				});
-			}
-			#showComponent = (initializeDeferredDecorator(this, "showComponent"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "id", [tracked]);
-			}
-			#id = (initializeDeferredDecorator(this, "id"), void 0);
-		}
-		let driver = new Driver();
-		class ResourceConsumer extends Component {
-			resource = getCard(this, () => driver.id);
-			get renderedCard() {
-				return this.resource.card?.constructor.getComponent(this.resource.card);
-			}
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "XWrL4bCI",
-					"block": "[[[41,[30,0,[\"resource\",\"card\"]],[[[1,\"  \"],[8,[30,0,[\"renderedCard\"]],[[16,\"data-test-rendered-card\",[30,0,[\"resource\",\"id\"]]]],null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hNRtWalG",
-					"block": "[[[41,[32,0,[\"showComponent\"]],[[[1,\"  \"],[8,[32,1],null,null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [driver, ResourceConsumer],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		driver.showComponent = true;
-		let jade = `${testRealmURL}Person/jade`;
-		let hassan = `${testRealmURL}Person/hassan`;
-		driver.id = hassan;
-		await settleCardRender(assert, hassan, `[data-test-rendered-card="${hassan}"]`);
-		assert.strictEqual(storeService.getReferenceCount(jade), 0, `reference count for ${jade} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 1, `reference count for ${hassan} is 1`);
-		driver.id = jade;
-		await settleCardRender(assert, jade, `[data-test-rendered-card="${jade}"]`);
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 0, `reference count for ${hassan} is 0`);
-		driver.showComponent = false;
-		await waitFor(`[data-test-rendered-card]`, { count: 0 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 0, `reference count for ${jade} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 0, `reference count for ${hassan} is 0`);
-	});
-	(0, import_qunit.test)("reference count is balanced when used with CardResource for file-meta that is destroyed", async function(assert) {
-		class Driver {
-			static {
-				decorateFieldV2(this.prototype, "showComponent", [tracked], function() {
-					return false;
-				});
-			}
-			#showComponent = (initializeDeferredDecorator(this, "showComponent"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "id", [tracked]);
-			}
-			#id = (initializeDeferredDecorator(this, "id"), void 0);
-		}
-		let driver = new Driver();
-		let firstFile = `${testRealmURL}notes.txt`;
-		let secondFile = `${testRealmURL}README.txt`;
-		await testRealm.write("notes.txt", "notes");
-		await testRealm.write("README.txt", "readme");
-		class ResourceConsumer extends Component {
-			resource = getCard(this, () => driver.id, { type: "file-meta" });
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "5jWS7tbo",
-					"block": "[[[41,[30,0,[\"resource\",\"card\"]],[[[1,\"  \"],[10,0],[15,\"data-test-rendered-file\",[30,0,[\"resource\",\"id\"]]],[12],[13],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hNRtWalG",
-					"block": "[[[41,[32,0,[\"showComponent\"]],[[[1,\"  \"],[8,[32,1],null,null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [driver, ResourceConsumer],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		driver.showComponent = true;
-		driver.id = firstFile;
-		await settleCardRender(assert, firstFile, `[data-test-rendered-file="${firstFile}"]`, { type: "file-meta" });
-		assert.strictEqual(storeService.getReferenceCount(firstFile), 1, `reference count for ${firstFile} is 1`);
-		assert.strictEqual(storeService.getReferenceCount(secondFile), 0, `reference count for ${secondFile} is 0`);
-		driver.id = secondFile;
-		await settleCardRender(assert, secondFile, `[data-test-rendered-file="${secondFile}"]`, { type: "file-meta" });
-		assert.strictEqual(storeService.getReferenceCount(firstFile), 0, `reference count for ${firstFile} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(secondFile), 1, `reference count for ${secondFile} is 1`);
-		driver.showComponent = false;
-		await waitFor(`[data-test-rendered-file]`, { count: 0 });
-		assert.strictEqual(storeService.getReferenceCount(firstFile), 0, `reference count for ${firstFile} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(secondFile), 0, `reference count for ${secondFile} is 0`);
-	});
-	(0, import_qunit.test)("reference count is balanced during auto saving", async function(assert) {
-		let hassan = `${testRealmURL}Person/hassan`;
-		setCardInOperatorModeState(hassan, "edit");
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "ZD1xwmB+",
-					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [OperatorModeContainer, noop],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		assert.strictEqual(storeService.getReferenceCount(hassan), 1, `reference count for ${hassan} is 1`);
-		await withSlowSave(1e3, async () => {
-			await typeIn(`[data-test-stack-card="${testRealmURL}Person/hassan"] [data-test-field="name"] input`, " Paper");
-			assert.strictEqual(storeService.getReferenceCount(hassan), 1, `reference count for ${hassan} is 1`);
-		});
-		assert.strictEqual(storeService.getReferenceCount(hassan), 1, `reference count for ${hassan} is 1`);
-	});
-	(0, import_qunit.test)("reference count is balanced when used with CardCollectionResource that is destroyed", async function(assert) {
-		class Driver {
-			static {
-				decorateFieldV2(this.prototype, "showComponent", [tracked], function() {
-					return false;
-				});
-			}
-			#showComponent = (initializeDeferredDecorator(this, "showComponent"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "id", [tracked]);
-			}
-			#id = (initializeDeferredDecorator(this, "id"), void 0);
-		}
-		let driver = new Driver();
-		class ResourceConsumer extends Component {
-			resource = getCardCollection(this, () => driver.id ? [driver.id] : []);
-			get card() {
-				return this.resource.cards[0];
-			}
-			get renderedCard() {
-				return this.card?.constructor.getComponent(this.card);
-			}
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "99aOV2w7",
-					"block": "[[[41,[30,0,[\"card\"]],[[[1,\"  \"],[8,[30,0,[\"renderedCard\"]],[[16,\"data-test-rendered-card\",[30,0,[\"card\",\"id\"]]]],null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hNRtWalG",
-					"block": "[[[41,[32,0,[\"showComponent\"]],[[[1,\"  \"],[8,[32,1],null,null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [driver, ResourceConsumer],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		driver.showComponent = true;
-		let jade = `${testRealmURL}Person/jade`;
-		let hassan = `${testRealmURL}Person/hassan`;
-		driver.id = hassan;
-		await settleCardRender(assert, hassan, `[data-test-rendered-card="${hassan}"]`);
-		assert.strictEqual(storeService.getReferenceCount(jade), 0, `reference count for ${jade} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 1, `reference count for ${hassan} is 1`);
-		driver.id = jade;
-		await settleCardRender(assert, jade, `[data-test-rendered-card="${jade}"]`);
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 0, `reference count for ${hassan} is 0`);
-		driver.showComponent = false;
-		await waitFor(`[data-test-rendered-card]`, { count: 0 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 0, `reference count for ${jade} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 0, `reference count for ${hassan} is 0`);
-	});
-	(0, import_qunit.test)("reference count is balanced when used with SearchResource that is destroyed", async function(assert) {
-		class Driver {
-			static {
-				decorateFieldV2(this.prototype, "showComponent", [tracked], function() {
-					return false;
-				});
-			}
-			#showComponent = (initializeDeferredDecorator(this, "showComponent"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "id", [tracked]);
-			}
-			#id = (initializeDeferredDecorator(this, "id"), void 0);
-		}
-		let driver = new Driver();
-		class ResourceConsumer extends Component {
-			static {
-				decorateFieldV2(this.prototype, "store", [service]);
-			}
-			#store = (initializeDeferredDecorator(this, "store"), void 0);
-			get resource() {
-				return this.store.getSearchResource(this, () => driver.id ? { filter: {
-					on: baseCardRef,
-					eq: { id: driver.id }
-				} } : void 0);
-			}
-			static {
-				decorateMethodV2(this.prototype, "resource", [cached]);
-			}
-			get card() {
-				return this.resource.instances[0];
-			}
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "F3i58yQO",
-					"block": "[[[41,[30,0,[\"card\"]],[[[1,\"  \"],[10,0],[15,\"data-test-rendered-card\",[30,0,[\"card\",\"id\"]]],[12],[1,\"\\n    \"],[1,[30,0,[\"card\",\"id\"]]],[1,\"\\n  \"],[13],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "hNRtWalG",
-					"block": "[[[41,[32,0,[\"showComponent\"]],[[[1,\"  \"],[8,[32,1],null,null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [driver, ResourceConsumer],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		driver.showComponent = true;
-		let jade = `${testRealmURL}Person/jade`;
-		let hassan = `${testRealmURL}Person/hassan`;
-		driver.id = hassan;
-		await waitUntil(() => storeService.getReferenceCount(hassan) === 1 && storeService.getReferenceCount(jade) === 0, { timeout: 1e4 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 0, `reference count for ${jade} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 1, `reference count for ${hassan} is 1`);
-		driver.id = jade;
-		await waitUntil(() => storeService.getReferenceCount(jade) === 1 && storeService.getReferenceCount(hassan) === 0, { timeout: 1e4 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 0, `reference count for ${hassan} is 0`);
-		driver.showComponent = false;
-		await waitUntil(() => storeService.getReferenceCount(jade) === 0 && storeService.getReferenceCount(hassan) === 0, { timeout: 1e4 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 0, `reference count for ${jade} is 0`);
-		assert.strictEqual(storeService.getReferenceCount(hassan), 0, `reference count for ${hassan} is 0`);
-	});
-	(0, import_qunit.test)("reference count is balanced when used with SearchResource that live updates when there is a index event", async function(assert) {
-		class Driver {
-			static {
-				decorateFieldV2(this.prototype, "id", [tracked]);
-			}
-			#id = (initializeDeferredDecorator(this, "id"), void 0);
-		}
-		let driver = new Driver();
-		class ResourceConsumer extends Component {
-			static {
-				decorateFieldV2(this.prototype, "store", [service]);
-			}
-			#store = (initializeDeferredDecorator(this, "store"), void 0);
-			get resource() {
-				return this.store.getSearchResource(this, () => driver.id ? { filter: {
-					on: baseCardRef,
-					eq: { id: driver.id }
-				} } : void 0, void 0, { isLive: true });
-			}
-			static {
-				decorateMethodV2(this.prototype, "resource", [cached]);
-			}
-			get card() {
-				return this.resource.instances[0];
-			}
-			get renderedCard() {
-				return this.card?.constructor.getComponent(this.card);
-			}
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "99aOV2w7",
-					"block": "[[[41,[30,0,[\"card\"]],[[[1,\"  \"],[8,[30,0,[\"renderedCard\"]],[[16,\"data-test-rendered-card\",[30,0,[\"card\",\"id\"]]]],null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "HtmuKyv7",
-					"block": "[[[8,[32,0],null,null,null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [ResourceConsumer],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		let jade = `${testRealmURL}Person/jade`;
-		driver.id = jade;
-		await waitFor(`[data-test-rendered-card="${jade}"]`, { timeout: 5e3 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-		let deferred = new Deferred();
-		let unsubscribe = getService("message-service").subscribe(testRealmURL, (ev) => {
-			if (ev.eventName === "index" && ev.indexType === "incremental") {
-				unsubscribe();
-				deferred.fulfill();
-			}
-		});
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Paper" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await deferred.promise;
-		deferred = new Deferred();
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Paper" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-	});
-	(0, import_qunit.test)("reference count is balanced when used with CardCollectionResource when there is a index event", async function(assert) {
-		class Driver {
-			static {
-				decorateFieldV2(this.prototype, "id", [tracked]);
-			}
-			#id = (initializeDeferredDecorator(this, "id"), void 0);
-		}
-		let driver = new Driver();
-		class ResourceConsumer extends Component {
-			resource = getCardCollection(this, () => driver.id ? [driver.id] : []);
-			get card() {
-				return this.resource.cards[0];
-			}
-			get renderedCard() {
-				return this.card?.constructor.getComponent(this.card);
-			}
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "99aOV2w7",
-					"block": "[[[41,[30,0,[\"card\"]],[[[1,\"  \"],[8,[30,0,[\"renderedCard\"]],[[16,\"data-test-rendered-card\",[30,0,[\"card\",\"id\"]]]],null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "HtmuKyv7",
-					"block": "[[[8,[32,0],null,null,null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [ResourceConsumer],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		let jade = `${testRealmURL}Person/jade`;
-		driver.id = jade;
-		await waitFor(`[data-test-rendered-card="${jade}"]`, { timeout: 5e3 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-		let deferred = new Deferred();
-		let unsubscribe = getService("message-service").subscribe(testRealmURL, (ev) => {
-			if (ev.eventName === "index" && ev.indexType === "incremental") {
-				unsubscribe();
-				deferred.fulfill();
-			}
-		});
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Paper" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await deferred.promise;
-		deferred = new Deferred();
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Paper" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-	});
-	(0, import_qunit.test)("reference count is balanced when used with CardResource when there is a index event", async function(assert) {
-		class Driver {
-			static {
-				decorateFieldV2(this.prototype, "id", [tracked]);
-			}
-			#id = (initializeDeferredDecorator(this, "id"), void 0);
-		}
-		let driver = new Driver();
-		class ResourceConsumer extends Component {
-			resource = getCard(this, () => driver.id);
-			get renderedCard() {
-				return this.resource.card?.constructor.getComponent(this.resource.card);
-			}
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "XWrL4bCI",
-					"block": "[[[41,[30,0,[\"resource\",\"card\"]],[[[1,\"  \"],[8,[30,0,[\"renderedCard\"]],[[16,\"data-test-rendered-card\",[30,0,[\"resource\",\"id\"]]]],null,null],[1,\"\\n\"]],[]],null]],[],[\"if\"]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"isStrictMode": true
-				}), this);
-			}
-		}
-		await renderComponent(class TestDriver extends Component {
-			static {
-				setComponentTemplate(templateFactory({
-					"id": "HtmuKyv7",
-					"block": "[[[8,[32,0],null,null,null]],[],[]]",
-					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/store-test.gts",
-					"scope": () => [ResourceConsumer],
-					"isStrictMode": true
-				}), this);
-			}
-		});
-		let jade = `${testRealmURL}Person/jade`;
-		driver.id = jade;
-		await waitFor(`[data-test-rendered-card="${jade}"]`, { timeout: 5e3 });
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-		let deferred = new Deferred();
-		let unsubscribe = getService("message-service").subscribe(testRealmURL, (ev) => {
-			if (ev.eventName === "index" && ev.indexType === "incremental") {
-				unsubscribe();
-				deferred.fulfill();
-			}
-		});
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Paper" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		await deferred.promise;
-		deferred = new Deferred();
-		await testRealm.write("Person/hassan.json", JSON.stringify({ data: {
-			attributes: { name: "Paper" },
-			meta: { adoptsFrom: {
-				module: testRRI("person"),
-				name: "Person"
-			} }
-		} }));
-		assert.strictEqual(storeService.getReferenceCount(jade), 1, `reference count for ${jade} is 1`);
-	});
-});
-//#endregion