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

package/bundled-test-harness/assets/inspector-test-CVZVQdIJ.js

@@ -0,0 +1,1776 @@
+import { s as __toESM } from "./chunk-CGdGNDIi.js";
+import { Jr as wrapper_default, Yn as testRRI, Zn as testRealmURL, ca as Deferred, ua as rri, vi as baseRealm } from "./runtime-common-C7uLt5dN.js";
+import { f as fileDefFormats } from "./dompurify-runtime-DnZEeRZb.js";
+import { n as Submodes } from "./submode-switcher-C7knA9zW.js";
+import { i as CodeModePanelHeights, v as src_default } from "./local-storage-keys-wtjuKtZY.js";
+import { A as settled, I as waitUntil, N as visit, a as find, d as click, o as waitFor, s as fillIn, w as currentURL } from "./dist-D1U_uSwt.js";
+import { s as Position } from "./editor.api-C-6J5J7V.js";
+import "./editor.main-CpuM6HrX.js";
+import { t as require_qunit } from "./qunit-Cqwmt9Vl.js";
+import { r as getService } from "./dist-CY3T64Hs.js";
+import { D as setupAcceptanceTestRealm, E as setMonacoContent, F as setupUserSubscription, M as setupOnSave, N as setupRealmCacheTeardown, _ as elementIsVisible, a as SYSTEM_CARD_FIXTURE_CONTENTS, at as setupAuthEndpoints, b as getMonacoContent, dt as percySnapshot, j as setupLocalIndexing, nt as setupApplicationTest, q as withCachedRealmSetup, t as setupMockMatrix, tt as visitOperatorMode, u as cardDefFieldCount, w as realmConfigCardJSON, x as makeMinimalPng } from "./mock-matrix-BhFWlMMr.js";
+import { t as assertRecentFileURLs } from "./recent-files-cards-C3vIjaKb.js";
+//#region tests/acceptance/code-submode/inspector-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var testRealmURL2 = "http://test-realm/test2/";
+var realmAFiles = {
+	"realm.json": realmConfigCardJSON({
+		name: "Test Workspace A",
+		backgroundURL: "https://i.postimg.cc/VNvHH93M/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+		iconURL: "https://i.postimg.cc/L8yXRvws/icon.png"
+	}),
+	"index.json": { data: {
+		type: "card",
+		attributes: {},
+		meta: { adoptsFrom: {
+			module: "https://cardstack.com/base/cards-grid",
+			name: "CardsGrid"
+		} }
+	} }
+};
+var indexCardSource = `
+  import { CardDef, Component } from "https://cardstack.com/base/card-api";
+
+  export class Index extends CardDef {
+    static isolated = class Isolated extends Component<typeof this> {
+      <template>
+        <div data-test-index-card>
+          Hello, world!
+        </div>
+      </template>
+    };
+  }
+`;
+var personCardSource = `
+  import { contains, containsMany, field, linksToMany, CardDef, Component } from "https://cardstack.com/base/card-api";
+  import StringField from "https://cardstack.com/base/string";
+  import { Friend } from './friend';
+
+  export class Person extends CardDef {
+    static displayName = 'Person';
+    @field firstName = contains(StringField);
+    @field lastName = contains(StringField);
+    @field cardTitle = contains(StringField, {
+      computeVia: function (this: Person) {
+        return [this.firstName, this.lastName].filter(Boolean).join(' ');
+      },
+    });
+    @field friends = linksToMany(Friend);
+    @field address = containsMany(StringField);
+    static isolated = class Isolated extends Component<typeof this> {
+      <template>
+        <div data-test-person>
+          <p>First name: <@fields.firstName /></p>
+          <p>Last name: <@fields.lastName /></p>
+          <p>Title: <@fields.cardTitle /></p>
+          <p>Address List: <@fields.address /></p>
+          <p>Friends: <@fields.friends /></p>
+        </div>
+        <style scoped>
+          div {
+            color: green;
+            content: '';
+          }
+        </style>
+      </template>
+    };
+  }
+`;
+var petCardSource = `
+  import { contains, field, Component, CardDef } from "https://cardstack.com/base/card-api";
+  import StringField from "https://cardstack.com/base/string";
+
+  export class Pet extends CardDef {
+    static displayName = 'Pet';
+    @field name = contains(StringField);
+    @field cardTitle = contains(StringField, {
+      computeVia: function (this: Pet) {
+        return this.name;
+      },
+    });
+    static embedded = class Embedded extends Component<typeof this> {
+      <template>
+        <h3 data-test-pet={{@model.name}}>
+          <@fields.name/>
+        </h3>
+      </template>
+    }
+  }
+`;
+var employeeCardSource = `
+  import {
+    contains,
+    field,
+    Component,
+  } from 'https://cardstack.com/base/card-api';
+  import StringField from 'https://cardstack.com/base/string';
+  import { Person } from './person';
+
+  export class Employee extends Person {
+    static displayName = 'Employee';
+    @field department = contains(StringField);
+
+    static isolated = class Isolated extends Component<typeof this> {
+      <template>
+        <@fields.firstName /> <@fields.lastName />
+
+        Department: <@fields.department />
+      </template>
+    };
+  }
+`;
+var erroringModuleSource = `throw new Error('boom');`;
+var inThisFileSource = `
+  import {
+    contains,
+    field,
+    CardDef,
+    FieldDef,
+  } from 'https://cardstack.com/base/card-api';
+  import StringField from 'https://cardstack.com/base/string';
+
+  export const exportedVar = 'exported var';
+
+  const localVar = 'local var';
+
+  class LocalClass {}
+  export class ExportedClass {}
+
+  export class ExportedClassInheritLocalClass extends LocalClass {}
+
+  function localFunction() {}
+  export function exportedFunction() {}
+
+  export { LocalClass as AClassWithExportName };
+
+  class LocalCard extends CardDef {
+    static displayName = 'local card';
+  }
+
+  export class ExportedCard extends CardDef {
+    static displayName = 'exported card';
+    @field someString = contains(StringField);
+  }
+
+  export class ExportedCardInheritLocalCard extends LocalCard {
+    static displayName = 'exported card extends local card';
+  }
+
+  class LocalField extends FieldDef {
+    static displayName = 'local field';
+  }
+  export class ExportedField extends FieldDef {
+    static displayName = 'exported field';
+    @field someString = contains(StringField);
+  }
+
+  export class ExportedFieldInheritLocalField extends LocalField {
+    static displayName = 'exported field extends local field';
+  }
+
+  class LocalCardWithoutExportRelationship extends CardDef {
+    static displayName = 'local card but without export relationship';
+  }
+
+  export default class DefaultClass {}
+`;
+var exportedCardFieldCount = `${cardDefFieldCount + 1}`;
+var commandModuleSource = `
+  import { Command } from '@cardstack/runtime-common';
+
+  export class SampleCommand extends Command {
+    async getInputType() {
+      return undefined;
+    }
+
+    protected async run(input) {
+      return input;
+    }
+  }
+`;
+var componentModuleSource = `
+  import GlimmerComponent from '@glimmer/component';
+
+  export default class SampleComponent extends GlimmerComponent {
+    <template>
+      <div data-test-sample-component>Hello</div>
+    </template>
+  }
+`;
+var friendCardSource = `
+  import { contains, linksTo, field, CardDef, Component } from "https://cardstack.com/base/card-api";
+  import StringField from "https://cardstack.com/base/string";
+
+  export class Friend extends CardDef {
+    static displayName = 'Friend';
+    @field name = contains(StringField);
+    @field friend = linksTo(() => Friend);
+    @field cardTitle = contains(StringField, {
+      computeVia: function (this: Person) {
+        return name;
+      },
+    });
+    static isolated = class Isolated extends Component<typeof this> {
+      <template>
+        <div data-test-person>
+          <p>First name: <@fields.firstName /></p>
+          <p>Last name: <@fields.lastName /></p>
+          <p>Title: <@fields.cardTitle /></p>
+        </div>
+        <style scoped>
+          div {
+            color: green;
+            content: '';
+          }
+        </style>
+      </template>
+    };
+  }
+`;
+var exportsSource = `
+  import {
+    contains,
+    field,
+    CardDef,
+    FieldDef
+  } from 'https://cardstack.com/base/card-api';
+  import StringField from 'https://cardstack.com/base/string';
+
+  export class AncestorCard1 extends CardDef {
+    static displayName = 'AncestorCard1';
+    @field name = contains(StringField);
+  }
+
+  export class AncestorCard2 extends CardDef {
+    static displayName = 'AncestorCard2';
+    @field name = contains(StringField);
+  }
+
+  export class AncestorCard3 extends CardDef {
+    static displayName = 'AncestorCard3';
+    @field name = contains(StringField);
+  }
+
+  export class AncestorField1 extends FieldDef {
+    static displayName = 'AncestorField1';
+    @field name = contains(StringField);
+  }
+`;
+var specialExportsSource = `
+  import {
+    contains,
+    field,
+    CardDef
+  } from 'https://cardstack.com/base/card-api';
+  import StringField from 'https://cardstack.com/base/string';
+
+  class AncestorCard extends CardDef {
+    static displayName = 'Ancestor';
+    @field name = contains(StringField);
+  }
+
+  export default class DefaultAncestorCard extends CardDef {
+    static displayName = 'DefaultAncestor';
+    @field name = contains(StringField);
+  }
+
+  export { AncestorCard as RenamedAncestorCard}
+`;
+var importsSource = `
+  import { AncestorCard2, AncestorField1 } from './exports';
+  import  { AncestorCard3 as FatherCard3 } from './exports';
+  import  DefaultAncestorCard from './special-exports';
+  import  { RenamedAncestorCard } from './special-exports';
+  import {
+    contains,
+    field,
+    linksTo,
+    linksToMany
+  } from 'https://cardstack.com/base/card-api';
+
+  export class ChildCard1 extends AncestorCard2 {
+    static displayName = 'ChildCard1';
+    @field field1 = contains(AncestorField1)
+    @field field2 = linksTo(AncestorCard2)
+    @field field3 = linksTo(()=>ChildCard2)
+    @field field4 = linksToMany(AncestorCard2)
+  }
+
+  export class ChildCard2 extends DefaultAncestorCard {
+    static displayName = 'ChildCard2';
+  }
+
+  export class ChildCard3 extends RenamedAncestorCard{
+    static displayName = 'ChildCard3';
+  }
+
+  export class ChildCard4 extends FatherCard3{
+    static displayName = 'ChildCard4';
+  }
+
+  export class ChildCard5 extends ChildCard2 {
+    static displayName = 'ChildCard5';
+  }
+
+  export class ChildField1 extends AncestorField1{
+    static displayName = 'ChildField1';
+  }
+`;
+var reExportSource = `
+  import {
+    CardDef,
+    FieldDef,
+    BaseDef as BDef,
+    contains,
+  } from 'https://cardstack.com/base/card-api';
+  import StringField from 'https://cardstack.com/base/string';
+  import NumberField from 'https://cardstack.com/base/number';
+
+  export const exportedVar = 'exported var';
+
+  export { StringField as StrCard };
+
+  export { FieldDef as FDef, CardDef, contains, BDef };
+
+  export * from './in-this-file'; //Will not display inside "in-this-file"
+
+  export default NumberField;
+  export { Person as Human } from './person';
+
+  export { default as Date } from 'https://cardstack.com/base/date';
+`;
+var fileDefSource = `
+  import { FileDef } from 'https://cardstack.com/base/file-api';
+  import {
+    contains,
+    field,
+  } from 'https://cardstack.com/base/card-api';
+  import StringField from 'https://cardstack.com/base/string';
+
+  export class CustomFileDef extends FileDef {
+    static displayName = 'custom file';
+    @field customTag = contains(StringField);
+  }
+`;
+var pngDefModuleSource = `
+  export { PngDef } from 'https://cardstack.com/base/png-image-def';
+`;
+var localInheritSource = `
+  import {
+    contains,
+    field,
+    CardDef,
+    FieldDef,
+  } from 'https://cardstack.com/base/card-api';
+
+  class GrandParent extends CardDef {
+    static displayName = 'local grandparent';
+  }
+
+  class Parent extends GrandParent {
+    static displayName = 'local parent';
+  }
+
+  class Activity extends FieldDef {
+    static displayName = 'my activity';
+  }
+  class Hobby extends Activity {
+    static displayName = 'my hobby';
+  }
+  class Sport extends Hobby {
+    static displayName = 'my sport';
+  }
+
+  export class Child extends Parent {
+    static displayName = 'exported child';
+    @field sport = contains(Sport);
+  }
+`;
+(0, import_qunit.module)("Acceptance | code submode | inspector tests", function(hooks) {
+	let adapter;
+	let monacoService;
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupRealmCacheTeardown(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL, testRealmURL2],
+		autostart: true
+	});
+	let { setRealmPermissions, createAndJoinRoom } = mockMatrixUtils;
+	hooks.beforeEach(async function() {
+		setRealmPermissions({
+			[testRealmURL]: ["read", "write"],
+			[testRealmURL2]: ["read", "write"]
+		});
+		createAndJoinRoom({
+			sender: "@testuser:localhost",
+			name: "room-test"
+		});
+		setupUserSubscription();
+		setupAuthEndpoints();
+		({adapter} = await withCachedRealmSetup(async () => {
+			await setupAcceptanceTestRealm({
+				mockMatrixUtils,
+				contents: {
+					...SYSTEM_CARD_FIXTURE_CONTENTS,
+					...realmAFiles
+				},
+				realmURL: testRealmURL2
+			});
+			return setupAcceptanceTestRealm({
+				mockMatrixUtils,
+				contents: {
+					...SYSTEM_CARD_FIXTURE_CONTENTS,
+					"index.gts": indexCardSource,
+					"pet-person.gts": personCardSource,
+					"person.gts": personCardSource,
+					"pet.gts": petCardSource,
+					"friend.gts": friendCardSource,
+					"employee.gts": employeeCardSource,
+					"in-this-file.gts": inThisFileSource,
+					"exports.gts": exportsSource,
+					"special-exports.gts": specialExportsSource,
+					"imports.gts": importsSource,
+					"re-export.gts": reExportSource,
+					"local-inherit.gts": localInheritSource,
+					"file-def.gts": fileDefSource,
+					"png-def-module.gts": pngDefModuleSource,
+					"images/sample.png": makeMinimalPng(),
+					"images/logo.png": makeMinimalPng(2, 2),
+					"command-module.gts": commandModuleSource,
+					"component-module.gts": componentModuleSource,
+					"erroring-module.gts": erroringModuleSource,
+					"empty-file.gts": "",
+					"sample-styles.css": "body { color: red; }",
+					"person-entry.json": { data: {
+						type: "card",
+						attributes: {
+							cardTitle: "Person",
+							cardDescription: "Spec",
+							specType: "card",
+							ref: {
+								module: `./person`,
+								name: "Person"
+							}
+						},
+						meta: { adoptsFrom: {
+							module: `${baseRealm.url}spec`,
+							name: "Spec"
+						} }
+					} },
+					"index.json": { data: {
+						type: "card",
+						attributes: {},
+						meta: { adoptsFrom: {
+							module: "./index",
+							name: "Index"
+						} }
+					} },
+					"léame.md": "hola mundo",
+					"readme.md": "hello world",
+					"not-json.json": "I am not JSON.",
+					"Person/1.json": { data: {
+						type: "card",
+						attributes: {
+							firstName: "Hassan",
+							lastName: "Abdel-Rahman"
+						},
+						meta: { adoptsFrom: {
+							module: "../person",
+							name: "Person"
+						} }
+					} },
+					"Pet/mango.json": { data: {
+						attributes: { name: "Mango" },
+						meta: { adoptsFrom: {
+							module: `${testRealmURL}pet`,
+							name: "Pet"
+						} }
+					} },
+					"Pet/vangogh.json": { data: {
+						attributes: { name: "Van Gogh" },
+						meta: { adoptsFrom: {
+							module: `${testRealmURL}pet`,
+							name: "Pet"
+						} }
+					} },
+					"z00.json": "{}",
+					"z01.json": "{}",
+					"z02.json": "{}",
+					"z03.json": "{}",
+					"z04.json": "{}",
+					"z05.json": "{}",
+					"z06.json": "{}",
+					"z07.json": "{}",
+					"z08.json": "{}",
+					"z09.json": "{}",
+					"z10.json": "{}",
+					"z11.json": "{}",
+					"z12.json": "{}",
+					"z13.json": "{}",
+					"z14.json": "{}",
+					"z15.json": "{}",
+					"z16.json": "{}",
+					"z17.json": "{}",
+					"z18.json": "{}",
+					"z19.json": "{}",
+					"zzz/zzz/file.json": "{}",
+					"realm.json": realmConfigCardJSON({
+						name: "Test Workspace B",
+						backgroundURL: "https://i.postimg.cc/VNvHH93M/pawel-czerwinski-Ly-ZLa-A5jti-Y-unsplash.jpg",
+						iconURL: "https://i.postimg.cc/L8yXRvws/icon.png"
+					})
+				}
+			});
+		}));
+		monacoService = getService("monaco-service");
+	});
+	(0, import_qunit.test)("inspector will show json instance definition and module definition in card inheritance panel", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[{
+				id: `${testRealmURL}Person/1`,
+				format: "isolated"
+			}]],
+			submode: "code",
+			codePath: `${testRealmURL}Person/1.json`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-card-module-definition]");
+		await waitFor("[data-test-card-instance-definition]");
+		assert.dom("[data-test-card-module-definition]").includesText("Card");
+		assert.dom("[data-test-card-module-definition] [data-test-definition-file-extension]").includesText(".gts");
+		await waitFor("[data-test-card-module-definition] [data-test-definition-realm-name]");
+		assert.dom("[data-test-card-module-definition] [data-test-definition-realm-name]").includesText("Test Workspace B");
+		assert.dom("[data-test-card-module-definition]").doesNotHaveClass("active");
+		assert.dom("[data-test-card-instance-definition]").includesText("Hassan Abdel-Rahman");
+		assert.dom("[data-test-card-instance-definition] [data-test-definition-file-extension]").includesText(".JSON");
+		await waitFor("[data-test-card-instance-definition] [data-test-definition-realm-name]");
+		assert.dom("[data-test-card-instance-definition] [data-test-definition-realm-name]").includesText("Test Workspace B");
+		assert.dom("[data-test-definition-info-text]").includesText("Last saved just now");
+		assert.dom("[data-test-card-instance-definition] [data-test-definition-header]").hasClass("active");
+	});
+	(0, import_qunit.test)("inspector will show module definition in card inheritance panel", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}person.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-card-module-definition]").includesText("Card");
+		assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}person.gts`);
+		assert.dom("[data-test-card-module-definition] [data-test-definition-header]").hasClass("active");
+		assert.dom("[data-test-card-module-definition] [data-test-definition-file-extension]").includesText(".gts");
+		assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}person.gts`);
+		assert.dom("[data-test-card-module-definition]").includesText("Card");
+		await waitFor("[data-test-card-module-definition] [data-test-definition-realm-name]");
+		assert.dom("[data-test-card-module-definition] [data-test-definition-realm-name]").includesText("Test Workspace B");
+		assert.dom("[data-test-card-instance-definition]").doesNotExist();
+	});
+	(0, import_qunit.test)("can switch between inspector showing module definition and inspector showing json instance definition in card inheritance panel", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}person.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-card-module-definition]").includesText("Card");
+		assert.dom("[data-test-card-instance-definition]").doesNotExist();
+		await click("[data-test-file-browser-toggle]");
+		await click("[data-test-directory=\"Person/\"]");
+		await waitFor("[data-test-file=\"Person/1.json\"]");
+		await click("[data-test-file=\"Person/1.json\"]");
+		await click("[data-test-inspector-toggle]");
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-card-instance-definition]").includesText("Hassan Abdel-Rahman");
+		assert.dom("[data-test-card-instance-definition] [data-test-definition-file-extension]").includesText(".JSON");
+	});
+	(0, import_qunit.test)("\"in-this-file\" panel displays all elements and re-highlights upon selection", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		let elementName = "default (DefaultClass) class";
+		assert.dom("[data-test-boxel-selector-item]:nth-of-type(11)").hasText(elementName, "defaults to the last declaration");
+		assert.true(monacoService.getLineCursorOn()?.includes("DefaultClass"));
+		[
+			"AClassWithExportName (LocalClass) class",
+			"ExportedClass class",
+			"ExportedClassInheritLocalClass class",
+			"exportedFunction function",
+			"LocalCard card def",
+			"ExportedCard card def",
+			"ExportedCardInheritLocalCard card def",
+			"LocalField field def",
+			"ExportedField field def",
+			"ExportedFieldInheritLocalField field def",
+			"default (DefaultClass) class"
+		].forEach(async (elementName, index) => {
+			await waitFor(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`);
+			assert.dom(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`).hasText(elementName);
+		});
+		assert.dom("[data-test-boxel-selector-item]").exists({ count: 11 });
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(elementName);
+		assert.dom("[data-test-inheritance-panel-header]").doesNotExist();
+		elementName = "ExportedCard";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} card def`);
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-inheritance-panel-header]").exists();
+		assert.dom("[data-test-card-module-definition]").exists();
+		assert.dom("[data-test-definition-header]").includesText("Card Definition");
+		assert.dom("[data-test-card-module-definition]").includesText("exported card");
+		await waitFor("[data-test-card-schema=\"exported card\"]");
+		assert.dom("[data-test-card-schema=\"exported card\"]").exists({ count: 1 });
+		assert.dom(`[data-test-card-schema="exported card"] [data-test-field-name="someString"] [data-test-card-display-name="String"]`).exists();
+		assert.dom(`[data-test-total-fields]`).containsText(exportedCardFieldCount);
+		assert.true(monacoService.getLineCursorOn()?.includes(elementName));
+		elementName = "ExportedField";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} field def`);
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-inheritance-panel-header]").exists();
+		assert.dom("[data-test-definition-header]").includesText("Field Definition");
+		assert.dom("[data-test-card-module-definition]").includesText("exported field");
+		await waitFor("[data-test-card-schema=\"exported field\"]");
+		assert.dom("[data-test-card-schema=\"exported field\"]").exists({ count: 1 });
+		assert.dom(`[data-test-total-fields]`).containsText("1");
+		assert.dom(`[data-test-card-schema="exported field"] [data-test-field-name="someString"] [data-test-card-display-name="String"]`).exists();
+		assert.true(monacoService.getLineCursorOn()?.includes(elementName));
+		elementName = "exportedFunction";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} function`);
+		assert.dom("[data-test-inheritance-panel-header]").doesNotExist();
+		assert.dom("[data-test-card-module-definition]").doesNotExist();
+		assert.dom("[data-test-schema-editor-file-incompatibility-message]").hasText(`No tools are available for the selected item: function "exportedFunction". Select a card or field definition in the inspector.`);
+		assert.true(monacoService.getLineCursorOn()?.includes(elementName));
+	});
+	(0, import_qunit.test)("inspector persists scroll position but choosing another element overrides it", async function(assert) {
+		src_default.localStorage.setItem(CodeModePanelHeights, JSON.stringify({
+			filePanel: 50,
+			recentPanel: 50
+		}));
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		let localClassSelector = "[data-test-boxel-selector-item-text=\"LocalClass\"]";
+		let localClassElement = find(localClassSelector);
+		if (!localClassElement) assert.ok(localClassElement, "local class should exist");
+		else {
+			assert.notOk(await elementIsVisible(localClassElement), "expected local class not to be within view");
+			localClassElement.scrollIntoView({ block: "center" });
+			assert.ok(await elementIsVisible(localClassElement), "expected local class to now be within view");
+		}
+		await click("[data-test-file-browser-toggle]");
+		assert.dom(localClassSelector).doesNotExist();
+		await click("[data-test-inspector-toggle]");
+		await waitFor(localClassSelector);
+		let position = new Position(15, 0);
+		monacoService.updateCursorPosition(position);
+		await settled();
+		let exportedClassElement = find("[data-test-boxel-selector-item-text=\"ExportedClass\"]");
+		if (!exportedClassElement) assert.ok(exportedClassElement, "exported class element should exist");
+		else assert.ok(await elementIsVisible(exportedClassElement), "expected exported class to have scrolled into view");
+	});
+	(0, import_qunit.test)("can duplicate an instance in same realm", async function(assert) {
+		assert.expect(7);
+		let operatorModeStateParam = wrapper_default({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}Pet/vangogh.json`
+		});
+		await visit(`/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(operatorModeStateParam)}`);
+		await waitFor(`[data-test-action-button="Duplicate"]`);
+		await click("[data-test-action-button=\"Duplicate\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		await percySnapshot(assert);
+		let deferred = new Deferred();
+		let id;
+		this.onSave((url, json) => {
+			if (typeof json === "string") throw new Error(`expected json save data`);
+			if (json.data.meta.adoptsFrom?.name === "Pet") {
+				id = url.href;
+				assert.strictEqual(json.data.attributes?.name, "Van Gogh", "the name field is correct");
+				assert.deepEqual(json.data.meta.adoptsFrom, {
+					module: rri("../pet"),
+					name: "Pet"
+				});
+				assert.strictEqual(json.data.meta.realmURL, testRealmURL);
+				this.unregisterOnSave?.();
+				deferred.fulfill();
+			}
+		});
+		await click("[data-test-duplicate-card-instance]");
+		await waitFor("[data-test-create-file-modal]", { count: 0 });
+		await deferred.promise;
+		await settled();
+		await waitFor(`[data-test-code-mode-card-renderer-header="${id}"]`);
+		assert.dom("[data-test-card-resource-loaded]").containsText("Pet");
+		assert.dom(`[data-test-code-mode-card-renderer-header="${id}"] [data-test-realm-icon-url]`).hasAttribute("aria-label", "Test Workspace B");
+		assert.dom("[data-test-field=\"name\"] input").hasValue("Van Gogh");
+		assert.dom("[data-test-card-url-bar-input]").hasValue(`${id}.json`);
+	});
+	(0, import_qunit.test)("can duplicate an instance in different realm", async function(assert) {
+		assert.expect(8);
+		let operatorModeStateParam = wrapper_default({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}Pet/vangogh.json`
+		});
+		await visit(`/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(operatorModeStateParam)}`);
+		await waitFor(`[data-test-action-button="Duplicate"]`);
+		await click("[data-test-action-button=\"Duplicate\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		await click(`[data-test-realm-dropdown-trigger]`);
+		await waitFor("[data-test-boxel-menu-item-text=\"Test Workspace A\"]");
+		await click("[data-test-boxel-menu-item-text=\"Test Workspace A\"]");
+		await waitFor(`[data-test-realm-name="Test Workspace A"]`);
+		assert.dom("[data-test-realm-name]").hasText("Test Workspace A");
+		let deferred = new Deferred();
+		let id;
+		this.onSave((url, json) => {
+			if (typeof json === "string") throw new Error(`expected json save data`);
+			id = url.href;
+			assert.strictEqual(json.data.attributes?.name, "Van Gogh", "the name field is correct");
+			assert.deepEqual(json.data.meta.adoptsFrom, {
+				module: testRRI("pet"),
+				name: "Pet"
+			});
+			assert.strictEqual(json.data.meta.realmURL, testRealmURL2);
+			deferred.fulfill();
+		});
+		await click("[data-test-duplicate-card-instance]");
+		await waitFor("[data-test-create-file-modal]", { count: 0 });
+		await deferred.promise;
+		await settled();
+		await waitFor(`[data-test-code-mode-card-renderer-header="${id}"]`);
+		assert.dom("[data-test-card-resource-loaded]").containsText("Pet");
+		assert.dom(`[data-test-code-mode-card-renderer-header="${id}"] [data-test-realm-icon-url]`).hasAttribute("aria-label", "Test Workspace A");
+		assert.dom("[data-test-field=\"name\"] input").hasValue("Van Gogh");
+		assert.dom("[data-test-card-url-bar-input]").hasValue(`${id}.json`);
+	});
+	(0, import_qunit.test)("can delete a card instance from code submode with no recent files to fall back on", async function(assert) {
+		let recentCardsService = getService("recent-cards-service");
+		let recentFilesService = getService("recent-files-service");
+		[`${testRealmURL}Pet/vangogh`, `${testRealmURL}Person/1`].map((url) => recentCardsService.add(url));
+		recentFilesService.addRecentFileUrl(`${testRealmURL}Pet/vangogh.json`);
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}Person/1`,
+			format: "isolated"
+		}, {
+			id: `${testRealmURL}Pet/vangogh`,
+			format: "isolated"
+		}]] });
+		assert.dom(`[data-test-stack-card="${testRealmURL}Person/1"]`).exists();
+		assert.dom(`[data-test-stack-card="${testRealmURL}Pet/vangogh"]`).exists();
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		assertRecentFileURLs(assert, recentFilesService.recentFiles, [`${testRealmURL}Pet/vangogh.json`], "recent file is correct");
+		assert.dom("[data-test-delete-modal-container]").doesNotExist();
+		assert.dom("[data-test-empty-code-mode]").doesNotExist();
+		await click("[data-test-action-button=\"Delete\"]");
+		assert.dom(`[data-test-delete-modal="${testRealmURL}Pet/vangogh"]`).exists();
+		assert.dom("[data-test-delete-msg]").includesText("Delete the card Van Gogh?");
+		await percySnapshot(assert);
+		await click("[data-test-confirm-delete-button]");
+		assert.dom("[data-test-empty-code-mode]").exists();
+		await percySnapshot("Acceptance | operator mode tests | can delete a card instance from code submode with no recent files - empty code submode");
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Interact\"]");
+		assert.dom(`[data-test-stack-card="${testRealmURL}Person/1"`).exists();
+		assert.dom(`[data-test-stack-card="${testRealmURL}Pet/vangogh"`).doesNotExist("stack item removed");
+		assert.deepEqual(recentCardsService.recentCardIds, [`${testRealmURL}Person/1`], "the deleted card has been removed from recent cards");
+		assert.deepEqual(recentFilesService.recentFiles.length, 0, "the deleted card has been removed from recent files");
+		let notFound = await adapter.openFile("Pet/vangogh.json");
+		assert.strictEqual(notFound, void 0, "file ref does not exist");
+		assert.dom("[data-test-delete-modal-container]").doesNotExist();
+	});
+	(0, import_qunit.test)("Can delete a card instance from code submode and fall back to recent file", async function(assert) {
+		let recentFilesService = getService("recent-files-service");
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}Person/1`,
+			format: "isolated"
+		}, {
+			id: `${testRealmURL}Pet/vangogh`,
+			format: "isolated"
+		}]] });
+		assert.dom(`[data-test-stack-card="${testRealmURL}Person/1"]`).exists();
+		assert.dom(`[data-test-stack-card="${testRealmURL}Pet/vangogh"]`).exists();
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Code\"]");
+		assert.strictEqual(recentFilesService.recentFiles.length, 1);
+		recentFilesService.addRecentFileUrl(`${testRealmURL}Pet/mango.json`);
+		assertRecentFileURLs(assert, recentFilesService.recentFiles, [`${testRealmURL}Pet/mango.json`, `${testRealmURL}Pet/vangogh.json`]);
+		await click("[data-test-action-button=\"Delete\"]");
+		assert.dom(`[data-test-delete-modal="${testRealmURL}Pet/vangogh"]`).exists();
+		await click("[data-test-confirm-delete-button]");
+		assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}Pet/mango.json`);
+		assert.deepEqual(JSON.parse(getMonacoContent()), { data: {
+			attributes: { name: "Mango" },
+			meta: { adoptsFrom: {
+				module: `${testRealmURL}pet`,
+				name: "Pet"
+			} }
+		} });
+		await click("[data-test-submode-switcher] button");
+		await click("[data-test-boxel-menu-item-text=\"Interact\"]");
+		assert.dom(`[data-test-stack-card="${testRealmURL}Person/1"`).exists();
+		assert.dom(`[data-test-stack-card="${testRealmURL}Pet/vangogh"`).doesNotExist("stack item removed");
+		assertRecentFileURLs(assert, recentFilesService.recentFiles, [`${testRealmURL}Pet/mango.json`], "the deleted card has been removed from recent files");
+	});
+	(0, import_qunit.test)("can delete a card definition and fallback to recent file", async function(assert) {
+		let recentFilesService = getService("recent-files-service");
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}pet.gts`
+		});
+		recentFilesService.addRecentFileUrl(`${testRealmURL}Pet/mango.json`);
+		assertRecentFileURLs(assert, recentFilesService.recentFiles, [`${testRealmURL}Pet/mango.json`, `${testRealmURL}pet.gts`]);
+		assert.dom("[data-test-delete-modal-container]").doesNotExist();
+		await click("[data-test-delete-module-button]");
+		assert.dom(`[data-test-delete-modal="${testRealmURL}pet.gts"]`).exists();
+		await click("[data-test-confirm-delete-button]");
+		assert.dom("[data-test-card-url-bar-input]").hasValue(`${testRealmURL}Pet/mango.json`);
+		assertRecentFileURLs(assert, recentFilesService.recentFiles, [`${testRealmURL}Pet/mango.json`], "the deleted card def has been removed from recent files");
+		let notFound = await adapter.openFile("pet.gts");
+		assert.strictEqual(notFound, void 0, "file ref does not exist");
+		assert.dom("[data-test-delete-modal-container]").doesNotExist();
+	});
+	(0, import_qunit.test)("can delete a card definition with no recent files to fall back on", async function(assert) {
+		let recentFilesService = getService("recent-files-service");
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}pet.gts`
+		});
+		assertRecentFileURLs(assert, recentFilesService.recentFiles, [`${testRealmURL}pet.gts`], "recent file is correct");
+		assert.dom("[data-test-empty-code-mode]").doesNotExist();
+		await click("[data-test-delete-module-button]");
+		assert.dom(`[data-test-delete-modal="${testRealmURL}pet.gts"]`).exists();
+		await click("[data-test-confirm-delete-button]");
+		assert.dom("[data-test-empty-code-mode]").exists();
+		assert.strictEqual(recentFilesService.recentFiles.length, 0, "the deleted card has been removed from recent files");
+		assertRecentFileURLs(assert, recentFilesService.recentFiles, [], "recent file is correct");
+		let notFound = await adapter.openFile("pet.gts");
+		assert.strictEqual(notFound, void 0, "file ref does not exist");
+	});
+	(0, import_qunit.test)("shows command panel for command declarations", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: Submodes.Code,
+			codePath: `${testRealmURL}command-module.gts`
+		});
+		await waitFor("[data-test-command-panel-header]");
+		assert.dom("[data-test-command-panel-header]").hasText("Command", "renders command panel");
+		assert.dom("[data-test-card-module-definition]").hasTextContaining("SampleCommand", "shows command definition details");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText("SampleCommand command", "selector shows command type");
+	});
+	(0, import_qunit.test)("shows component panel and Create Listing action for component declarations", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: Submodes.Code,
+			codePath: `${testRealmURL}component-module.gts`
+		});
+		await waitFor("[data-test-component-panel-header]");
+		assert.dom("[data-test-component-panel-header]").hasText("Component", "renders component panel");
+		assert.dom("[data-test-action-button=\"Create Listing\"]").exists("Create Listing action is available for a component");
+		await click("[data-test-action-button=\"Create Listing\"]");
+		await waitFor("[data-test-create-listing-modal]");
+		assert.dom("[data-test-create-listing-modal]").exists("clicking Create Listing opens the create listing modal");
+	});
+	(0, import_qunit.test)("can delete a misc file", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}léame.md`
+		});
+		assert.dom("[data-test-delete-modal-container]").doesNotExist();
+		await waitFor(`[data-test-action-button="Delete"]`);
+		await click("[data-test-action-button=\"Delete\"]");
+		await waitFor(`[data-test-delete-modal="${testRealmURL}l%C3%A9ame.md"]`);
+		assert.dom("[data-test-delete-msg]").includesText("Delete the file léame.md?");
+		await click("[data-test-confirm-delete-button]");
+		await waitFor("[data-test-empty-code-mode]");
+		let notFound = await adapter.openFile("léame.md");
+		assert.strictEqual(notFound, void 0, "file ref does not exist");
+		assert.dom("[data-test-delete-modal-container]").doesNotExist();
+	});
+	(0, import_qunit.test)("After opening inherited definition inside inheritance panel, \"in-this-file\" highlights selected definition", async function(assert) {
+		let operatorModeState = {
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}imports.gts`
+		};
+		await visitOperatorMode(operatorModeState);
+		let elementName = "ChildCard1";
+		await waitFor(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		let selected = "AncestorCard2 card def";
+		await waitFor(`[data-test-clickable-definition-container]`);
+		await click(`[data-test-clickable-definition-container]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(selected);
+		await visitOperatorMode(operatorModeState);
+		elementName = "ChildCard2";
+		await waitFor(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		selected = "default (DefaultAncestorCard) card def";
+		await waitFor(`[data-test-clickable-definition-container]`);
+		await click(`[data-test-clickable-definition-container]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(selected);
+		await visitOperatorMode(operatorModeState);
+		elementName = "ChildCard3";
+		await waitFor(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		selected = "RenamedAncestorCard (AncestorCard) card def";
+		await waitFor(`[data-test-clickable-definition-container]`);
+		await click(`[data-test-clickable-definition-container]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(selected);
+		await visitOperatorMode(operatorModeState);
+		elementName = "ChildCard4";
+		await waitFor(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		selected = "AncestorCard3 card def";
+		await click(`[data-test-clickable-definition-container]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(selected);
+		await visitOperatorMode(operatorModeState);
+		elementName = "ChildCard5";
+		await waitFor(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		selected = "ChildCard2 card def";
+		await waitFor(`[data-test-clickable-definition-container]`);
+		await click(`[data-test-clickable-definition-container]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(selected);
+		await visitOperatorMode(operatorModeState);
+		elementName = "ChildField1";
+		await waitFor(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		selected = "AncestorField1 field def";
+		await click(`[data-test-clickable-definition-container]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(selected);
+	});
+	(0, import_qunit.test)("After opening definition from card type and fields in module inspector, \"in-this-file\" highlights selected definition", async function(assert) {
+		let operatorModeState = {
+			submode: Submodes.Code,
+			codePath: `${testRealmURL}imports.gts`
+		};
+		await visitOperatorMode(operatorModeState);
+		await visitOperatorMode(operatorModeState);
+		await click(`[data-test-boxel-selector-item-text="ChildCard1"]`);
+		let elementName = "AncestorCard2";
+		await waitFor(`[data-test-card-schema="${elementName}"] [data-test-card-schema-navigational-button]`);
+		await click(`[data-test-card-schema="${elementName}"] [data-test-card-schema-navigational-button]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} card def`);
+		await visitOperatorMode(operatorModeState);
+		elementName = "AncestorField1";
+		await waitFor(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field1"] [data-test-card-display-name="${elementName}"]`);
+		await click(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field1"] [data-test-card-display-name="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} field def`);
+		await visitOperatorMode(operatorModeState);
+		elementName = "AncestorCard2";
+		await waitFor(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field2"] [data-test-card-display-name="${elementName}"]`);
+		await click(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field2"] [data-test-card-display-name="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} card def`);
+		await visitOperatorMode(operatorModeState);
+		elementName = "ChildCard2";
+		await waitFor(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field3"] [data-test-card-display-name="${elementName}"]`);
+		await click(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field3"] [data-test-card-display-name="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} card def`);
+		await click("[data-boxel-selector-item-text=\"ChildCard1\"]");
+		elementName = "AncestorCard2";
+		await waitFor(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field4"] [data-test-card-display-name="${elementName}"]`);
+		await click(`[data-test-card-schema="ChildCard1"] [data-test-field-name="field4"] [data-test-card-display-name="${elementName}"]`);
+		assert.operatorModeParametersMatch(currentURL(), { codeSelection: elementName });
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} card def`);
+	});
+	(0, import_qunit.test)("in-this-file panel displays re-exports", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}re-export.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		let elementName = "StrCard (StringField) field def";
+		assert.dom("[data-test-boxel-selector-item]:nth-of-type(1)").hasText(elementName);
+		[
+			"StrCard (StringField) field def",
+			"FDef (FieldDef) field def",
+			"CardDef card def",
+			"BDef base def",
+			"default (NumberField) field def",
+			"Human (Person) card def",
+			"Date (default) field def"
+		].forEach(async (elementName, index) => {
+			await waitFor(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`);
+			assert.dom(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`).hasText(elementName);
+		});
+		assert.dom("[data-test-boxel-selector-item]").exists({ count: 7 });
+		elementName = "BDef";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} base def`);
+		assert.dom("[data-test-inheritance-panel-header]").exists();
+		assert.dom("[data-test-card-module-definition]").exists();
+		assert.dom("[data-test-definition-header]").includesText("Re-exported Base Definition");
+		assert.dom("[data-test-card-module-definition]").includesText("Base");
+		assert.true(monacoService.getLineCursorOn()?.includes("BDef"));
+		assert.dom("[data-test-file-incompatibility-message]").doesNotExist();
+		elementName = "Person";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`Human (${elementName}) card def`);
+		assert.dom("[data-test-inheritance-panel-header]").exists();
+		assert.dom("[data-test-card-module-definition]").exists();
+		assert.dom("[data-test-definition-header]").includesText("Re-exported Card Definition");
+		assert.dom("[data-test-card-module-definition]").includesText("Card");
+		assert.true(monacoService.getLineCursorOn()?.includes("Human"));
+		assert.dom("[data-test-file-incompatibility-message]").doesNotExist();
+	});
+	(0, import_qunit.test)("\"in-this-file\" panel displays FileDef declarations with correct labeling", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}file-def.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		assert.dom("[data-test-boxel-selector-item]").exists({ count: 1 });
+		assert.dom("[data-test-boxel-selector-item]:nth-of-type(1)").hasText("CustomFileDef file def");
+		let elementName = "CustomFileDef";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} file def`);
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-inheritance-panel-header]").exists();
+		assert.dom("[data-test-inheritance-panel-header]").hasText("File Def Inheritance");
+		assert.dom("[data-test-card-module-definition]").exists();
+		assert.dom("[data-test-definition-header]").includesText("File Definition");
+		assert.dom("[data-test-card-module-definition]").includesText("custom file");
+		assert.dom("[data-test-action-button=\"Inherit\"]").exists("Inherit action is shown for exported FileDef declarations");
+	});
+	(0, import_qunit.test)("Schema/Playground/Spec panes render for a focused FileDef declaration", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}file-def.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		await click(`[data-test-boxel-selector-item-text="CustomFileDef"]`);
+		await waitFor("[data-test-card-schema=\"custom file\"]");
+		assert.dom("[data-test-card-schema=\"custom file\"]").exists({ count: 1 });
+		assert.dom(`[data-test-card-schema="custom file"] [data-test-field-name="customTag"] [data-test-card-display-name="String"]`).exists("customTag field is shown in schema");
+		assert.dom("[data-test-module-inspector=\"card-or-field\"]").exists("module inspector 3-pane view renders for FileDef");
+		await click("[data-test-module-inspector-view=\"preview\"]");
+		assert.dom("[data-test-active-module-inspector-view=\"preview\"]").exists("playground pane renders for FileDef");
+		await waitFor("[data-test-playground-filedef-message]");
+		assert.dom("[data-test-playground-filedef-message]").includesText("No file instances found", "shows no-instances message for FileDef with no matching files");
+		assert.dom("[data-test-instance-chooser]").doesNotExist("instance chooser is not shown when there are no file instances");
+		assert.dom("[data-test-playground-format-chooser]").doesNotExist("format chooser is not shown when there are no file instances");
+		await click("[data-test-module-inspector-view=\"spec\"]");
+		assert.dom("[data-test-active-module-inspector-view=\"spec\"]").exists("spec pane renders for FileDef");
+		await click("[data-test-module-inspector-view=\"schema\"]");
+		assert.dom("[data-test-active-module-inspector-view=\"schema\"]").exists("schema pane renders for FileDef");
+		assert.dom("[data-test-card-schema=\"custom file\"]").exists();
+	});
+	(0, import_qunit.test)("Playground displays file-meta instances for PngDef with preview, instance chooser, and format chooser", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}png-def-module.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		await click("[data-test-boxel-selector-item-text=\"PngDef\"]");
+		await click("[data-test-module-inspector-view=\"preview\"]");
+		await waitFor("[data-test-instance-chooser]", { timeout: 1e4 });
+		assert.dom("[data-test-playground-panel]").exists("playground panel renders");
+		assert.dom("[data-test-instance-chooser]").exists("instance chooser is shown");
+		assert.dom("[data-test-playground-format-chooser]").exists("format chooser is shown");
+		assert.dom("[data-test-playground-filedef-message]").doesNotExist("no-instances message is NOT shown when instances exist");
+		assert.dom("[data-test-selected-item]").exists("selected item is displayed");
+		assert.dom("[data-test-selected-item]").containsText(".png", "selected item title contains filename");
+		assert.dom("[data-test-playground-panel] [data-test-boxel-card-header-title]").exists("card header renders for file preview");
+		assert.dom("[data-test-playground-format-chooser] [data-test-format-chooser=\"isolated\"]").exists("isolated format available");
+		assert.dom("[data-test-playground-format-chooser] [data-test-format-chooser=\"embedded\"]").exists("embedded format available");
+		assert.dom("[data-test-playground-format-chooser] [data-test-format-chooser=\"fitted\"]").exists("fitted format available");
+		assert.dom("[data-test-playground-format-chooser] [data-test-format-chooser=\"atom\"]").exists("atom format available");
+		assert.dom("[data-test-playground-format-chooser] [data-test-format-chooser=\"edit\"]").doesNotExist("edit format is NOT available for FileDef");
+		assert.dom("[data-test-format-chooser=\"isolated\"]").hasClass("active", "isolated is the default active format");
+	});
+	(0, import_qunit.test)("Playground FileDef format switching renders different formats", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}png-def-module.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		await click("[data-test-boxel-selector-item-text=\"PngDef\"]");
+		await click("[data-test-module-inspector-view=\"preview\"]");
+		await waitFor("[data-test-instance-chooser]", { timeout: 1e4 });
+		assert.dom("[data-test-format-chooser]").exists({ count: fileDefFormats.length });
+		assert.dom("[data-test-format-chooser=\"isolated\"]").hasClass("active", "starts in isolated format");
+		await click("[data-test-format-chooser=\"embedded\"]");
+		assert.dom("[data-test-format-chooser=\"isolated\"]").hasNoClass("active", "isolated no longer active");
+		assert.dom("[data-test-format-chooser=\"embedded\"]").hasClass("active", "embedded is now active");
+		await click("[data-test-format-chooser=\"atom\"]");
+		assert.dom("[data-test-format-chooser=\"embedded\"]").hasNoClass("active", "embedded no longer active");
+		assert.dom("[data-test-format-chooser=\"atom\"]").hasClass("active", "atom is now active");
+		assert.dom("[data-test-atom-preview]").exists("atom preview container renders");
+		await click("[data-test-format-chooser=\"fitted\"]");
+		assert.dom("[data-test-format-chooser=\"atom\"]").hasNoClass("active", "atom no longer active");
+		assert.dom("[data-test-format-chooser=\"fitted\"]").hasClass("active", "fitted is now active");
+	});
+	(0, import_qunit.test)("Playground FileDef instance selection switches the displayed file", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}png-def-module.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		await click("[data-test-boxel-selector-item-text=\"PngDef\"]");
+		await click("[data-test-module-inspector-view=\"preview\"]");
+		await waitFor("[data-test-instance-chooser]", { timeout: 1e4 });
+		let initialTitle = document.querySelector("[data-test-selected-item]")?.textContent?.trim() ?? "";
+		assert.ok(initialTitle.length > 0, "initial selection has a title");
+		await click("[data-test-instance-chooser]");
+		assert.dom("[data-option-index=\"0\"]").exists("first dropdown option exists");
+		assert.dom("[data-option-index=\"1\"]").exists("second dropdown option exists");
+		await click("[data-option-index=\"1\"]");
+		let newTitle = document.querySelector("[data-test-selected-item]")?.textContent?.trim() ?? "";
+		assert.ok(newTitle.length > 0, "new selection has a title");
+		assert.notEqual(newTitle, initialTitle, "selected instance changed after clicking a different option");
+	});
+	(0, import_qunit.test)("\"in-this-file\" panel displays local grandfather card. selection will move cursor and display card or field schema", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}local-inherit.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		await click(`[data-test-boxel-selector-item-text="GrandParent"]`);
+		let elementName = "GrandParent card def";
+		assert.dom("[data-test-boxel-selector-item]:nth-of-type(1)").hasText(elementName);
+		assert.true(monacoService.getLineCursorOn()?.includes("GrandParent"));
+		assert.true(monacoService.getLineCursorOn()?.includes("CardDef"));
+		[
+			"GrandParent card def",
+			"Parent card def",
+			"Activity field def",
+			"Hobby field def",
+			"Sport field def",
+			"Child card def"
+		].forEach(async (elementName, index) => {
+			await waitFor(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`);
+			assert.dom(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`).hasText(elementName);
+		});
+		elementName = "Parent";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} card def`);
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-inheritance-panel-header]").exists();
+		assert.dom("[data-test-card-module-definition]").exists();
+		assert.dom("[data-test-definition-header]").includesText("Card Definition");
+		assert.dom("[data-test-card-module-definition]").includesText("local parent");
+		await waitFor("[data-test-card-schema=\"local parent\"]");
+		assert.dom("[data-test-card-schema=\"local grandparent\"]").exists({ count: 1 });
+		assert.dom(`[data-test-card-schema="local parent"]`).exists();
+		assert.dom(`[data-test-card-schema="local grandparent"]`).exists();
+		assert.dom(`[data-test-total-fields]`).containsText(`${cardDefFieldCount}`);
+		assert.true(monacoService.getLineCursorOn()?.includes(elementName));
+		assert.true(monacoService.getLineCursorOn()?.includes("GrandParent"));
+		elementName = "Sport";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} field def`);
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-inheritance-panel-header]").exists();
+		assert.dom("[data-test-card-module-definition]").exists();
+		assert.dom("[data-test-definition-header]").includesText("Field Definition");
+		assert.dom("[data-test-card-module-definition]").includesText("my sport");
+		await waitFor("[data-test-card-schema=\"my sport\"]");
+		assert.dom("[data-test-card-schema=\"my sport\"]").exists({ count: 1 });
+		assert.dom(`[data-test-card-schema="my hobby"]`).exists({ count: 1 });
+		assert.dom(`[data-test-card-schema="my activity"]`).exists({ count: 1 });
+		assert.dom(`[data-test-total-fields]`).containsText("0");
+		assert.true(monacoService.getLineCursorOn()?.includes(elementName));
+		await waitFor(`[data-test-clickable-definition-container]`);
+		await click(`[data-test-clickable-definition-container]`);
+		await waitFor("[data-test-boxel-selector-item-selected]");
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText("Hobby field def");
+		await waitFor("[data-test-card-schema=\"my hobby\"]");
+		assert.dom(`[data-test-card-schema="my hobby"]`).exists({ count: 1 });
+		assert.dom(`[data-test-card-schema="my activity"]`).exists({ count: 1 });
+		assert.dom(`[data-test-total-fields]`).containsText("0");
+		assert.true(monacoService.getLineCursorOn()?.includes("Hobby"));
+		assert.true(monacoService.getLineCursorOn()?.includes("Activity"));
+	});
+	(0, import_qunit.test)("\"in-this-file\" panel maintains selection after editing name of declaration", async function(assert) {
+		let operatorModeStateParam = wrapper_default({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await visit(`/?operatorModeEnabled=true&operatorModeState=${encodeURIComponent(operatorModeStateParam)}`);
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name]");
+		await waitFor("[data-test-in-this-file-selector]");
+		let elementName = "default (DefaultClass) class";
+		assert.dom("[data-test-boxel-selector-item]:nth-of-type(11)").hasText(elementName);
+		assert.true(monacoService.getLineCursorOn()?.includes("DefaultClass"));
+		[
+			"AClassWithExportName (LocalClass) class",
+			"ExportedClass class",
+			"ExportedClassInheritLocalClass class",
+			"exportedFunction function",
+			"LocalCard card def",
+			"ExportedCard card def",
+			"ExportedCardInheritLocalCard card def",
+			"LocalField field def",
+			"ExportedField field def",
+			"ExportedFieldInheritLocalField field def",
+			"default (DefaultClass) class"
+		].forEach(async (elementName, index) => {
+			await waitFor(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`);
+			assert.dom(`[data-test-boxel-selector-item]:nth-of-type(${index + 1})`).hasText(elementName);
+		});
+		assert.dom("[data-test-boxel-selector-item]").exists({ count: 11 });
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(elementName);
+		assert.dom("[data-test-inheritance-panel-header]").doesNotExist();
+		elementName = "exportedFunction";
+		await click(`[data-test-boxel-selector-item-text="${elementName}"]`);
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${elementName} function`);
+		assert.dom("[data-test-inheritance-panel-header]").doesNotExist();
+		assert.dom("[data-test-card-module-definition]").doesNotExist();
+		assert.dom("[data-test-schema-editor-file-incompatibility-message]").hasText("No tools are available for the selected item: function \"exportedFunction\". Select a card or field definition in the inspector.");
+		assert.true(monacoService.getLineCursorOn()?.includes(elementName));
+		let renamedElementName = "exportedFunc";
+		setMonacoContent(inThisFileSource.replace("exportedFunction", renamedElementName));
+		await waitFor(`[data-test-boxel-selector-item]:nth-of-type(4)`);
+		await waitFor("[data-test-code-mode][data-test-save-idle]");
+		await waitFor(`[data-test-boxel-selector-item]:nth-of-type(4)`);
+		await waitUntil(() => {
+			return !document.querySelector("[data-test-boxel-selector-item]:nth-of-type(4)")?.textContent?.includes("exportedFunction");
+		});
+		assert.dom(`[data-test-boxel-selector-item]:nth-of-type(4)`).hasText(`${renamedElementName} function`);
+		assert.dom("[data-test-boxel-selector-item]").exists({ count: 11 });
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${renamedElementName} function`);
+		assert.dom("[data-test-inheritance-panel-header]").doesNotExist();
+		assert.dom("[data-test-boxel-selector-item-selected]").hasText(`${renamedElementName} function`);
+		assert.dom("[data-test-inheritance-panel-header]").doesNotExist();
+		assert.dom("[data-test-card-module-definition]").doesNotExist();
+		assert.dom("[data-test-schema-editor-file-incompatibility-message]").hasText(`No tools are available for the selected item: function "${renamedElementName}". Select a card or field definition in the inspector.`);
+	});
+	(0, import_qunit.test)("can inherit from an exported card def declaration", async function(assert) {
+		assert.expect(11);
+		let expectedSrc = `
+import { ExportedCard } from './in-this-file';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestCard extends ExportedCard {
+  static displayName = "Test Card";
+}`.trim();
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		assert.dom("[data-test-inherits-from-field] .pill").includesText("exported card", "the inherits from is correct");
+		assert.dom("[data-test-create-definition]").isDisabled();
+		await fillIn("[data-test-display-name-field]", "Test Card");
+		assert.dom("[data-test-create-definition]").isEnabled();
+		await fillIn("[data-test-file-name-field]", "/test-card");
+		assert.dom("[data-test-create-definition]").isEnabled();
+		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 percySnapshot(assert);
+		await click("[data-test-create-definition]");
+		await waitFor("[data-test-create-file-modal]", { count: 0 });
+		await deferred.promise;
+		await settled();
+		assert.strictEqual(getMonacoContent(), expectedSrc, "monaco displays the new definition");
+		await waitFor("[data-test-card-schema=\"Test Card\"]");
+		assert.dom("[data-test-card-schema]").exists({ count: 4 }, "the card hierarchy is displayed in schema editor");
+		assert.dom("[data-test-total-fields]").containsText(exportedCardFieldCount);
+		await settled();
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		assert.dom("[data-test-inherits-from-field] .pill").includesText("Test Card", "the inherits from is correct");
+		assert.dom("[data-test-display-name-field]").hasNoValue("display name field is empty");
+		assert.dom("[data-test-file-name-field]").hasNoValue("filename field is empty");
+	});
+	(0, import_qunit.test)("can inherit from an exported field def declaration", async function(assert) {
+		assert.expect(2);
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		assert.dom("[data-test-inherits-from-field] .pill").includesText("exported field", "the inherits from is correct");
+		await fillIn("[data-test-display-name-field]", "Test Field");
+		await fillIn("[data-test-file-name-field]", "/test-field");
+		let deferred = new Deferred();
+		this.onSave((_, content) => {
+			if (typeof content !== "string") throw new Error(`expected string save data`);
+			assert.strictEqual(content, `
+import { ExportedField } from './in-this-file';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class TestField extends ExportedField {
+  static displayName = "Test Field";
+}`.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 inherit from an exported file def declaration", async function(assert) {
+		assert.expect(2);
+		let expectedSrc = `
+import { CustomFileDef } from './file-def';
+export class TestFileDef extends CustomFileDef {
+  static displayName = "Test File Def";
+}`.trim();
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}file-def.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"CustomFileDef\"]");
+		await click("[data-boxel-selector-item-text=\"CustomFileDef\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		assert.dom("[data-test-inherits-from-field] .pill").includesText("custom file", "the inherits from is correct");
+		await fillIn("[data-test-display-name-field]", "Test File Def");
+		await fillIn("[data-test-file-name-field]", "/test-file-def");
+		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 - no Component import for file defs");
+			deferred.fulfill();
+		});
+		await click("[data-test-create-definition]");
+		await waitFor("[data-test-create-file-modal]", { count: 0 });
+		await deferred.promise;
+	});
+	(0, import_qunit.test)("inherit modal state is cleared when modal is cancelled", async function(assert) {
+		assert.expect(3);
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		await fillIn("[data-test-display-name-field]", "Test Card");
+		await fillIn("[data-test-file-name-field]", "/test-card");
+		this.onSave(() => assert.ok(false, "should not save a file"));
+		await click("[data-test-cancel-create-file]");
+		await waitFor("[data-test-create-file-modal]", { count: 0 });
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		assert.dom("[data-test-inherits-from-field] .pill").includesText("exported card", "the inherits from is correct");
+		assert.dom("[data-test-display-name-field]").hasNoValue("display name field is empty");
+		assert.dom("[data-test-file-name-field]").hasNoValue("filename field is empty");
+	});
+	(0, import_qunit.test)(`can handle the situation where there is a class name collision with the inherited cards class name`, async function(assert) {
+		assert.expect(4);
+		let expectedSrc = `
+import { ExportedCard as ExportedCardParent } from './in-this-file';
+import { Component } from 'https://cardstack.com/base/card-api';
+export class ExportedCard extends ExportedCardParent {
+  static displayName = "Exported Card";
+}`.trim();
+		await visitOperatorMode({
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		await fillIn("[data-test-display-name-field]", "Exported 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;
+		await settled();
+		assert.strictEqual(getMonacoContent(), expectedSrc, "monaco displays the new definition");
+		await waitFor("[data-test-card-schema=\"Exported Card\"]");
+		assert.dom("[data-test-card-schema]").exists({ count: 4 }, "the card hierarchy is displayed in schema editor");
+		assert.dom("[data-test-total-fields]").containsText(exportedCardFieldCount);
+	});
+	(0, import_qunit.test)("field error message displays if you try to inherit using a filename that already exists", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Inherit\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		await fillIn("[data-test-display-name-field]", "Test Card");
+		await fillIn("[data-test-file-name-field]", "in-this-file");
+		await click("[data-test-create-definition]");
+		assert.dom("[data-test-file-name-field][data-test-boxel-input-validation-state=\"invalid\"]").exists("error state for filename field is displayed");
+		assert.dom("[data-test-boxel-input-error-message]").includesText("This file already exists");
+		await fillIn("[data-test-file-name-field]", "test-file");
+		assert.dom("[data-test-file-name-field][data-test-boxel-input-validation-state=\"invalid\"]").doesNotExist("error state for filename field is not displayed");
+		assert.dom("[data-test-boxel-input-error-message]").doesNotExist("no error message displayed");
+	});
+	(0, import_qunit.test)("Inherit action item is not displayed when definition is not exported", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await click("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Inherit\"]").doesNotExist("non-exported cards do not display an inherit button");
+	});
+	(0, import_qunit.test)("can create an instance from an exported card definition", async function(assert) {
+		assert.expect(8);
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Create Instance\"]");
+		await waitFor(`[data-test-create-file-modal][data-test-ready] [data-test-realm-name="Test Workspace B"]`);
+		assert.dom("[data-test-inherits-from-field] .pill").includesText("exported card", "the inherits from is correct");
+		assert.dom("[data-test-create-card-instance]").isEnabled();
+		let deferred = new Deferred();
+		let id;
+		this.onSave((url, json) => {
+			if (typeof json === "string") throw new Error(`expected JSON save data`);
+			id = url.href;
+			assert.strictEqual(json.data.attributes?.someString, null, "someString field is empty");
+			assert.strictEqual(json.data.meta.realmURL, testRealmURL, "realm url is correct");
+			assert.deepEqual(json.data.meta.adoptsFrom, {
+				module: rri("../in-this-file"),
+				name: "ExportedCard"
+			}, "adoptsFrom is correct");
+			deferred.fulfill();
+		});
+		await percySnapshot(assert);
+		await click("[data-test-create-card-instance]");
+		await waitFor("[data-test-create-file-modal]", { count: 0 });
+		await deferred.promise;
+		if (!id) assert.ok(false, "card instance ID does not exist");
+		await waitFor("[data-test-create-file-modal]", { count: 0 });
+		await waitFor(`[data-test-code-mode-card-renderer-header="${id}"]`);
+		assert.dom("[data-test-card-resource-loaded]").containsText("exported card");
+		assert.dom("[data-test-field=\"someString\"] input").hasValue("");
+		assert.dom("[data-test-card-url-bar-input]").hasValue(`${id}.json`);
+	});
+	(0, import_qunit.test)("Create instance action is not displayed for non-exported Card definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await click("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Create Instance\"]").doesNotExist("non-exported card defs do not display a create instance button");
+	});
+	(0, import_qunit.test)("Create instance action is not displayed for field definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Create Instance\"]").doesNotExist("field defs do not display a create instance button");
+	});
+	(0, import_qunit.test)("Create listing action is displayed for exported card definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Create Listing\"]").exists("exported card defs display a Create Listing button");
+	});
+	(0, import_qunit.test)("Create listing action is displayed for exported field definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Create Listing\"]").exists("exported field defs display a Create Listing button");
+	});
+	(0, import_qunit.test)("Create listing action is not displayed for non-exported Card definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await click("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Create Listing\"]").doesNotExist("non-exported card defs do not display a Create Listing button");
+	});
+	(0, import_qunit.test)("can find instances of an exported card definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}pet`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"Pet\"]");
+		await click("[data-boxel-selector-item-text=\"Pet\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Find instances\"]");
+		await waitFor("[data-test-search-sheet-search-result]");
+		assert.dom("[data-test-search-field]").hasValue("");
+		await waitUntil(() => document.querySelector("[data-test-search-label]")?.innerText.includes("2 results"));
+		assert.dom("[data-test-search-label]").includesText("2 results");
+		assert.dom(`[data-test-search-result="${testRealmURL}Pet/mango"]`).exists();
+		assert.dom(`[data-test-search-result="${testRealmURL}Pet/vangogh"]`).exists();
+	});
+	(0, import_qunit.test)("find instances action is not displayed for non-exported Card definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await click("[data-boxel-selector-item-text=\"LocalCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Find instances\"]").doesNotExist("non-exported card defs do not display a Find instances button");
+	});
+	(0, import_qunit.test)("find instances action is not displayed for field definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedField\"]");
+		await waitFor("[data-test-card-module-definition]");
+		assert.dom("[data-test-action-button=\"Find instances\"]").doesNotExist("field defs do not display a Find instances button");
+	});
+	(0, import_qunit.test)("inspector shows empty file panel with delete button when file is empty", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}empty-file.gts`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-current-module-name=\"empty-file.gts\"]");
+		assert.dom("[data-test-current-module-name=\"empty-file.gts\"]").exists();
+		assert.dom("[data-test-in-this-file-selector]").doesNotExist();
+		assert.dom("[data-test-inheritance-panel-header]").doesNotExist();
+		assert.dom("[data-test-delete-module-button]").exists();
+	});
+	(0, import_qunit.test)("can delete an erroring module file", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}erroring-module.gts`
+		});
+		await waitFor("[data-test-syntax-error]");
+		await waitFor("[data-test-action-button=\"Delete\"]");
+		await click("[data-test-action-button=\"Delete\"]");
+		await waitFor(`[data-test-delete-modal="${testRealmURL}erroring-module.gts"]`);
+		await click("[data-test-confirm-delete-button]");
+		await waitFor("[data-test-empty-code-mode]");
+		let notFound = await adapter.openFile("erroring-module.gts");
+		assert.strictEqual(notFound, void 0, "file ref does not exist");
+	});
+	(0, import_qunit.module)("when the user lacks write permissions", function(hooks) {
+		hooks.beforeEach(async function() {
+			setRealmPermissions({ [testRealmURL]: ["read"] });
+		});
+		(0, import_qunit.test)("delete button is not displayed for module when user does not have permission to write to realm", async function(assert) {
+			await visitOperatorMode({
+				submode: "code",
+				codePath: `${testRealmURL}pet.gts`
+			});
+			await waitFor("[data-test-current-module-name=\"pet.gts\"]");
+			assert.dom("[data-test-delete-module-button]").doesNotExist();
+		});
+		(0, import_qunit.test)("delete button is not displayed for card instance when user does not have permission to write to realm", async function(assert) {
+			await visitOperatorMode({
+				submode: "code",
+				codePath: `${testRealmURL}Pet/mango.json`
+			});
+			assert.dom("[data-test-action-button=\"Delete\"]").doesNotExist();
+		});
+		(0, import_qunit.test)("delete button is not displayed for misc file when user does not have permission to write to realm", async function(assert) {
+			await visitOperatorMode({
+				stacks: [[]],
+				submode: "code",
+				codePath: `${testRealmURL}readme.md`
+			});
+			assert.dom("[data-test-action-button=\"Delete\"]").doesNotExist();
+		});
+		(0, import_qunit.test)("delete button is not displayed for empty file when user does not have permission to write to realm", async function(assert) {
+			await visitOperatorMode({
+				stacks: [[]],
+				submode: "code",
+				codePath: `${testRealmURL}empty-file.gts`
+			});
+			await waitFor("[data-test-current-module-name=\"empty-file.gts\"]");
+			assert.dom("[data-test-delete-module-button]").doesNotExist();
+		});
+		(0, import_qunit.test)("Create listing action is not displayed when user does not have permission to write to realm", async function(assert) {
+			await visitOperatorMode({
+				stacks: [[]],
+				submode: "code",
+				codePath: `${testRealmURL}in-this-file.gts`
+			});
+			await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+			await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+			await waitFor("[data-test-card-module-definition]");
+			assert.dom("[data-test-action-button=\"Create Listing\"]").doesNotExist("Create Listing button is not displayed when user lacks write permissions");
+		});
+		(0, import_qunit.test)("inspector shows file inheritance panel for non-module files", async function(assert) {
+			await visitOperatorMode({
+				stacks: [[]],
+				submode: "code",
+				codePath: `${testRealmURL}sample-styles.css`
+			});
+			await waitFor("[data-test-card-inspector-panel]");
+			await waitFor("[data-test-inheritance-panel-header]");
+			assert.dom("[data-test-inheritance-panel-header]").hasText("File Inheritance");
+			assert.dom("[data-test-card-instance-definition]").exists("file instance definition is shown");
+			assert.dom("[data-test-card-instance-definition] [data-test-definition-header]").includesText("File Instance");
+			assert.dom("[data-test-card-instance-definition] [data-test-definition-file-extension]").includesText(".css");
+			assert.dom("[data-test-card-module-definition]").exists("file definition (adopts from) is shown");
+			assert.dom("[data-test-card-module-definition]").includesText("File Definition");
+		});
+	});
+	(0, import_qunit.test)("clicking \"Create Listing\" opens confirmation modal for card definition", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Create Listing\"]");
+		await waitFor("[data-test-create-listing-modal]");
+		assert.dom("[data-test-create-listing-modal]").exists("confirmation modal appears after clicking Create Listing");
+	});
+	(0, import_qunit.test)("clicking \"Create Listing\" on a card instance opens modal with instance pre-selected", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}Pet/mango.json`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-card-instance-definition]");
+		await click("[data-test-action-button=\"Create Listing\"]");
+		await waitFor("[data-test-create-listing-modal]");
+		assert.dom("[data-test-create-listing-modal]").exists("confirmation modal appears after clicking Create Listing");
+		await waitFor(`[data-test-selected-example="${testRealmURL}Pet/mango.json"]`);
+		assert.dom(`[data-test-selected-example="${testRealmURL}Pet/mango.json"]`).exists("the opened instance is pre-selected");
+		assert.dom("[data-test-selected-examples] [data-test-card-format=\"atom\"]").exists({ count: 1 }, "mango instance is shown as atom");
+		assert.dom("[data-test-choose-examples-button]").hasText("Add Examples", "button remains the default label");
+	});
+	(0, import_qunit.test)("Create listing action is not displayed for index.json card instance", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}index.json`
+		});
+		await waitFor("[data-test-card-inspector-panel]");
+		await waitFor("[data-test-card-instance-definition]");
+		assert.dom("[data-test-action-button=\"Create Listing\"]").doesNotExist("index.json card instances do not display a Create Listing button");
+	});
+	(0, import_qunit.test)("cancel button in Create Listing modal closes the modal", async function(assert) {
+		await visitOperatorMode({
+			stacks: [[]],
+			submode: "code",
+			codePath: `${testRealmURL}in-this-file.gts`
+		});
+		await waitFor("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await click("[data-boxel-selector-item-text=\"ExportedCard\"]");
+		await waitFor("[data-test-card-module-definition]");
+		await click("[data-test-action-button=\"Create Listing\"]");
+		await waitFor("[data-test-create-listing-modal]");
+		await click("[data-test-create-listing-cancel-button]");
+		assert.dom("[data-test-create-listing-modal]").doesNotExist("modal is dismissed after clicking Cancel");
+	});
+});
+//#endregion