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

package/bundled-test-harness/assets/formatted-user-message-test-CodbrU3t.js

@@ -0,0 +1,43 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { h as render } from "./dist-BOAdzfkP.js";
+import { t as UserMessage } from "./user-message-BAOt1hS3.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+//#region tests/integration/components/formatted-user-message-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | Component | FormattedUserMessage", function(hooks) {
+	setupRenderingTest(hooks);
+	async function renderFormattedUserMessage(testScenario) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "en6IWB3e",
+			"block": "[[[8,[32,0],null,[[\"@html\"],[[32,1,[\"html\"]]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/formatted-user-message-test.gts",
+			"scope": () => [UserMessage, testScenario],
+			"isStrictMode": true
+		}), templateOnly()));
+	}
+	(0, import_qunit.test)("it renders content without monaco editor", async function(assert) {
+		await renderFormattedUserMessage({
+			renderCodeBlocks: false,
+			html: `
+<p>Hey there, for Valentine's day I made you a code block!</p>
+<pre data-code-language="haskell">
+import Data.List (intercalate)
+main :: IO ()
+main = putStrLn "🖤"
+</pre>
+<p>I hope you like it!</p>
+`,
+			isStreaming: false
+		});
+		let messageElement = this.element.querySelector("[data-test-user-message-text]");
+		assert.ok(messageElement?.innerHTML.includes(`<p>Hey there, for Valentine's day I made you a code block!</p>\n<pre data-code-language="haskell">import Data.List (intercalate)\nmain :: IO ()\nmain = putStrLn "🖤"\n</pre>\n<p>I hope you like it!</p>`), "message should render html without monaco editor");
+		assert.dom(".monaco-editor").doesNotExist();
+	});
+});
+//#endregion

package/bundled-test-harness/assets/freestyle-test-faQhSciz.js

