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

package/bundled-test-harness/assets/store-test-DaqI-HRh.js

@@ -1,1562 +0,0 @@
-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-C2rtbx32.js";
-import { t as OperatorModeContainer } from "./container-D8y7fmir.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-2hoQyeAZ.js";
-import { r as getService } from "./dist-BfNSLd0O.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-DqDbNhEj.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-43wjttN2.js";
-import { n as renderComponent } from "./render-component-g_fhz2dX.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