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

package/bundled-test-harness/assets/image-file-def-B0rpS3Yy.js

@@ -0,0 +1,3 @@
+import { f as ImageDef } from "./card-api-Dzje0smT.js";
+import { n as image_file_def_default, r as rasterImageAttributes, t as RasterImageDef } from "./image-file-def-DUFmjNL8.js";
+export { ImageDef, RasterImageDef, image_file_def_default as default, rasterImageAttributes };

package/bundled-test-harness/assets/image-file-def-DUFmjNL8.js

@@ -0,0 +1,65 @@
+import "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { A as field, f as ImageDef, w as contains } from "./card-api-Dzje0smT.js";
+import { t as IMAGE_RENDITION_CAPTURES } from "./image-captures-Db4V2tdL.js";
+import { a as ExifMetadataField, r as ColorProfileField } from "./metadata-fields-WiOuUCDl.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+import { r as enumField } from "./enum-BWiCyJlu.js";
+//#region ../base/image-file-def.gts
+var image_file_def_default = ImageDef;
+var ANIMATION_VALUES = ["animated", "still"];
+var RasterImageDef = class extends ImageDef {
+	static displayName = "Raster Image";
+	static captures = IMAGE_RENDITION_CAPTURES;
+	static {
+		decorateFieldV2(this.prototype, "exif", [field], function() {
+			return contains(ExifMetadataField);
+		});
+	}
+	#exif = (initializeDeferredDecorator(this, "exif"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "colorProfile", [field], function() {
+			return contains(ColorProfileField);
+		});
+	}
+	#colorProfile = (initializeDeferredDecorator(this, "colorProfile"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "animation", [field], function() {
+			return contains(enumField(string_default, { options: ANIMATION_VALUES }));
+		});
+	}
+	#animation = (initializeDeferredDecorator(this, "animation"), void 0);
+};
+function rasterImageAttributes(exif, colorProfile, animated) {
+	let { colorSpace: exifColorSpace, ...cameraFacts } = exif ?? {};
+	let { colorSpace: headerColorSpace, ...pixelFacts } = colorProfile ?? {};
+	let colorSpace = headerColorSpace ?? exifColorSpace;
+	let hasPixelFacts = Object.values(pixelFacts).some((value) => value !== void 0);
+	return {
+		...Object.keys(cameraFacts).length > 0 ? { exif: cameraFacts } : {},
+		...hasPixelFacts || colorSpace ? { colorProfile: {
+			...pixelFacts,
+			...colorSpace ? { colorSpace: {
+				code: colorSpace,
+				scheme: "color-space"
+			} } : {}
+		} } : {},
+		...animated !== void 0 ? { animation: animated ? "animated" : "still" } : {}
+	};
+}
+(globalThis.__boxelBundledBaseScopedCSS ??= {})["image-file-def"] = {
+	"css": [],
+	"imports": [
+		"card-api",
+		"enum",
+		"string",
+		"file-formats/image-captures",
+		"file-formats/metadata-fields"
+	]
+};
+(globalThis.__boxelBundledBaseIdentities ??= {})["image-file-def"] = {
+	"RasterImageDef": RasterImageDef,
+	"rasterImageAttributes": rasterImageAttributes
+};
+//#endregion
+export { image_file_def_default as n, rasterImageAttributes as r, RasterImageDef as t };

package/bundled-test-harness/assets/image-olOUqgMQ.js

