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

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

@@ -0,0 +1,3460 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, Dr as testRRI, Po as isCardInstance, Ro as isFileDefInstance, Sc as Deferred, Wn as APP_BOXEL_REALM_EVENT_TYPE, uo as SupportedMimeType } from "./runtime-common-ClpqhbwG.js";
+import { C as baseCardRef, K as realmURL, V as localId } from "./constants-CqKWhRfY.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-BXiO3i7R.js";
+import { n as getCard } from "./card-resource-JGLjQUy6.js";
+import { t as OperatorModeContainer } from "./container-Dj-5prh9.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, _t as registerRealmServerRoute, et as withSlowSave, gt as registerDefaultRoutes, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.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-Dzje0smT.js";
+import "./file-api-DPMJghBY.js";
+import { t as BooleanField } from "./boolean-CcKPYUph.js";
+import { t as string_default } from "./string-BHZZwNlZ.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}`
+				});
+				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;
+			}
+		};
+	}
+	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 saveFinished = new Deferred();
+		this.onSave((url) => {
+			if (url.href === `${testRealmURL}Person/hassan`) {
+				assert.strictEqual(url.href, `${testRealmURL}Person/hassan`);
+				assert.strictEqual(storeService.getReferenceCount(`${testRealmURL}Person/hassan`), 0, "save() does not create a separate resolved-url reference count");
+				assert.strictEqual(storeService.getReferenceCount("@test-prefix/Person/hassan"), 0, "save() does not create a separate prefix reference count");
+				saveFinished.fulfill();
+			}
+		});
+		storeService.save("@test-prefix/Person/hassan");
+		await saveFinished;
+		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() {
+			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") writes.push({
+					url: request?.url ?? String(input),
+					keepalive: init?.keepalive ?? request?.keepalive ?? false
+				});
+				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();
+			for (let i = 1; i <= edits; i++) {
+				instance.name = `Hassan ${i}`;
+				await pause(100);
+			}
+			let editingMs = Date.now() - startedAt;
+			let savedWhileEditing = saves.length;
+			await storeService.flushSaves();
+			assert.ok(savedWhileEditing >= 1, `edits are saved while editing goes on (${savedWhileEditing} saved)`);
+			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)`);
+			assert.ok(saves.length < edits / 3, `${edits} edits take far fewer saves than edits (${saves.length} saved)`);
+			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 didSave = false;
+		this.onSave(() => {
+			didSave = true;
+		});
+		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 updated" },
+			meta: { adoptsFrom: {
+				module: testRRI("person"),
+				name: "Person"
+			} }
+		} }));
+		await waitUntil(() => storeService.peek(`${testRealmURL}Person/hassan`)?.name === "Hassan updated");
+		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 holds but has not indexed yet shows as being prepared, then renders once indexing lands", async function(assert) {
+		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) {
+		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) {
+		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) {
+		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