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

package/bundled-test-harness/assets/realm-test-BX6C9SS5.js

@@ -1,2363 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Ar as testRealmURL, Or as testRealmInfo, is as isSingleCardDocument, na as searchEntryWireQueryFromQuery } from "./runtime-common-ClpqhbwG.js";
-import { y as rri } from "./paths-BYHDgqsT.js";
-import { C as baseCardRef, O as baseRealmRRI } from "./constants-CqKWhRfY.js";
-import { l as validate } from "./esm-browser-CIYLo70w.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 require_qunit } from "./qunit-C-Foo4Nd.js";
-import { D as realmConfigCardJSON, F as setupLocalIndexing, H as testModuleRealm, M as setupCardLogs, P as setupIntegrationTestRealm, d as cardInfo, lt as setupRenderingTest, t as setupMockMatrix, x as getFileCreatedAt } from "./mock-matrix-DPQ0j2MD.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { A as field, H as linksTo, T as containsMany, U as linksToMany, a as CardDef, l as FieldDef, s as Component, w as contains } from "./card-api-u1pOrwS6.js";
-import { t as string_default } from "./string-DHlQEHYm.js";
-import { t as searchCardsForTest } from "./search-cards-O_RNz8_i.js";
-import "./code-equality-assertion-CGfac7T7.js";
-//#region ../runtime-common/etc/test-fixtures.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var cardSrc = `
-import {
-  contains,
-  field,
-  Component,
-  CardDef,
-} from '@cardstack/base/card-api';
-import StringField from '@cardstack/base/string';
-
-export class Person extends CardDef {
-  static displayName = 'Person';
-  @field firstName = contains(StringField);
-  @field cardTitle = contains(StringField, {
-    computeVia: function (this: Person) {
-      return this.firstName;
-    },
-  });
-  static isolated = class Isolated extends Component<typeof this> {
-    <template>
-      <h1 data-test-card><@fields.firstName /></h1>
-    </template>
-  };
-}
-
-export let counter = 0;
-export function increment() {
-  counter++;
-}
-`.trim();
-function compiledCard(id = "null", moduleName = "/dir/person.gts") {
-	return `
-import { contains, field, Component, CardDef } from '@cardstack/base/card-api';
-import StringField from '@cardstack/base/string';
-import { setComponentTemplate } from "@ember/component";
-import { createTemplateFactory } from "@ember/template-factory";
-export class Person extends CardDef {
-  static displayName = 'Person';
-  static {
-    dt7948.g(this.prototype, "firstName", [field], function () {
-      return contains(StringField);
-    });
-  }
-  #firstName = (dt7948.i(this, "firstName"), void 0);
-  static {
-    dt7948.g(this.prototype, "cardTitle", [field], function () {
-      return contains(StringField, {
-        computeVia: function () {
-          return this.firstName;
-        }
-      });
-    });
-  }
-  #cardTitle = (dt7948.i(this, "cardTitle"), void 0);
-  static isolated = class Isolated extends Component {
-    static {
-      setComponentTemplate(createTemplateFactory(
-      /*
-        <h1 data-test-card><@fields.firstName /></h1>
-      */
-      {
-        "id": ${id},
-        "block": "[[[10,\\"h1\\"],[14,\\"data-test-card\\",\\"\\"],[12],[8,[30,1,[\\"firstName\\"]],null,null,null],[13]],[\\"@fields\\"],[]]",
-        "moduleName": "${moduleName}",
-        "isStrictMode": true
-      }), this);
-    }
-  };}
-export let counter = 0;
-export function increment() {
-  counter++;
-}`.trim();
-}
-//#endregion
-//#region ../runtime-common/helpers/strip-scoped-css-glimmer-attributes.ts
-function stripScopedCSSGlimmerAttributes(compiledTemplateString) {
-	let attributeArray = `\\[(14|24),\\\\"data\\-scopedcss\\-[0-9a-f]{10}\\-[0-9a-f]{10}\\\\",\\\\"\\\\"\\]`;
-	let double = new RegExp(`\\[${attributeArray}\\]`, "g");
-	let single = new RegExp(`${attributeArray},`, "g");
-	return compiledTemplateString.replace(double, "null").replace(single, "");
-}
-//#endregion
-//#region tests/integration/realm-test.gts
-var loader;
-(0, import_qunit.module)("Integration | realm", function(hooks) {
-	setupRenderingTest(hooks);
-	hooks.beforeEach(function() {
-		loader = getService("loader-service").loader;
-	});
-	let mockMatrixUtils = setupMockMatrix(hooks);
-	setupLocalIndexing(hooks);
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	async function handle(realm, ...args) {
-		let result = await realm.handle(...args);
-		if (!result) throw new Error(`realm didn't handle request`);
-		return result;
-	}
-	(0, import_qunit.test)("realm can serve readiness checks without a server-side job queue", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}_readiness-check`, { headers: { Accept: "application/vnd.api+json" } }));
-		assert.strictEqual(response.status, 200, "reports ready");
-	});
-	(0, import_qunit.test)("realm can serve GET card requests", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/empty.json": { data: { meta: { adoptsFrom: {
-				module: "@cardstack/base/card-api",
-				name: "CardDef"
-			} } } } }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/empty`, { headers: { Accept: "application/vnd.card+json" } }));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		let resourceCreatedAt = await getFileCreatedAt(realm, "dir/empty.json");
-		delete json.data.meta.generation;
-		delete json.data.meta.version;
-		assert.deepEqual(json, { data: {
-			type: "card",
-			id: `${testRealmURL}dir/empty`,
-			attributes: {
-				cardInfo,
-				cardDescription: null,
-				cardThumbnailURL: null,
-				cardTitle: "Untitled Card"
-			},
-			meta: {
-				adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}dir/empty.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			},
-			links: { self: `${testRealmURL}dir/empty` }
-		} });
-		assert.ok(json.data.meta.lastModified, "lastModified is populated");
-	});
-	(0, import_qunit.test)("realm serves instance ids in canonical RRI form for a prefix-mapped realm", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/empty.json": { data: { meta: { adoptsFrom: {
-				module: "@cardstack/base/card-api",
-				name: "CardDef"
-			} } } } }
-		});
-		let urlDoc = await (await handle(realm, new Request(`${testRealmURL}dir/empty`, { headers: { Accept: "application/vnd.card+json" } }))).json();
-		assert.strictEqual(urlDoc.data.id, `${testRealmURL}dir/empty`, "an unmapped realm serves the instance id in URL form");
-		let virtualNetwork = getService("network").virtualNetwork;
-		virtualNetwork.addRealmMapping("@test-prefix/", testRealmURL);
-		try {
-			let rriDoc = await (await handle(realm, new Request(`${testRealmURL}dir/empty`, { headers: { Accept: "application/vnd.card+json" } }))).json();
-			assert.strictEqual(rriDoc.data.id, "@test-prefix/dir/empty", "a prefix-mapped realm serves the instance id in canonical RRI form");
-			assert.strictEqual(rriDoc.data.links.self, "@test-prefix/dir/empty", "links.self is served in canonical RRI form too");
-		} finally {
-			virtualNetwork.removeRealmMapping("@test-prefix/");
-		}
-	});
-	(0, import_qunit.test)("realm can serve GET card requests with linksTo relationships", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/owner.json": { data: {
-					id: `${testRealmURL}dir/owner`,
-					attributes: {
-						firstName: "Hassan",
-						lastName: "Abdel-Rahman",
-						cardInfo,
-						cardDescription: null,
-						cardThumbnailURL: null
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: {
-						firstName: "Mango",
-						cardInfo,
-						cardDescription: null,
-						cardThumbnailURL: null
-					},
-					relationships: { owner: { links: { self: `${testRealmURL}dir/owner` } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} }
-			}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/mango`, { headers: { Accept: "application/vnd.card+json" } }));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		let mangoCreatedAt = await getFileCreatedAt(realm, "dir/mango.json");
-		let ownerCreatedAt = await getFileCreatedAt(realm, "dir/owner.json");
-		delete json.data.meta.generation;
-		delete json.data.meta.version;
-		assert.deepEqual(json, {
-			data: {
-				type: "card",
-				id: `${testRealmURL}dir/mango`,
-				attributes: {
-					firstName: "Mango",
-					cardTitle: "Mango",
-					cardInfo,
-					cardDescription: null,
-					cardThumbnailURL: null
-				},
-				relationships: { owner: {
-					links: { self: `./owner` },
-					data: {
-						type: "card",
-						id: `${testRealmURL}dir/owner`
-					}
-				} },
-				meta: {
-					adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					},
-					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}dir/mango.json`),
-					resourceCreatedAt: mangoCreatedAt,
-					realmInfo: testRealmInfo,
-					realmURL: testRealmURL
-				},
-				links: { self: `${testRealmURL}dir/mango` }
-			},
-			included: [{
-				type: "card",
-				id: `${testRealmURL}dir/owner`,
-				attributes: {
-					cardDescription: "Person",
-					email: null,
-					posts: null,
-					cardThumbnailURL: null,
-					firstName: "Hassan",
-					lastName: "Abdel-Rahman",
-					cardTitle: "Hassan Abdel-Rahman",
-					fullName: "Hassan Abdel-Rahman",
-					cardInfo
-				},
-				meta: {
-					adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					},
-					lastModified: adapter.lastModifiedMap.get(`${testRealmURL}dir/owner.json`),
-					resourceCreatedAt: ownerCreatedAt,
-					realmInfo: testRealmInfo,
-					realmURL: testRealmURL
-				},
-				links: { self: `./owner` }
-			}]
-		});
-	});
-	(0, import_qunit.test)("realm can serve GET card requests with linksTo relationships to other realms", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/mango.json": { data: {
-				id: `${testRealmURL}dir/mango`,
-				attributes: {
-					cardDescription: null,
-					cardThumbnailURL: null,
-					firstName: "Mango"
-				},
-				relationships: { owner: { links: { self: `${testModuleRealm}hassan` } } },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet`,
-					name: "Pet"
-				} }
-			} } }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/mango`, { headers: { Accept: "application/vnd.card+json" } }));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		let { included = [] } = json;
-		delete included[0]?.meta.lastModified;
-		delete included[0]?.meta.resourceCreatedAt;
-		let resourceCreatedAt = await getFileCreatedAt(realm, "dir/mango.json");
-		assert.strictEqual(json.data.id, `${testRealmURL}dir/mango`, "mango id");
-		assert.strictEqual(json.data.attributes.firstName, "Mango", "mango firstName");
-		assert.strictEqual(json.data.relationships.owner.links.self, `${testModuleRealm}hassan`, "owner self link points to other realm");
-		assert.strictEqual(json.data.relationships.owner.data.id, `${testModuleRealm}hassan`, "owner data id points to other realm");
-		assert.strictEqual(json.data.meta.lastModified, adapter.lastModifiedMap.get(`${testRealmURL}dir/mango.json`), "mango lastModified");
-		assert.strictEqual(json.data.meta.resourceCreatedAt, resourceCreatedAt, "mango resourceCreatedAt");
-		assert.strictEqual(included.length, 1, "one included card");
-		let hassan = included[0];
-		assert.strictEqual(hassan.id, `${testModuleRealm}hassan`, "included hassan id");
-	});
-	(0, import_qunit.test)("realm can route requests correctly when mounted in the origin's subdir", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/empty.json": { data: { meta: { adoptsFrom: {
-				module: "@cardstack/base/card-api",
-				name: "CardDef"
-			} } } } },
-			realmURL: `${testRealmURL}root/`
-		});
-		{
-			let response = await handle(realm, new Request(`${testRealmURL}root/dir/empty`, { headers: { Accept: "application/vnd.card+json" } }));
-			assert.strictEqual(response.status, 200, "successful http status");
-			let json = await response.json();
-			assert.strictEqual(json.data.id, `${testRealmURL}root/dir/empty`, "card ID is correct");
-		}
-		{
-			let json = await (await handle(realm, new Request(`${testRealmURL}root/_search`, {
-				method: "QUERY",
-				headers: {
-					Accept: "application/vnd.card+json",
-					"Content-Type": "application/json"
-				},
-				body: JSON.stringify(searchEntryWireQueryFromQuery({ filter: { type: baseCardRef } }, { fields: ["item"] }))
-			}))).json();
-			assert.strictEqual(json.data.length, 1, "the card is returned in the search results");
-			assert.strictEqual(json.data[0].id, `${testRealmURL}root/dir/empty`, "card ID is correct");
-		}
-	});
-	(0, import_qunit.test)("realm can serve create card requests", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		});
-		let json = await (await handle(realm, new Request(testRealmURL, {
-			method: "POST",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} }
-			} }, null, 2)
-		}))).json();
-		let id;
-		if (isSingleCardDocument(json)) {
-			id = json.data.id.split("/").pop();
-			assert.true(validate(id), "card ID is a UUID");
-			assert.strictEqual(json.data.id, `${testRealmURL}CardDef/${id}`, "the card URL is correct");
-			assert.ok((await adapter.openFile(`CardDef/${id}.json`))?.content, "file contents exist");
-			let createdAt = await getFileCreatedAt(realm, `CardDef/${id}.json`);
-			assert.ok(json.data.meta?.resourceCreatedAt, "resourceCreatedAt meta exists on created card");
-			assert.strictEqual(json.data.meta?.resourceCreatedAt, createdAt, "resourceCreatedAt matches file created time");
-		} else assert.ok(false, "response body is not a card document");
-		if (!id) assert.ok(false, "card document is missing an ID");
-		let result = await realm.realmIndexQueryEngine.cardDocument(new URL(json.data.links.self));
-		if (result?.type === "error") throw new Error(`unexpected error when getting card from index: ${result.error.errorDetail.message}`);
-		assert.strictEqual(result?.doc.data.id, `${testRealmURL}CardDef/${id}`, "found card in index");
-	});
-	(0, import_qunit.test)("realm cannot create card request which is NOT directory", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		});
-		let notDirPath = `${testRealmURL}SomeDirectory`;
-		let notFoundResponse = await handle(realm, new Request(notDirPath, {
-			method: "POST",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} }
-			} }, null, 2)
-		}));
-		let notFoundJson = await notFoundResponse.json();
-		assert.strictEqual(notFoundJson.errors[0].status, 404);
-		assert.strictEqual(notFoundResponse.status, 404);
-	});
-	(0, import_qunit.test)("realm allows create card requests into directories of the realm", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		});
-		let dirName = "SomeDirectory";
-		let dirPath = `${testRealmURL}${dirName}/`;
-		let json = await (await handle(realm, new Request(dirPath, {
-			method: "POST",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} }
-			} }, null, 2)
-		}))).json();
-		let id;
-		if (isSingleCardDocument(json)) {
-			id = json.data.id.split("/").pop();
-			assert.true(validate(id), "card ID is a UUID");
-			assert.strictEqual(json.data.id, `${dirPath}CardDef/${id}`, "the card URL is correct");
-			assert.ok((await adapter.openFile(`${dirName}/CardDef/${id}.json`))?.content, "file contents exist");
-			let createdAt = await getFileCreatedAt(realm, `${dirName}/CardDef/${id}.json`);
-			assert.ok(json.data.meta?.resourceCreatedAt, "resourceCreatedAt meta exists on created card in directory");
-			assert.strictEqual(json.data.meta?.resourceCreatedAt, createdAt, "resourceCreatedAt matches file created time (directory)");
-		} else assert.ok(false, "response body is not a card document");
-		if (!id) assert.ok(false, "card document is missing an ID");
-		let result = await realm.realmIndexQueryEngine.cardDocument(new URL(json.data.links.self));
-		if (result?.type === "error") throw new Error(`unexpected error when getting card from index: ${result.error.errorDetail.message}`);
-		assert.strictEqual(result?.doc.data.id, `${testRealmURL}${dirName}/CardDef/${id}`, "found card in index");
-	});
-	(0, import_qunit.test)("realm can serve POST requests that include linksTo fields", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/owner.json": { data: {
-				id: `${testRealmURL}dir/owner`,
-				attributes: {
-					firstName: "Hassan",
-					lastName: "Abdel-Rahman"
-				},
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}person`,
-					name: "Person"
-				} }
-			} } }
-		});
-		let response = await handle(realm, new Request(testRealmURL, {
-			method: "POST",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				attributes: { firstName: "Mango" },
-				relationships: { owner: { links: { self: `${testRealmURL}dir/owner` } } },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet`,
-					name: "Pet"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 201, "successful http status");
-		let json = await response.json();
-		let id = json.data.id.split("/").pop();
-		let petCreatedAt = await getFileCreatedAt(realm, `Pet/${id}.json`);
-		assert.ok(validate(id), "card ID is a UUID");
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json, { data: {
-			type: "card",
-			id: `${testRealmURL}Pet/${id}`,
-			attributes: {
-				firstName: "Mango",
-				cardTitle: "Mango",
-				cardDescription: null,
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: { owner: { links: { self: `../dir/owner` } } },
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet`,
-					name: "Pet"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}Pet/${id}.json`),
-				resourceCreatedAt: petCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			},
-			links: { self: `${testRealmURL}Pet/${id}` }
-		} });
-		let fileRef = await adapter.openFile(`Pet/${id}.json`);
-		if (!fileRef) throw new Error("file not found");
-		assert.deepEqual(JSON.parse(fileRef.content), { data: {
-			type: "card",
-			attributes: { firstName: "Mango" },
-			relationships: { owner: { links: { self: `../dir/owner` } } },
-			meta: { adoptsFrom: {
-				module: `${testModuleRealm}pet`,
-				name: "Pet"
-			} }
-		} }, "file contents are correct");
-	});
-	(0, import_qunit.test)("realm returns 500 error for POST requests that set the value of a polymorphic field to an incompatible type", async function(assert) {
-		class Person extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "firstName", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
-		}
-		class Car extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "make", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#make = (initializeDeferredDecorator(this, "make"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "model", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#model = (initializeDeferredDecorator(this, "model"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "year", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#year = (initializeDeferredDecorator(this, "year"), void 0);
-		}
-		class Driver extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "card", [field], function() {
-					return contains(Person);
-				});
-			}
-			#card = (initializeDeferredDecorator(this, "card"), void 0);
-		}
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"driver.gts": { Driver },
-				"person.gts": { Person },
-				"car.gts": { Car }
-			}
-		});
-		let response = await handle(realm, new Request(testRealmURL, {
-			method: "POST",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				attributes: { card: {
-					firstName: null,
-					make: "Mercedes Benz",
-					model: "C300",
-					year: "2024"
-				} },
-				meta: {
-					adoptsFrom: {
-						module: `${testRealmURL}driver`,
-						name: "Driver"
-					},
-					fields: { card: { adoptsFrom: {
-						module: `${testRealmURL}car`,
-						name: "Car"
-					} } }
-				}
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 500, "500 server error");
-		let json = await response.json();
-		assert.strictEqual(json.errors[0].additionalErrors[0].errorDetail.message, "field validation error: tried set instance of Car as field 'card' but it is not an instance of Person");
-	});
-	(0, import_qunit.test)("realm can serve patch card requests", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/card.json": { data: {
-				attributes: {
-					firstName: "Mango",
-					lastName: "Abdel-Rahman"
-				},
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}person`,
-					name: "Person"
-				} }
-			} } }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/card`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				attributes: { firstName: "Van Gogh" },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}person`,
-					name: "Person"
-				} }
-			} }, null, 2)
-		}));
-		await realm.flushUpdateEvents();
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		if (isSingleCardDocument(json)) {
-			assert.strictEqual(json.data.id, `${testRealmURL}dir/card`, "the id is correct");
-			assert.strictEqual(json.data.attributes?.firstName, "Van Gogh", "field value is correct");
-			assert.strictEqual(json.data.attributes?.lastName, "Abdel-Rahman", "field value is correct");
-			assert.strictEqual(json.data.meta.lastModified, adapter.lastModifiedMap.get(`${testRealmURL}dir/card.json`), "lastModified is correct");
-			let fileRef = await adapter.openFile("dir/card.json");
-			if (!fileRef) throw new Error("file not found");
-			assert.deepEqual(JSON.parse(fileRef.content), { data: {
-				type: "card",
-				attributes: {
-					firstName: "Van Gogh",
-					lastName: "Abdel-Rahman"
-				},
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}person`,
-					name: "Person"
-				} }
-			} }, "file contents are correct");
-		} else assert.ok(false, "response body is not a card document");
-		let queryEngine = realm.realmIndexQueryEngine;
-		let result = await queryEngine.cardDocument(new URL(json.data.links.self));
-		if (result?.type === "error") throw new Error(`unexpected error when getting card from index: ${result.error.errorDetail.message}`);
-		assert.strictEqual(result?.doc.data.id, `${testRealmURL}dir/card`, "found card in index");
-		assert.strictEqual(result?.doc.data.attributes?.firstName, "Van Gogh", "field value is correct");
-		assert.strictEqual(result?.doc.data.attributes?.lastName, "Abdel-Rahman", "field value is correct");
-		let { data: cards } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: rri(`${testModuleRealm}person`),
-				name: "Person"
-			},
-			eq: { firstName: "Van Gogh" }
-		} });
-		assert.strictEqual(cards.length, 1, "search finds updated value");
-	});
-	(0, import_qunit.test)("realm can remove item from containsMany field via PATCH request", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "ski-trip.json": { data: {
-				attributes: {
-					cardTitle: "Gore Mountain Ski Trip",
-					venue: "Gore Mountain",
-					startTime: "2023-02-18T10:00:00.000Z",
-					endTime: "2023-02-19T02:00:00.000Z",
-					hosts: [{ firstName: "Hassan" }, { firstName: "Mango" }],
-					sponsors: ["Burton", "Spy Optics"],
-					posts: []
-				},
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}booking`,
-					name: "Booking"
-				} }
-			} } }
-		});
-		let resourceCreatedAt = await getFileCreatedAt(realm, "ski-trip.json");
-		let response = await handle(realm, new Request(`${testRealmURL}ski-trip`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				attributes: {
-					hosts: [{
-						firstName: "Hassan",
-						lastName: null
-					}],
-					sponsors: ["Burton"]
-				},
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}booking`,
-					name: "Booking"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json, { data: {
-			type: "card",
-			id: `${testRealmURL}ski-trip`,
-			links: { self: `${testRealmURL}ski-trip` },
-			attributes: {
-				cardTitle: "Gore Mountain Ski Trip",
-				venue: "Gore Mountain",
-				startTime: "2023-02-18T10:00:00.000Z",
-				endTime: "2023-02-19T02:00:00.000Z",
-				hosts: [{
-					cardDescription: "Person",
-					firstName: "Hassan",
-					lastName: null,
-					fullName: "Hassan ",
-					cardTitle: "Hassan ",
-					email: null,
-					posts: null
-				}],
-				sponsors: ["Burton"],
-				posts: [],
-				cardDescription: "Gore Mountain",
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}booking`,
-					name: "Booking"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}ski-trip.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			}
-		} });
-		let fileRef = await adapter.openFile("ski-trip.json");
-		if (!fileRef) throw new Error("file not found");
-		assert.deepEqual(JSON.parse(fileRef.content), { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Gore Mountain Ski Trip",
-				venue: "Gore Mountain",
-				startTime: "2023-02-18T10:00:00.000Z",
-				endTime: "2023-02-19T02:00:00.000Z",
-				hosts: [{
-					firstName: "Hassan",
-					lastName: null
-				}],
-				sponsors: ["Burton"],
-				posts: []
-			},
-			meta: { adoptsFrom: {
-				module: `${testModuleRealm}booking`,
-				name: "Booking"
-			} }
-		} }, "file contents are correct");
-	});
-	(0, import_qunit.test)("realm PATCH replaces a primitive field holding an object rather than merging into it", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "realm.json": { data: {
-				type: "card",
-				attributes: {
-					cardInfo: {
-						name: "Settings Workspace",
-						summary: "Kept"
-					},
-					config: {
-						approver: "@mae:localhost",
-						retired: true
-					}
-				},
-				meta: { adoptsFrom: {
-					module: "@cardstack/base/realm-config",
-					name: "RealmConfig"
-				} }
-			} } }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}realm`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				attributes: {
-					cardInfo: { name: "Renamed Workspace" },
-					config: { approvers: "@mae:localhost" }
-				},
-				meta: { adoptsFrom: {
-					module: "@cardstack/base/realm-config",
-					name: "RealmConfig"
-				} }
-			} })
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let fileRef = await adapter.openFile("realm.json");
-		if (!fileRef) throw new Error("file not found");
-		let { attributes } = JSON.parse(fileRef.content).data;
-		assert.deepEqual(attributes.config, { approvers: "@mae:localhost" }, "the stored map is the one the patch sent, with the renamed and dropped keys gone");
-		assert.strictEqual(attributes.cardInfo.name, "Renamed Workspace", "the compound field takes the nested value the patch names");
-		assert.strictEqual(attributes.cardInfo.summary, "Kept", "and keeps the nested value the patch leaves out");
-	});
-	(0, import_qunit.test)("realm PATCH replaces a primitive inside a compound field, by the type the card names for it", async function(assert) {
-		let { JsonField } = await loader.import("@cardstack/base/json-field");
-		class Settings extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "label", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#label = (initializeDeferredDecorator(this, "label"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "values", [field], function() {
-					return contains(JsonField);
-				});
-			}
-			#values = (initializeDeferredDecorator(this, "values"), void 0);
-		}
-		class SpecialSettings extends Settings {
-			static {
-				decorateFieldV2(this.prototype, "extra", [field], function() {
-					return contains(JsonField);
-				});
-			}
-			#extra = (initializeDeferredDecorator(this, "extra"), void 0);
-		}
-		class Holder extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "settings", [field], function() {
-					return contains(Settings);
-				});
-			}
-			#settings = (initializeDeferredDecorator(this, "settings"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "special", [field], function() {
-					return contains(Settings);
-				});
-			}
-			#special = (initializeDeferredDecorator(this, "special"), void 0);
-		}
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"holder.gts": {
-					Holder,
-					Settings,
-					SpecialSettings
-				},
-				"holder-1.json": { data: {
-					type: "card",
-					attributes: {
-						settings: {
-							label: "Kept",
-							values: {
-								a: 1,
-								b: 2
-							}
-						},
-						special: {
-							label: "Special",
-							extra: {
-								a: 1,
-								b: 2
-							}
-						}
-					},
-					meta: {
-						adoptsFrom: {
-							module: `${testRealmURL}holder`,
-							name: "Holder"
-						},
-						fields: { special: { adoptsFrom: {
-							module: `${testRealmURL}holder`,
-							name: "SpecialSettings"
-						} } }
-					}
-				} }
-			}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}holder-1`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				attributes: {
-					settings: { values: { a: 1 } },
-					special: { extra: { a: 1 } }
-				},
-				meta: { adoptsFrom: {
-					module: `${testRealmURL}holder`,
-					name: "Holder"
-				} }
-			} })
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let fileRef = await adapter.openFile("holder-1.json");
-		if (!fileRef) throw new Error("file not found");
-		let { attributes } = JSON.parse(fileRef.content).data;
-		assert.deepEqual(attributes.settings.values, { a: 1 }, "the primitive inside the compound field is replaced");
-		assert.strictEqual(attributes.settings.label, "Kept", "while the compound field keeps the nested value the patch leaves out");
-		assert.deepEqual(attributes.special.extra, { a: 1 }, "a primitive the polymorphic type declares is replaced too");
-	});
-	(0, import_qunit.test)("realm can remove item from linksToMany field via PATCH request", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/van-gogh.json": { data: {
-					id: `${testRealmURL}dir/van-gogh`,
-					attributes: { firstName: "Van Gogh" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: { firstName: "Mango" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/friend.json": { data: {
-					id: `${testRealmURL}dir/friend`,
-					attributes: {
-						firstName: "Hassan",
-						lastName: "Abdel-Rahman"
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"jackie.json": { data: {
-					id: `${testRealmURL}jackie`,
-					attributes: { firstName: "Jackie" },
-					relationships: {
-						"pets.0": { links: { self: `${testRealmURL}dir/van-gogh` } },
-						"pets.1": { links: { self: `${testRealmURL}dir/mango` } },
-						friend: { links: { self: `${testRealmURL}dir/friend` } }
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet-person`,
-						name: "PetPerson"
-					} }
-				} }
-			}
-		});
-		let resourceCreatedAt = await getFileCreatedAt(realm, "jackie.json");
-		let response = await handle(realm, new Request(`${testRealmURL}jackie`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: { "pets.0": { links: { self: `${testRealmURL}dir/van-gogh` } } },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json, { data: {
-			type: "card",
-			id: `${testRealmURL}jackie`,
-			links: { self: `${testRealmURL}jackie` },
-			attributes: {
-				firstName: "Jackie",
-				cardTitle: "Jackie Pet Person",
-				cardDescription: "A person with pets",
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: {
-				"pets.0": { links: { self: `./dir/van-gogh` } },
-				friend: { links: { self: `./dir/friend` } }
-			},
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				},
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL,
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}jackie.json`),
-				resourceCreatedAt
-			}
-		} });
-		let fileRef = await adapter.openFile("jackie.json");
-		if (!fileRef) throw new Error("file not found");
-		assert.deepEqual(JSON.parse(fileRef.content), { data: {
-			type: "card",
-			attributes: { firstName: "Jackie" },
-			relationships: {
-				"pets.0": { links: { self: `./dir/van-gogh` } },
-				friend: { links: { self: `./dir/friend` } }
-			},
-			meta: { adoptsFrom: {
-				module: `${testModuleRealm}pet-person`,
-				name: "PetPerson"
-			} }
-		} }, "file contents are correct");
-	});
-	(0, import_qunit.test)("realm can add an item to linksToMany relationships via PATCH request", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/van-gogh.json": { data: {
-					id: `${testRealmURL}dir/van-gogh`,
-					attributes: { firstName: "Van Gogh" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: { firstName: "Mango" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/friend.json": { data: {
-					id: `${testRealmURL}dir/friend`,
-					attributes: {
-						firstName: "Hassan",
-						lastName: "Abdel-Rahman"
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"jackie.json": { data: {
-					id: `${testRealmURL}jackie`,
-					attributes: { firstName: "Jackie" },
-					relationships: {
-						"pets.0": { links: { self: `${testRealmURL}dir/van-gogh` } },
-						friend: { links: { self: `${testRealmURL}dir/friend` } }
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet-person`,
-						name: "PetPerson"
-					} }
-				} }
-			}
-		});
-		let resourceCreatedAt = await getFileCreatedAt(realm, "jackie.json");
-		let response = await handle(realm, new Request(`${testRealmURL}jackie`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: {
-					"pets.0": { links: { self: `${testRealmURL}dir/mango` } },
-					"pets.1": { links: { self: `${testRealmURL}dir/van-gogh` } }
-				},
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json.data, {
-			type: "card",
-			id: `${testRealmURL}jackie`,
-			links: { self: `${testRealmURL}jackie` },
-			attributes: {
-				firstName: "Jackie",
-				cardTitle: "Jackie Pet Person",
-				cardDescription: "A person with pets",
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: {
-				"pets.0": { links: { self: `./dir/mango` } },
-				"pets.1": { links: { self: `./dir/van-gogh` } },
-				friend: { links: { self: `./dir/friend` } }
-			},
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}jackie.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			}
-		});
-	});
-	(0, import_qunit.test)("realm can add items to null linksToMany relationship via PATCH request", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/van-gogh.json": { data: {
-					id: `${testRealmURL}dir/van-gogh`,
-					attributes: { firstName: "Van Gogh" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: { firstName: "Mango" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"jackie.json": { data: {
-					id: `${testRealmURL}jackie`,
-					attributes: { firstName: "Jackie" },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet-person`,
-						name: "PetPerson"
-					} }
-				} }
-			}
-		});
-		let resourceCreatedAt = await getFileCreatedAt(realm, "jackie.json");
-		let response = await handle(realm, new Request(`${testRealmURL}jackie`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: {
-					"pets.0": { links: { self: `${testRealmURL}dir/mango` } },
-					"pets.1": { links: { self: `${testRealmURL}dir/van-gogh` } }
-				},
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json.data, {
-			type: "card",
-			id: `${testRealmURL}jackie`,
-			links: { self: `${testRealmURL}jackie` },
-			attributes: {
-				firstName: "Jackie",
-				cardTitle: "Jackie Pet Person",
-				cardDescription: "A person with pets",
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: {
-				"pets.0": { links: { self: `./dir/mango` } },
-				"pets.1": { links: { self: `./dir/van-gogh` } }
-			},
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}jackie.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			}
-		});
-	});
-	(0, import_qunit.test)("realm PATCH request can set a linksTo nested within a containsMany", async function(assert) {
-		class Other extends CardDef {
-			static displayName = "Other";
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		class Inner extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "message", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#message = (initializeDeferredDecorator(this, "message"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "other", [field], function() {
-					return linksTo(Other);
-				});
-			}
-			#other = (initializeDeferredDecorator(this, "other"), void 0);
-			static embedded = class Embedded extends Component {
-				static {
-					setComponentTemplate(templateFactory({
-						"id": "k2LMuWBu",
-						"block": "[[[1,\"x: \"],[1,[30,1,[\"other\",\"name\"]]]],[\"@model\"],[]]",
-						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/realm-test.gts",
-						"isStrictMode": true
-					}), this);
-				}
-			};
-		}
-		class Outer extends CardDef {
-			static displayName = "Outer2";
-			static {
-				decorateFieldV2(this.prototype, "inners", [field], function() {
-					return containsMany(Inner);
-				});
-			}
-			#inners = (initializeDeferredDecorator(this, "inners"), void 0);
-		}
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"outer.gts": {
-					Outer,
-					Inner,
-					Other
-				},
-				"1.json": { data: {
-					id: `${testRealmURL}1`,
-					attributes: { inners: [{ message: "hello" }] },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testRealmURL}outer`,
-						name: "Outer"
-					} }
-				} },
-				"2.json": { data: {
-					id: `${testRealmURL}2`,
-					attributes: { name: "Jackie" },
-					meta: { adoptsFrom: {
-						module: `${testRealmURL}outer`,
-						name: "Other"
-					} }
-				} }
-			}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}1`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: { "inners.0.other": { links: { self: `${testRealmURL}2` } } },
-				meta: { adoptsFrom: {
-					module: `${testRealmURL}outer`,
-					name: "Outer"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.deepEqual(json.data.relationships, { "inners.0.other": { links: { self: `./2` } } });
-		assert.deepEqual(JSON.parse(adapter.files.contents["1.json"].content).data.relationships, { "inners.0.other": { links: { self: "./2" } } });
-	});
-	(0, import_qunit.test)("realm can remove all items to in a linksToMany relationship via PATCH request", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/van-gogh.json": { data: {
-					id: `${testRealmURL}dir/van-gogh`,
-					attributes: { firstName: "Van Gogh" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: { firstName: "Mango" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"jackie.json": { data: {
-					id: `${testRealmURL}jackie`,
-					attributes: { firstName: "Jackie" },
-					relationships: {
-						"pets.0": { links: { self: `${testRealmURL}dir/mango` } },
-						"pets.1": { links: { self: `${testRealmURL}dir/van-gogh` } }
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet-person`,
-						name: "PetPerson"
-					} }
-				} }
-			}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}jackie`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: { pets: { links: { self: null } } },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				} }
-			} }, null, 2)
-		}));
-		let resourceCreatedAt = await getFileCreatedAt(realm, "jackie.json");
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json.data, {
-			type: "card",
-			id: `${testRealmURL}jackie`,
-			links: { self: `${testRealmURL}jackie` },
-			attributes: {
-				firstName: "Jackie",
-				cardTitle: "Jackie Pet Person",
-				cardDescription: "A person with pets",
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: { pets: { links: { self: null } } },
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}jackie.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			}
-		});
-	});
-	(0, import_qunit.test)("realm can serve PATCH requests to linksTo field in a card that also has a linksToMany field", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/van-gogh.json": { data: {
-					id: `${testRealmURL}dir/van-gogh`,
-					attributes: { firstName: "Van Gogh" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/friend.json": { data: {
-					id: `${testRealmURL}dir/friend`,
-					attributes: {
-						firstName: "Hassan",
-						lastName: "Abdel-Rahman"
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"dir/different-friend.json": { data: {
-					id: `${testRealmURL}dir/different-friend`,
-					attributes: { firstName: "Burcu" },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"jackie.json": { data: {
-					id: `${testRealmURL}jackie`,
-					attributes: { firstName: "Jackie" },
-					relationships: {
-						"pets.0": { links: { self: `${testRealmURL}dir/van-gogh` } },
-						friend: { links: { self: `${testRealmURL}dir/friend` } }
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet-person`,
-						name: "PetPerson"
-					} }
-				} }
-			}
-		});
-		let resourceCreatedAt = await getFileCreatedAt(realm, "jackie.json");
-		let response = await handle(realm, new Request(`${testRealmURL}jackie`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: { friend: { links: { self: `${testRealmURL}dir/different-friend` } } },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json.data, {
-			type: "card",
-			id: `${testRealmURL}jackie`,
-			links: { self: `${testRealmURL}jackie` },
-			attributes: {
-				firstName: "Jackie",
-				cardTitle: "Jackie Pet Person",
-				cardDescription: "A person with pets",
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: {
-				"pets.0": { links: { self: `./dir/van-gogh` } },
-				friend: { links: { self: `./dir/different-friend` } }
-			},
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}jackie.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			}
-		});
-	});
-	(0, import_qunit.test)("realm can serve PATCH requests to both linksTo and linksToMany fields", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/van-gogh.json": { data: {
-					id: `${testRealmURL}dir/van-gogh`,
-					attributes: { firstName: "Van Gogh" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: { firstName: "Mango" },
-					relationships: { owner: { links: { self: null } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/friend.json": { data: {
-					id: `${testRealmURL}dir/friend`,
-					attributes: {
-						firstName: "Hassan",
-						lastName: "Abdel-Rahman"
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"dir/different-friend.json": { data: {
-					id: `${testRealmURL}dir/different-friend`,
-					attributes: { firstName: "Burcu" },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"jackie.json": { data: {
-					id: `${testRealmURL}jackie`,
-					attributes: { firstName: "Jackie" },
-					relationships: {
-						"pets.0": { links: { self: `${testRealmURL}dir/van-gogh` } },
-						friend: { links: { self: `${testRealmURL}dir/friend` } }
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet-person`,
-						name: "PetPerson"
-					} }
-				} }
-			}
-		});
-		let resourceCreatedAt = await getFileCreatedAt(realm, "jackie.json");
-		let response = await handle(realm, new Request(`${testRealmURL}jackie`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: { friend: { links: { self: `${testRealmURL}dir/different-friend` } } },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json.data, {
-			type: "card",
-			id: `${testRealmURL}jackie`,
-			links: { self: `${testRealmURL}jackie` },
-			attributes: {
-				firstName: "Jackie",
-				cardTitle: "Jackie Pet Person",
-				cardDescription: "A person with pets",
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: {
-				friend: { links: { self: `./dir/different-friend` } },
-				"pets.0": { links: { self: `./dir/van-gogh` } }
-			},
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet-person`,
-					name: "PetPerson"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}jackie.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			}
-		});
-	});
-	(0, import_qunit.test)("realm can serve PATCH requests that include linksTo fields", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/hassan.json": { data: {
-					id: `${testRealmURL}dir/hassan`,
-					attributes: {
-						firstName: "Hassan",
-						lastName: "Abdel-Rahman"
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"dir/mariko.json": { data: {
-					id: `${testRealmURL}dir/mariko`,
-					attributes: {
-						firstName: "Mariko",
-						lastName: "Abdel-Rahman"
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: {
-						cardDescription: null,
-						cardThumbnailURL: null,
-						firstName: "Mango"
-					},
-					relationships: { owner: { links: { self: `${testRealmURL}dir/hassan` } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} }
-			}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/mango`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				relationships: { owner: { links: { self: `${testRealmURL}dir/mariko` } } },
-				meta: { adoptsFrom: {
-					module: `${testModuleRealm}pet`,
-					name: "Pet"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		let mangoCreatedAt = await getFileCreatedAt(realm, "dir/mango.json");
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json, { data: {
-			type: "card",
-			id: `${testRealmURL}dir/mango`,
-			attributes: {
-				firstName: "Mango",
-				cardTitle: "Mango",
-				cardDescription: null,
-				cardThumbnailURL: null,
-				cardInfo
-			},
-			relationships: { owner: { links: { self: `./mariko` } } },
-			meta: {
-				adoptsFrom: {
-					module: `${testModuleRealm}pet`,
-					name: "Pet"
-				},
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}dir/mango.json`),
-				resourceCreatedAt: mangoCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			},
-			links: { self: `${testRealmURL}dir/mango` }
-		} });
-		let fileRef = await adapter.openFile("dir/mango.json");
-		if (!fileRef) throw new Error("file not found");
-		assert.deepEqual(JSON.parse(fileRef.content), { data: {
-			type: "card",
-			attributes: { firstName: "Mango" },
-			relationships: { owner: { links: { self: `./mariko` } } },
-			meta: { adoptsFrom: {
-				module: `${testModuleRealm}pet`,
-				name: "Pet"
-			} }
-		} }, "file contents are correct");
-	});
-	(0, import_qunit.test)("realm can serve PATCH requests that include polymorphic updates", async function(assert) {
-		class Driver extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "card", [field], function() {
-					return contains(FieldDef);
-				});
-			}
-			#card = (initializeDeferredDecorator(this, "card"), void 0);
-		}
-		class Person extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "firstName", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
-		}
-		class Car extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "make", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#make = (initializeDeferredDecorator(this, "make"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "model", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#model = (initializeDeferredDecorator(this, "model"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "year", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#year = (initializeDeferredDecorator(this, "year"), void 0);
-		}
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"driver.gts": { Driver },
-				"person.gts": { Person },
-				"car.gts": { Car },
-				"dir/driver.json": { data: {
-					id: `${testRealmURL}dir/driver`,
-					attributes: { card: { firstName: "Mango" } },
-					meta: {
-						adoptsFrom: {
-							module: `${testRealmURL}driver`,
-							name: "Driver"
-						},
-						fields: { card: { adoptsFrom: {
-							module: `${testRealmURL}person`,
-							name: "Person"
-						} } }
-					}
-				} }
-			}
-		});
-		let resourceCreatedAt = await getFileCreatedAt(realm, "dir/driver.json");
-		let response = await handle(realm, new Request(`${testRealmURL}dir/driver`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				attributes: { card: {
-					firstName: null,
-					make: "Mercedes Benz",
-					model: "C300",
-					year: "2024"
-				} },
-				meta: {
-					adoptsFrom: {
-						module: `${testRealmURL}driver`,
-						name: "Driver"
-					},
-					fields: { card: { adoptsFrom: {
-						module: `${testRealmURL}car`,
-						name: "Car"
-					} } }
-				}
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let json = await response.json();
-		assert.strictEqual(typeof json.data.meta.version, "string", "the write response carries the stored file version");
-		delete json.data.meta.version;
-		assert.deepEqual(json, { data: {
-			type: "card",
-			id: `${testRealmURL}dir/driver`,
-			attributes: {
-				card: {
-					make: "Mercedes Benz",
-					model: "C300",
-					year: "2024"
-				},
-				cardDescription: null,
-				cardThumbnailURL: null,
-				cardTitle: "Untitled Card",
-				cardInfo
-			},
-			meta: {
-				adoptsFrom: {
-					module: `../driver`,
-					name: "Driver"
-				},
-				fields: { card: { adoptsFrom: {
-					module: `../car`,
-					name: "Car"
-				} } },
-				lastModified: adapter.lastModifiedMap.get(`${testRealmURL}dir/driver.json`),
-				resourceCreatedAt,
-				realmInfo: testRealmInfo,
-				realmURL: testRealmURL
-			},
-			links: { self: `${testRealmURL}dir/driver` }
-		} });
-		let fileRef = await adapter.openFile("dir/driver.json");
-		if (!fileRef) throw new Error("file not found");
-		assert.deepEqual(JSON.parse(fileRef.content), { data: {
-			type: "card",
-			attributes: { card: {
-				make: "Mercedes Benz",
-				model: "C300",
-				year: "2024"
-			} },
-			meta: {
-				adoptsFrom: {
-					module: `../driver`,
-					name: "Driver"
-				},
-				fields: { card: { adoptsFrom: {
-					module: `../car`,
-					name: "Car"
-				} } }
-			}
-		} }, "file contents are correct");
-	});
-	(0, import_qunit.test)("realm returns 400 error for PATCH requests that change the type of the underlying instance", async function(assert) {
-		class Person extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "firstName", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
-		}
-		class Car extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "make", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#make = (initializeDeferredDecorator(this, "make"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "model", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#model = (initializeDeferredDecorator(this, "model"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "year", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#year = (initializeDeferredDecorator(this, "year"), void 0);
-		}
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"person.gts": { Person },
-				"car.gts": { Car },
-				"dir/person.json": { data: {
-					attributes: { firstName: "Mango" },
-					meta: { adoptsFrom: {
-						module: `../person`,
-						name: "Person"
-					} }
-				} }
-			}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/person`, {
-			method: "PATCH",
-			headers: { Accept: "application/vnd.card+json" },
-			body: JSON.stringify({ data: {
-				type: "card",
-				attributes: {
-					make: "Mercedes Benz",
-					model: "C300",
-					year: "2024"
-				},
-				meta: { adoptsFrom: {
-					module: `${testRealmURL}car`,
-					name: "Car"
-				} }
-			} }, null, 2)
-		}));
-		assert.strictEqual(response.status, 400, "400 server error");
-		let fileRef = await adapter.openFile("dir/person.json");
-		if (!fileRef) throw new Error("file not found");
-		assert.deepEqual(JSON.parse(fileRef.content), { data: {
-			attributes: { firstName: "Mango" },
-			meta: { adoptsFrom: {
-				module: `../person`,
-				name: "Person"
-			} }
-		} }, "file contents are correct");
-	});
-	(0, import_qunit.test)("realm returns 500 error for PATCH requests that set the value of a polymorphic field to an incompatible type", async function(assert) {
-		class Person extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "firstName", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
-		}
-		class Car extends FieldDef {
-			static {
-				decorateFieldV2(this.prototype, "make", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#make = (initializeDeferredDecorator(this, "make"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "model", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#model = (initializeDeferredDecorator(this, "model"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "year", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#year = (initializeDeferredDecorator(this, "year"), void 0);
-		}
-		class Driver extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "card", [field], function() {
-					return contains(Person);
-				});
-			}
-			#card = (initializeDeferredDecorator(this, "card"), void 0);
-		}
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"driver.gts": { Driver },
-				"person.gts": { Person },
-				"car.gts": { Car },
-				"dir/driver.json": { data: {
-					attributes: { card: { firstName: "Mango" } },
-					meta: {
-						adoptsFrom: {
-							module: `${testRealmURL}driver`,
-							name: "Driver"
-						},
-						fields: { card: { adoptsFrom: {
-							module: `../person`,
-							name: "Person"
-						} } }
-					}
-				} }
-			}
-		});
-		try {
-			globalThis.__emulateServerPatchFailure = true;
-			let response = await handle(realm, new Request(`${testRealmURL}dir/driver`, {
-				method: "PATCH",
-				headers: { Accept: "application/vnd.card+json" },
-				body: JSON.stringify({ data: {
-					type: "card",
-					attributes: { card: {
-						firstName: null,
-						make: "Mercedes Benz",
-						model: "C300",
-						year: "2024"
-					} },
-					meta: {
-						adoptsFrom: {
-							module: `${testRealmURL}driver`,
-							name: "Driver"
-						},
-						fields: { card: { adoptsFrom: {
-							module: `${testRealmURL}car`,
-							name: "Car"
-						} } }
-					}
-				} }, null, 2)
-			}));
-			assert.strictEqual(response.status, 500, "500 server error");
-			let json = await response.json();
-			assert.strictEqual(json.errors[0].additionalErrors[0].errorDetail.message, "field validation error: tried set instance of Car as field 'card' but it is not an instance of Person");
-		} finally {
-			delete globalThis.__emulateServerPatchFailure;
-		}
-	});
-	(0, import_qunit.test)("realm can serve delete card requests", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"cards/1.json": { data: { meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} } } },
-				"cards/2.json": { data: { meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} } } }
-			}
-		});
-		let queryEngine = realm.realmIndexQueryEngine;
-		let { data: cards } = await searchCardsForTest(queryEngine, { filter: { type: baseCardRef } });
-		assert.strictEqual(cards.length, 2, "two cards found");
-		let result = await queryEngine.cardDocument(new URL(`${testRealmURL}cards/2`));
-		if (result?.type === "error") throw new Error(`unexpected error when getting card from index: ${result.error.errorDetail.message}`);
-		assert.strictEqual(result?.doc.data.id, `${testRealmURL}cards/2`, "found card in index");
-		let response = await handle(realm, new Request(`${testRealmURL}cards/2`, {
-			method: "DELETE",
-			headers: { Accept: "application/vnd.card+json" }
-		}));
-		await realm.flushUpdateEvents();
-		assert.strictEqual(response.status, 204, "status was 204");
-		result = await queryEngine.cardDocument(new URL(`${testRealmURL}cards/2`));
-		assert.strictEqual(result, void 0, "card was deleted");
-		let deletedFile = await adapter.openFile("cards/2.json");
-		assert.strictEqual(deletedFile, void 0, "underlying file for deleted card no longer exists");
-		result = await queryEngine.cardDocument(new URL(`${testRealmURL}cards/1`));
-		if (result?.type === "error") throw new Error(`unexpected error when getting card from index: ${result.error.errorDetail.message}`);
-		assert.strictEqual(result?.doc.data.id, `${testRealmURL}cards/1`, "card 1 is still there");
-		cards = (await searchCardsForTest(queryEngine, { filter: { type: baseCardRef } })).data;
-		assert.strictEqual(cards.length, 1, "only one card remains");
-	});
-	(0, import_qunit.test)("realm can serve card source file", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/person.gts": cardSrc }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/person.gts`, { headers: { Accept: "application/vnd.card+source" } }));
-		assert.strictEqual(response.status, 200, "200 HTTP status");
-		let responseText = await response.text();
-		assert.strictEqual(responseText, cardSrc, "the card source is correct");
-		assert.ok(response.headers.get("last-modified"), "last-modified header exists");
-	});
-	(0, import_qunit.test)("realm provide redirect for card source", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/person.gts": cardSrc }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/person`, { headers: { Accept: "application/vnd.card+source" } }));
-		assert.strictEqual(response.status, 302, "302 HTTP status");
-		assert.strictEqual(response.headers.get("Location"), "/test/dir/person.gts", "Location header is correct");
-	});
-	(0, import_qunit.test)("realm returns 404 when no card source can be found", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/person`, { headers: { Accept: "application/vnd.card+source" } }));
-		assert.strictEqual(response.status, 404, "404 HTTP status");
-	});
-	(0, import_qunit.test)("realm can serve card source post request", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		});
-		{
-			let response = await handle(realm, new Request(`${testRealmURL}dir/person.gts`, {
-				method: "POST",
-				headers: { Accept: "application/vnd.card+source" },
-				body: cardSrc
-			}));
-			await realm.flushUpdateEvents();
-			assert.strictEqual(response.status, 204, "HTTP status is 204");
-			assert.ok(response.headers.get("last-modified"), "last-modified header exists");
-		}
-		{
-			let response = await handle(realm, new Request(`${testRealmURL}dir/person.gts`, { headers: { Accept: "application/vnd.card+source" } }));
-			assert.strictEqual(response.status, 200, "200 HTTP status");
-			let responseText = await response.text();
-			assert.strictEqual(responseText, cardSrc, "the card source is correct");
-		}
-	});
-	(0, import_qunit.test)("realm can serve card source delete request", async function(assert) {
-		let { field, contains, CardDef } = await loader.import("@cardstack/base/card-api");
-		let { default: StringField } = await loader.import("@cardstack/base/string");
-		class Person extends CardDef {
-			static {
-				decorateFieldV2(this.prototype, "firstName", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "lastName", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
-		}
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "person.gts": { Person } }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}person`, { headers: { Accept: "application/vnd.card+source" } }));
-		await realm.flushUpdateEvents();
-		assert.strictEqual(response.status, 302, "file exists");
-		response = await handle(realm, new Request(`${testRealmURL}person`, {
-			method: "DELETE",
-			headers: { Accept: "application/vnd.card+source" }
-		}));
-		await realm.flushUpdateEvents();
-		assert.strictEqual(response.status, 204, "file is deleted");
-		response = await handle(realm, new Request(`${testRealmURL}person`, { headers: { Accept: "application/vnd.card+source" } }));
-		assert.strictEqual(response.status, 404, "file no longer exists");
-	});
-	(0, import_qunit.test)("realm can serve compiled js file when requested without file extension ", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/person.gts": cardSrc }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/person`));
-		assert.strictEqual(response.status, 200, "HTTP 200 status code");
-		let compiledJS = await response.text();
-		assert.codeEqual(stripScopedCSSGlimmerAttributes(compiledJS.replace(/"id":\s"[^"]+"/, "\"id\": \"<id>\"")), compiledCard("\"<id>\""), "compiled card is correct");
-	});
-	(0, import_qunit.test)("realm can serve compiled js file when requested with file extension ", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/person.gts": cardSrc }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/person.gts`));
-		assert.strictEqual(response.status, 200, "HTTP 200 status code");
-		let compiledJS = await response.text();
-		assert.codeEqual(stripScopedCSSGlimmerAttributes(compiledJS.replace(/"id":\s"[^"]+"/, "\"id\": \"<id>\"")), compiledCard("\"<id>\""), "compiled card is correct");
-	});
-	(0, import_qunit.test)("realm can serve file asset (not card source, not js, not JSON-API)", async function(assert) {
-		let html = `
-      <html>
-        <body>
-          <h1>Hello World</h1>
-        </body>
-      </html>
-    `.trim();
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/index.html": html }
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/index.html`));
-		assert.strictEqual(response.status, 200, "HTTP 200 status code");
-		let responseText = await response.text();
-		assert.strictEqual(responseText, html, "asset contents are correct");
-	});
-	(0, import_qunit.test)("realm can serve search requests", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "dir/empty.json": { data: {
-				attributes: {},
-				meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "CardDef"
-				} }
-			} } }
-		});
-		let json = await (await handle(realm, new Request(`${testRealmURL}_search`, {
-			method: "QUERY",
-			headers: {
-				Accept: "application/vnd.card+json",
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify(searchEntryWireQueryFromQuery({ filter: { type: baseCardRef } }, { fields: ["item"] }))
-		}))).json();
-		assert.strictEqual(json.data.length, 1, "the card is returned in the search results");
-		assert.strictEqual(json.data[0].id, `${testRealmURL}dir/empty`, "card ID is correct");
-	});
-	(0, import_qunit.test)("realm can serve search requests whose results have linksTo fields", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/mariko.json": { data: {
-					id: `${testRealmURL}dir/mariko`,
-					attributes: {
-						firstName: "Mariko",
-						lastName: "Abdel-Rahman"
-					},
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}person`,
-						name: "Person"
-					} }
-				} },
-				"dir/mango.json": { data: {
-					id: `${testRealmURL}dir/mango`,
-					attributes: {
-						cardDescription: null,
-						cardThumbnailURL: null,
-						firstName: "Mango"
-					},
-					relationships: { owner: { links: { self: `${testRealmURL}dir/mariko` } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} },
-				"dir/vanGogh.json": { data: {
-					id: `${testRealmURL}dir/vanGogh`,
-					attributes: { firstName: "Van Gogh" },
-					relationships: { owner: { links: { self: `${testModuleRealm}hassan` } } },
-					meta: { adoptsFrom: {
-						module: `${testModuleRealm}pet`,
-						name: "Pet"
-					} }
-				} }
-			}
-		});
-		let json = await (await handle(realm, new Request(`${testRealmURL}_search`, {
-			method: "QUERY",
-			headers: {
-				Accept: "application/vnd.card+json",
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify(searchEntryWireQueryFromQuery({
-				filter: { type: baseCardRef },
-				sort: [{
-					by: "id",
-					on: {
-						module: rri(`${baseRealmRRI}card-api`),
-						name: "CardDef"
-					}
-				}]
-			}, { fields: ["item"] }))
-		}))).json();
-		let mangoCreatedAt = await getFileCreatedAt(realm, "dir/mango.json");
-		let marikoCreatedAt = await getFileCreatedAt(realm, "dir/mariko.json");
-		let vanGoghCreatedAt = await getFileCreatedAt(realm, "dir/vanGogh.json");
-		let entries = json.data;
-		assert.strictEqual(entries.length, 3, "returns 3 search entries");
-		assert.strictEqual(json.meta.page.total, 3, "meta page total is 3");
-		let included = json.included ?? [];
-		let mango = included.find((r) => r.id === `${testRealmURL}dir/mango`);
-		assert.ok(mango, "mango is in results");
-		assert.strictEqual(mango.attributes.firstName, "Mango", "mango name");
-		assert.strictEqual(mango.relationships.owner.links.self, "./mariko", "mango owner self link");
-		assert.strictEqual(mango.relationships.owner.data.id, `${testRealmURL}dir/mariko`, "mango owner id");
-		assert.strictEqual(mango.meta.resourceCreatedAt, mangoCreatedAt, "mango createdAt");
-		let mariko = included.find((r) => r.id === `${testRealmURL}dir/mariko`);
-		assert.ok(mariko, "mariko is in results");
-		assert.strictEqual(mariko.attributes.fullName, "Mariko Abdel-Rahman", "mariko fullName");
-		assert.strictEqual(mariko.meta.resourceCreatedAt, marikoCreatedAt, "mariko createdAt");
-		let vanGogh = included.find((r) => r.id === `${testRealmURL}dir/vanGogh`);
-		assert.ok(vanGogh, "vanGogh is in results");
-		assert.strictEqual(vanGogh.relationships.owner.links.self, `${testModuleRealm}hassan`, "vanGogh owner self link");
-		assert.strictEqual(vanGogh.relationships.owner.data.id, `${testModuleRealm}hassan`, "vanGogh owner id");
-		assert.strictEqual(vanGogh.meta.resourceCreatedAt, vanGoghCreatedAt, "vanGogh createdAt");
-		let hassan = included.find((r) => r.id === `${testModuleRealm}hassan`);
-		assert.ok(hassan, "hassan (cross-realm linksTo target) is included");
-	});
-	(0, import_qunit.test)("included card uses correct module path when realm is mounted", async function(assert) {
-		let mountedRealmURL = "https://localhost:4201/mounted-test/";
-		let spreadsheet1Id = "spreadsheet-1";
-		let spreadsheet2Id = "spreadsheet-2";
-		class Spreadsheet extends CardDef {
-			static displayName = "Spreadsheet";
-			static {
-				decorateFieldV2(this.prototype, "name", [field], function() {
-					return contains(string_default);
-				});
-			}
-			#name = (initializeDeferredDecorator(this, "name"), void 0);
-		}
-		class CatalogIndex extends CardDef {
-			static displayName = "CatalogIndex";
-			static {
-				decorateFieldV2(this.prototype, "spreadsheets", [field], function() {
-					return linksToMany(Spreadsheet);
-				});
-			}
-			#spreadsheets = (initializeDeferredDecorator(this, "spreadsheets"), void 0);
-		}
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: mountedRealmURL,
-			contents: {
-				"spreadsheet/spreadsheet.gts": { Spreadsheet },
-				"index.gts": { CatalogIndex },
-				[`spreadsheet/Spreadsheet/${spreadsheet1Id}.json`]: { data: {
-					attributes: { name: "Sheet 1" },
-					meta: { adoptsFrom: {
-						module: "../spreadsheet",
-						name: "Spreadsheet"
-					} }
-				} },
-				[`spreadsheet/Spreadsheet/${spreadsheet2Id}.json`]: { data: {
-					attributes: { name: "Sheet 2" },
-					meta: { adoptsFrom: {
-						module: "../spreadsheet",
-						name: "Spreadsheet"
-					} }
-				} },
-				"index.json": { data: {
-					relationships: {
-						"spreadsheets.0": { links: { self: `./spreadsheet/Spreadsheet/${spreadsheet1Id}` } },
-						"spreadsheets.1": { links: { self: `./spreadsheet/Spreadsheet/${spreadsheet2Id}` } }
-					},
-					meta: { adoptsFrom: {
-						module: "./index",
-						name: "CatalogIndex"
-					} }
-				} }
-			}
-		});
-		let response = await handle(realm, new Request(`${mountedRealmURL}index`, { headers: { Accept: "application/vnd.card+json" } }));
-		assert.strictEqual(response.status, 200, "successful http status");
-		let included = (await response.json()).included?.find((resource) => resource.id === `${mountedRealmURL}spreadsheet/Spreadsheet/${spreadsheet1Id}`);
-		assert.ok(included, "linked spreadsheet card is included");
-		assert.strictEqual(included?.meta?.adoptsFrom?.module, "../spreadsheet", "included adoptsFrom.module is relative to the resource own id");
-	});
-	(0, import_qunit.test)("realm can serve directory requests", async function(assert) {
-		let { realm, adapter } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"dir/empty.json": { data: {
-					attributes: {},
-					meta: { adoptsFrom: {
-						module: "@cardstack/base/card-api",
-						name: "CardDef"
-					} }
-				} },
-				"dir/subdir/file.txt": ""
-			}
-		});
-		let response = await handle(realm, new Request(`${testRealmURL}dir/`, { headers: { Accept: "application/vnd.api+json" } }));
-		assert.strictEqual(response.status, 200, "HTTP 200 status code");
-		let json = await response.json();
-		let resourceCreatedAt = await getFileCreatedAt(realm, "dir/empty.json");
-		assert.deepEqual(json, { data: {
-			id: `${testRealmURL}dir/`,
-			type: "directory",
-			relationships: {
-				"subdir/": {
-					links: { related: `${testRealmURL}dir/subdir/` },
-					meta: { kind: "directory" }
-				},
-				"empty.json": {
-					links: { related: `${testRealmURL}dir/empty.json` },
-					meta: {
-						kind: "file",
-						lastModified: adapter.lastModifiedMap.get(`${testRealmURL}dir/empty.json`),
-						resourceCreatedAt
-					}
-				}
-			}
-		} }, "the directory response is correct");
-	});
-	(0, import_qunit.test)("requests do not contain entries that match patterns in ignore files", async function(assert) {
-		const cardSource = `
-      import { CardDef } from '@cardstack/base/card-api';
-      export class Post extends CardDef {}
-    `;
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"sample-post.json": "",
-				"posts/1.json": "",
-				"posts/nested.gts": cardSource,
-				"posts/ignore-me.gts": cardSource,
-				"posts/2.json": "",
-				"post.gts": cardSource,
-				"dir/card.gts": cardSource,
-				".gitignore": `
-*.json
-/dir
-posts/ignore-me.gts
-`
-			}
-		});
-		{
-			let response = await handle(realm, new Request(`${testRealmURL}dir/`, { headers: { Accept: "application/vnd.api+json" } }));
-			assert.strictEqual(response.status, 404, "HTTP 404 response");
-		}
-		{
-			let json = await (await handle(realm, new Request(testRealmURL, { headers: { Accept: "application/vnd.api+json" } }))).json();
-			assert.deepEqual(Object.keys(json.data.relationships).sort(), [
-				".gitignore",
-				"post.gts",
-				"posts/"
-			], "top level entries are correct");
-		}
-		{
-			let json = await (await handle(realm, new Request(`${testRealmURL}posts/`, { headers: { Accept: "application/vnd.api+json" } }))).json();
-			assert.deepEqual(Object.keys(json.data.relationships).sort(), ["nested.gts"], "nested entries are correct");
-		}
-	});
-	(0, import_qunit.test)("realm can serve info requests by reading the RealmConfig card", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "realm.json": realmConfigCardJSON({
-				name: "Example Workspace",
-				backgroundURL: "/test-fixtures/realm-images/4k-powder-puff.jpg",
-				iconURL: "/test-fixtures/realm-images/boxel-logo.png"
-			}) }
-		});
-		let json = await (await handle(realm, new Request(`${testRealmURL}_info`, {
-			method: "QUERY",
-			headers: { Accept: "application/vnd.api+json" }
-		}))).json();
-		assert.strictEqual(json.data.id, testRealmURL, "id is correct");
-		assert.strictEqual(json.data.type, "realm-info", "type is correct");
-		let attributes = json.data.attributes;
-		assert.strictEqual(attributes.name, "Example Workspace", "name");
-		assert.strictEqual(attributes.backgroundURL, "/test-fixtures/realm-images/4k-powder-puff.jpg", "backgroundURL");
-		assert.strictEqual(attributes.iconURL, "/test-fixtures/realm-images/boxel-logo.png", "iconURL");
-		assert.strictEqual(attributes.realmUserId, "@realm_server:localhost", "realmUserId");
-		assert.strictEqual(attributes.showAsCatalog, null, "showAsCatalog");
-		assert.strictEqual(attributes.visibility, "public", "visibility");
-		assert.strictEqual(attributes.publishable, null, "publishable");
-		assert.strictEqual(attributes.lastPublishedAt, null, "lastPublishedAt");
-		assert.strictEqual(attributes.includePrerenderedDefaultRealmIndex, null, "includePrerenderedDefaultRealmIndex");
-	});
-	(0, import_qunit.test)("realm can serve info requests if the RealmConfig card is missing", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		});
-		let json = await (await handle(realm, new Request(`${testRealmURL}_info`, {
-			method: "QUERY",
-			headers: { Accept: "application/vnd.api+json" }
-		}))).json();
-		assert.deepEqual(json, { data: {
-			id: testRealmURL,
-			type: "realm-info",
-			attributes: testRealmInfo
-		} }, "/_info response is correct");
-	});
-	(0, import_qunit.test)("realm can serve info requests if the RealmConfig card is malformed", async function(assert) {
-		let { realm } = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "realm.json": `Some example content that is not valid json` }
-		});
-		let json = await (await handle(realm, new Request(`${testRealmURL}_info`, {
-			method: "QUERY",
-			headers: { Accept: "application/vnd.api+json" }
-		}))).json();
-		assert.deepEqual(json, { data: {
-			id: testRealmURL,
-			type: "realm-info",
-			attributes: testRealmInfo
-		} }, "/_info response is correct");
-	});
-	(0, import_qunit.test)("realm does not crash when indexing a broken instance", async function(assert) {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "FieldDef/1.json": { data: {
-				type: "card",
-				meta: { adoptsFrom: {
-					module: "@cardstack/base/card-api",
-					name: "FieldDef"
-				} }
-			} } }
-		});
-		assert.ok(true, "realm did not crash when trying to index a broken instance");
-	});
-});
-//#endregion