@@ -0,0 +1,47 @@
+import "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { A as field, a as CardDef, s as Component, w as contains } from "./card-api-Dzje0smT.js";
+import { n as UrlField } from "./url-mFskVPSX.js";
+//#region ../base/image.gts
+var ImageCardView = class extends Component {
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "d4qHGjAF",
+			"block": "[[[41,[30,1,[\"url\"]],[[[1,\"  \"],[10,\"img\"],[14,0,\"image\"],[15,\"src\",[30,1,[\"url\"]]],[14,\"alt\",\"\"],[14,\"loading\",\"lazy\"],[14,\"data-scopedcss-ba40c3c5ec-a26e2d8670\",\"\"],[12],[13],[1,\"\\n\"]],[]],[[[1,\"  \"],[10,0],[14,0,\"empty-placeholder\"],[14,\"data-scopedcss-ba40c3c5ec-a26e2d8670\",\"\"],[12],[1,\"No image URL provided\"],[13],[1,\"\\n\"]],[]]]],[\"@model\"],[\"if\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/base/image.gts",
+			"isStrictMode": true
+		}), this);
+	}
+};
+var ImageCard = class extends CardDef {
+	static displayName = "Image";
+	static {
+		decorateFieldV2(this.prototype, "url", [field], function() {
+			return contains(UrlField);
+		});
+	}
+	#url = (initializeDeferredDecorator(this, "url"), void 0);
+	static isolated = ImageCardView;
+	static embedded = ImageCardView;
+	static atom = class extends Component {
+		static {
+			setComponentTemplate(templateFactory({
+				"id": "1qS+yjK0",
+				"block": "[[[8,[30,1,[\"url\"]],null,[[\"@format\"],[\"atom\"]],null]],[\"@fields\"],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/base/image.gts",
+				"isStrictMode": true
+			}), this);
+		}
+	};
+};
+(globalThis.__boxelBundledBaseScopedCSS ??= {})["image"] = {
+	"css": ["./image.gts.CiAgLmltYWdlW2RhdGEtc2NvcGVkY3NzLWJhNDBjM2M1ZWMtYTI2ZTJkODY3MF0gewogICAgZGlzcGxheTogYmxvY2s7CiAgICBtYXgtd2lkdGg6IDEwMCU7CiAgICBoZWlnaHQ6IGF1dG87CiAgICBib3JkZXItcmFkaXVzOiB2YXIoLS1ib3hlbC1mb3JtLWNvbnRyb2wtYm9yZGVyLXJhZGl1cyk7CiAgfQogIC5lbXB0eS1wbGFjZWhvbGRlcltkYXRhLXNjb3BlZGNzcy1iYTQwYzNjNWVjLWEyNmUyZDg2NzBdIHsKICAgIHBhZGRpbmc6IHZhcigtLWJveGVsLXNwKTsKICAgIHRleHQtYWxpZ246IGNlbnRlcjsKICAgIGNvbG9yOiB2YXIoLS1ib3hlbC01MDApOwogICAgYmFja2dyb3VuZC1jb2xvcjogdmFyKC0tYm94ZWwtNTApOwogICAgYm9yZGVyLXJhZGl1czogdmFyKC0tYm94ZWwtZm9ybS1jb250cm9sLWJvcmRlci1yYWRpdXMpOwogIH0K.glimmer-scoped.css"],
+	"imports": ["card-api", "url"]
+};
+(globalThis.__boxelBundledBaseIdentities ??= {})["image"] = { "default": ImageCard };
+//#endregion
+export { ImageCard as default };

package/bundled-test-harness/assets/index-changes-test-D7OE-99k.js