@@ -0,0 +1,17 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { k as visit } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { ct as setupApplicationTest, mt as setupAuthEndpoints } from "./mock-matrix-FjsXmU7-.js";
+//#region tests/acceptance/freestyle-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Acceptance | Freestyle", function(hooks) {
+	setupApplicationTest(hooks);
+	hooks.beforeEach(function() {
+		setupAuthEndpoints();
+	});
+	(0, import_qunit.test)("smoke check", async function(assert) {
+		await visit("/_freestyle");
+		assert.dom("h2.FreestyleUsage-name").containsText("AiAssistant::ComposerCap");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/full-reindex-realm-test-CE5RJTIC.js

@@ -0,0 +1,101 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Rr as testRealmInfo, Xn as APP_BOXEL_REALM_EVENT_TYPE } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { T as settled } from "./dist-BOAdzfkP.js";
+import { t as FullReindexRealmTool } from "./full-reindex-realm-BWu8Upyy.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, R as setupRealmServerEndpoints, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/tools/full-reindex-realm-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | tools | full-reindex-realm", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let receivedAuthorizationHeader = null;
+	let receivedMethod = null;
+	let receivedPathname = null;
+	let responseStatus = 204;
+	let responseBody = null;
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	setupRealmServerEndpoints(hooks, [{
+		route: "test/_full-reindex",
+		getResponse: async (req) => {
+			receivedAuthorizationHeader = req.headers.get("Authorization");
+			receivedMethod = req.method;
+			receivedPathname = new URL(req.url).pathname;
+			return new Response(responseBody, { status: responseStatus });
+		}
+	}]);
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		getOwner(this).register("service:realm", StubRealmService);
+		receivedAuthorizationHeader = null;
+		receivedMethod = null;
+		receivedPathname = null;
+		responseStatus = 204;
+		responseBody = null;
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealmURL,
+			contents: {}
+		}));
+	});
+	(0, import_qunit.test)("calls realm endpoint with expected auth header", async function(assert) {
+		let toolService = getService("tool-service");
+		let realmServer = getService("realm-server");
+		let realmService = getService("realm");
+		let command = new FullReindexRealmTool(toolService.toolContext);
+		let realmURL = new URL("test/", realmServer.url).href;
+		assert.false(realmService.info(realmURL).isIndexing, "realm is not indexing before the command runs");
+		let result = await command.execute({ realmIdentifier: realmURL });
+		assert.strictEqual(result, void 0, "command has no result card");
+		assert.strictEqual(receivedMethod, "POST", "uses POST");
+		assert.strictEqual(receivedPathname, "/test/_full-reindex", "calls endpoint");
+		assert.ok(receivedAuthorizationHeader, "authorization header is present");
+		assert.true(receivedAuthorizationHeader?.startsWith("Bearer "), "authorization header uses Bearer scheme");
+		let [_header, payload] = receivedAuthorizationHeader.replace("Bearer ", "").split(".");
+		let tokenClaims = JSON.parse(atob(payload));
+		assert.strictEqual(tokenClaims.realm, realmURL, "authorization token is realm-scoped");
+		assert.deepEqual(tokenClaims.permissions, ["read", "write"], "authorization token contains realm permissions");
+		assert.notStrictEqual(receivedAuthorizationHeader, `Bearer ${realmServer.token}`, "authorization header does not use realm-server session token");
+		assert.true(realmService.info(realmURL).isIndexing, "command starts the realm indexing animation immediately");
+		mockMatrixUtils.simulateRemoteMessage(mockMatrixUtils.getRoomIdForRealmAndUser(realmURL, "@testuser:localhost"), testRealmInfo.realmUserId, {
+			eventName: "index",
+			indexType: "incremental",
+			invalidations: [],
+			realmURL
+		}, { type: APP_BOXEL_REALM_EVENT_TYPE });
+		await settled();
+		assert.false(realmService.info(realmURL).isIndexing, "incremental realm event stops the indexing animation");
+	});
+	(0, import_qunit.test)("throws when full reindex endpoint returns non-204", async function(assert) {
+		let toolService = getService("tool-service");
+		let realmServer = getService("realm-server");
+		let realmService = getService("realm");
+		let command = new FullReindexRealmTool(toolService.toolContext);
+		let realmURL = new URL("test/", realmServer.url).href;
+		responseStatus = 500;
+		responseBody = "boom";
+		await assert.rejects(command.execute({ realmIdentifier: realmURL }), /Full reindex realm failed: 500 - boom/, "propagates non-204 failure as an error");
+		assert.false(realmService.info(realmURL).isIndexing, "failed full reindex restores the pre-command animation state");
+	});
+	(0, import_qunit.test)("description explains forced full reindex semantics", async function(assert) {
+		let command = new FullReindexRealmTool(getService("tool-service").toolContext);
+		assert.true(command.description.includes("every file in the realm is revisited"), "description identifies this as the forced full option");
+		assert.true(command.description.includes("stale cached results"), "description explains when to choose it");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/garbage-collection-test-v-3sev77.js

@@ -0,0 +1,403 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { B as localId } from "./constants-Icc0nFW-.js";
+import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
+import { T as settled } from "./dist-BOAdzfkP.js";
+import { t as CardStoreWithGarbageCollection } from "./gc-card-store-yOsxGgxR.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { Mt as tagTestModuleExports, O as saveCard, lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, H as linksTo, U as linksToMany, a as CardDef, d as FileDef, w as contains } from "./card-api-Cc8uZunB.js";
+import "./file-api-BsT3Q6C9.js";
+import { t as string_default } from "./string-5IAMEUit.js";
+//#region tests/unit/garbage-collection-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var loader;
+(0, import_qunit.module)("Unit | identity-context garbage collection", function(hooks) {
+	setupRenderingTest(hooks);
+	let api;
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		api = await loader.import("@cardstack/base/card-api");
+		delete globalThis.__boxelRenderContext;
+	});
+	function makeError(id) {
+		return {
+			id,
+			status: 500,
+			title: "test card error",
+			message: "i'm a test card error",
+			realm: void 0,
+			meta: {
+				lastKnownGoodHtml: null,
+				cardTitle: null,
+				scopedCssUrls: [],
+				stack: null
+			}
+		};
+	}
+	async function saveAll({ store, jade, queenzy, germaine, boris, hassan }) {
+		await saveCard(jade, `${testRealmURL}jade`, loader, store);
+		await saveCard(queenzy, `${testRealmURL}queenzy`, loader, store);
+		await saveCard(germaine, `${testRealmURL}germaine`, loader, store);
+		await saveCard(boris, `${testRealmURL}boris`, loader, store);
+		await saveCard(hassan, `${testRealmURL}hassan`, loader, store);
+	}
+	async function setupTest(doSave) {
+		class Person extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "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);
+		}
+		tagTestModuleExports(`${testRealmURL}test-cards`, { Person });
+		let jade = new Person({ name: "Jade" });
+		let queenzy = new Person({ name: "Queenzy" });
+		let germaine = new Person({
+			name: "Germaine",
+			bestFriend: queenzy
+		});
+		let boris = new Person({ name: "Boris" });
+		let hassan = new Person({
+			name: "Hassan",
+			bestFriend: jade,
+			friends: [germaine]
+		});
+		let referenceCount = /* @__PURE__ */ new Map();
+		let network = getService("network");
+		let store = new CardStoreWithGarbageCollection(referenceCount, network.fetch, network.virtualNetwork);
+		store.setCard(jade[localId], jade);
+		store.setCard(germaine[localId], germaine);
+		store.setCard(queenzy[localId], queenzy);
+		store.setCard(boris[localId], boris);
+		store.setCard(hassan[localId], hassan);
+		await doSave?.({
+			store,
+			jade,
+			queenzy,
+			germaine,
+			boris,
+			hassan
+		});
+		return {
+			referenceCount,
+			store,
+			instances: {
+				jade,
+				queenzy,
+				germaine,
+				boris,
+				hassan
+			}
+		};
+	}
+	(0, import_qunit.test)("can mark saved instances that have 0 reference count for GC", async function(assert) {
+		let { referenceCount, store, instances: { jade, germaine, queenzy, boris, hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates, [boris[localId]], "the GC candidates are correct");
+		assert.strictEqual(store.getCard(jade.id), jade, "store contains \"jade\"");
+		assert.strictEqual(store.getCard(queenzy.id), queenzy, "store contains \"queenzy\"");
+		assert.strictEqual(store.getCard(germaine.id), germaine, "store contains \"germaine\"");
+		assert.strictEqual(store.getCard(boris.id), boris, "store contains \"boris\"");
+		assert.strictEqual(store.getCard(hassan.id), hassan, "store contains \"hassan\"");
+	});
+	(0, import_qunit.test)("can mark unsaved instances without that have a 0 reference count for GC", async function(assert) {
+		let { referenceCount, store, instances: { jade, germaine, queenzy, boris, hassan } } = await setupTest();
+		referenceCount.set(hassan[localId], 1);
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates, [boris[localId]], "the GC candidates are correct");
+		assert.strictEqual(store.getCard(jade[localId]), jade, "store contains \"jade\"");
+		assert.strictEqual(store.getCard(queenzy[localId]), queenzy, "store contains \"queenzy\"");
+		assert.strictEqual(store.getCard(germaine[localId]), germaine, "store contains \"germaine\"");
+		assert.strictEqual(store.getCard(boris[localId]), boris, "store contains \"boris\"");
+		assert.strictEqual(store.getCard(hassan[localId]), hassan, "store contains \"hassan\"");
+	});
+	(0, import_qunit.test)("can remove unsubscribed instances for GC after being marked in 2 consecutive sweeps", async function(assert) {
+		let { referenceCount, store, instances: { jade, germaine, queenzy, boris, hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct");
+		assert.strictEqual(store.getCard(jade.id), jade, "store contains \"jade\"");
+		assert.strictEqual(store.getCard(queenzy.id), queenzy, "store contains \"queenzy\"");
+		assert.strictEqual(store.getCard(germaine.id), germaine, "store contains \"germaine\"");
+		assert.strictEqual(store.getCard(hassan.id), hassan, "store contains \"hassan\"");
+		assert.strictEqual(store.getCard(boris.id), void 0, "store does not contain \"boris\"");
+	});
+	(0, import_qunit.test)("instances removed by GC have destructors run", async function(assert) {
+		let { store, instances: { boris } } = await setupTest(saveAll);
+		registerDestructor(boris, () => {
+			assert.step("boris destructor called");
+		});
+		store.sweep(api);
+		store.sweep(api);
+		await settled();
+		assert.verifySteps(["boris destructor called"], "destructor was called exactly once");
+	});
+	(0, import_qunit.test)("a GC candidate is no longer considered a GC candidate if it is consumed by an instance that has a reference count > 0 ", async function(assert) {
+		let { referenceCount, store, instances: { germaine, boris, hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		germaine.friends = [boris];
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct");
+		assert.strictEqual(store.getCard(boris.id), boris, "store contains \"boris\"");
+	});
+	(0, import_qunit.test)("a GC candidate is no longer considered a GC candidate if it is consumed by an unsaved instance that has a reference count > 0", async function(assert) {
+		let { referenceCount, store, instances: { germaine, boris, hassan } } = await setupTest();
+		referenceCount.set(hassan[localId], 1);
+		store.sweep(api);
+		germaine.friends = [boris];
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct");
+		assert.strictEqual(store.getCard(boris[localId]), boris, "store contains \"boris\"");
+	});
+	(0, import_qunit.test)("FileDef dependencies keep file-meta instances reachable via card references", async function(assert) {
+		class FilePerson extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "attachment", [field], function() {
+					return linksTo(FileDef);
+				});
+			}
+			#attachment = (initializeDeferredDecorator(this, "attachment"), void 0);
+		}
+		let referenceCount = /* @__PURE__ */ new Map();
+		let network = getService("network");
+		let store = new CardStoreWithGarbageCollection(referenceCount, network.fetch, network.virtualNetwork);
+		let fileUrl = `${testRealmURL}hero.png`;
+		let fileDef = new FileDef({
+			id: fileUrl,
+			sourceUrl: fileUrl,
+			url: fileUrl,
+			name: "hero.png",
+			contentType: "image/png"
+		});
+		let person = new FilePerson({ attachment: fileDef });
+		store.setFileMeta(fileUrl, fileDef);
+		store.setCard(person[localId], person);
+		referenceCount.set(person[localId], 1);
+		store.sweep(api);
+		store.sweep(api);
+		assert.strictEqual(store.getFileMeta(fileUrl), fileDef, "file meta instance is retained when referenced via a card dependency");
+		assert.deepEqual(store.gcCandidates, [], "no GC candidates remain when file meta is reachable");
+	});
+	(0, import_qunit.test)("a `.json` FileDef does not collide with the same-named card id (CS-11622)", async function(assert) {
+		let referenceCount = /* @__PURE__ */ new Map();
+		let network = getService("network");
+		let store = new CardStoreWithGarbageCollection(referenceCount, network.fetch, network.virtualNetwork);
+		class RealmConfig extends CardDef {}
+		let cardId = `${testRealmURL}realm`;
+		let fileUrl = `${cardId}.json`;
+		let realmConfig = new RealmConfig();
+		store.setCard(cardId, realmConfig);
+		let fileDef = new FileDef({
+			id: fileUrl,
+			sourceUrl: fileUrl,
+			url: fileUrl,
+			name: "realm.json",
+			contentType: "application/json"
+		});
+		store.setFileMeta(fileUrl, fileDef);
+		assert.strictEqual(store.getFileMeta(fileUrl), fileDef, "the FileDef is found by its full `.json` URL");
+		assert.strictEqual(store.getFileMeta(cardId), void 0, "the card id does not resolve to the colliding FileDef");
+		assert.strictEqual(store.getCard(cardId), realmConfig, "the card is still found by its (extension-less) card id");
+		store.delete(fileUrl);
+		assert.strictEqual(store.getFileMeta(fileUrl), void 0, "the FileDef is removed when deleted by its `.json` URL");
+		assert.strictEqual(store.getCard(cardId), realmConfig, "deleting the `.json` file leaves the same-named card in place");
+		store.setFileMeta(fileUrl, fileDef);
+		store.delete(cardId);
+		assert.strictEqual(store.getCard(cardId), void 0, "the card is removed when deleted by its (extension-less) id");
+		assert.strictEqual(store.getFileMeta(fileUrl), fileDef, "deleting the card leaves the same-named FileDef in place");
+	});
+	(0, import_qunit.test)("an instance becomes a GC candidate when its reference count drops to 0 for its remote id", async function(assert) {
+		let { referenceCount, store, instances: { jade, germaine, queenzy, hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		referenceCount.set(hassan.id, 0);
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates.sort(), [
+			jade[localId],
+			germaine[localId],
+			queenzy[localId],
+			hassan[localId]
+		].sort(), "the GC candidates are correct");
+	});
+	(0, import_qunit.test)("an instance becomes a GC candidate when its reference count drops to zero for its local id", async function(assert) {
+		let { referenceCount, store, instances: { jade, germaine, queenzy, hassan } } = await setupTest();
+		referenceCount.set(hassan[localId], 1);
+		store.sweep(api);
+		referenceCount.set(hassan[localId], 0);
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates.sort(), [
+			jade[localId],
+			germaine[localId],
+			queenzy[localId],
+			hassan[localId]
+		].sort(), "the GC candidates are correct");
+	});
+	(0, import_qunit.test)("a GC candidate no longer becomes a GC candidate if it is accessed in the identity map by remote id", async function(assert) {
+		let { referenceCount, store, instances: { boris, hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		store.getCard(boris.id);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct after getting by remote id");
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates, [boris[localId]], "the GC candidates are correct, sweep reintroduces GC candidate");
+		store.setCard(boris.id, boris);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct after setting by remote id");
+	});
+	(0, import_qunit.test)("a GC candidate no longer becomes a GC candidate if it is accessed in the identity map by local id", async function(assert) {
+		let { referenceCount, store, instances: { boris, hassan } } = await setupTest();
+		referenceCount.set(hassan[localId], 1);
+		store.sweep(api);
+		store.getCard(boris[localId]);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct after getting by local id");
+		store.sweep(api);
+		assert.deepEqual(store.gcCandidates, [boris[localId]], "the GC candidates are correct, sweep reintroduces GC candidate");
+		store.setCard(boris[localId], boris);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct after setting by local id");
+	});
+	(0, import_qunit.test)("a GC candidate no longer remains a GC candidate if it accessed via setting a card error in the identity map", async function(assert) {
+		let { referenceCount, store, instances: { boris, hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		store.addCardInstanceOrError(boris.id, makeError(boris.id));
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct");
+	});
+	(0, import_qunit.test)("can delete an instance from the identity map", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		store.delete(hassan.id);
+		assert.deepEqual(store.getCard(hassan.id), void 0, "the instance does not exist");
+		assert.deepEqual(store.getCard(hassan[localId]), void 0, "the instance does not exist via local id");
+		assert.deepEqual(store.getCardInstanceOrError(hassan.id), void 0, "the instance does not exist");
+	});
+	(0, import_qunit.test)("can delete an instance from the identity map by local id", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		store.delete(hassan[localId]);
+		assert.deepEqual(store.getCard(hassan[localId]), void 0, "the instance does not exist");
+		assert.deepEqual(store.getCard(hassan.id), void 0, "the instance does not exist via remote id");
+		assert.deepEqual(store.getCardInstanceOrError(hassan[localId]), void 0, "the instance does not exist");
+	});
+	(0, import_qunit.test)("can delete a card error from the identity map", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		store.addCardInstanceOrError(hassan.id, makeError(hassan.id));
+		store.delete(hassan.id);
+		assert.deepEqual(store.getCardInstanceOrError(hassan.id), void 0, "the instance does not exist");
+	});
+	(0, import_qunit.test)("deleting an entry from the identity map by remote id removes the GC candidate", async function(assert) {
+		let { referenceCount, store, instances: { boris, hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		store.delete(boris.id);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct");
+	});
+	(0, import_qunit.test)("deleting an entry from the identity map by local id removes the GC candidate", async function(assert) {
+		let { referenceCount, store, instances: { boris, hassan } } = await setupTest();
+		referenceCount.set(hassan[localId], 1);
+		store.sweep(api);
+		store.delete(boris[localId]);
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct");
+	});
+	(0, import_qunit.test)("resetting the identity map clears all GC candidates", async function(assert) {
+		let { referenceCount, store, instances: { hassan } } = await setupTest(saveAll);
+		referenceCount.set(hassan.id, 1);
+		store.sweep(api);
+		store.reset();
+		assert.deepEqual(store.gcCandidates, [], "the GC candidates are correct");
+	});
+	(0, import_qunit.test)("garbage collects instances that only consume each other", async function(assert) {
+		let { referenceCount, store, instances: { hassan } } = await setupTest();
+		referenceCount.clear();
+		store.reset();
+		let Person = hassan.constructor;
+		let alpha = new Person({ name: "Alpha" });
+		let beta = new Person({ name: "Beta" });
+		alpha.bestFriend = beta;
+		beta.bestFriend = alpha;
+		store.setCard(alpha[localId], alpha);
+		store.setCard(beta[localId], beta);
+		store.sweep(api);
+		assert.deepEqual([...store.gcCandidates].sort(), [alpha[localId], beta[localId]].sort(), "cyclic instances become GC candidates after initial sweep");
+		store.sweep(api);
+		assert.strictEqual(store.getCard(alpha[localId]), void 0, "alpha instance is collected");
+		assert.strictEqual(store.getCard(beta[localId]), void 0, "beta instance is collected");
+		assert.deepEqual(store.gcCandidates, [], "no GC candidates remain after collecting the cycle");
+	});
+	(0, import_qunit.test)("resetting the identity map clears instances and errors", async function(assert) {
+		let { store, instances: { hassan, jade } } = await setupTest(saveAll);
+		store.addCardInstanceOrError(hassan.id, makeError(hassan.id));
+		store.reset();
+		assert.strictEqual(store.getCardInstanceOrError(hassan.id), void 0, "card errors are cleared alongside instances");
+		assert.deepEqual(store.getCardInstanceOrError(jade.id), void 0, "no instance is returned from identity map");
+	});
+	(0, import_qunit.test)("can add a card error to the identity map", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		store.delete(hassan.id);
+		let error = makeError(hassan.id);
+		store.addCardInstanceOrError(hassan.id, error);
+		assert.strictEqual(store.getCard(hassan.id), void 0, "no card instance exists for the id");
+		assert.strictEqual(store.getCardInstanceOrError(hassan.id), error, "a card error exists for the id");
+	});
+	(0, import_qunit.test)("can get a card from identity map using getInstanceOrError() by remote id", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		assert.strictEqual(store.getCardInstanceOrError(hassan.id), hassan, "card instance is returned");
+	});
+	(0, import_qunit.test)("can get a card from identity map using getInstanceOrError() by local id", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest();
+		assert.strictEqual(store.getCardInstanceOrError(hassan[localId]), hassan, "card instance is returned");
+	});
+	(0, import_qunit.test)("can get a card from the identity map by correlating the last part of the remote id with the local id, without reconciling the instance id", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest();
+		let idBefore = hassan.id;
+		assert.strictEqual(store.getCardInstanceOrError(`${testRealmURL}${hassan[localId]}`), hassan, "card instance is returned by correlating the remote id tail to the local id");
+		assert.strictEqual(hassan.id, idBefore, "the bare lookup leaves the instance id unchanged");
+	});
+	(0, import_qunit.test)("return a stale instance when the server state reflects an error for an id", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		let error = makeError(hassan.id);
+		store.addCardInstanceOrError(hassan.id, error);
+		assert.strictEqual(store.getCard(hassan.id), hassan, "stale hassan instance is returned");
+		assert.strictEqual(store.getCardInstanceOrError(hassan.id), hassan, "stale hassan instance is returned");
+	});
+	(0, import_qunit.test)("can get an error for an id when a stale instance exists", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		let error = makeError(hassan.id);
+		store.addCardInstanceOrError(hassan.id, error);
+		assert.strictEqual(store.getCardError(hassan.id), error, "a card error exists for the id");
+	});
+	(0, import_qunit.test)("setting an instance clears a card error", async function(assert) {
+		let { store, instances: { hassan } } = await setupTest(saveAll);
+		let error = makeError(hassan.id);
+		store.addCardInstanceOrError(hassan.id, error);
+		assert.strictEqual(store.getCardError(hassan.id), error, "a card error exists for the id");
+		store.addCardInstanceOrError(hassan.id, hassan);
+		assert.strictEqual(store.getCardError(hassan.id), void 0, "a card error does not exist for the id");
+	});
+	(0, import_qunit.test)("can get the consumers of an instance", async function(assert) {
+		let { store, instances: { germaine, queenzy } } = await setupTest();
+		let consumers = store.consumersOf(api, queenzy);
+		assert.deepEqual(consumers, [germaine], "the consumers for queenzy are correct");
+	});
+	(0, import_qunit.test)("can get the dependencies of an instance", async function(assert) {
+		let { store, instances: { hassan, jade, germaine } } = await setupTest();
+		let dependencies = store.dependenciesOf(api, hassan);
+		assert.deepEqual(dependencies, [jade, germaine], "the dependencies for hassan are correct");
+	});
+});
+//#endregion