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

package/bundled-test-harness/assets/create-file-test-DjMf88u_.js

@@ -0,0 +1,1086 @@
+import { i as __name, s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Lr as testRRI, Rc as Deferred } from "./runtime-common-BTaLJEw-.js";
+import { T as rri } from "./paths-C9-NYXnM.js";
+import { D as baseRRI, O as baseRealm, it as baseRealmRRI } from "./constants-Icc0nFW-.js";
+import { n as TrackedObject } from "./dist-B9tGPKZz.js";
+import { M as waitUntil, T as settled, d as click, l as triggerEvent, o as waitFor, s as fillIn } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, Et as percySnapshot, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, S as getMonacoContent, Z as withCachedRealmSetup, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, mt as setupAuthEndpoints, st as visitOperatorMode, t as setupMockMatrix, u as cardDefFieldCount, y as fixtureImageURL, z as setupUserSubscription } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/acceptance/code-submode/create-file-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealmURL2 = "http://test-realm/test2/";
+var testRealmAIconURL = "/test-fixtures/realm-images/boxel-logo.png";
+var testPrefixRealmURL2 = `@test-realm/test2/`;
+var files = {
+	"realm.json": realmConfigCardJSON({
+		name: "Test Workspace A",
+		backgroundURL: "/test-fixtures/realm-images/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+		iconURL: testRealmAIconURL
+	}),
+	"index.json": { data: {
+		type: "card",
+		attributes: {},
+		meta: { adoptsFrom: {
+			module: "@cardstack/base/cards-grid",
+			name: "CardsGrid"
+		} }
+	} },
+	"error.gts": `
+    import { CardDef } from '@cardstack/base/card-api';
+
+    export default class ErrorCard extends CardDef {
+      static displayName = 'error';
+
+      constructor(owner: unknown, args: any) {
+        super(owner, args);
+        throw new Error('A deliberate constructor error');
+      }
+    }
+  `,
+	"pet.gts": `
+    import { contains, linksTo, field, CardDef, Component } from "@cardstack/base/card-api";
+    import StringField from "@cardstack/base/string";
+
+    export default class Pet extends CardDef {
+      static displayName = 'Pet';
+      @field name = contains(StringField);
+
+      static embedded = class Embedded extends Component<typeof this> {
+        <template>
+          <span data-test-pet><@fields.name /></span>
+        </template>
+      }
+    }
+  `,
+	"person.gts": `
+    import { contains, linksTo, field, CardDef } from "@cardstack/base/card-api";
+    import StringField from "@cardstack/base/string";
+    import Pet from "./pet";
+
+    export class Person extends CardDef {
+      static displayName = 'Person';
+      @field firstName = contains(StringField);
+      @field lastName = contains(StringField);
+      @field pet = linksTo(Pet);
+    }
+  `,
+	"spec/error.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Error",
+			cardDescription: "Spec for Error",
+			specType: "card",
+			ref: {
+				module: "../error",
+				name: "default"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "@cardstack/base/spec",
+			name: "Spec"
+		} }
+	} },
+	"spec/pet.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Pet",
+			cardDescription: "Spec for Pet",
+			specType: "card",
+			ref: {
+				module: `../pet`,
+				name: "default"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "@cardstack/base/spec",
+			name: "Spec"
+		} }
+	} },
+	"spec/person.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Person",
+			cardDescription: "Spec for Person",
+			specType: "card",
+			ref: {
+				module: `../person`,
+				name: "Person"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "@cardstack/base/spec",
+			name: "Spec"
+		} }
+	} },
+	"Pet/mango.json": { data: {
+		attributes: { name: "Mango" },
+		meta: { adoptsFrom: {
+			module: `../pet`,
+			name: "default"
+		} }
+	} },
+	"fields/biginteger-field.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Bigint Field",
+			cardDescription: "A field that captures big int values",
+			specType: "field",
+			ref: {
+				module: `${baseRealmRRI}big-integer`,
+				name: "default"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: `${baseRealmRRI}spec`,
+			name: "Spec"
+		} }
+	} },
+	"fields/field.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "General Field",
+			cardDescription: "A FieldDef spec",
+			specType: "field",
+			ref: {
+				module: `${baseRealmRRI}card-api`,
+				name: "FieldDef"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: `${baseRealmRRI}spec`,
+			name: "Spec"
+		} }
+	} }
+};
+var filesB = {
+	"realm.json": realmConfigCardJSON({
+		name: "Test Workspace B",
+		backgroundURL: "/test-fixtures/realm-images/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+		iconURL: "/test-fixtures/realm-images/boxel-logo.png"
+	}),
+	"index.json": { data: {
+		type: "card",
+		attributes: {},
+		meta: { adoptsFrom: {
+			module: "@cardstack/base/cards-grid",
+			name: "CardsGrid"
+		} }
+	} },
+	"animal.gts": `
+    import { contains, field, CardDef } from "@cardstack/base/card-api";
+    import StringField from "@cardstack/base/string";
+
+    export class Animal extends CardDef {
+      static displayName = 'Animal';
+      @field name = contains(StringField);
+    }
+  `,
+	"spec/animal.json": { data: {
+		type: "card",
+		attributes: {
+			cardTitle: "Animal",
+			cardDescription: "Spec for Animal",
+			specType: "card",
+			ref: {
+				module: "@test-realm/test2/animal",
+				name: "Animal"
+			}
+		},
+		meta: { adoptsFrom: {
+			module: "@cardstack/base/spec",
+			name: "Spec"
+		} }
+	} }
+};
+(0, import_qunit.module)("Acceptance | code submode | create-file tests", function(hooks) {
+	async function openNewFileModal(menuSelection, expectedRealmName = "Test Workspace A") {
+		await waitFor("[data-test-new-file-button]");
+		await click("[data-test-new-file-button]");
+		await click(`[data-test-boxel-menu-item-text="${menuSelection}"]`);
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="${expectedRealmName}"]`);
+	}
+	async function visitOperatorMode$1(codePath = `${testRealmURL}index.json`) {
+		await visitOperatorMode({
+			submode: "code",
+			codePath
+		});
+	}
+	__name(visitOperatorMode$1, "visitOperatorMode");
+	let adapter;
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [
+			baseRealm.url,
+			testRealmURL,
+			testRealmURL2
+		]
+	});
+	let { setRealmPermissions, createAndJoinRoom } = mockMatrixUtils;
+	hooks.beforeEach(async function() {
+		if ((import_qunit.default.config.current?.module?.name ?? "").includes("uses a prefix-form ref")) getService("network").virtualNetwork.addRealmMapping(testPrefixRealmURL2, testRealmURL2);
+		({adapter} = await withCachedRealmSetup(async () => {
+			await setupAcceptanceTestRealm({
+				contents: {
+					...SYSTEM_CARD_FIXTURE_CONTENTS,
+					...filesB
+				},
+				realmURL: testRealmURL2,
+				mockMatrixUtils
+			});
+			return await setupAcceptanceTestRealm({
+				contents: {
+					...SYSTEM_CARD_FIXTURE_CONTENTS,
+					...files
+				},
+				mockMatrixUtils
+			});
+		}));
+		createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		setupUserSubscription();
+		setupAuthEndpoints();
+		getService("network").mount(async (req) => {
+			if (req.url.includes("fetch-failure")) throw new Error("A deliberate fetch error");
+			return null;
+		}, { prepend: true });
+	});
+	(0, import_qunit.module)("when user has permissions to both test realms", function(hooks) {
+		hooks.beforeEach(async function() {
+			setRealmPermissions({
+				[baseRealm.url]: ["read"],
+				[testRealmURL]: ["read", "write"],
+				[testRealmURL2]: ["read", "write"]
+			});
+		});
+		(0, import_qunit.test)("new file button has options to create card def, field def, card instance, skill, text files, and upload file", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text]").exists({ count: 6 });
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Card Definition\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Field Definition\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Card Instance\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Skill\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Text File\"]").exists();
+			assert.dom("[data-test-new-file-dropdown-menu] [data-test-boxel-menu-item-text=\"Upload File…\"]").exists();
+		});
+		(0, import_qunit.test)("can create text files with txt and md extensions", async function(assert) {
+			assert.expect(4);
+			await visitOperatorMode$1();
+			let deferred = new Deferred();
+			let savedUrls = [];
+			this.onSave(async (url, content) => {
+				savedUrls.push(url.href);
+				assert.strictEqual(content, "", "text file is created empty");
+				if (savedUrls.length === 2) deferred.fulfill();
+			});
+			await openNewFileModal("Text File");
+			await fillIn("[data-test-text-file-name-field]", "notes");
+			await click("[data-test-create-text-file]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await openNewFileModal("Text File");
+			await fillIn("[data-test-text-file-name-field]", "readme");
+			await click("[data-test-text-file-extension-select]");
+			await click("[data-test-text-file-extension-option=\".md\"]");
+			await click("[data-test-create-text-file]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			assert.ok(savedUrls.some((url) => url.endsWith("notes.txt")));
+			assert.ok(savedUrls.some((url) => url.endsWith("readme.md")));
+		});
+		(0, import_qunit.test)("can create a skill file with starter frontmatter", async function(assert) {
+			assert.expect(2);
+			await visitOperatorMode$1();
+			let deferred = new Deferred();
+			this.onSave(async (url, content) => {
+				assert.true(url.href.endsWith("skills/trip-planner/SKILL.md"), "conventional skills/<slug>/SKILL.md path from the cleansed name");
+				assert.true(content.includes("boxel:\n  kind: skill"), "starter frontmatter marks the file as a skill");
+				deferred.fulfill();
+			});
+			await openNewFileModal("Skill");
+			await fillIn("[data-test-skill-name-field]", "Trip Planner");
+			await click("[data-test-create-skill-file]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can upload a file via the New menu", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			getService("file-upload").__queueLocalFileBatchForTesting([new File(["hello upload"], "uploaded-via-menu.txt", { type: "text/plain" })]);
+			await click("[data-test-boxel-menu-item-text=\"Upload File…\"]");
+			await waitUntil(() => document.querySelector("[data-test-card-url-bar-input]")?.value?.includes("uploaded-via-menu.txt"), {
+				timeout: 1e4,
+				timeoutMessage: "code editor did not navigate to the uploaded file"
+			});
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}uploaded-via-menu.txt`, "code editor navigated to the uploaded file");
+		});
+		(0, import_qunit.test)("can upload multiple files via the New menu", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await click("[data-test-file-browser-toggle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			let fileUpload = getService("file-upload");
+			fileUpload.__queueLocalFileBatchForTesting([new File(["file one"], "multi-upload-first.txt", { type: "text/plain" }), new File(["file two"], "multi-upload-second.txt", { type: "text/plain" })]);
+			await click("[data-test-boxel-menu-item-text=\"Upload File…\"]");
+			await waitUntil(() => fileUpload.activeUploads.length === 0, {
+				timeout: 2e4,
+				timeoutMessage: "uploads did not all complete"
+			});
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}multi-upload-first.txt`, "code editor navigated to the first uploaded file");
+			await waitUntil(() => document.querySelector("[data-test-file=\"multi-upload-second.txt\"]") != null, {
+				timeout: 1e4,
+				timeoutMessage: "second uploaded file did not appear in the file tree"
+			});
+			assert.dom("[data-test-file=\"multi-upload-first.txt\"]").exists("first uploaded file is shown in the file tree");
+			assert.dom("[data-test-file=\"multi-upload-second.txt\"]").exists("second uploaded file is shown in the file tree");
+		});
+		(0, import_qunit.test)("cancelling upload file picker does not cause errors", async function(assert) {
+			await visitOperatorMode$1();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-new-file-button]");
+			await click("[data-test-new-file-button]");
+			getService("file-upload").__queueLocalFileBatchForTesting([]);
+			await click("[data-test-boxel-menu-item-text=\"Upload File…\"]");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}index.json`, "URL bar still shows the original file");
+		});
+		(0, import_qunit.test)("the realm dropdown shows the selected realm name and URL in a tooltip", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await triggerEvent("[data-test-realm-dropdown-trigger] [data-test-realm-url-tooltip-trigger]", "mouseenter");
+			assert.dom("[data-test-realm-url-tooltip-label]").hasText("Test Workspace A");
+			assert.dom("[data-test-realm-url-tooltip]").hasText("test-realm/test");
+		});
+		(0, import_qunit.test)("the realm dropdown shows a truncated realm name in full in its tooltip", async function(assert) {
+			await visitOperatorMode$1();
+			let realmA = getService("realm").realms.get(testRealmURL);
+			let previousInfo = realmA.info;
+			let longName = "A workspace with a name far too long to fit inside the realm dropdown, no matter which font the browser renders it in, because it keeps going well past the width of the modal";
+			realmA.info = new TrackedObject({
+				...previousInfo,
+				name: longName
+			});
+			try {
+				await openNewFileModal("Card Definition", longName);
+				let name = document.querySelector("[data-test-realm-dropdown-trigger] [data-test-selected-realm]");
+				assert.ok(name.scrollWidth > name.clientWidth, "the name is truncated in the trigger");
+				assert.dom("[data-test-realm-dropdown-trigger] [data-test-realm-url-tooltip-trigger] [data-test-selected-realm]").exists("hovering the name opens the tooltip");
+				await triggerEvent("[data-test-realm-dropdown-trigger] [data-test-realm-url-tooltip-trigger]", "mouseenter");
+				assert.dom("[data-test-realm-url-tooltip-label]").hasText(longName);
+			} finally {
+				realmA.info = previousInfo;
+			}
+		});
+		(0, import_qunit.test)("the realm dropdown checks only the selected realm when two realms share a name", async function(assert) {
+			await visitOperatorMode$1();
+			let realmB = getService("realm").realms.get(testRealmURL2);
+			let previousInfo = realmB.info;
+			realmB.info = new TrackedObject({
+				...previousInfo,
+				name: "Test Workspace A"
+			});
+			try {
+				await openNewFileModal("Card Definition");
+				await click("[data-test-realm-dropdown-trigger]");
+				await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace A\"]");
+				assert.dom("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace A\"]").exists({ count: 2 });
+				assert.dom("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-selected]").exists({ count: 1 });
+			} finally {
+				realmB.info = previousInfo;
+			}
+		});
+		(0, import_qunit.test)("filename is auto-populated from display name", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", `Très test's card 😀`);
+			assert.dom("[data-test-file-name-field]").hasValue("tres-tests-card");
+		});
+		(0, import_qunit.test)("filename stops auto-populating after user edits it", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-file-name-field]", "test_card");
+			await fillIn("[data-test-display-name-field]", "Très test card 😀");
+			assert.dom("[data-test-file-name-field]").hasValue("test_card");
+		});
+		(0, import_qunit.test)("can create new card-instance file in local realm with card type from same realm", async function(assert) {
+			const baseRealmIconURL = "https://boxel-images.boxel.ai/icons/cardstack.png";
+			assert.expect(13);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace A");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			assert.dom(`[data-test-inherits-from-field] [data-test-boxel-field-label]`).hasText("Adopted From");
+			assert.dom(`[data-test-selected-type]`).hasText("General Card");
+			assert.dom(`[data-test-selected-type] [data-test-realm-icon-url]`).hasStyle({ backgroundImage: `url("${baseRealmIconURL}")` });
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			assert.dom(`[data-test-selected-type]`).hasText("Person");
+			assert.dom(`[data-test-selected-type] [data-test-realm-icon-url]`).hasStyle({ backgroundImage: `url("${fixtureImageURL(testRealmAIconURL)}")` });
+			let deferred = new Deferred();
+			let fileID = "";
+			this.onSave(async (url, json) => {
+				fileID = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.firstName, null, "firstName field is empty");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: rri("../person"),
+					name: "Person"
+				}, "adoptsFrom is correct");
+				assert.deepEqual(json.data.relationships, void 0, "relationships data is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor(`[data-test-code-mode-card-renderer-header="${fileID}"]`);
+			assert.dom("[data-test-card-resource-loaded]").containsText("Person");
+			assert.dom("[data-test-field=\"firstName\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileID}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("an error when creating a new card instance is shown", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/error"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/error"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Error"]`);
+			await click("[data-test-create-card-instance]");
+			assert.dom("[data-test-error-container]").exists();
+			assert.dom("[data-test-error-type]").containsText("Error creating card instance");
+			assert.dom("[data-test-create-file-modal] [data-test-error-message]").hasText("A deliberate constructor error");
+			await click("[data-test-toggle-details]");
+			assert.dom("[data-test-error-details]").containsText("A deliberate constructor error");
+			await click("[data-test-cancel-create-file]");
+			await openNewFileModal("Card Instance");
+			assert.dom("[data-test-error-container]").doesNotExist("error is cleared");
+		});
+		(0, import_qunit.test)("can create new card-instance file in local realm with card type from a remote realm", async function(assert) {
+			assert.expect(8);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace A");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			let deferred = new Deferred();
+			let fileURL = "";
+			this.onSave(async (url, json) => {
+				fileURL = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.cardTitle, "Untitled Card", "title field defaults to fallback");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: baseRRI("card-api"),
+					name: "CardDef"
+				}, "adoptsFrom is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await waitFor("[data-test-code-mode-card-renderer-header][data-test-card-resource-loaded]");
+			assert.dom("[data-test-code-mode-card-renderer-header] [data-test-realm-icon-url]").hasAttribute("aria-label", "Test Workspace A");
+			assert.dom("[data-test-card-resource-loaded]").containsText("Card");
+			assert.dom("[data-test-field=\"cardInfo-name\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileURL}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create new card-instance file in a remote realm with card type from another realm", async function(assert) {
+			assert.expect(8);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await click("[data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await waitFor(`[data-test-realm-name="Test Workspace B"]`);
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace B");
+			let deferred = new Deferred();
+			let fileID = "";
+			this.onSave(async (url, json) => {
+				fileID = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.cardTitle, "Untitled Card", "title field defaults to fallback");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL2, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: baseRRI("card-api"),
+					name: "CardDef"
+				}, "adoptsFrom is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor(`[data-test-code-mode-card-renderer-header="${fileID}"]`);
+			assert.dom("[data-test-code-mode-card-renderer-header] [data-test-realm-icon-url]").hasAttribute("aria-label", "Test Workspace B");
+			assert.dom("[data-test-card-resource-loaded]").containsText("Card");
+			assert.dom("[data-test-field=\"cardInfo-name\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileID}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create new card-instance file in a remote realm with card type from a local realm", async function(assert) {
+			assert.expect(8);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await click("[data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			await waitFor(`[data-test-realm-name="Test Workspace B"]`);
+			assert.dom("[data-test-realm-name]").hasText("Test Workspace B");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			let deferred = new Deferred();
+			let fileID = "";
+			this.onSave(async (url, json) => {
+				fileID = url.href;
+				if (typeof json === "string") throw new Error("expected JSON save data");
+				assert.strictEqual(json.data.attributes?.firstName, null, "firstName field is empty");
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL2, "realm url is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: testRRI("person"),
+					name: "Person"
+				}, "adoptsFrom is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-card-instance]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await waitFor(`[data-test-code-mode-card-renderer-header="${fileID}"]`);
+			assert.dom("[data-test-code-mode-card-renderer-header] [data-test-realm-icon-url]").hasAttribute("aria-label", "Test Workspace B");
+			assert.dom("[data-test-card-resource-loaded]").containsText("Person");
+			assert.dom("[data-test-field=\"firstName\"] input").hasValue("");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${fileID}.json`);
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create a new card definition in different realm than inherited definition", async function(assert) {
+			assert.expect(12);
+			let expectedSrc = `
+import { CardDef } from '@cardstack/base/card-api';
+import { Component } from '@cardstack/base/card-api';
+export class TrèsTestCard extends CardDef {
+  static displayName = "Très test card 😀";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			assert.dom("[data-test-selected-type]").hasText("General Card");
+			assert.dom("[data-test-create-definition]").isDisabled("create button is disabled");
+			await fillIn("[data-test-display-name-field]", "Très test card 😀");
+			assert.dom(`[data-test-inherits-from-field] [data-test-boxel-field-label]`).hasText("Inherits From");
+			assert.dom("[data-test-create-definition]").isEnabled("create button is enabled");
+			await fillIn("[data-test-file-name-field]", "très-test-card");
+			assert.dom("[data-test-create-definition]").isEnabled("create button is enabled");
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			assert.strictEqual(getMonacoContent(), expectedSrc, "monaco displays the new definition");
+			await waitFor("[data-test-card-schema=\"Très test card 😀\"]");
+			assert.dom("[data-test-current-module-name]").hasText("très-test-card.gts");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}très-test-card.gts`);
+			assert.dom("[data-test-card-schema]").exists({ count: 3 }, "the card hierarchy is displayed in schema editor");
+			assert.dom("[data-test-total-fields]").containsText(`${cardDefFieldCount}`).hasAttribute("title", `${cardDefFieldCount} fields`);
+		});
+		(0, import_qunit.test)("can create a new card definition in same realm as inherited definition", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import { Person } from './person';
+import { Component } from '@cardstack/base/card-api';
+export class TestCard extends Person {
+  static displayName = "Test Card";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can create new card definition in different realm than realm of current file opened in code mode", async function(assert) {
+			let done = assert.async();
+			await visitOperatorMode$1(`${baseRealm.url}card-api.gts`);
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			this.onSave((url, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(url.href, `${testRealmURL}test-card.gts`);
+				done();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+		});
+		(0, import_qunit.test)("an error when creating a new card definition is shown", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/person"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Person"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-fetch-failure-card");
+			await click("[data-test-create-definition]");
+			assert.dom("[data-test-error-container]").exists();
+			assert.dom("[data-test-error-type]").containsText("Error creating card definition");
+			assert.dom("[data-test-create-file-modal] [data-test-error-message]").hasText("A deliberate fetch error");
+			await click("[data-test-toggle-details]");
+			assert.dom("[data-test-error-details]").containsText("A deliberate fetch error");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			assert.dom("[data-test-error-container]").doesNotExist("changing a field should clear the error");
+		});
+		(0, import_qunit.test)("modal cannot be dismissed while creation is in progress (CS-10557)", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Dismiss Test Card");
+			await fillIn("[data-test-file-name-field]", "dismiss-test-card");
+			let saveDeferred = new Deferred();
+			let postIntercepted = false;
+			getService("network").mount(async (req) => {
+				if (req.method === "POST" && req.url.includes("dismiss-test-card.gts")) {
+					postIntercepted = true;
+					await saveDeferred.promise;
+				}
+				return null;
+			}, { prepend: true });
+			let createClickPromise = click("[data-test-create-definition]");
+			await waitUntil(() => postIntercepted, {
+				timeout: 1e4,
+				timeoutMessage: "Timed out waiting for save POST to be intercepted"
+			});
+			let cancelBtn = document.querySelector("[data-test-cancel-create-file]");
+			if (!cancelBtn) throw new Error("Could not find [data-test-cancel-create-file] button while creation is in progress");
+			cancelBtn.click();
+			assert.dom("[data-test-create-file-modal]").exists("modal stays open during creation");
+			this.onSave(() => {});
+			saveDeferred.fulfill();
+			await createClickPromise;
+			assert.dom("[data-test-create-file-modal]").doesNotExist("modal closes after creation completes");
+		});
+		(0, import_qunit.test)("can create a new field definition that extends field definition that uses default export", async function(assert) {
+			assert.expect(3);
+			await visitOperatorMode$1();
+			await openNewFileModal("Field Definition");
+			assert.dom("[data-test-selected-type]").hasText("General Field");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}fields/biginteger-field"]`);
+			await click(`[data-test-item-button="${testRealmURL}fields/biginteger-field"]`);
+			await click("[data-test-card-chooser-go-button]");
+			assert.dom("[data-test-create-definition]").isDisabled();
+			await fillIn("[data-test-display-name-field]", "Field that extends from big int");
+			await fillIn("[data-test-file-name-field]", "big-int-v2");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import BigInteger from '@cardstack/base/big-integer';
+import { Component } from '@cardstack/base/card-api';
+export class FieldThatExtendsFromBigInt extends BigInteger {
+  static displayName = "Field that extends from big int";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("an error when creating a new field definition is shown", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Field Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}fields/biginteger-field"]`);
+			await click(`[data-test-item-button="${testRealmURL}fields/biginteger-field"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await fillIn("[data-test-display-name-field]", "Field that will not save");
+			await fillIn("[data-test-file-name-field]", "test-fetch-failure-card");
+			await click("[data-test-create-definition]");
+			assert.dom("[data-test-error-type]").containsText("Error creating field definition");
+			assert.dom("[data-test-create-file-modal] [data-test-error-message]").hasText("A deliberate fetch error");
+			await click("[data-test-toggle-details]");
+			assert.dom("[data-test-error-details]").containsText("A deliberate fetch error");
+		});
+		(0, import_qunit.test)("can create a new definition that extends card definition which uses default export", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/pet"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/pet"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Pet"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import Pet from './pet';
+import { Component } from '@cardstack/base/card-api';
+export class TestCard extends Pet {
+  static displayName = "Test Card";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await percySnapshot(assert);
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can reconcile a classname collision with the selected name of extending a card definition which uses a default export", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/pet"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/pet"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Pet"]`);
+			await fillIn("[data-test-display-name-field]", "Pet");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import PetParent from './pet';
+import { Component } from '@cardstack/base/card-api';
+export class Pet extends PetParent {
+  static displayName = "Pet";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can reconcile a classname collision with a javascript builtin object", async function(assert) {
+			assert.expect(1);
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL}spec/pet"]`);
+			await click(`[data-test-item-button="${testRealmURL}spec/pet"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Pet"]`);
+			await fillIn("[data-test-display-name-field]", "Map");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import Pet from './pet';
+import { Component } from '@cardstack/base/card-api';
+export class Map0 extends Pet {
+  static displayName = "Map";
+}`.trim(), "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+		(0, import_qunit.test)("can specify new directory as part of filename when creating a new definition", async function(assert) {
+			assert.expect(2);
+			let expectedSrc = `
+import { CardDef } from '@cardstack/base/card-api';
+import { Component } from '@cardstack/base/card-api';
+export class TestCard extends CardDef {
+  static displayName = "Test Card";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-dir/test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			let file = await adapter.openFile("test-dir/test-card.gts");
+			assert.strictEqual(file?.content, expectedSrc, "the source exists at the correct location");
+		});
+		(0, import_qunit.test)("can handle filename with .gts extension in filename when creating a new definition", async function(assert) {
+			assert.expect(2);
+			let expectedSrc = `
+import { CardDef } from '@cardstack/base/card-api';
+import { Component } from '@cardstack/base/card-api';
+export class TestCard extends CardDef {
+  static displayName = "Test Card";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card.gts");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			let file = await adapter.openFile("test-card.gts");
+			assert.strictEqual(file?.content, expectedSrc, "the source exists at the correct location");
+		});
+		(0, import_qunit.test)("can handle leading \"/\" in filename when creating a new definition", async function(assert) {
+			assert.expect(2);
+			let expectedSrc = `
+import { CardDef } from '@cardstack/base/card-api';
+import { Component } from '@cardstack/base/card-api';
+export class TestCard extends CardDef {
+  static displayName = "Test Card";
+}`.trim();
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "/test-card");
+			let deferred = new Deferred();
+			this.onSave((_, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, expectedSrc, "the source is correct");
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+			let file = await adapter.openFile("test-card.gts");
+			assert.strictEqual(file?.content, expectedSrc, "the source exists at the correct location");
+		});
+	});
+	(0, import_qunit.module)("when a selected spec uses a prefix-form ref", function() {
+		(0, import_qunit.test)("can create new card definition in workspace A that extends a card from workspace B via prefix-form ref", async function(assert) {
+			assert.expect(2);
+			await visitOperatorMode$1(`${baseRealm.url}card-api.gts`);
+			await openNewFileModal("Card Definition");
+			await click("[data-test-select-card-type]");
+			await waitFor("[data-test-card-chooser-modal]");
+			await waitFor(`[data-test-item-button="${testRealmURL2}spec/animal"]`);
+			await click(`[data-test-item-button="${testRealmURL2}spec/animal"]`);
+			await click("[data-test-card-chooser-go-button]");
+			await waitFor(`[data-test-selected-type="Animal"]`);
+			await fillIn("[data-test-display-name-field]", "Test Card");
+			await fillIn("[data-test-file-name-field]", "test-card");
+			let deferred = new Deferred();
+			this.onSave((url, content) => {
+				if (typeof content !== "string") throw new Error(`expected string save data`);
+				assert.strictEqual(content, `
+import { Animal } from '${testPrefixRealmURL2}animal';
+import { Component } from '@cardstack/base/card-api';
+export class TestCard extends Animal {
+  static displayName = "Test Card";
+}`.trim(), "The source imports the parent by its realm's registered prefix");
+				assert.strictEqual(url.href, `${testRealmURL}test-card.gts`, [
+					"Saved file URL should point to Test Workspace A",
+					`Expected: ${testRealmURL}test-card.gts`,
+					`Actual: ${url.href}`
+				].join("\n"));
+				deferred.fulfill();
+			});
+			await click("[data-test-create-definition]");
+			await waitFor("[data-test-create-file-modal]", { count: 0 });
+			await deferred.promise;
+		});
+	});
+	(0, import_qunit.module)("when the user lacks write permissions in remote realm", function(hooks) {
+		async function assertRealmDropDownIsCorrect(assert) {
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace A\"]");
+			assert.dom("[data-test-selected-realm]").containsText("Test Workspace A");
+			let menuItems = document.querySelector("[data-test-realm-dropdown-menu]").textContent.replace(/^\s*/gm, "").trim().split("\n");
+			assert.deepEqual(menuItems, ["Test Workspace A"], "the realm dropdown list is correct");
+		}
+		hooks.beforeEach(async function() {
+			setRealmPermissions({
+				[baseRealm.url]: ["read"],
+				[testRealmURL2]: ["read"],
+				[testRealmURL]: ["read", "write"]
+			});
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card definition", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card instance", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when duplicating card instance", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}Pet/mango.json`);
+			await waitFor(`[data-test-action-button="Duplicate"]`);
+			await click("[data-test-action-button=\"Duplicate\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when inheriting card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Inherit"]`);
+			await click("[data-test-action-button=\"Inherit\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating instance of card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Create Instance"]`);
+			await click("[data-test-action-button=\"Create Instance\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+	});
+	(0, import_qunit.module)("when the user lacks write permissions in local realm", function(hooks) {
+		async function assertRealmDropDownIsCorrect(assert) {
+			await click(`[data-test-realm-dropdown-trigger]`);
+			await waitFor("[data-test-boxel-dropdown-content] [data-test-boxel-menu-item-text=\"Test Workspace B\"]");
+			assert.dom("[data-test-selected-realm]").containsText("Test Workspace B");
+			let menuItems = document.querySelector("[data-test-realm-dropdown-menu]").textContent.replace(/^\s*/gm, "").trim().split("\n");
+			assert.deepEqual(menuItems, ["Test Workspace B"], "the realm dropdown list is correct");
+		}
+		hooks.beforeEach(async function() {
+			setRealmPermissions({
+				[baseRealm.url]: ["read"],
+				[testRealmURL2]: ["read", "write"],
+				[testRealmURL]: ["read"]
+			});
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card definition", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Definition", "Test Workspace B");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating card instance", async function(assert) {
+			await visitOperatorMode$1();
+			await openNewFileModal("Card Instance", "Test Workspace B");
+			await waitFor(`[data-test-selected-type="General Card"]`);
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when duplicating card instance", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}Pet/mango.json`);
+			await waitFor(`[data-test-action-button="Duplicate"]`);
+			await click("[data-test-action-button=\"Duplicate\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when inheriting card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Inherit"]`);
+			await click("[data-test-action-button=\"Inherit\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+		(0, import_qunit.test)("read only realm is not present in realm drop down when creating instance of card definition", async function(assert) {
+			await visitOperatorMode$1(`${testRealmURL}pet.gts`);
+			await waitFor(`[data-test-action-button="Create Instance"]`);
+			await click("[data-test-action-button=\"Create Instance\"]");
+			await assertRealmDropDownIsCorrect(assert);
+		});
+	});
+	(0, import_qunit.module)("when an external write creates a new file", function(hooks) {
+		hooks.beforeEach(function() {
+			setRealmPermissions({
+				[baseRealm.url]: ["read"],
+				[testRealmURL]: ["read", "write"]
+			});
+		});
+		(0, import_qunit.test)("code submode recovers when a newly-created file arrives via a realm index/incremental event", async function(assert) {
+			let newFileUrl = `${testRealmURL}ai-created-card.gts`;
+			let newFileSource = `
+        import { CardDef } from '@cardstack/base/card-api';
+        export default class AiCreatedCard extends CardDef {
+          static displayName = 'Ai Created Card';
+        }
+      `;
+			await visitOperatorMode$1(newFileUrl);
+			await waitFor("[data-test-card-url-bar-error]");
+			assert.dom("[data-test-card-url-bar-error]").containsText("This resource does not exist", "URL bar surfaces the not-found error on initial 404");
+			let incrementalEvent = new Deferred();
+			let unsubscribe = getService("message-service").subscribe(testRealmURL, (ev) => {
+				if (ev.eventName === "index" && ev.indexType === "incremental" && Array.isArray(ev.invalidations) && ev.invalidations.includes(newFileUrl)) {
+					unsubscribe();
+					incrementalEvent.fulfill();
+				}
+			});
+			await getService("card-service").saveSource(new URL(newFileUrl), newFileSource, "create-file");
+			await incrementalEvent.promise;
+			await settled();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			assert.dom("[data-test-card-url-bar-error]").doesNotExist("URL bar error clears after the realm broadcasts the index/incremental event for the new file");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(newFileUrl, "code submode stays on the new file URL after recovery");
+			assert.ok(getMonacoContent().includes("AiCreatedCard"), "monaco loads the recovered file body, not a stale buffer");
+		});
+		(0, import_qunit.test)("navigating from a ready file to a newly-created file recovers via index/incremental", async function(assert) {
+			let newFileUrl = `${testRealmURL}navigated-to-card.gts`;
+			let newFileSource = `
+        import { CardDef } from '@cardstack/base/card-api';
+        export default class NavigatedToCard extends CardDef {
+          static displayName = 'Navigated To Card';
+        }
+      `;
+			await visitOperatorMode$1(`${testRealmURL}index.json`);
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			await visitOperatorMode$1(newFileUrl);
+			await waitFor("[data-test-card-url-bar-error]");
+			assert.dom("[data-test-card-url-bar-error]").containsText("This resource does not exist", "URL bar surfaces the not-found error on initial 404 after navigation");
+			let incrementalEvent = new Deferred();
+			let unsubscribe = getService("message-service").subscribe(testRealmURL, (ev) => {
+				if (ev.eventName === "index" && ev.indexType === "incremental" && Array.isArray(ev.invalidations) && ev.invalidations.includes(newFileUrl)) {
+					unsubscribe();
+					incrementalEvent.fulfill();
+				}
+			});
+			await getService("card-service").saveSource(new URL(newFileUrl), newFileSource, "create-file");
+			await incrementalEvent.promise;
+			await settled();
+			await waitFor("[data-test-code-mode][data-test-save-idle]");
+			assert.dom("[data-test-card-url-bar-error]").doesNotExist("URL bar error clears after the realm broadcasts the index/incremental event for the new file");
+			assert.dom("[data-test-card-url-bar-input]").hasValue(newFileUrl, "code submode stays on the new file URL after recovery");
+			assert.ok(getMonacoContent().includes("NavigatedToCard"), "monaco loads the recovered file body after the navigate-then-create sequence");
+		});
+	});
+});
+//#endregion