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

package/bundled-test-harness/assets/query-field-membership-status-test-C8yTTBkc.js

@@ -1,323 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { O as baseRealm, x as PermissionsContextName } from "./constants-Icc0nFW-.js";
-import { T as settled } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, nt as provide, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { A as field, H as linksTo, U as linksToMany, a as CardDef, w as contains } from "./card-api-Cc8uZunB.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-//#region tests/integration/components/query-field-membership-status-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var HOST_URL = `${testRealmURL}Host/anchor`;
-(0, import_qunit.module)("Integration | query-field relationship status", function(hooks) {
-	let loader;
-	let cardApi;
-	let queryFieldSupport;
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [baseRealm.url, testRealmURL],
-		autostart: true
-	});
-	hooks.beforeEach(async function() {
-		provide(PermissionsContextName, {
-			canWrite: true,
-			canRead: true
-		});
-		loader = getService("loader-service").loader;
-		cardApi = await loader.import("@cardstack/base/card-api");
-		queryFieldSupport = await loader.import("@cardstack/base/query-field-support");
-		class Person extends CardDef {
-			static displayName = "Person";
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		class Host extends CardDef {
-			static displayName = "Host";
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "favorite", [field], function() {
-					return linksTo(() => Person, { query: { filter: { eq: { name: "$this.cardTitle" } } } });
-				});
-			}
-			#favorite = (initializeDeferredDecorator(this, "favorite"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "matches", [field], function() {
-					return linksToMany(() => Person, { query: { filter: { eq: { name: "$this.cardTitle" } } } });
-				});
-			}
-			#matches = (initializeDeferredDecorator(this, "matches"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "deferred", [field], function() {
-					return linksToMany(() => Person, {
-						query: { filter: { eq: { name: "$this.cardTitle" } } },
-						eager: false
-					});
-				});
-			}
-			#deferred = (initializeDeferredDecorator(this, "deferred"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "unmatched", [field], function() {
-					return linksToMany(() => Person, { query: { filter: { eq: { name: "Nobody" } } } });
-				});
-			}
-			#unmatched = (initializeDeferredDecorator(this, "unmatched"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "firstMatch", [field], function() {
-					return linksToMany(() => Person, { query: {
-						filter: { eq: { name: "$this.cardTitle" } },
-						page: { size: 1 }
-					} });
-				});
-			}
-			#firstMatch = (initializeDeferredDecorator(this, "firstMatch"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "declared", [field], function() {
-					return linksToMany(() => Person);
-				});
-			}
-			#declared = (initializeDeferredDecorator(this, "declared"), void 0);
-		}
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"test-cards.gts": {
-					Person,
-					Host
-				},
-				"Person/one.json": new Person({ name: "Anchor" }),
-				"Person/two.json": new Person({ name: "Anchor" }),
-				"Person/three.json": new Person({ name: "Different" }),
-				"Host/anchor.json": new Host({ cardTitle: "Anchor" })
-			}
-		});
-		await getService("realm").login(testRealmURL);
-	});
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	async function loadHost() {
-		let host = await getService("store").get(HOST_URL);
-		await settled();
-		return host;
-	}
-	async function fetchHostDoc() {
-		return await (await getService("network").authedFetch(HOST_URL, { headers: { Accept: "application/vnd.card+json" } })).json();
-	}
-	function spliceThirdMember(hostDoc) {
-		let relationships = hostDoc.data.relationships;
-		let template = hostDoc.included?.find((resource) => resource.id.endsWith("Person/one"));
-		if (!template) throw new Error(`expected the host document to carry Person/one as a resolved member of 'matches'; included ids were ${JSON.stringify((hostDoc.included ?? []).map((r) => r.id))}`);
-		let spliced = JSON.parse(JSON.stringify(template));
-		spliced.id = template.id.replace("Person/one", "Person/three");
-		hostDoc.included.push(spliced);
-		let umbrella = relationships.matches;
-		umbrella.data.push({
-			type: "card",
-			id: spliced.id
-		});
-		umbrella.meta = {
-			...umbrella.meta,
-			total: umbrella.data.length
-		};
-		relationships[`matches.${umbrella.data.length - 1}`] = {
-			links: { self: spliced.id },
-			data: {
-				type: "card",
-				id: spliced.id
-			}
-		};
-	}
-	(0, import_qunit.test)("a singular query-backed field reports the one slot it surfaces, not the whole result set", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let host = await loadHost();
-		let plural = getRelationshipMembershipState(host, "matches");
-		assert.strictEqual(plural.membership?.length, 2, "the query matches both people, so the plural field holds both");
-		let singular = getRelationshipMembershipState(host, "favorite");
-		assert.strictEqual(singular.membership?.length, 1, "the singular field reports one slot even though the query matched two");
-		assert.strictEqual(singular.membership?.[0].kind, "present", "that slot holds the result the getter surfaces");
-		assert.strictEqual(singular.membership?.[0].value, host.favorite, "membership and the field getter agree on which result it is");
-	});
-	(0, import_qunit.test)("isLoaded separates a field still loading from a settled empty one", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let host = await loadHost();
-		let deferred = getRelationshipMembershipState(host, "deferred");
-		assert.true(deferred.isLoading, "a field being resolved is loading");
-		assert.false(deferred.isLoaded, "so it is not loaded");
-		assert.strictEqual(deferred.membership, void 0, "and it has no membership to report yet");
-		let unmatched = getRelationshipMembershipState(host, "unmatched");
-		assert.false(unmatched.isLoading, "a settled field is not loading");
-		assert.true(unmatched.isLoaded, "and it is loaded");
-		assert.strictEqual(unmatched.membership?.length, 0, "an empty result set is a membership, not the absence of one");
-		let matches = getRelationshipMembershipState(host, "matches");
-		assert.true(matches.isLoaded, "a field with results is loaded too");
-		assert.strictEqual(matches.membership?.length, 2, "and it carries its membership");
-	});
-	(0, import_qunit.test)("a field that opts out of eager resolution resolves on first read", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let { peekQueryFieldSearchResource } = queryFieldSupport;
-		let host = await loadHost();
-		assert.strictEqual(peekQueryFieldSearchResource(host, "deferred"), void 0, "loading the owner does not resolve a field that opted out");
-		host.deferred;
-		await settled();
-		let deferred = getRelationshipMembershipState(host, "deferred");
-		assert.true(deferred.isLoaded, "reading the field resolves it");
-		assert.strictEqual(deferred.membership?.length, 2, "and it carries the same membership as its eager twin");
-	});
-	(0, import_qunit.test)("asking an unresolved field for its state starts it", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let { peekQueryFieldSearchResource } = queryFieldSupport;
-		let host = await loadHost();
-		assert.strictEqual(peekQueryFieldSearchResource(host, "deferred"), void 0, "nothing has resolved the field");
-		assert.false(getRelationshipMembershipState(host, "deferred").isLoaded, "the first read of the state reports it not yet loaded");
-		assert.notStrictEqual(peekQueryFieldSearchResource(host, "deferred"), void 0, "and starts it");
-		await settled();
-		assert.true(getRelationshipMembershipState(host, "deferred").isLoaded, "so the state settles without the field ever being read");
-	});
-	(0, import_qunit.test)("isLoaded never claims a result set the seed has not applied yet", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let host = await getService("store").get(HOST_URL);
-		let status = getRelationshipMembershipState(host, "matches");
-		let claimsAnIncompleteSet = status.isLoaded && status.membership?.length !== 2;
-		assert.false(claimsAnIncompleteSet, "isLoaded is claimed only once the membership is the real one");
-		await settled();
-		let settledStatus = getRelationshipMembershipState(host, "matches");
-		assert.true(settledStatus.isLoaded, "and it is claimed once settled");
-		assert.strictEqual(settledStatus.membership?.length, 2);
-	});
-	(0, import_qunit.test)("a field whose page cuts its result set short reports the shortfall", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "firstMatch");
-		assert.true(status.isLoaded, "the field settled");
-		assert.strictEqual(status.membership?.length, 1, "and holds the one row its page allowed");
-		assert.strictEqual(status.totalMatchCount, 2, "while reporting what the query actually matched");
-		assert.true(status.isPartial, "so a rollup reducing over the rows is short by one");
-	});
-	(0, import_qunit.test)("a field holding its whole result set reports no shortfall", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "matches");
-		assert.strictEqual(status.membership?.length, 2);
-		assert.strictEqual(status.totalMatchCount, 2, "the count agrees with the membership");
-		assert.false(status.isPartial, "so nothing was cut short");
-	});
-	(0, import_qunit.test)("a field still loading claims no shortfall", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "deferred");
-		assert.strictEqual(status.totalMatchCount, void 0);
-		assert.false(status.isPartial);
-	});
-	(0, import_qunit.test)("a singular query-backed field reports no match count", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "favorite");
-		assert.strictEqual(status.membership?.length, 1);
-		assert.strictEqual(status.totalMatchCount, void 0);
-		assert.false(status.isPartial);
-	});
-	(0, import_qunit.test)("a document fetched after the field resolved hands it the fresher result set", async function(assert) {
-		let { getRelationshipMembershipState, updateFromSerialized } = cardApi;
-		let host = await loadHost();
-		assert.strictEqual(getRelationshipMembershipState(host, "matches").membership?.length, 2, "the field resolves to the two cards the query matches");
-		assert.strictEqual(getRelationshipMembershipState(host, "matches").totalMatchCount, 2, "and reports the count the indexer resolved it under");
-		let hostDoc = await fetchHostDoc();
-		spliceThirdMember(hostDoc);
-		await updateFromSerialized(host, hostDoc);
-		await settled();
-		let matches = getRelationshipMembershipState(host, "matches");
-		assert.strictEqual(matches.totalMatchCount, 3, "the newer document supersedes the result set the resource was holding");
-		assert.strictEqual(matches.membership?.length, 3, "and the field surfaces all three members");
-		assert.true(matches.membership?.some((member) => member.kind === "present" && member.reference.endsWith("Person/three")), "including the one the document introduced");
-	});
-	(0, import_qunit.test)("a document reporting a higher match count refreshes a page-clamped field", async function(assert) {
-		let { getRelationshipMembershipState, updateFromSerialized } = cardApi;
-		let host = await loadHost();
-		let before = getRelationshipMembershipState(host, "firstMatch");
-		assert.strictEqual(before.totalMatchCount, 2, "two matches are reported");
-		let hostDoc = await fetchHostDoc();
-		hostDoc.data.relationships.firstMatch.meta = { total: 3 };
-		await updateFromSerialized(host, hostDoc);
-		await settled();
-		let after = getRelationshipMembershipState(host, "firstMatch");
-		assert.strictEqual(after.membership?.length, 1, "the field still holds the one row its page allowed");
-		assert.strictEqual(after.totalMatchCount, 3, "against the count the newer document reports");
-		assert.true(after.isPartial, "so the shortfall is still reported");
-		await updateFromSerialized(host, await fetchHostDoc());
-		await settled();
-		assert.strictEqual(getRelationshipMembershipState(host, "firstMatch").totalMatchCount, 2, "and a document restoring the earlier count is applied in turn");
-	});
-	(0, import_qunit.test)("a document resolved before the result set the field holds is declined", async function(assert) {
-		let { getRelationshipMembershipState, updateFromSerialized } = cardApi;
-		let host = await loadHost();
-		let hostDoc = await fetchHostDoc();
-		let newerGeneration = (hostDoc.data.meta.generation ?? 0) + 10;
-		hostDoc.data.meta.generation = newerGeneration;
-		spliceThirdMember(hostDoc);
-		await updateFromSerialized(host, hostDoc);
-		await settled();
-		assert.strictEqual(getRelationshipMembershipState(host, "matches").totalMatchCount, 3, "the field holds the set that document resolved");
-		let staleDoc = await fetchHostDoc();
-		staleDoc.data.meta.generation = newerGeneration - 1;
-		await updateFromSerialized(host, staleDoc);
-		await settled();
-		assert.strictEqual(getRelationshipMembershipState(host, "matches").totalMatchCount, 3, "the older document does not displace it");
-	});
-	(0, import_qunit.test)("a document that did not resolve the field cannot displace a result set", async function(assert) {
-		let { getRelationshipMembershipState, updateFromSerialized } = cardApi;
-		let host = await loadHost();
-		let hostDoc = await fetchHostDoc();
-		let relationships = hostDoc.data.relationships;
-		delete relationships.matches.links.search;
-		relationships.matches.data = [relationships.matches.data[0]];
-		relationships.matches.meta = { total: 1 };
-		delete relationships["matches.1"];
-		await updateFromSerialized(host, hostDoc);
-		await settled();
-		assert.strictEqual(getRelationshipMembershipState(host, "matches").membership?.length, 2, "the field keeps the result set the indexer resolved");
-	});
-	(0, import_qunit.test)("a document reporting an unreachable realm sends the field back to a live query", async function(assert) {
-		let { getRelationshipMembershipState, updateFromSerialized } = cardApi;
-		let network = getService("network");
-		let host = await loadHost();
-		assert.strictEqual(getRelationshipMembershipState(host, "matches").membership?.length, 2, "the field resolves from the document without querying");
-		let searchRequests = [];
-		let spy = async (request) => {
-			if (new URL(request.url).pathname.endsWith("/_federated-search")) searchRequests.push(request.url);
-			return null;
-		};
-		network.virtualNetwork.mount(spy, { prepend: true });
-		try {
-			let hostDoc = await fetchHostDoc();
-			let matches = hostDoc.data.relationships.matches;
-			matches.meta = {
-				...matches.meta,
-				errors: [{
-					realm: "http://unreachable-realm/test/",
-					type: "realm-unreachable",
-					message: "realm did not answer"
-				}]
-			};
-			await updateFromSerialized(host, hostDoc);
-			await settled();
-			assert.strictEqual(searchRequests.length, 1, "the field runs the query the failed realm left unanswered");
-		} finally {
-			network.virtualNetwork.unmount(spy);
-		}
-	});
-	(0, import_qunit.test)("a declared linksToMany reports no match count", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "declared");
-		assert.true(status.isLoaded);
-		assert.strictEqual(status.totalMatchCount, void 0);
-		assert.false(status.isPartial);
-	});
-});
-//#endregion