@@ -0,0 +1,367 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Ar as testRealmURL, Sc as Deferred, uo as SupportedMimeType } from "./runtime-common-ClpqhbwG.js";
+import { y as rri } from "./paths-BYHDgqsT.js";
+import { M as waitUntil, T as settled, a as find, d as click, r as typeIn, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { L as setupRealmCacheTeardown, st as visitOperatorMode, xt as getTestRealmRegistry } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { n as setupInteractSubmodeTests } from "./interact-submode-setup-D4M_e580.js";
+//#region tests/acceptance/interact-submode/index-changes-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Acceptance | interact submode | index changes tests", function(hooks) {
+	let realm;
+	setupInteractSubmodeTests(hooks, { setRealm(value) {
+		realm = value;
+	} });
+	(0, import_qunit.module)("index changes", function(hooks) {
+		setupRealmCacheTeardown(hooks);
+		(0, import_qunit.test)("a card another client created reads as being prepared, then renders itself once indexing lands", async function(assert) {
+			let { adapter } = getTestRealmRegistry().get(testRealmURL);
+			let cardURL = `${testRealmURL}Person/late`;
+			await adapter.write("Person/late.json", JSON.stringify({ data: {
+				type: "card",
+				attributes: { firstName: "Late" },
+				meta: { adoptsFrom: {
+					module: rri("../person"),
+					name: "Person"
+				} }
+			} }));
+			getService("message-service").relayRealmEvent({
+				eventName: "update",
+				added: ["Person/late.json"],
+				realmURL: testRealmURL
+			});
+			await settled();
+			assert.strictEqual(getService("store").peek(cardURL), void 0, "the card never passed through this tab, so nothing of it is in the store");
+			await visitOperatorMode({ stacks: [[{
+				id: cardURL,
+				format: "isolated"
+			}]] });
+			assert.dom("[data-test-card-awaiting-index]").containsText("Preparing this card", "the card reads as being prepared rather than missing");
+			assert.dom("[data-test-card-error]").doesNotExist("nothing is reported as an error");
+			assert.dom("[data-test-operator-mode-stack=\"0\"] [data-test-person]").doesNotExist("the card itself has nothing to render yet");
+			let response = await getService("network").authedFetch(`${testRealmURL}_invalidate`, {
+				method: "POST",
+				headers: {
+					Accept: SupportedMimeType.JSONAPI,
+					"Content-Type": SupportedMimeType.JSONAPI
+				},
+				body: JSON.stringify({ data: { attributes: { urls: [`${testRealmURL}Person/late.json`] } } })
+			});
+			assert.strictEqual(response.status, 204, "the realm indexed the file that was already on disk");
+			await settled();
+			assert.dom("[data-test-card-awaiting-index]").doesNotExist("the placeholder gives way on its own");
+			assert.dom("[data-test-operator-mode-stack=\"0\"] [data-test-person]").hasText("Late", "the card renders without a reload");
+		});
+		(0, import_qunit.test)("stack item live updates when index changes", async function(assert) {
+			await visitOperatorMode({ stacks: [[{
+				id: `${testRealmURL}Person/fadhlan`,
+				format: "isolated"
+			}]] });
+			assert.dom("[data-test-operator-mode-stack=\"0\"] [data-test-person]").hasText("Fadhlan");
+			await realm.write("Person/fadhlan.json", JSON.stringify({ data: {
+				type: "card",
+				attributes: { firstName: "FadhlanXXX" },
+				meta: { adoptsFrom: {
+					module: rri("../person"),
+					name: "Person"
+				} }
+			} }));
+			await settled();
+			assert.dom("[data-test-operator-mode-stack=\"0\"] [data-test-person]").hasText("FadhlanXXX");
+		});
+		(0, import_qunit.test)("stack item live updates with error in isolated mode", async function(assert) {
+			await visitOperatorMode({ stacks: [[{
+				id: `${testRealmURL}Person/fadhlan`,
+				format: "isolated"
+			}]] });
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/fadhlan"]`).exists("card is displayed");
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/fadhlan"] [data-test-card-error]`).doesNotExist("card error state is NOT displayed");
+			await realm.write("Person/fadhlan.json", JSON.stringify({ data: {
+				type: "card",
+				meta: { adoptsFrom: {
+					module: rri("../missing-person"),
+					name: "MissingPerson"
+				} }
+			} }));
+			await settled();
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/fadhlan"] [data-test-card-error]`).exists("card error state is displayed");
+			await realm.write("Person/fadhlan.json", JSON.stringify({ data: {
+				type: "card",
+				meta: { adoptsFrom: {
+					module: rri("../person"),
+					name: "Person"
+				} }
+			} }));
+			await settled();
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/fadhlan"]`).exists("card is displayed");
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/fadhlan"] [data-test-card-error]`).doesNotExist("card error state is NOT displayed");
+		});
+		(0, import_qunit.test)("stack item live shows stale card when server has an error in edit mode", async function(assert) {
+			await visitOperatorMode({ stacks: [[{
+				id: `${testRealmURL}Person/fadhlan`,
+				format: "edit"
+			}]] });
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/fadhlan"]`).exists("card is displayed");
+			assert.dom(`[data-test-stack-card="${testRealmURL}Person/fadhlan"] [data-test-card-error]`).doesNotExist("card error state is NOT displayed");
+			assert.dom("[data-test-field=\"firstName\"] input").hasValue("Fadhlan");
+		});
+		(0, import_qunit.test)("stack item edit results in index event that is ignored", async function(assert) {
+			assert.expect(6);
+			await visitOperatorMode({ stacks: [[{
+				id: `${testRealmURL}Person/fadhlan`,
+				format: "isolated"
+			}]] });
+			const messageService = getService("message-service");
+			const receivedEventDeferred = new Deferred();
+			const unsubscribe = messageService.subscribe(testRealmURL, (ev) => {
+				if (ev.eventName !== "index" || ev.indexType !== "incremental") return;
+				unsubscribe();
+				ev = ev;
+				assert.ok(ev.clientRequestId, `client request ID is included in event: ${JSON.stringify(ev)}`);
+				assert.strictEqual(ev.eventName, "index", "the event name is \"index\"");
+				assert.strictEqual(ev.indexType, "incremental", "the event type is \"incremental\"");
+				assert.deepEqual(ev.invalidations, [`${testRealmURL}Person/fadhlan`], "invalidations are correct");
+				receivedEventDeferred.fulfill();
+			});
+			await click("[data-test-edit-button]");
+			fillIn("[data-test-field=\"firstName\"] input", "FadhlanXXX");
+			let inputElement = find("[data-test-field=\"firstName\"] input");
+			inputElement.focus();
+			inputElement.select();
+			inputElement.setSelectionRange(0, 3);
+			await receivedEventDeferred.promise;
+			await settled();
+			inputElement = find("[data-test-field=\"firstName\"] input");
+			assert.strictEqual(document.activeElement, inputElement, "focus is preserved on the input element");
+			assert.strictEqual(document.getSelection()?.anchorOffset, 3, "select is preserved");
+		});
+		(0, import_qunit.test)("another client's write to a card being edited keeps the unsaved edit and takes the rest", async function(assert) {
+			let cardURL = `${testRealmURL}Pet/vangogh`;
+			let saveArrived = new Deferred();
+			let releaseSave = new Deferred();
+			let network = getService("network");
+			let holdSave = async (request) => {
+				if (request.method === "PATCH" && request.url.endsWith("/Pet/vangogh")) {
+					saveArrived.fulfill();
+					await releaseSave.promise;
+				}
+				return null;
+			};
+			network.virtualNetwork.mount(holdSave, { prepend: true });
+			await realm.write("Pet/vangogh.json", JSON.stringify({ data: {
+				type: "card",
+				attributes: {
+					name: "Van Gogh",
+					favoriteTreat: "Bones"
+				},
+				meta: { adoptsFrom: {
+					module: rri("../pet"),
+					name: "Pet"
+				} }
+			} }));
+			try {
+				await visitOperatorMode({ stacks: [[{
+					id: cardURL,
+					format: "edit"
+				}]] });
+				let nameInput = "[data-test-field=\"name\"] input";
+				assert.dom(nameInput).hasValue("Van Gogh");
+				let card = getService("store").peek(cardURL);
+				let typed = fillIn(nameInput, "Van Gogh typed locally");
+				await saveArrived.promise;
+				await realm.write("Pet/vangogh.json", JSON.stringify({ data: {
+					type: "card",
+					attributes: {
+						name: "Van Gogh",
+						favoriteTreat: "Carrots"
+					},
+					meta: { adoptsFrom: {
+						module: rri("../pet"),
+						name: "Pet"
+					} }
+				} }));
+				await waitUntil(() => card.favoriteTreat === "Carrots", { timeout: 15e3 }).catch(() => void 0);
+				assert.strictEqual(card.favoriteTreat, "Carrots", "the other client's change reaches the card");
+				assert.strictEqual(card.name, "Van Gogh typed locally", "the unsaved edit is not replaced by the server state");
+				assert.dom(nameInput).hasValue("Van Gogh typed locally");
+				releaseSave.fulfill();
+				await typed;
+				await settled();
+				assert.dom(nameInput).hasValue("Van Gogh typed locally", "the edit survives its save");
+				let json = await (await network.authedFetch(cardURL, { headers: { Accept: SupportedMimeType.CardJson } })).json();
+				assert.strictEqual(json.data.attributes.name, "Van Gogh typed locally", "the edit is what the realm now holds");
+				assert.strictEqual(json.data.attributes.favoriteTreat, "Carrots", "and the other client's change survives the save that was serialized before it");
+			} finally {
+				releaseSave.fulfill();
+				network.virtualNetwork.unmount(holdSave);
+			}
+		});
+		(0, import_qunit.test)("an edit typed while an earlier save is in flight stays protected after that save lands", async function(assert) {
+			let cardURL = `${testRealmURL}Pet/vangogh`;
+			let arrivals = [new Deferred(), new Deferred()];
+			let releases = [new Deferred(), new Deferred()];
+			let saves = 0;
+			let network = getService("network");
+			let holdSaves = async (request) => {
+				if (request.method === "PATCH" && request.url.endsWith("/Pet/vangogh")) {
+					let n = saves++;
+					if (n < arrivals.length) {
+						arrivals[n].fulfill();
+						await releases[n].promise;
+					}
+				}
+				return null;
+			};
+			network.virtualNetwork.mount(holdSaves, { prepend: true });
+			try {
+				await visitOperatorMode({ stacks: [[{
+					id: cardURL,
+					format: "edit"
+				}]] });
+				let nameInput = "[data-test-field=\"name\"] input";
+				let card = getService("store").peek(cardURL);
+				let firstEdit = fillIn(nameInput, "first edit");
+				await arrivals[0].promise;
+				let secondEdit = fillIn(nameInput, "second edit");
+				await waitUntil(() => card.name === "second edit");
+				releases[0].fulfill();
+				await arrivals[1].promise;
+				await realm.write("Pet/vangogh.json", JSON.stringify({ data: {
+					type: "card",
+					attributes: {
+						name: "first edit",
+						favoriteTreat: "Carrots"
+					},
+					meta: { adoptsFrom: {
+						module: rri("../pet"),
+						name: "Pet"
+					} }
+				} }));
+				await waitUntil(() => card.favoriteTreat === "Carrots", { timeout: 15e3 }).catch(() => void 0);
+				assert.strictEqual(card.favoriteTreat, "Carrots", "the other client's change reaches the card");
+				assert.strictEqual(card.name, "second edit", "the edit the first save did not carry is not replaced by it");
+				releases[1].fulfill();
+				await firstEdit;
+				await secondEdit;
+				await settled();
+				let json = await (await network.authedFetch(cardURL, { headers: { Accept: SupportedMimeType.CardJson } })).json();
+				assert.strictEqual(json.data.attributes.name, "second edit", "the later edit is what the realm ends up holding");
+			} finally {
+				for (let release of releases) release.fulfill();
+				network.virtualNetwork.unmount(holdSaves);
+			}
+		});
+		(0, import_qunit.test)("containsMany string field preserves focus while typing", async function(assert) {
+			const receivedEventDeferred = new Deferred();
+			const messageService = getService("message-service");
+			const typedText = "Ada";
+			const inputSelector = "[data-test-contains-many=\"names\"] [data-test-item=\"0\"] input";
+			const unsubscribe = messageService.subscribe(testRealmURL, (e) => {
+				if (e.eventName === "index" && e.indexType === "incremental-index-initiation") return;
+				unsubscribe();
+				receivedEventDeferred.fulfill();
+			});
+			await visitOperatorMode({ stacks: [[{
+				id: `${testRealmURL}FocusTest/1`,
+				format: "edit"
+			}]] });
+			await click("[data-test-contains-many=\"names\"] [data-test-add-new]");
+			let inputElement = find(inputSelector);
+			let focusStates = [];
+			let inputEventCount = 0;
+			const handleInputEvent = (event) => {
+				let target = event.target;
+				if (!(target instanceof HTMLInputElement)) return;
+				if (!target.matches(inputSelector)) return;
+				inputEventCount += 1;
+				focusStates.push(document.activeElement === target);
+			};
+			document.addEventListener("input", handleInputEvent, true);
+			try {
+				inputElement.focus();
+				await typeIn(inputSelector, typedText);
+			} finally {
+				document.removeEventListener("input", handleInputEvent, true);
+			}
+			await receivedEventDeferred.promise;
+			await settled();
+			assert.strictEqual(inputEventCount, 3, "input events are triggered for each keystroke");
+			assert.true(focusStates.every(Boolean), "focus is preserved on the input element during typing");
+			inputElement = find(inputSelector);
+			assert.strictEqual(document.activeElement, inputElement, "focus is preserved on the input element after typing");
+			assert.dom(inputSelector).hasValue(typedText);
+		});
+		(0, import_qunit.test)("containsMany field def preserves focus while typing", async function(assert) {
+			const messageService = getService("message-service");
+			const typedText = "Ada";
+			const withoutLinksSelector = "[data-test-contains-many=\"items\"] [data-test-item=\"0\"] [data-test-field=\"label\"] input";
+			const withLinksSelector = "[data-test-contains-many=\"items\"] [data-test-item=\"1\"] [data-test-field=\"label\"] input";
+			const waitForIndexEvent = () => {
+				const receivedEventDeferred = new Deferred();
+				const unsubscribe = messageService.subscribe(testRealmURL, (e) => {
+					if (e.eventName === "index" && e.indexType === "incremental-index-initiation") return;
+					unsubscribe();
+					receivedEventDeferred.fulfill();
+				});
+				return receivedEventDeferred;
+			};
+			const assertFocusPreserved = async (selector, expectedValue) => {
+				const receivedEventDeferred = waitForIndexEvent();
+				let inputElement = find(selector);
+				let focusStates = [];
+				let inputEventCount = 0;
+				const handleInputEvent = (event) => {
+					let target = event.target;
+					if (!(target instanceof HTMLInputElement)) return;
+					if (!target.matches(selector)) return;
+					inputEventCount += 1;
+					focusStates.push(document.activeElement === target);
+				};
+				document.addEventListener("input", handleInputEvent, true);
+				try {
+					inputElement.focus();
+					inputElement.setSelectionRange(inputElement.value.length, inputElement.value.length);
+					await typeIn(selector, typedText);
+				} finally {
+					document.removeEventListener("input", handleInputEvent, true);
+				}
+				await receivedEventDeferred.promise;
+				await settled();
+				assert.strictEqual(inputEventCount, 3, "input events are triggered for each keystroke");
+				assert.true(focusStates.every(Boolean), "focus is preserved on the input element during typing");
+				inputElement = find(selector);
+				assert.strictEqual(document.activeElement, inputElement, "focus is preserved on the input element after typing");
+				assert.dom(selector).hasValue(expectedValue);
+			};
+			await visitOperatorMode({ stacks: [[{
+				id: `${testRealmURL}FocusNested/1`,
+				format: "edit"
+			}]] });
+			assert.dom(withoutLinksSelector).hasValue("Plain");
+			await assertFocusPreserved(withoutLinksSelector, `Plain${typedText}`);
+			assert.dom("[data-test-contains-many=\"items\"] [data-test-item=\"1\"] [data-test-links-to-many=\"pets\"] [data-test-pill-item=\"0\"]").exists("linksToMany field has a linked card");
+			assert.dom(withLinksSelector).hasValue("With Pet");
+			await assertFocusPreserved(withLinksSelector, `With Pet${typedText}`);
+		});
+	});
+	(0, import_qunit.module)("size limit errors", function(hooks) {
+		setupRealmCacheTeardown(hooks);
+		(0, import_qunit.test)("edit view shows size limit error when save exceeds limit", async function(assert) {
+			let environmentService = getService("environment-service");
+			let originalMaxSize = environmentService.cardSizeLimitBytes;
+			environmentService.cardSizeLimitBytes = 1e3;
+			try {
+				await visitOperatorMode({ stacks: [[{
+					id: `${testRealmURL}Pet/mango`,
+					format: "edit"
+				}]] });
+				await fillIn(`[data-test-stack-card="${testRealmURL}Pet/mango"] [data-test-field="name"] input`, "x".repeat(5e3));
+				assert.dom(`[data-test-stack-card="${testRealmURL}Pet/mango"] [data-test-auto-save-indicator]`).includesText(`exceeds maximum allowed size (${environmentService.cardSizeLimitBytes} bytes)`);
+			} finally {
+				environmentService.cardSizeLimitBytes = originalMaxSize;
+			}
+		});
+	});
+});
+//#endregion