@cardstack/boxel-cli 0.3.2-unstable.59 → 0.3.2-unstable.60

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

@@ -0,0 +1,1562 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { Ai as realmURL, Di as localId, Sr as isCardInstance, Yn as testRRI, Zn as testRealmURL, ca as Deferred, mi as baseCardRef, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { $n as setComponentTemplate, r as service } from "./service-DJ87xpDt.js";
+import { V as templateFactory } from "./index-DaCZcoCY-D2gI_aMw.js";
+import { n as tracked, t as cached } from "./tracking-Dv1Q4IKh.js";
+import { o as Component } from "./dist-CXaz7pMY.js";
+import "./template-D3TMIrc1.js";
+import "./template-factory-DMEv2kVd.js";
+import { x as getCardCollection, y as getCard } from "./panel-rIdTMDfK.js";
+import { t as OperatorModeContainer } from "./container-C8gu0I0Q.js";
+import { A as settled, I as waitUntil, d as click, o as waitFor, r as typeIn } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, J as withSlowSave, M as setupOnSave, O as setupCardLogs, et as setupOperatorModeStateCleanup, j as setupLocalIndexing, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-BhFWlMMr.js";
+import { G as contains, I as StringField, Q as field, a as CardDef, d as Component$1, lt as linksTo, mt as setupBaseRealm, r as BooleanField, ut as linksToMany, x as FileDef } from "./base-realm-DpSTsZxD.js";
+import { n as renderComponent } from "./render-component-Bs21y6iv.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);
+	setupBaseRealm(hooks);
+	let api;
+	let loader;
+	let loaderService;
+	let testRealm;
+	let testRealmAdapter;
+	let storeService;
+	let operatorModeStateService;
+	let cardStore;
+	let PersonDef;
+	let BoomPersonDef;
+	let realmService;
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import(`${baseRealm.url}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 = () => {};
+	hooks.beforeEach(async function() {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#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(StringField, { 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(StringField);
+				});
+			}
+			#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;
+		loaderService = getService("loader-service");
+		loader = loaderService.loader;
+		api = await loader.import(`${baseRealm.url}card-api`);
+		storeService = getService("store");
+		operatorModeStateService = getService("operator-mode-state-service");
+		cardStore = storeService.store;
+		realmService = getService("realm");
+		({adapter: testRealmAdapter, realm: testRealm} = await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"person.gts": { Person },
+				"boom-person.gts": { BoomPerson },
+				"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 === `http://test-realm/test/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.add(instance, { doNotPersist: true });
+		storeService.addReference(instance[localId]);
+		forceGC();
+		let peekedInstance = storeService.peek(instance[localId]);
+		assert.strictEqual(peekedInstance, instance, "instance is not garbage collected");
+	});
+	(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.add(instance, { doNotPersist: true });
+		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.add(card, { doNotPersist: true });
+		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)("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.add(alpha, { doNotPersist: true });
+		await storeService.add(beta, { doNotPersist: true });
+		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 'https://cardstack.com/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)("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.add({ data: {
+			attributes: { name: "Andrea" },
+			meta: { adoptsFrom: {
+				module: testRRI("person"),
+				name: "Person"
+			} }
+		} }, { doNotPersist: true });
+		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.add(instance, { doNotWaitForPersist: true });
+		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.add(instance, {
+			doNotPersist: true,
+			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.add(lin, { doNotPersist: true });
+		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.add(conflictingInstance, { doNotPersist: true });
+			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.add(instance, { doNotPersist: true });
+		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 saveCount = 0;
+		this.onSave((url, doc) => {
+			saveCount++;
+			assert.strictEqual(url.href, `${testRealmURL}Person/hassan`, "correct document is saved");
+			switch (saveCount) {
+				case 1:
+					assert.strictEqual(doc.data?.attributes?.name, "Hassan ", "the initial instance mutation event is saved");
+					break;
+				case 2:
+					assert.strictEqual(doc.data?.attributes?.name, "Hassan Paper", "the final instance mutation event is saved");
+					break;
+				default: assert.ok(false, `unexpected number of saves: ${saveCount}`);
+			}
+		});
+		await withSlowSave(1e3, async () => {
+			await typeIn(`[data-test-stack-card="${testRealmURL}Person/hassan"] [data-test-field="name"] input`, " Paper");
+			assert.strictEqual(saveCount, 2, "the number of auto-saves is correct");
+		});
+	});
+	(0, import_qunit.test)("getSaveState works for initially unsaved instance", async function(assert) {
+		let instance = new PersonDef({ name: "Andrea" });
+		await storeService.add(instance, { doNotPersist: true });
+		assert.strictEqual(storeService.getSaveState(instance[localId]), void 0, "save state is undefined");
+		instance.name = "Air";
+		assert.true(storeService.getSaveState(instance[localId])?.isSaving, "isSaving state is correct");
+		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.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)("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)("loads FileDef links from included resources", async function(assert) {
+		await testRealm.writeMany(new Map([
+			["gallery.gts", `
+            import { CardDef, field, linksTo, linksToMany } from "https://cardstack.com/base/card-api";
+            import { FileDef } from "https://cardstack.com/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: "https://cardstack.com/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: "https://cardstack.com/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: "https://cardstack.com/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 "https://cardstack.com/base/card-api";
+            import { FileDef } from "https://cardstack.com/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);
+		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.add(instance, {
+			doNotPersist: true,
+			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");
+	});
+	(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 'https://cardstack.com/base/card-api';
+      import StringField from 'https://cardstack.com/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 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 waitFor("[data-test-card-error]");
+		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 waitFor("[data-test-card-error]", { count: 0 });
+		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)("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 'https://cardstack.com/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 'https://cardstack.com/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.add(newInstance, { doNotPersist: true });
+		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.add(newInstance, { doNotPersist: true });
+		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 waitFor(`[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 waitFor(`[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 waitFor(`[data-test-rendered-file="${firstFile}"]`);
+		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 waitFor(`[data-test-rendered-file="${secondFile}"]`);
+		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 waitFor(`[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 waitFor(`[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