package/bundled-test-harness/assets/query-field-page-optin-test-D4l_GcII.js

@@ -1,126 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Br as testRealmURL, bi as setSearchBoundsForTests, yi as resetSearchBoundsForTests } from "./runtime-common-BTaLJEw-.js";
-import { O as baseRealm, x as PermissionsContextName } from "./constants-Icc0nFW-.js";
-import { T as settled } from "./dist-BOAdzfkP.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, nt as provide, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { A as field, U as linksToMany, a as CardDef, w as contains } from "./card-api-Cc8uZunB.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-//#region tests/integration/components/query-field-page-optin-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var HOST_URL = `${testRealmURL}Host/anchor`;
-var DEFAULT_CEILING = 1;
-var ABSOLUTE_MAX = 5;
-var MATCH_COUNT = 7;
-(0, import_qunit.module)("Integration | query-field page opt-in", function(hooks) {
-	let loader;
-	let cardApi;
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [baseRealm.url, testRealmURL],
-		autostart: true
-	});
-	hooks.beforeEach(async function() {
-		setSearchBoundsForTests({
-			serverMaxPageSize: DEFAULT_CEILING,
-			serverAbsoluteMaxPageSize: ABSOLUTE_MAX
-		});
-		provide(PermissionsContextName, {
-			canWrite: true,
-			canRead: true
-		});
-		loader = getService("loader-service").loader;
-		cardApi = await loader.import("@cardstack/base/card-api");
-		class Person extends CardDef {
-			static displayName = "Person";
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		class Host extends CardDef {
-			static displayName = "Host";
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "capped", [field], function() {
-					return linksToMany(() => Person, { query: { filter: { eq: { name: "$this.cardTitle" } } } });
-				});
-			}
-			#capped = (initializeDeferredDecorator(this, "capped"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "optedIn", [field], function() {
-					return linksToMany(() => Person, { query: {
-						filter: { eq: { name: "$this.cardTitle" } },
-						page: { size: ABSOLUTE_MAX - 2 }
-					} });
-				});
-			}
-			#optedIn = (initializeDeferredDecorator(this, "optedIn"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "overAsking", [field], function() {
-					return linksToMany(() => Person, { query: {
-						filter: { eq: { name: "$this.cardTitle" } },
-						page: { size: 105 }
-					} });
-				});
-			}
-			#overAsking = (initializeDeferredDecorator(this, "overAsking"), void 0);
-		}
-		let people = Object.fromEntries(Array.from({ length: MATCH_COUNT }, (_v, i) => [`Person/${i}.json`, new Person({ name: "Anchor" })]));
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"test-cards.gts": {
-					Person,
-					Host
-				},
-				...people,
-				"Host/anchor.json": new Host({ cardTitle: "Anchor" })
-			}
-		});
-		await getService("realm").login(testRealmURL);
-	});
-	hooks.afterEach(function() {
-		resetSearchBoundsForTests();
-	});
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	async function loadHost() {
-		let host = await getService("store").get(HOST_URL);
-		await settled();
-		return host;
-	}
-	(0, import_qunit.test)("a field declaring no page takes the default ceiling", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "capped");
-		assert.strictEqual(status.membership?.length, DEFAULT_CEILING, "it holds the default page");
-		assert.strictEqual(status.totalMatchCount, MATCH_COUNT, "while reporting every match behind it");
-		assert.true(status.isPartial, "so it says it is holding a prefix");
-	});
-	(0, import_qunit.test)("a field declaring a larger page gets it", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "optedIn");
-		assert.strictEqual(status.membership?.length, ABSOLUTE_MAX - 2, "the declared page size is what it holds");
-		assert.true((status.membership?.length ?? 0) > DEFAULT_CEILING, "which is more than the default ceiling would have allowed");
-		assert.strictEqual(status.totalMatchCount, MATCH_COUNT);
-		assert.true(status.isPartial, "still short of the full match set, and still saying so");
-	});
-	(0, import_qunit.test)("a field declaring more than the maximum is clamped, and still indexes", async function(assert) {
-		let { getRelationshipMembershipState } = cardApi;
-		let status = getRelationshipMembershipState(await loadHost(), "overAsking");
-		assert.strictEqual(status.membership?.length, ABSOLUTE_MAX, "it holds the maximum, not the size it asked for");
-		assert.strictEqual(status.totalMatchCount, MATCH_COUNT);
-		assert.true(status.isPartial, "and reports the shortfall");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/query-field-schema-test-DDbcNNm5.js

@@ -1,231 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Vo as getField } from "./runtime-common-BTaLJEw-.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { lt as setupRenderingTest } from "./mock-matrix-Dd8k0DNa.js";
-import { A as field, H as linksTo, T as containsMany, U as linksToMany, a as CardDef, l as FieldDef, w as contains } from "./card-api-Cc8uZunB.js";
-import { t as string_default } from "./string-5IAMEUit.js";
-//#region tests/unit/query-field-schema-test.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-(0, import_qunit.module)("Unit | query field schema", function(hooks) {
-	setupRenderingTest(hooks);
-	(0, import_qunit.test)("linksToMany accepts a query option and exposes it via field metadata", function(assert) {
-		class Shirt extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		const query = {
-			filter: { eq: { size: "$this.size" } },
-			realm: "$REALM"
-		};
-		class Person extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "size", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#size = (initializeDeferredDecorator(this, "size"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "favoriteShirt", [field], function() {
-					return linksTo(Shirt, { query });
-				});
-			}
-			#favoriteShirt = (initializeDeferredDecorator(this, "favoriteShirt"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "shirts", [field], function() {
-					return linksToMany(Shirt, { query });
-				});
-			}
-			#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-		}
-		let fieldMeta = getField(Person, "shirts");
-		let singleFieldMeta = getField(Person, "favoriteShirt");
-		assert.ok(fieldMeta, "field metadata is registered for shirts");
-		assert.deepEqual(fieldMeta?.queryDefinition, query, "linksToMany stores the query definition");
-		assert.deepEqual(singleFieldMeta?.queryDefinition, query, "linksTo stores the query definition");
-	});
-	(0, import_qunit.test)("linksTo and linksToMany queries are preserved when defined inside FieldDefs", function(assert) {
-		class Shirt extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		const query = {
-			filter: { eq: { size: "$this.size" } },
-			realm: "$REALM"
-		};
-		class FavoriteField extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "size", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#size = (initializeDeferredDecorator(this, "size"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "favorite", [field], function() {
-					return linksTo(Shirt, { query });
-				});
-			}
-			#favorite = (initializeDeferredDecorator(this, "favorite"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "shirts", [field], function() {
-					return linksToMany(Shirt, { query });
-				});
-			}
-			#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-		}
-		class Person extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "favoriteField", [field], function() {
-					return contains(FavoriteField);
-				});
-			}
-			#favoriteField = (initializeDeferredDecorator(this, "favoriteField"), void 0);
-		}
-		let fieldMeta = getField(FavoriteField, "shirts");
-		let singleFieldMeta = getField(FavoriteField, "favorite");
-		assert.ok(fieldMeta, "field metadata is registered for nested shirts");
-		assert.deepEqual(fieldMeta?.queryDefinition, query, "linksToMany query inside FieldDef stores the query definition");
-		assert.deepEqual(singleFieldMeta?.queryDefinition, query, "linksTo query inside FieldDef stores the query definition");
-		assert.ok(getField(Person, "favoriteField"), "containing card can be introspected");
-	});
-	(0, import_qunit.test)("referencing a missing field in a query raises a descriptive error", function(assert) {
-		class Shirt extends CardDef {}
-		assert.throws(() => {
-			class Person extends CardDef {
-				static {
-					decorateFieldV2(this.prototype, "shirts", [field], function() {
-						return linksToMany(Shirt, { query: { filter: { eq: { size: "$this.missingField" } } } });
-					});
-				}
-				#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-			}
-		}, /query field "shirts" references unknown path "\$this\.missingField" on Person/, "validation error includes field name and card context");
-	});
-	(0, import_qunit.test)("referencing nested fields validates each segment", function(assert) {
-		class HangerField extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "label", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#label = (initializeDeferredDecorator(this, "label"), void 0);
-		}
-		class ClosetField extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "hanging", [field], function() {
-					return contains(HangerField);
-				});
-			}
-			#hanging = (initializeDeferredDecorator(this, "hanging"), void 0);
-		}
-		class Shirt extends CardDef {}
-		assert.throws(() => {
-			class Person extends CardDef {
-				static {
-					decorateFieldV2(this.prototype, "closet", [field], function() {
-						return contains(ClosetField);
-					});
-				}
-				#closet = (initializeDeferredDecorator(this, "closet"), void 0);
-				static {
-					decorateFieldV2(this.prototype, "shirts", [field], function() {
-						return linksToMany(Shirt, { query: { filter: { eq: { label: "$this.closet.hanging.missingField" } } } });
-					});
-				}
-				#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-			}
-		}, /query field "shirts" references unknown path "\$this\.closet\.hanging\.missingField" on HangerField/, "validation error reports nested card context");
-	});
-	(0, import_qunit.test)("dereferencing containsMany paths requires numeric indexes", function(assert) {
-		class ShirtField extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "label", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#label = (initializeDeferredDecorator(this, "label"), void 0);
-		}
-		class WardrobeField extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "shirts", [field], function() {
-					return containsMany(ShirtField);
-				});
-			}
-			#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-		}
-		class Shirt extends CardDef {}
-		assert.throws(() => {
-			class Person extends CardDef {
-				static {
-					decorateFieldV2(this.prototype, "wardrobe", [field], function() {
-						return contains(WardrobeField);
-					});
-				}
-				#wardrobe = (initializeDeferredDecorator(this, "wardrobe"), void 0);
-				static {
-					decorateFieldV2(this.prototype, "shirts", [field], function() {
-						return linksToMany(Shirt, { query: { filter: { eq: { label: "$this.wardrobe.shirts.label" } } } });
-					});
-				}
-				#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-			}
-		}, /query field "shirts" must use a numeric index when referencing "\$this\.wardrobe\.shirts\.label"/, "validation error requires indexes for containsMany dereferences");
-		class Person extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "wardrobe", [field], function() {
-					return contains(WardrobeField);
-				});
-			}
-			#wardrobe = (initializeDeferredDecorator(this, "wardrobe"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "shirts", [field], function() {
-					return linksToMany(Shirt, { query: { filter: { eq: { label: "$this.wardrobe.shirts.0.label" } } } });
-				});
-			}
-			#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-		}
-		assert.ok(getField(Person, "shirts"), "query passes validation when using numeric index");
-	});
-	(0, import_qunit.test)("dereferencing relationship fields is allowed during validation", function(assert) {
-		class Friend extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		class Shirt extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "label", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#label = (initializeDeferredDecorator(this, "label"), void 0);
-		}
-		class Person extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "favoriteFriend", [field], function() {
-					return linksTo(Friend);
-				});
-			}
-			#favoriteFriend = (initializeDeferredDecorator(this, "favoriteFriend"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "shirts", [field], function() {
-					return linksToMany(Shirt, { query: { filter: { eq: { label: "$this.favoriteFriend.name" } } } });
-				});
-			}
-			#shirts = (initializeDeferredDecorator(this, "shirts"), void 0);
-		}
-		assert.ok(getField(Person, "shirts"), "query passes validation when referencing relationship fields");
-	});
-});
-//#endregion