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

package/bundled-test-harness/assets/get-relationship-membership-state-test-DJAuhOVM.js

@@ -0,0 +1,1308 @@
+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, b as PermissionsContextName } from "./constants-CqKWhRfY.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 require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, M as setupCardLogs, O as saveCard, lt as setupRenderingTest, nt as provide, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { d as getRelationshipMembershipState, o as getBrokenLinks, s as getDataBucket } from "./field-support-DdQ7XgyM.js";
+import { A as field, H as linksTo, U as linksToMany, a as CardDef, l as FieldDef, w as contains } from "./card-api-Dzje0smT.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+//#region tests/integration/components/get-relationship-membership-state-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+function errorDoc(message, status = 500) {
+	return {
+		status,
+		message,
+		additionalErrors: null
+	};
+}
+function singleMember(assert, rel) {
+	let membership = rel.membership;
+	assert.strictEqual(membership?.length, 1, "singular linksTo returns a one-element membership");
+	if (!membership || membership.length !== 1) throw new Error("expected a one-element membership");
+	return membership[0];
+}
+function members(rel) {
+	return rel.membership ?? [];
+}
+function assertKind(assert, state, kind) {
+	assert.strictEqual(state.kind, kind, `expected kind '${kind}'`);
+	if (state.kind !== kind) throw new Error(`expected kind ${kind} but got ${state.kind}`);
+}
+(0, import_qunit.module)("Integration | getRelationshipMembershipState", function(hooks) {
+	let loader;
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(async function() {
+		provide(PermissionsContextName, {
+			canWrite: true,
+			canRead: true
+		});
+		loader = getService("loader-service").loader;
+	});
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	(0, import_qunit.module)("singular linksTo", function() {
+		(0, import_qunit.test)("returns kind 'present' for a loaded linked card", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let pet = new Pet({ firstName: "Mango" });
+			await saveCard(pet, `${testRealmURL}Pet/mango`, loader);
+			let state = singleMember(assert, getRelationshipMembershipState(new Person({
+				firstName: "Hassan",
+				pet
+			}), "pet"));
+			assertKind(assert, state, "present");
+			assert.strictEqual(state.value, pet);
+			assert.strictEqual(state.reference, `${testRealmURL}Pet/mango`);
+		});
+		(0, import_qunit.test)("returns kind 'present' with the local id as reference when the linked card is unsaved", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let unsavedPet = new Pet({ firstName: "Mango" });
+			let state = singleMember(assert, getRelationshipMembershipState(new Person({
+				firstName: "Hassan",
+				pet: unsavedPet
+			}), "pet"));
+			assertKind(assert, state, "present");
+			assert.strictEqual(state.value, unsavedPet);
+			assert.strictEqual(state.reference, unsavedPet[localId], "unsaved linked card uses its local id as the reference");
+			assert.strictEqual(typeof state.reference, "string", "reference is always a string for present");
+		});
+		(0, import_qunit.test)("returns kind 'not-set' when the field has never been assigned", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let state = singleMember(assert, getRelationshipMembershipState(new Person({ firstName: "Hassan" }), "pet"));
+			assertKind(assert, state, "not-set");
+			assert.strictEqual(state.value, void 0);
+			assert.strictEqual(state.reference, void 0);
+		});
+		(0, import_qunit.test)("returns kind 'not-loaded' when the data bucket holds a not-loaded sentinel", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let sentinel = {
+				type: "not-loaded",
+				reference: `${testRealmURL}Pet/mango`
+			};
+			getDataBucket(person).set("pet", sentinel);
+			let state = singleMember(assert, getRelationshipMembershipState(person, "pet"));
+			assertKind(assert, state, "not-loaded");
+			assert.strictEqual(state.value, void 0);
+			assert.strictEqual(state.reference, `${testRealmURL}Pet/mango`);
+		});
+		(0, import_qunit.test)("returns kind 'error' when the data bucket holds a link-error sentinel", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let doc = errorDoc("upstream pet exploded");
+			let sentinel = {
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: doc
+			};
+			getDataBucket(person).set("pet", sentinel);
+			let state = singleMember(assert, getRelationshipMembershipState(person, "pet"));
+			assertKind(assert, state, "error");
+			assert.strictEqual(state.value, void 0);
+			assert.strictEqual(state.reference, `${testRealmURL}Pet/exploded`);
+			assert.strictEqual(state.errorDoc, doc);
+		});
+		(0, import_qunit.test)("returns kind 'not-found' when the data bucket holds a link-not-found sentinel", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let doc = errorDoc("not found", 404);
+			let sentinel = {
+				type: "link-not-found",
+				reference: `${testRealmURL}Pet/missing`,
+				errorDoc: doc
+			};
+			getDataBucket(person).set("pet", sentinel);
+			let state = singleMember(assert, getRelationshipMembershipState(person, "pet"));
+			assertKind(assert, state, "not-found");
+			assert.strictEqual(state.value, void 0);
+			assert.strictEqual(state.reference, `${testRealmURL}Pet/missing`);
+			assert.strictEqual(state.errorDoc, doc);
+		});
+	});
+	(0, import_qunit.module)("plural linksToMany", function() {
+		(0, import_qunit.test)("returns an array with one state per element across all five kinds", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let mango = new Pet({ firstName: "Mango" });
+			await saveCard(mango, `${testRealmURL}Pet/mango`, loader);
+			let person = new Person({
+				firstName: "Hassan",
+				pets: [mango]
+			});
+			let errDoc = errorDoc("boom");
+			let notFoundDoc = errorDoc("missing", 404);
+			let pets = getDataBucket(person).get("pets");
+			assert.ok(Array.isArray(pets), "pets bucket entry is an array");
+			pets.push({
+				type: "not-loaded",
+				reference: `${testRealmURL}Pet/vangogh`
+			});
+			pets.push({
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: errDoc
+			});
+			pets.push({
+				type: "link-not-found",
+				reference: `${testRealmURL}Pet/missing`,
+				errorDoc: notFoundDoc
+			});
+			let states = members(getRelationshipMembershipState(person, "pets"));
+			assert.strictEqual(states.length, 4);
+			let [s0, s1, s2, s3] = states;
+			assertKind(assert, s0, "present");
+			assert.strictEqual(s0.value, mango);
+			assert.strictEqual(s0.reference, `${testRealmURL}Pet/mango`);
+			assertKind(assert, s1, "not-loaded");
+			assert.strictEqual(s1.reference, `${testRealmURL}Pet/vangogh`);
+			assertKind(assert, s2, "error");
+			assert.strictEqual(s2.reference, `${testRealmURL}Pet/exploded`);
+			assert.strictEqual(s2.errorDoc, errDoc);
+			assertKind(assert, s3, "not-found");
+			assert.strictEqual(s3.reference, `${testRealmURL}Pet/missing`);
+			assert.strictEqual(s3.errorDoc, notFoundDoc);
+		});
+		(0, import_qunit.test)("returns an empty array for a never-set linksToMany ('not-set' equivalent for plural)", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let states = members(getRelationshipMembershipState(new Person({ firstName: "Hassan" }), "pets"));
+			assert.strictEqual(states.length, 0);
+		});
+		(0, import_qunit.test)("whole-field sentinel (computed linksToMany unresolved upstream) surfaces as a one-element array", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let sentinel = {
+				type: "not-loaded",
+				reference: `${testRealmURL}upstream/computed-source`
+			};
+			getDataBucket(person).set("pets", sentinel);
+			let states = members(getRelationshipMembershipState(person, "pets"));
+			assert.strictEqual(states.length, 1);
+			assertKind(assert, states[0], "not-loaded");
+			assert.strictEqual(states[0].reference, `${testRealmURL}upstream/computed-source`);
+		});
+	});
+	(0, import_qunit.module)("computed relationships", function() {
+		(0, import_qunit.test)("computed linksTo: present member, never loading", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "petAlias", [field], function() {
+						return linksTo(Pet, { computeVia: function() {
+							return this.pet;
+						} });
+					});
+				}
+				#petAlias = (initializeDeferredDecorator(this, "petAlias"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let pet = new Pet({ firstName: "Mango" });
+			await saveCard(pet, `${testRealmURL}Pet/mango`, loader);
+			let rel = getRelationshipMembershipState(new Person({
+				firstName: "Hassan",
+				pet
+			}), "petAlias");
+			assert.false(rel.isLoading, "a computed linksTo never reports loading");
+			let state = singleMember(assert, rel);
+			assertKind(assert, state, "present");
+			assert.strictEqual(state.value, pet);
+			assert.strictEqual(state.reference, `${testRealmURL}Pet/mango`);
+		});
+		(0, import_qunit.test)("computed linksToMany: every member present, never loading", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "petsAlias", [field], function() {
+						return linksToMany(Pet, { computeVia: function() {
+							return this.pets;
+						} });
+					});
+				}
+				#petsAlias = (initializeDeferredDecorator(this, "petsAlias"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let mango = new Pet({ firstName: "Mango" });
+			let vangogh = new Pet({ firstName: "Van Gogh" });
+			await saveCard(mango, `${testRealmURL}Pet/mango`, loader);
+			await saveCard(vangogh, `${testRealmURL}Pet/vangogh`, loader);
+			let rel = getRelationshipMembershipState(new Person({
+				firstName: "Hassan",
+				pets: [mango, vangogh]
+			}), "petsAlias");
+			assert.false(rel.isLoading, "a computed linksToMany never reports loading");
+			let states = members(rel);
+			assert.deepEqual(states.map((s) => s.kind), ["present", "present"], "every computed element is present");
+			assert.deepEqual(states.map((s) => s.value), [mango, vangogh], "computed elements carry the running instances");
+		});
+		(0, import_qunit.test)("computed linksTo resolving to nothing is not-set, still not loading", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "maybePet", [field], function() {
+						return linksTo(Pet, { computeVia: function() {} });
+					});
+				}
+				#maybePet = (initializeDeferredDecorator(this, "maybePet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let rel = getRelationshipMembershipState(new Person({ firstName: "Hassan" }), "maybePet");
+			assert.false(rel.isLoading);
+			assertKind(assert, singleMember(assert, rel), "not-set");
+		});
+	});
+	(0, import_qunit.module)("getBrokenLinks", function() {
+		(0, import_qunit.test)("returns no findings when every declared link is present or unset", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let mango = new Pet({ firstName: "Mango" });
+			await saveCard(mango, `${testRealmURL}Pet/mango`, loader);
+			let person = new Person({
+				firstName: "Hassan",
+				pet: mango,
+				pets: [mango]
+			});
+			assert.deepEqual(getBrokenLinks(person), [], "a present singular link, a present plural link, and unset links yield nothing");
+		});
+		(0, import_qunit.test)("finds a singular linksTo in error state", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let doc = errorDoc("upstream exploded");
+			getDataBucket(person).set("pet", {
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: doc
+			});
+			let findings = getBrokenLinks(person);
+			assert.strictEqual(findings.length, 1, "one finding");
+			assert.strictEqual(findings[0].fieldName, "pet");
+			assert.strictEqual(findings[0].kind, "error");
+			assert.strictEqual(findings[0].reference, `${testRealmURL}Pet/exploded`);
+			assert.strictEqual(findings[0].errorDoc, doc);
+		});
+		(0, import_qunit.test)("finds a singular linksTo in not-found state", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let doc = errorDoc("missing", 404);
+			getDataBucket(person).set("pet", {
+				type: "link-not-found",
+				reference: `${testRealmURL}Pet/missing`,
+				errorDoc: doc
+			});
+			let findings = getBrokenLinks(person);
+			assert.strictEqual(findings.length, 1);
+			assert.strictEqual(findings[0].fieldName, "pet");
+			assert.strictEqual(findings[0].kind, "not-found");
+			assert.strictEqual(findings[0].reference, `${testRealmURL}Pet/missing`);
+			assert.strictEqual(findings[0].errorDoc, doc);
+		});
+		(0, import_qunit.test)("ignores a not-loaded (in-flight) link", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			getDataBucket(person).set("pet", {
+				type: "not-loaded",
+				reference: `${testRealmURL}Pet/loading`
+			});
+			assert.deepEqual(getBrokenLinks(person), [], "a not-loaded slot is an in-flight fetch, not a terminal failure");
+		});
+		(0, import_qunit.test)("plural: reports only the broken slots, one finding per slot, under the field name", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let mango = new Pet({ firstName: "Mango" });
+			await saveCard(mango, `${testRealmURL}Pet/mango`, loader);
+			let person = new Person({
+				firstName: "Hassan",
+				pets: [mango]
+			});
+			let errDoc = errorDoc("boom");
+			let notFoundDoc = errorDoc("missing", 404);
+			let pets = getDataBucket(person).get("pets");
+			pets.push({
+				type: "not-loaded",
+				reference: `${testRealmURL}Pet/vangogh`
+			});
+			pets.push({
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: errDoc
+			});
+			pets.push({
+				type: "link-not-found",
+				reference: `${testRealmURL}Pet/missing`,
+				errorDoc: notFoundDoc
+			});
+			let findings = getBrokenLinks(person);
+			assert.strictEqual(findings.length, 2, "only the error and not-found slots are reported (present + not-loaded skipped)");
+			assert.deepEqual(findings.map((f) => f.fieldName), ["pets", "pets"], "each finding carries the plural field name");
+			assert.deepEqual(findings.map((f) => f.kind).sort(), ["error", "not-found"]);
+			let errorFinding = findings.find((f) => f.kind === "error");
+			assert.strictEqual(errorFinding?.reference, `${testRealmURL}Pet/exploded`);
+			assert.strictEqual(errorFinding?.errorDoc, errDoc);
+		});
+		(0, import_qunit.test)("reports every broken declared field across a card", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			getDataBucket(person).set("pet", {
+				type: "link-not-found",
+				reference: `${testRealmURL}Pet/missing`,
+				errorDoc: errorDoc("missing", 404)
+			});
+			getDataBucket(person).set("pets", [{
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: errorDoc("boom")
+			}]);
+			let findings = getBrokenLinks(person);
+			assert.deepEqual(findings.map((f) => f.fieldName).sort(), ["pet", "pets"], "both the broken singular and plural fields are reported");
+		});
+		(0, import_qunit.test)("skips computed relationship fields", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "petAlias", [field], function() {
+						return linksTo(Pet, { computeVia: function() {
+							return this.pet;
+						} });
+					});
+				}
+				#petAlias = (initializeDeferredDecorator(this, "petAlias"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			getDataBucket(person).set("pet", {
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: errorDoc("upstream exploded")
+			});
+			let findings = getBrokenLinks(person);
+			assert.deepEqual(findings.map((f) => f.fieldName), ["pet"], "only the declared field is reported, not the computed alias");
+		});
+		(0, import_qunit.test)("recurses into a contained FieldDef and finds its broken linksTo", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "name", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#name = (initializeDeferredDecorator(this, "name"), void 0);
+			}
+			class Detail extends FieldDef {
+				static {
+					decorateFieldV2(this.prototype, "label", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#label = (initializeDeferredDecorator(this, "label"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "detail", [field], function() {
+						return contains(Detail);
+					});
+				}
+				#detail = (initializeDeferredDecorator(this, "detail"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet,
+				Detail
+			});
+			let person = new Person({
+				firstName: "Hassan",
+				detail: new Detail({ label: "x" })
+			});
+			let doc = errorDoc("upstream exploded");
+			getDataBucket(person.detail).set("pet", {
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: doc
+			});
+			let findings = getBrokenLinks(person);
+			assert.strictEqual(findings.length, 1, "the contained broken link is found");
+			assert.strictEqual(findings[0].fieldName, "pet");
+			assert.strictEqual(findings[0].kind, "error");
+			assert.strictEqual(findings[0].reference, `${testRealmURL}Pet/exploded`);
+			assert.strictEqual(findings[0].errorDoc, doc);
+		});
+		(0, import_qunit.test)("recurses into a present linked card and finds its broken linksTo", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "name", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#name = (initializeDeferredDecorator(this, "name"), void 0);
+			}
+			class Child extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "name", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#name = (initializeDeferredDecorator(this, "name"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			class Parent extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "name", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#name = (initializeDeferredDecorator(this, "name"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "child", [field], function() {
+						return linksTo(Child);
+					});
+				}
+				#child = (initializeDeferredDecorator(this, "child"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Parent,
+				Child,
+				Pet
+			});
+			let child = new Child({ name: "Child" });
+			await saveCard(child, `${testRealmURL}Child/c`, loader);
+			let parent = new Parent({
+				name: "Parent",
+				child
+			});
+			let doc = errorDoc("missing", 404);
+			getDataBucket(child).set("pet", {
+				type: "link-not-found",
+				reference: `${testRealmURL}Pet/missing`,
+				errorDoc: doc
+			});
+			let findings = getBrokenLinks(parent);
+			assert.strictEqual(findings.length, 1, "the present linked child's broken link is found");
+			assert.strictEqual(findings[0].fieldName, "pet");
+			assert.strictEqual(findings[0].kind, "not-found");
+			assert.strictEqual(findings[0].reference, `${testRealmURL}Pet/missing`);
+		});
+		(0, import_qunit.test)("cycle protection: a present self-link does not loop", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "name", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#name = (initializeDeferredDecorator(this, "name"), void 0);
+			}
+			class Node extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "name", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#name = (initializeDeferredDecorator(this, "name"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "self", [field], function() {
+						return linksTo(() => Node);
+					});
+				}
+				#self = (initializeDeferredDecorator(this, "self"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Node,
+				Pet
+			});
+			let node = new Node({ name: "Node" });
+			await saveCard(node, `${testRealmURL}Node/n`, loader);
+			getDataBucket(node).set("self", node);
+			getDataBucket(node).set("pet", {
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: errorDoc("boom")
+			});
+			let findings = getBrokenLinks(node);
+			assert.strictEqual(findings.length, 1, "the broken link is found exactly once; the self-cycle terminates");
+			assert.strictEqual(findings[0].fieldName, "pet");
+		});
+		(0, import_qunit.test)("is a pure read: does not initialize absent fields in the data bucket", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "name", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#name = (initializeDeferredDecorator(this, "name"), void 0);
+			}
+			class Detail extends FieldDef {
+				static {
+					decorateFieldV2(this.prototype, "label", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#label = (initializeDeferredDecorator(this, "label"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "bestFriend", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#bestFriend = (initializeDeferredDecorator(this, "bestFriend"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "detail", [field], function() {
+						return contains(Detail);
+					});
+				}
+				#detail = (initializeDeferredDecorator(this, "detail"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet,
+				Detail
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let bucket = getDataBucket(person);
+			let bestFriend = {
+				type: "link-error",
+				reference: `${testRealmURL}Pet/exploded`,
+				errorDoc: errorDoc("boom")
+			};
+			bucket.set("bestFriend", bestFriend);
+			let keysBefore = [...bucket.keys()].sort();
+			let findings = getBrokenLinks(person);
+			assert.strictEqual(findings.length, 1, "finds the one broken link");
+			assert.strictEqual(findings[0].fieldName, "bestFriend");
+			assert.deepEqual([...bucket.keys()].sort(), keysBefore, "no new bucket entries: absent fields stay absent after the scan");
+			assert.false(bucket.has("pet"), "unset singular linksTo not initialized");
+			assert.false(bucket.has("pets"), "unset linksToMany not initialized");
+			assert.false(bucket.has("detail"), "unset contains not initialized");
+			assert.strictEqual(bucket.get("bestFriend"), bestFriend, "present sentinel entry is the same object after the scan");
+		});
+	});
+	(0, import_qunit.module)("purity guarantees", function() {
+		(0, import_qunit.test)("does not trigger lazilyLoadLink: the not-loaded sentinel survives the read intact", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			let sentinel = {
+				type: "not-loaded",
+				reference: `${testRealmURL}Pet/never-fetched`
+			};
+			getDataBucket(person).set("pet", sentinel);
+			getRelationshipMembershipState(person, "pet");
+			getRelationshipMembershipState(person, "pet");
+			getRelationshipMembershipState(person, "pet");
+			assert.strictEqual(getDataBucket(person).get("pet"), sentinel, "bucket entry is the same sentinel object after three reads");
+			assert.notOk(sentinel.loading, "sentinel has no `.loading` flag — lazy loader was not invoked");
+		});
+		(0, import_qunit.test)("does not trigger lazilyLoadLink for linksToMany either", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let person = new Person({ firstName: "Hassan" });
+			getRelationshipMembershipState(person, "pets");
+			let pets = getDataBucket(person).get("pets");
+			let sentinelA = {
+				type: "not-loaded",
+				reference: `${testRealmURL}Pet/a`
+			};
+			let sentinelB = {
+				type: "not-loaded",
+				reference: `${testRealmURL}Pet/b`
+			};
+			pets.push(sentinelA, sentinelB);
+			getRelationshipMembershipState(person, "pets");
+			getRelationshipMembershipState(person, "pets");
+			assert.notOk(sentinelA.loading, "sentinelA has no `.loading` flag");
+			assert.notOk(sentinelB.loading, "sentinelB has no `.loading` flag");
+		});
+		(0, import_qunit.test)("repeated reads inside a render cause exactly one render — pure read, no extra invalidations", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pet", [field], function() {
+						return linksTo(Pet);
+					});
+				}
+				#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let renderCount = 0;
+			let bump = () => {
+				renderCount++;
+				return "";
+			};
+			let stateKind = (s) => (s.membership ?? []).map((x) => x.kind).join(",");
+			let person = new Person({ firstName: "Hassan" });
+			await render(setComponentTemplate(templateFactory({
+				"id": "lBIRqyCp",
+				"block": "[[[10,1],[12],[1,[32,0]],[13],[1,\"\\n\"],[10,1],[14,\"data-test-a\",\"\"],[12],[1,[28,[32,1],[[28,[32,2],[[32,3],\"pet\"],null]],null]],[13],[1,\"\\n\"],[10,1],[14,\"data-test-b\",\"\"],[12],[1,[28,[32,1],[[28,[32,2],[[32,3],\"pet\"],null]],null]],[13],[1,\"\\n\"],[10,1],[14,\"data-test-c\",\"\"],[12],[1,[28,[32,1],[[28,[32,2],[[32,3],\"pet\"],null]],null]],[13]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/get-relationship-membership-state-test.gts",
+				"scope": () => [
+					bump,
+					stateKind,
+					getRelationshipMembershipState,
+					person
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			assert.dom("[data-test-a]").hasText("not-set", "first read returns not-set");
+			assert.dom("[data-test-b]").hasText("not-set", "second read returns not-set");
+			assert.dom("[data-test-c]").hasText("not-set", "third read returns not-set");
+			assert.strictEqual(renderCount, 1, "three getRelationshipMembershipState reads in one render frame did not schedule re-renders");
+		});
+		(0, import_qunit.test)("stability anchors: value and reference are stable across calls even though the envelope is fresh", async function(assert) {
+			class Pet extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+				static {
+					decorateFieldV2(this.prototype, "pets", [field], function() {
+						return linksToMany(Pet);
+					});
+				}
+				#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, {
+				Person,
+				Pet
+			});
+			let mango = new Pet({ firstName: "Mango" });
+			let vangogh = new Pet({ firstName: "Van Gogh" });
+			await saveCard(mango, `${testRealmURL}Pet/mango`, loader);
+			await saveCard(vangogh, `${testRealmURL}Pet/vangogh`, loader);
+			let person = new Person({
+				firstName: "Hassan",
+				pets: [mango, vangogh]
+			});
+			let first = members(getRelationshipMembershipState(person, "pets"));
+			let second = members(getRelationshipMembershipState(person, "pets"));
+			assert.notStrictEqual(first, second, "the returned array is a fresh object each call");
+			assert.notStrictEqual(first[0], second[0], "each envelope is a fresh object each call");
+			assert.strictEqual(first[0].value, second[0].value, "value (card instance) is identical across calls");
+			assert.strictEqual(first[0].value, mango, "value is the original card instance");
+			assert.strictEqual(first[0].reference, second[0].reference, "reference string is stable across calls");
+			assert.strictEqual(first[1].value, vangogh);
+		});
+	});
+	(0, import_qunit.module)("error cases", function() {
+		(0, import_qunit.test)("throws when the field does not exist", async function(assert) {
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, { Person });
+			let person = new Person({ firstName: "Hassan" });
+			assert.throws(() => getRelationshipMembershipState(person, "pet"), /does not have a field 'pet'/);
+		});
+		(0, import_qunit.test)("throws when the field is not a linksTo / linksToMany", async function(assert) {
+			class Person extends CardDef {
+				static {
+					decorateFieldV2(this.prototype, "firstName", [field], function() {
+						return contains(string_default);
+					});
+				}
+				#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			}
+			loader.shimModule(`${testRealmURL}test-cards`, { Person });
+			let person = new Person({ firstName: "Hassan" });
+			assert.throws(() => getRelationshipMembershipState(person, "firstName"), /requires a 'linksTo' or 'linksToMany' field/);
+		});
+	});
+});
+//#endregion