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

package/bundled-test-harness/assets/linksto-many-broken-link-placeholder-test-mt-RrRta.js

@@ -0,0 +1,303 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { Yn as testRRI, Zn as testRealmURL, ci as PermissionsContextName, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { $n as setComponentTemplate } from "./service-DJ87xpDt.js";
+import { V as templateFactory } from "./index-DaCZcoCY-D2gI_aMw.js";
+import { i as templateOnly } from "./dist-CXaz7pMY.js";
+import "./template-D3TMIrc1.js";
+import "./template-factory-DMEv2kVd.js";
+import { I as waitUntil, d as click, o as waitFor, s as fillIn, x as render } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, O as setupCardLogs, X as provide, j as setupLocalIndexing, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-BhFWlMMr.js";
+import { G as contains, I as StringField, Q as field, a as CardDef, d as Component, mt as setupBaseRealm, tt as getDataBucket, ut as linksToMany } from "./base-realm-DpSTsZxD.js";
+import { t as renderCard } from "./render-component-Bs21y6iv.js";
+//#region tests/integration/components/linksto-many-broken-link-placeholder-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var GHOST_URL = `${testRealmURL}Pet/ghost`;
+var MANGO_URL = `${testRealmURL}Pet/mango`;
+var VANGOGH_URL = `${testRealmURL}Pet/vangogh`;
+var EXPLODED_URL = `${testRealmURL}Pet/exploded`;
+function makeCards() {
+	class Pet extends CardDef {
+		static displayName = "Pet";
+		static {
+			decorateFieldV2(this.prototype, "firstName", [field], function() {
+				return contains(StringField);
+			});
+		}
+		#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		static fitted = class extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "v0XJ5rjm",
+					"block": "[[[41,[30,1],[[[10,1],[14,\"data-test-pet\",\"\"],[12],[1,[30,1,[\"firstName\"]]],[13]],[]],null]],[\"@model\"],[\"if\"]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/linksto-many-broken-link-placeholder-test.gts",
+					"isStrictMode": true
+				}), this);
+			}
+		};
+		static atom = class extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "v0XJ5rjm",
+					"block": "[[[41,[30,1],[[[10,1],[14,\"data-test-pet\",\"\"],[12],[1,[30,1,[\"firstName\"]]],[13]],[]],null]],[\"@model\"],[\"if\"]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/linksto-many-broken-link-placeholder-test.gts",
+					"isStrictMode": true
+				}), this);
+			}
+		};
+	}
+	class Person extends CardDef {
+		static displayName = "Person";
+		static {
+			decorateFieldV2(this.prototype, "firstName", [field], function() {
+				return contains(StringField);
+			});
+		}
+		#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		static {
+			decorateFieldV2(this.prototype, "pets", [field], function() {
+				return linksToMany(Pet);
+			});
+		}
+		#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+		static isolated = class extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "Ekaeitws",
+					"block": "[[[8,[30,1,[\"pets\"]],null,[[\"@format\"],[\"fitted\"]],null]],[\"@fields\"],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/linksto-many-broken-link-placeholder-test.gts",
+					"isStrictMode": true
+				}), this);
+			}
+		};
+		static edit = class extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "zwfOdKDf",
+					"block": "[[[10,\"section\"],[14,\"data-test-name-field\",\"\"],[12],[8,[30,1,[\"firstName\"]],null,null,null],[13],[1,\"\\n\"],[8,[30,1,[\"pets\"]],null,null,null]],[\"@fields\"],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/linksto-many-broken-link-placeholder-test.gts",
+					"isStrictMode": true
+				}), this);
+			}
+		};
+	}
+	return {
+		Person,
+		Pet
+	};
+}
+async function createPerson(relationships) {
+	let store = getService("store");
+	let resource = {
+		attributes: { firstName: "Hassan" },
+		relationships,
+		meta: { adoptsFrom: {
+			module: testRRI("test-cards"),
+			name: "Person"
+		} }
+	};
+	return await store.__dangerousCreateFromSerialized(resource, { data: resource }, new URL(testRealmURL));
+}
+var loader;
+(0, import_qunit.module)("Integration | linksToMany broken-link placeholder (per element)", function(hooks) {
+	setupRenderingTest(hooks);
+	setupBaseRealm(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(function() {
+		provide(PermissionsContextName, {
+			canWrite: true,
+			canRead: true
+		});
+		loader = getService("loader-service").loader;
+	});
+	setupCardLogs(hooks, async () => await loader.import(`${baseRealm.url}card-api`));
+	async function setupRealm() {
+		let { Person, Pet } = makeCards();
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"test-cards.gts": {
+					Person,
+					Pet
+				},
+				"Pet/mango.json": { data: {
+					attributes: { firstName: "Mango" },
+					meta: { adoptsFrom: {
+						module: testRRI("test-cards"),
+						name: "Pet"
+					} }
+				} },
+				"Pet/vangogh.json": { data: {
+					attributes: { firstName: "Van Gogh" },
+					meta: { adoptsFrom: {
+						module: testRRI("test-cards"),
+						name: "Pet"
+					} }
+				} }
+			}
+		});
+	}
+	(0, import_qunit.test)("a mixed list renders each element correctly — present cards plus a per-element placeholder for the broken slot", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({
+			"pets.0": { links: { self: MANGO_URL } },
+			"pets.1": { links: { self: GHOST_URL } },
+			"pets.2": { links: { self: VANGOGH_URL } }
+		});
+		await renderCard(loader, person, "isolated");
+		await waitFor("[data-test-broken-link-template]");
+		await waitFor("[data-test-plural-view-item=\"0\"] [data-test-pet]");
+		await waitFor("[data-test-plural-view-item=\"2\"] [data-test-pet]");
+		assert.dom("[data-test-plural-view-item=\"0\"] [data-test-pet]").hasText("Mango", "the first (present) element renders its card");
+		assert.dom("[data-test-plural-view-item=\"2\"] [data-test-pet]").hasText("Van Gogh", "the sibling after the broken slot still renders");
+		assert.dom(".linksToMany-itemContainer").exists({ count: 3 });
+		assert.dom("[data-test-pet]").exists({ count: 2 });
+		assert.dom("[data-test-broken-link-template]").exists({ count: 1 });
+		assert.dom("[data-test-broken-link-state]").hasAttribute("data-test-broken-link-state", "not-found");
+		assert.dom("[data-test-broken-link-url]").hasText(GHOST_URL);
+		assert.dom("[data-test-plural-view-item=\"0\"] [data-test-broken-link-template]").doesNotExist("the first (present) slot is not the broken one");
+		assert.dom("[data-test-plural-view-item=\"2\"] [data-test-broken-link-template]").doesNotExist("the last (present) slot is not the broken one");
+	});
+	(0, import_qunit.test)("a link-error sentinel element renders the error placeholder with its message", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({ "pets.0": { links: { self: MANGO_URL } } });
+		person.pets;
+		await waitUntil(() => {
+			let arr = getDataBucket(person).get("pets");
+			return Array.isArray(arr) && arr.length === 1 && arr[0]?.firstName;
+		});
+		getDataBucket(person).get("pets").push({
+			type: "link-error",
+			reference: EXPLODED_URL,
+			errorDoc: {
+				status: 500,
+				title: "Internal Server Error",
+				message: "upstream exploded",
+				additionalErrors: null
+			}
+		});
+		await renderCard(loader, person, "isolated");
+		await waitFor("[data-test-broken-link-template]");
+		await waitFor("[data-test-plural-view-item=\"0\"] [data-test-pet]");
+		assert.dom("[data-test-plural-view-item=\"0\"] [data-test-pet]").hasText("Mango", "the present element still renders its card");
+		assert.dom("[data-test-broken-link-template]").exists({ count: 1 });
+		assert.dom("[data-test-broken-link-template]").hasAttribute("data-test-broken-link-template", "fitted");
+		assert.dom("[data-test-broken-link-state]").hasAttribute("data-test-broken-link-state", "error");
+		assert.dom("[data-test-broken-link-url]").hasText(EXPLODED_URL);
+		assert.dom("[data-test-plural-view-item=\"0\"] [data-test-broken-link-template]").doesNotExist("the present slot is not the broken one");
+	});
+	(0, import_qunit.test)("a list of only present links renders no placeholder", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({
+			"pets.0": { links: { self: MANGO_URL } },
+			"pets.1": { links: { self: VANGOGH_URL } }
+		});
+		await renderCard(loader, person, "isolated");
+		await waitFor("[data-test-plural-view-item=\"1\"] [data-test-pet]");
+		assert.dom("[data-test-broken-link-template]").doesNotExist("no placeholder for a healthy list");
+		assert.dom("[data-test-pet]").exists({ count: 2 });
+	});
+	(0, import_qunit.test)("the placeholder occupies the same per-element item container as a card", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({ "pets.0": { links: { self: GHOST_URL } } });
+		await renderCard(loader, person, "isolated");
+		await waitFor("[data-test-broken-link-template]");
+		assert.dom(".linksToMany-itemContainer [data-test-broken-link-template]").exists("the placeholder renders inside the item container");
+		assert.dom("[data-test-broken-link-template]").hasAttribute("data-test-broken-link-template", "fitted", "the placeholder adopts the fitted footprint of the list item");
+	});
+	(0, import_qunit.test)("a list with one broken element converges in at most two renders", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({ "pets.0": { links: { self: GHOST_URL } } });
+		let PersonComponent = (await loader.import(`${baseRealm.url}card-api`)).getComponent(person);
+		let renderCount = 0;
+		let bump = () => {
+			renderCount++;
+			person.pets;
+			return "";
+		};
+		await render(setComponentTemplate(templateFactory({
+			"id": "Rb2xs8Oe",
+			"block": "[[[10,1],[12],[1,[32,0]],[13],[1,\"\\n\"],[8,[32,1],null,[[\"@format\"],[\"isolated\"]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/linksto-many-broken-link-placeholder-test.gts",
+			"scope": () => [bump, PersonComponent],
+			"isStrictMode": true
+		}), templateOnly()));
+		await waitFor("[data-test-broken-link-template]");
+		assert.ok(renderCount <= 2, `a list with a permanently-broken element converged in ${renderCount} render(s) (initial + post-lazy-load)`);
+	});
+	(0, import_qunit.test)("in edit format a broken element shows the placeholder and can be removed", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({
+			"pets.0": { links: { self: MANGO_URL } },
+			"pets.1": { links: { self: GHOST_URL } }
+		});
+		await renderCard(loader, person, "edit");
+		await waitFor("[data-test-broken-link-template]");
+		await waitFor("[data-test-pet]");
+		assert.dom("[data-test-broken-link-template]").exists({ count: 1 }, "the broken element shows the placeholder");
+		assert.dom("[data-test-broken-link-url]").hasText(GHOST_URL, "editor placeholder shows the broken URL");
+		assert.dom("[data-test-pet]").exists({ count: 1 });
+		assert.dom("[data-test-add-new]").exists();
+		await click("[data-test-remove=\"1\"]");
+		await waitUntil(() => !document.querySelector("[data-test-broken-link-template]") && document.querySelectorAll("[data-test-pet]").length === 1);
+		assert.dom("[data-test-broken-link-template]").doesNotExist("removing clears the broken reference");
+		assert.dom("[data-test-pet]").exists({ count: 1 }, "the healthy sibling is untouched by the removal");
+	});
+	(0, import_qunit.test)("editing a sibling field while a broken element is present does not tear down the present element", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({
+			"pets.0": { links: { self: MANGO_URL } },
+			"pets.1": { links: { self: GHOST_URL } }
+		});
+		await renderCard(loader, person, "edit");
+		await waitFor("[data-test-broken-link-template]");
+		await waitFor("[data-test-item=\"0\"] [data-test-pet]");
+		let presentNodeBefore = document.querySelector("[data-test-item=\"0\"] [data-test-pet]");
+		assert.dom(presentNodeBefore).hasText("Mango");
+		await fillIn("[data-test-name-field] input", "Hassan A.");
+		let presentNodeAfter = document.querySelector("[data-test-item=\"0\"] [data-test-pet]");
+		assert.strictEqual(presentNodeBefore, presentNodeAfter, "the present element keeps its DOM identity across an unrelated re-render — the list is stable");
+		assert.dom("[data-test-broken-link-template]").exists({ count: 1 }, "the broken placeholder is still in place");
+	});
+	(0, import_qunit.test)("removing a present sibling preserves a broken element in the list", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({
+			"pets.0": { links: { self: MANGO_URL } },
+			"pets.1": { links: { self: GHOST_URL } },
+			"pets.2": { links: { self: VANGOGH_URL } }
+		});
+		await renderCard(loader, person, "edit");
+		await waitFor("[data-test-broken-link-template]");
+		await waitFor("[data-test-item=\"0\"] [data-test-pet]");
+		await waitFor("[data-test-item=\"2\"] [data-test-pet]");
+		await click("[data-test-remove=\"0\"]");
+		await waitUntil(() => document.querySelectorAll("[data-test-pet]").length === 1);
+		assert.dom("[data-test-broken-link-template]").exists({ count: 1 }, "the broken element is preserved after removing a present sibling");
+		assert.dom("[data-test-broken-link-url]").hasText(GHOST_URL, "the broken reference is not lost on removal");
+		assert.dom("[data-test-pet]").exists({ count: 1 }, "the surviving present sibling still renders");
+		assert.dom("[data-test-pet]").hasText("Van Gogh");
+	});
+	(0, import_qunit.test)("typing into a sibling field while a broken element is present keeps input focus", async function(assert) {
+		await setupRealm();
+		let person = await createPerson({
+			"pets.0": { links: { self: MANGO_URL } },
+			"pets.1": { links: { self: GHOST_URL } }
+		});
+		await renderCard(loader, person, "edit");
+		await waitFor("[data-test-broken-link-template]");
+		await waitFor("[data-test-pet]");
+		let inputBefore = document.querySelector("[data-test-name-field] input");
+		await fillIn("[data-test-name-field] input", "Hassan A.");
+		assert.strictEqual(document.querySelector("[data-test-name-field] input"), inputBefore, "the firstName input keeps its DOM identity across the re-render");
+		assert.strictEqual(document.activeElement, inputBefore, "focus stays on the firstName input — the broken slot does not steal it");
+		assert.dom("[data-test-broken-link-template]").exists({ count: 1 }, "the broken placeholder is still in place");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/linksto-many-per-slot-access-test-CdGUXZsi.js

@@ -0,0 +1,301 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { Yn as testRRI, Zn as testRealmURL, ci as PermissionsContextName, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { I as waitUntil } from "./dist-D1U_uSwt.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { A as setupIntegrationTestRealm, O as setupCardLogs, T as saveCard, X as provide, j as setupLocalIndexing, rt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-BhFWlMMr.js";
+import { G as contains, I as StringField, Q as field, a as CardDef, at as getRelationshipMembershipState, b as FieldDef, mt as setupBaseRealm, tt as getDataBucket, ut as linksToMany } from "./base-realm-DpSTsZxD.js";
+//#region tests/integration/components/linksto-many-per-slot-access-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var MANGO_URL = `${testRealmURL}Pet/mango`;
+var VANGOGH_URL = `${testRealmURL}Pet/vangogh`;
+var GHOST_URL = `${testRealmURL}Pet/ghost`;
+var EXPLODED_URL = `${testRealmURL}Pet/exploded`;
+function errorDoc(message, status = 500) {
+	return {
+		status,
+		message,
+		additionalErrors: null
+	};
+}
+function notFoundSentinel(reference) {
+	return {
+		type: "link-not-found",
+		reference,
+		errorDoc: errorDoc(`missing file ${reference}`, 404)
+	};
+}
+function linkErrorSentinel(reference) {
+	return {
+		type: "link-error",
+		reference,
+		errorDoc: errorDoc("upstream exploded", 500)
+	};
+}
+(0, import_qunit.module)("Integration | linksToMany per-slot JS-access contract", function(hooks) {
+	let loader;
+	setupRenderingTest(hooks);
+	setupBaseRealm(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(function() {
+		provide(PermissionsContextName, {
+			canWrite: true,
+			canRead: true
+		});
+		loader = getService("loader-service").loader;
+	});
+	setupCardLogs(hooks, async () => await loader.import(`${baseRealm.url}card-api`));
+	async function makeMixedPerson(brokenSlot) {
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		}
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#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, MANGO_URL, loader);
+		await saveCard(vangogh, VANGOGH_URL, loader);
+		let person = new Person({ firstName: "Hassan" });
+		person.pets = [
+			mango,
+			brokenSlot,
+			vangogh
+		];
+		return {
+			person,
+			mango,
+			vangogh
+		};
+	}
+	(0, import_qunit.test)("present slots are the card, a not-found slot is undefined, length includes the broken slot", async function(assert) {
+		let { person, mango, vangogh } = await makeMixedPerson(notFoundSentinel(GHOST_URL));
+		let pets = person.pets;
+		assert.strictEqual(pets.length, 3, "length counts the broken slot");
+		assert.strictEqual(pets[0], mango, "present slot 0 is the card");
+		assert.strictEqual(pets[2], vangogh, "present slot 2 is the card");
+		assert.strictEqual(pets[1], void 0, "the not-found slot reads as undefined, never the sentinel");
+	});
+	(0, import_qunit.test)("a link-error slot is also undefined per-slot", async function(assert) {
+		let { person, mango, vangogh } = await makeMixedPerson(linkErrorSentinel(EXPLODED_URL));
+		let pets = person.pets;
+		assert.strictEqual(pets[0], mango);
+		assert.strictEqual(pets[2], vangogh);
+		assert.strictEqual(pets[1], void 0, "the error slot reads as undefined, never the sentinel");
+	});
+	(0, import_qunit.test)("repeated reads of a terminal slot return undefined consistently", async function(assert) {
+		let { person } = await makeMixedPerson(notFoundSentinel(GHOST_URL));
+		let pets = person.pets;
+		assert.strictEqual(pets[1], void 0, "first read");
+		assert.strictEqual(pets[1], void 0, "second read");
+		assert.strictEqual(pets[1], void 0, "third read");
+		let states = getRelationshipMembershipState(person, "pets").membership;
+		assert.strictEqual(states[1].kind, "not-found");
+		assert.strictEqual(states[1].reference, GHOST_URL);
+	});
+	(0, import_qunit.test)("iteration with a c == null guard skips the broken slot and keeps the siblings", async function(assert) {
+		let { person } = await makeMixedPerson(notFoundSentinel(GHOST_URL));
+		let pets = person.pets;
+		let names = [];
+		for (let c of pets) {
+			if (c == null) continue;
+			names.push(c.firstName);
+		}
+		assert.deepEqual(names, ["Mango", "Van Gogh"], "one broken element does not break iteration over its siblings");
+	});
+	(0, import_qunit.test)("map with optional chaining yields undefined for the broken slot; map without it throws", async function(assert) {
+		let { person } = await makeMixedPerson(notFoundSentinel(GHOST_URL));
+		let pets = person.pets;
+		assert.deepEqual(pets.map((c) => c?.firstName), [
+			"Mango",
+			void 0,
+			"Van Gogh"
+		], "optional chaining surfaces undefined for the broken slot");
+		assert.throws(() => pets.map((c) => c.firstName), /Cannot read properties of undefined/, "a non-optional read throws on the broken slot per ordinary JS semantics");
+	});
+	(0, import_qunit.test)("a broken slot nested in a contained FieldDef surfaces as undefined; siblings render", async function(assert) {
+		class Tag extends CardDef {
+			static displayName = "Tag";
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class TagSet extends FieldDef {
+			static displayName = "TagSet";
+			static {
+				decorateFieldV2(this.prototype, "items", [field], function() {
+					return linksToMany(Tag);
+				});
+			}
+			#items = (initializeDeferredDecorator(this, "items"), void 0);
+		}
+		class Post extends CardDef {
+			static displayName = "Post";
+			static {
+				decorateFieldV2(this.prototype, "tags", [field], function() {
+					return contains(TagSet);
+				});
+			}
+			#tags = (initializeDeferredDecorator(this, "tags"), void 0);
+		}
+		loader.shimModule(`${testRealmURL}nested-cards`, {
+			Post,
+			TagSet,
+			Tag
+		});
+		let red = new Tag({ name: "red" });
+		let blue = new Tag({ name: "blue" });
+		await saveCard(red, `${testRealmURL}Tag/red`, loader);
+		await saveCard(blue, `${testRealmURL}Tag/blue`, loader);
+		let post = new Post();
+		post.tags.items = [
+			red,
+			notFoundSentinel(GHOST_URL),
+			blue
+		];
+		let items = post.tags.items;
+		assert.strictEqual(items.length, 3, "length counts the broken slot");
+		assert.strictEqual(items[0], red, "present nested slot 0 is the card");
+		assert.strictEqual(items[2], blue, "present nested slot 2 is the card");
+		assert.strictEqual(items[1], void 0, "the broken nested slot surfaces as undefined in card.tags.items[i]");
+	});
+	(0, import_qunit.test)("a not-loaded slot reads undefined, drives the load, and stays undefined once it fails", async function(assert) {
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		}
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "pets", [field], function() {
+					return linksToMany(Pet);
+				});
+			}
+			#pets = (initializeDeferredDecorator(this, "pets"), void 0);
+		}
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {
+				"test-cards.gts": {
+					Person,
+					Pet
+				},
+				"Pet/mango.json": { data: {
+					attributes: { firstName: "Mango" },
+					meta: { adoptsFrom: {
+						module: testRRI("test-cards"),
+						name: "Pet"
+					} }
+				} }
+			}
+		});
+		let store = getService("store");
+		let resource = {
+			attributes: { firstName: "Hassan" },
+			relationships: {
+				"pets.0": { links: { self: MANGO_URL } },
+				"pets.1": { links: { self: GHOST_URL } }
+			},
+			meta: { adoptsFrom: {
+				module: testRRI("test-cards"),
+				name: "Person"
+			} }
+		};
+		let person = await store.__dangerousCreateFromSerialized(resource, { data: resource }, new URL(testRealmURL));
+		assert.strictEqual(person.pets.length, 2, "length includes both slots");
+		assert.strictEqual(person.pets[1], void 0, "a not-loaded slot reads as undefined");
+		await waitUntil(() => {
+			let states = getRelationshipMembershipState(person, "pets").membership;
+			return states[0]?.kind === "present" && states[1]?.kind === "not-found";
+		});
+		assert.strictEqual(person.pets[0]?.firstName, "Mango", "the present sibling resolves to its card");
+		assert.strictEqual(person.pets[1], void 0, "the failed slot stays undefined — terminal, never the sentinel");
+		let bucket = getDataBucket(person).get("pets");
+		assert.strictEqual(bucket.length, 2, "the backing array still has both slots");
+	});
+	(0, import_qunit.test)("a list of only present links exposes every slot as its card", async function(assert) {
+		class Pet extends CardDef {
+			static displayName = "Pet";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
+		}
+		class Person extends CardDef {
+			static displayName = "Person";
+			static {
+				decorateFieldV2(this.prototype, "firstName", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#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, MANGO_URL, loader);
+		await saveCard(vangogh, VANGOGH_URL, loader);
+		let pets = new Person({
+			firstName: "Hassan",
+			pets: [mango, vangogh]
+		}).pets;
+		assert.strictEqual(pets.length, 2);
+		assert.strictEqual(pets[0], mango);
+		assert.strictEqual(pets[1], vangogh);
+		assert.deepEqual(pets.map((c) => c.firstName), ["Mango", "Van Gogh"], "a healthy list reads cleanly with a non-optional map");
+	});
+});
+//#endregion