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

package/bundled-test-harness/assets/from-elsewhere-BXcLYxxu.js

@@ -0,0 +1,131 @@
+import "./chunk-Rp0pCe6z.js";
+import { i as deprecate } from "./debug-Dg0TiPYl.js";
+import { et as tracked, wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { _t as schedule, n as inject, r as service, x as Promise$1 } from "./service-LFpJ8EEP.js";
+import { r as getOwner } from "./application-VoCE-EjL.js";
+import { H as templateFactory, n as Helper, z as runtime_exports } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./rsvp-BUQYrGTG.js";
+import "./tracking-CNiq91Pk.js";
+import { a as get } from "./helper-m6jA5HmU.js";
+import { t as esCompat } from "./es-compat2-CZCbH4TS.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import "./helper-DazkUnmP.js";
+var { isCurriedComponentDefinition, CurriedComponentDefinition, curry, CurriedValue } = esCompat(runtime_exports);
+if (!isCurriedComponentDefinition) isCurriedComponentDefinition = function(value) {
+	return value instanceof CurriedValue;
+};
+function runtimeResolver(owner) {
+	let resolver = owner.lookup("renderer:-dom")._runtimeResolver;
+	if (resolver) return resolver;
+	let entry = Object.entries(owner.__container__.cache).find((e) => e[0].startsWith("template-compiler:main-"));
+	if (entry) return entry[1].resolver.resolver;
+	throw new Error(`@embroider/util couldn't locate the runtime resolver on this ember version`);
+}
+function lookupCurriedComponentDefinition(name, owner) {
+	let resolver = runtimeResolver(owner);
+	if (typeof resolver.lookupComponentHandle === "function") {
+		let handle = resolver.lookupComponentHandle(name, contextForLookup(owner));
+		if (handle != null) return new CurriedComponentDefinition(resolver.resolve(handle), null);
+	}
+	if (!resolver.lookupComponent(name, owner)) throw new Error(`Attempted to resolve \`${name}\` via ensureSafeComponent, but nothing was found.`);
+	return curry(0, name, owner, {
+		named: {},
+		positional: []
+	});
+}
+function contextForLookup(owner) {
+	return owner;
+}
+//#endregion
+//#region node_modules/.embroider/rewritten-packages/@embroider/util.a022fcec/node_modules/@embroider/util/index.js
+function ensureSafeComponent(value, thingWithOwner) {
+	if (typeof value === "string") return handleString(value, thingWithOwner);
+	else if (isCurriedComponentDefinition(value)) return value;
+	else if (value == null) return value;
+	else return handleClass(value, thingWithOwner);
+}
+var EnsureSafeComponentHelper = class extends Helper {
+	compute([value]) {
+		return ensureSafeComponent(value, this);
+	}
+};
+function handleString(name, thingWithOwner) {
+	deprecate(`You're trying to invoke the component "${name}" by passing its name as a string. This won't work under Embroider.`, false, {
+		id: "ensure-safe-component.string",
+		url: "https://github.com/embroider-build/embroider/blob/main/docs/replacing-component-helper.md#when-youre-passing-a-component-to-someone-else",
+		until: "embroider",
+		for: "@embroider/util",
+		since: "0.27.0"
+	});
+	return lookupCurriedComponentDefinition(name, getOwner(thingWithOwner));
+}
+function handleClass(klass, thingWithOwner) {
+	return klass;
+}
+//#endregion
+//#region node_modules/.embroider/rewritten-packages/ember-elsewhere.909fa84c/node_modules/ember-elsewhere/components/from-elsewhere.hbs
+var from_elsewhere_default = templateFactory({
+	"id": "G2rRjcEy",
+	"block": "[[[41,[30,0,[\"initialized\"]],[[[44,[[28,[32,0],[[30,0,[\"service\",\"actives\"]],[30,0,[\"name\"]]],null]],[[[41,[48,[30,3]],[[[1,\"      \"],[18,3,[[30,1,[\"lastObject\",\"component\"]],[30,1,[\"lastObject\",\"outsideParams\"]]]],[1,\"\\n\"]],[]],[[[44,[[30,1,[\"lastObject\",\"component\"]]],[[[1,\"        \"],[46,[28,[32,1],[[30,2]],null],null,null,null],[1,\"\\n\"]],[2]]]],[]]]],[1]]]],[]],null]],[\"active\",\"c\",\"&default\"],[\"if\",\"let\",\"has-block\",\"yield\",\"component\"]]",
+	"moduleName": "/home/runner/work/boxel/boxel/packages/host/node_modules/.embroider/rewritten-packages/ember-elsewhere.909fa84c/node_modules/ember-elsewhere/components/from-elsewhere.hbs",
+	"scope": () => [get, EnsureSafeComponentHelper],
+	"isStrictMode": false
+});
+//#endregion
+//#region node_modules/.embroider/rewritten-packages/ember-elsewhere.909fa84c/node_modules/ember-elsewhere/components/from-elsewhere.js
+var _dec;
+var _class2;
+var _descriptor;
+var _descriptor2;
+function _initializerDefineProperty(e, i, r, l) {
+	r && Object.defineProperty(e, i, {
+		enumerable: r.enumerable,
+		configurable: r.configurable,
+		writable: r.writable,
+		value: r.initializer ? r.initializer.call(l) : void 0
+	});
+}
+function _applyDecoratedDescriptor(i, e, r, n, l) {
+	var a = {};
+	return Object.keys(n).forEach(function(i) {
+		a[i] = n[i];
+	}), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function(r, n) {
+		return n(i, e, r) || r;
+	}, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a;
+}
+var _class = (_dec = (service ?? inject)("ember-elsewhere"), _class2 = class _class2 extends Component {
+	get name() {
+		if (this.args.named) throw new Error(`<FromElsewhere> takes a "@name=" parameter, not "@named="`);
+		return this.args.name ?? "default";
+	}
+	constructor(...args) {
+		super(...args);
+		_initializerDefineProperty(this, "service", _descriptor, this);
+		_initializerDefineProperty(this, "initialized", _descriptor2, this);
+		let promise = new Promise$1((resolve) => {
+			schedule("afterRender", () => {
+				this.initialized = true;
+				resolve();
+			});
+		});
+		let fastboot = getOwner(this).lookup("service:fastboot");
+		if (fastboot && fastboot.isFastBoot) fastboot.deferRendering(promise);
+	}
+}, _descriptor = _applyDecoratedDescriptor(_class2.prototype, "service", [_dec], {
+	configurable: true,
+	enumerable: true,
+	writable: true,
+	initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "initialized", [tracked], {
+	configurable: true,
+	enumerable: true,
+	writable: true,
+	initializer: function() {
+		return false;
+	}
+}), _class2);
+setComponentTemplate(from_elsewhere_default, _class);
+//#endregion
+export { _class as t };

package/bundled-test-harness/assets/frontmatter-field-CciolgL3.js

@@ -0,0 +1,41 @@
+import "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.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 { A as field, l as FieldDef, s as Component, w as contains } from "./card-api-Dzje0smT.js";
+import { t as JsonField } from "./json-field-CxOZvp3k.js";
+//#region ../base/frontmatter-field.gts
+var FrontmatterField = class extends FieldDef {
+	static displayName = "Frontmatter";
+	static {
+		decorateFieldV2(this.prototype, "rawContent", [field], function() {
+			return contains(JsonField);
+		});
+	}
+	#rawContent = (initializeDeferredDecorator(this, "rawContent"), void 0);
+	static async fromFrontmatter(frontmatter, _context) {
+		return { attributes: { rawContent: frontmatter } };
+	}
+	static embedded = class Embedded extends Component {
+		get kind() {
+			return (this.args.model?.rawContent)?.boxel?.kind ?? "";
+		}
+		static {
+			setComponentTemplate(templateFactory({
+				"id": "mBU0LeHR",
+				"block": "[[[1,[30,0,[\"kind\"]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/base/frontmatter-field.gts",
+				"isStrictMode": true
+			}), this);
+		}
+	};
+};
+(globalThis.__boxelBundledBaseScopedCSS ??= {})["frontmatter-field"] = {
+	"css": [],
+	"imports": ["card-api", "json-field"]
+};
+(globalThis.__boxelBundledBaseIdentities ??= {})["frontmatter-field"] = { "FrontmatterField": FrontmatterField };
+//#endregion
+export { FrontmatterField };

package/bundled-test-harness/assets/garbage-collection-test-BTOLAfB6.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 { Ar as testRealmURL } from "./runtime-common-ClpqhbwG.js";
+import { V as localId } from "./constants-CqKWhRfY.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-eg5fHk_x.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { O as saveCard, lt as setupRenderingTest } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, H as linksTo, U as linksToMany, a as CardDef, d as FileDef, w as contains } from "./card-api-Dzje0smT.js";
+import "./file-api-DPMJghBY.js";
+import { t as string_default } from "./string-BHZZwNlZ.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);
+		}
+		loader.shimModule(`${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

package/bundled-test-harness/assets/gauge-C1loqGq3.js

@@ -0,0 +1,2 @@
+import { n as GaugeEmbedded, t as GaugeAtom } from "./gauge-u8dxl90d.js";
+export { GaugeAtom, GaugeEmbedded };