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

package/bundled-test-harness/assets/operator-mode-state-service-gwiTSiWX.js

@@ -0,0 +1,1275 @@
+import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Po as isCardInstance, Sc as Deferred, Ss as wrapper_default, d as isLocalId, l as hasExecutableExtension, ms as logger, rs as isResolvedCodeRef, tn as parse, u as internalKeyFor, uo as SupportedMimeType, ws as isRealmIndexCardId } from "./runtime-common-ClpqhbwG.js";
+import { a as RealmPaths, v as ri, y as rri } from "./paths-BYHDgqsT.js";
+import { K as realmURL, V as localId } from "./constants-CqKWhRfY.js";
+import { r as setOwner } from "./owner-CP0__uFm.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { Tn as destroy, wn as associateDestroyableChild } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { r as service, t as Service, vt as scheduleOnce } from "./service-LFpJ8EEP.js";
+import { r as getOwner$1 } from "./application-VoCE-EjL.js";
+import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
+import { t as isTesting } from "./runtime-9O0mNd7j.js";
+import { n as src_default } from "./src-DPaAwa4H.js";
+import { c as ModuleInspectorSelections, n as AiAssistantOpen } from "./local-storage-keys-CS7XLz7J.js";
+import { n as buildTask } from "./async-arrow-runtime-STsj7E8Y.js";
+import { n as resource } from "./dist-C2IXvIKX.js";
+import { n as Resource } from "./dist-B-fYvxfL.js";
+import { a as TrackedMap, n as TrackedObject, r as TrackedArray } from "./dist-B9tGPKZz.js";
+import { n as Submodes } from "./submode-switcher-D-U9cXo0.js";
+import { n as tracked, t as cached } from "./tracking-800VJb8b.js";
+import { a as takesFileDeleteRoute, n as StackItemOpening, t as StackItem } from "./stack-item-CWwIF25s.js";
+import { n as removeTopmost, r as unwindOrPush } from "./host-mode-stack-Cvr41RLM.js";
+import { t as removeCardJsonExtension } from "./types-CF5if_Vm.js";
+//#region app/resources/file.ts
+var file_exports = /* @__PURE__ */ __exportAll({
+	file: () => file,
+	isReady: () => isReady
+});
+var log = logger("resource:file");
+var realmEventsLogger = logger("realm:events");
+var TextDecoderImpl = globalThis.TextDecoder;
+var TextEncoderImpl = globalThis.TextEncoder;
+var BufferImpl = globalThis.Buffer;
+var utf8Decoder = TextDecoderImpl ? new TextDecoderImpl() : void 0;
+var utf8Encoder = TextEncoderImpl ? new TextEncoderImpl() : void 0;
+function decodeUtf8(buffer) {
+	if (utf8Decoder) return utf8Decoder.decode(buffer);
+	if (BufferImpl) return BufferImpl.from(buffer).toString("utf8");
+	throw new Error("No UTF-8 decoder available in this environment");
+}
+function utf8ByteLength(content) {
+	if (utf8Encoder) return utf8Encoder.encode(content).byteLength;
+	if (BufferImpl) {
+		if (typeof BufferImpl.byteLength === "function") return BufferImpl.byteLength(content, "utf8");
+		return BufferImpl.from(content, "utf8").length;
+	}
+	return content.length;
+}
+var _FileResource = class extends Resource {
+	onStateChange;
+	onRedirect;
+	subscription;
+	writing;
+	static {
+		decorateFieldV2(this.prototype, "innerState", [tracked], function() {
+			return { state: "loading" };
+		});
+	}
+	#innerState = (initializeDeferredDecorator(this, "innerState"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "loaderService", [service]);
+	}
+	#loaderService = (initializeDeferredDecorator(this, "loaderService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network = (initializeDeferredDecorator(this, "network"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "messageService", [service]);
+	}
+	#messageService = (initializeDeferredDecorator(this, "messageService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "cardService", [service]);
+	}
+	#cardService = (initializeDeferredDecorator(this, "cardService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "recentFilesService", [service]);
+	}
+	#recentFilesService = (initializeDeferredDecorator(this, "recentFilesService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "operatorModeStateService", [service]);
+	}
+	#operatorModeStateService = (initializeDeferredDecorator(this, "operatorModeStateService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realm", [service]);
+	}
+	#realm = (initializeDeferredDecorator(this, "realm"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "store", [service]);
+	}
+	#store = (initializeDeferredDecorator(this, "store"), void 0);
+	constructor(owner) {
+		super(owner);
+		registerDestructor(this, () => {
+			if (this.subscription) {
+				this.subscription.unsubscribe();
+				this.subscription = void 0;
+			}
+		});
+	}
+	setSubscription(realmURL, callback) {
+		if (this.subscription && this.subscription.url !== realmURL) {
+			this.subscription.unsubscribe();
+			this.subscription = void 0;
+		}
+		if (!this.subscription) this.subscription = {
+			url: realmURL,
+			unsubscribe: this.messageService.subscribe(realmURL, callback)
+		};
+	}
+	modify(_positional, named) {
+		let { url, onStateChange, onRedirect } = named;
+		this._url = url;
+		this.onStateChange = onStateChange;
+		this.onRedirect = onRedirect;
+		let realmId = this.realm.realmOf(rri(url));
+		if (realmId) this.setSubscription(realmId, this.onRealmInvalidation);
+		else log.debug(`FileResource: no known realm for ${url} at modify-time; deferring subscription to read-success branch`);
+		this.read.perform();
+	}
+	updateState(newState) {
+		let prevState = this.innerState;
+		this.innerState = newState;
+		if (this.onStateChange && this.innerState.state !== prevState.state) this.onStateChange(this.innerState.state);
+		if (this.innerState.state === "ready") {
+			this.recentFilesService.addRecentFileUrl(this.innerState.url);
+			if (this.onRedirect && this._url != this.innerState.url) this.onRedirect(this.innerState.url);
+		}
+	}
+	read = buildTask(() => ({
+		context: this,
+		generator: function* (opts) {
+			let response;
+			try {
+				response = yield this.network.authedFetch(this._url, { headers: { Accept: SupportedMimeType.CardSource } });
+				if (!response.ok) {
+					log.error(`Could not get file ${this._url}, status ${response.status}: ${response.statusText} - ${yield response.text()}`);
+					if (response.status === 404) this.updateState({
+						state: "not-found",
+						url: rri(this._url)
+					});
+					else this.updateState({
+						state: "server-error",
+						url: rri(this._url)
+					});
+					return;
+				}
+			} catch (err) {
+				log.error(`Could not get file ${this._url}, err: ${err.message}`);
+				this.updateState({
+					state: "not-found",
+					url: rri(this._url)
+				});
+				return;
+			}
+			let lastModified = response.headers.get("last-modified") || void 0;
+			if (!opts?.force && lastModified && this.innerState.state === "ready" && this.innerState.url === rri(response.url) && this.innerState.lastModified === lastModified) return;
+			let realmURL = response.headers.get("x-boxel-realm-url");
+			if (!realmURL) throw new Error("Missing x-boxel-realm-url header in response.");
+			let buffer = yield response.arrayBuffer();
+			let size = buffer.byteLength;
+			let content = decodeUtf8(buffer);
+			let self = this;
+			let rawName = response.url.split("/").pop();
+			this.updateState({
+				state: "ready",
+				lastModified,
+				realmURL,
+				content,
+				name: rawName ? decodeURIComponent(rawName) : rawName,
+				size,
+				url: rri(response.url),
+				write(content, opts) {
+					self.writing = self.writeTask.unlinked().perform(this, content, opts);
+					return self.writing;
+				}
+			});
+			this.setSubscription(realmURL, this.onRealmInvalidation);
+		}
+	}), null, "read", "keepLatest");
+	reloadsForRequest(clientRequestId, normalizedURL) {
+		let reloadFile = false;
+		if (!clientRequestId || clientRequestId.startsWith("instance:")) {
+			reloadFile = true;
+			realmEventsLogger.debug(`reloading file resource ${normalizedURL} because realm event has ${!clientRequestId ? "no clientRequestId" : "clientRequestId from instance editor"}`);
+		} else if (clientRequestId.startsWith("editor:") || clientRequestId.startsWith("editor-with-instance:")) if (this.cardService.clientRequestIds.has(clientRequestId)) realmEventsLogger.debug(`ignoring because request id is contained in known clientRequestIds`, clientRequestId);
+		else {
+			reloadFile = true;
+			realmEventsLogger.debug(`reloading file resource ${normalizedURL} because request id is ${clientRequestId}, not contained within known clientRequestIds`, Object.keys(this.cardService.clientRequestIds));
+		}
+		else if (clientRequestId.startsWith("bot-patch:") || clientRequestId.startsWith("create-file:")) {
+			reloadFile = true;
+			realmEventsLogger.debug(`reloading file resource ${normalizedURL} because request id is ${clientRequestId}`);
+		}
+		return reloadFile;
+	}
+	onRealmInvalidation = (event) => {
+		if (event.eventName !== "index" || event.indexType !== "incremental" || !Array.isArray(event.invalidations)) return;
+		let { invalidations } = event;
+		let normalize = (raw) => raw.endsWith(".json") ? raw.replace(/\.json$/, "") : raw;
+		let candidates = new Set([normalize(this._url)]);
+		if (this.innerState.state !== "loading") candidates.add(normalize(this.innerState.url));
+		let normalizedURL = invalidations.find((inv) => candidates.has(inv));
+		if (normalizedURL) {
+			realmEventsLogger.trace(`file resource ${normalizedURL} processing invalidation`, event);
+			let requestIds = (event.coalescedWrites ?? []).filter(({ changed }) => changed === null || changed.includes(normalizedURL)).map(({ clientRequestId }) => clientRequestId);
+			if (requestIds.length === 0) requestIds = [event.clientRequestId ?? null];
+			if (requestIds.some((clientRequestId) => this.reloadsForRequest(clientRequestId, normalizedURL))) {
+				if (hasExecutableExtension(normalizedURL) && this.loaderService.loader.isModuleLoaded(normalizedURL)) this.loaderService.resetLoader({
+					clearFetchCache: true,
+					reason: "file-resource-external-invalidation",
+					codeChange: true
+				});
+				this.read.perform({ force: true });
+			}
+		}
+	};
+	writeTask = buildTask(() => ({
+		context: this,
+		generator: function* (state, content, opts) {
+			let moduleWasLoaded = opts?.flushLoader && this.loaderService.loader.isModuleLoaded(this._url);
+			let response = yield this.cardService.saveSource(new URL(this._url), content, opts?.saveType ?? "editor", {
+				resetLoader: opts?.flushLoader,
+				clientRequestId: opts?.clientRequestId
+			});
+			if (moduleWasLoaded) this.store.refreshReferencesForCodeChange("file write", {
+				triggerModule: this._url,
+				realm: state.realmURL
+			});
+			if (this.innerState.state === "not-found") throw new Error("this should be impossible--we are creating the specified path");
+			let size = utf8ByteLength(content);
+			this.updateState({
+				state: "ready",
+				content,
+				lastModified: response.headers.get("last-modified") || void 0,
+				url: state.url,
+				name: state.name,
+				size,
+				write: state.write,
+				realmURL: state.realmURL
+			});
+		}
+	}), null, "writeTask", "restartable");
+	get state() {
+		return this.innerState.state;
+	}
+	get content() {
+		return this.innerState.content;
+	}
+	get name() {
+		return this.innerState.name;
+	}
+	get url() {
+		return this.innerState.url;
+	}
+	get size() {
+		return this.innerState.size;
+	}
+	get isBinary() {
+		return isBinary(this.content);
+	}
+	get lastModified() {
+		return this.innerState.lastModified;
+	}
+	get lastModifiedAsDate() {
+		let rfc7321Date = this.innerState.lastModified;
+		if (!rfc7321Date) return;
+		return parse(rfc7321Date.replace(/ GMT$/, "Z"), "EEE, dd MMM yyyy HH:mm:ssX", /* @__PURE__ */ new Date());
+	}
+	get realmURL() {
+		return this.innerState.realmURL;
+	}
+	get write() {
+		return this.innerState.write;
+	}
+};
+function file(parent, args) {
+	return _FileResource.from(parent, () => ({ named: args() }));
+}
+function isReady(f) {
+	return f?.state === "ready";
+}
+function isBinary(content) {
+	return /\ufffd/.test(content);
+}
+//#endregion
+//#region app/resources/maybe.ts
+var maybe_exports = /* @__PURE__ */ __exportAll({ maybe: () => maybe });
+/**
+* This resource is meant for consumers to instantiate resources when some asynchronous
+* conditions are met, e.g. if argument already exists. Callers should return a resource in resourceBuilder callback.
+* @param parent - The parent object that owns this resource (must have an owner)
+* @param resourceBuilder - Function that attempts to build the resource, returning undefined if unavailable
+* @returns Resource with `current` property that may be undefined
+*/
+function maybe(parent, resourceBuilder) {
+	return resource(parent, ({ on }) => {
+		let context = {};
+		let owner = getOwner(parent);
+		if (!owner) throw new Error("bug: maybe() needs an owned object as its first argument");
+		setOwner(context, owner);
+		associateDestroyableChild(parent, context);
+		on.cleanup(() => destroy(context));
+		return { current: resourceBuilder(context) ?? void 0 };
+	});
+}
+//#endregion
+//#region app/utils/normalized-dir-path.ts
+var normalized_dir_path_exports = /* @__PURE__ */ __exportAll({ normalizeDirPath: () => normalizeDirPath });
+function normalizeDirPath(entryPath) {
+	return entryPath.endsWith("/") ? entryPath : `${entryPath}/`;
+}
+//#endregion
+//#region app/services/operator-mode-state-service.ts
+var operator_mode_state_service_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_MODULE_INSPECTOR_VIEW: () => DEFAULT_MODULE_INSPECTOR_VIEW,
+	codeSubmodeUnavailable: () => codeSubmodeUnavailable,
+	default: () => OperatorModeStateService
+});
+var DEFAULT_MODULE_INSPECTOR_VIEW = "schema";
+function codeSubmodeUnavailable(url) {
+	return `Code mode is not available${url ? ` for ${url}` : ""}: it needs read permission on the realm, which serves its modules and file tree only to a user who may read it`;
+}
+function readPersistedAiAssistantOpen() {
+	let raw = src_default.localStorage.getItem(AiAssistantOpen);
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	return false;
+}
+var OperatorModeStateService = class extends Service {
+	static {
+		decorateFieldV2(this.prototype, "_state", [tracked], function() {
+			return new TrackedObject({
+				stacks: new TrackedArray([]),
+				submode: Submodes.Interact,
+				codePath: null,
+				hostModePrimaryCard: null,
+				hostModeStack: new TrackedArray([]),
+				openDirs: new TrackedMap(),
+				aiAssistantOpen: readPersistedAiAssistantOpen(),
+				newFileDropdownOpen: false,
+				cardPreviewFormat: "isolated",
+				workspaceChooserOpened: false
+			});
+		});
+	}
+	#_state = (initializeDeferredDecorator(this, "_state"), void 0);
+	cachedRealmURL = null;
+	openFileSubscribers = [];
+	cardTitles = new TrackedMap();
+	moduleInspectorHistory;
+	static {
+		decorateFieldV2(this.prototype, "profileSettingsOpen", [tracked], function() {
+			return false;
+		});
+	}
+	#profileSettingsOpen = (initializeDeferredDecorator(this, "profileSettingsOpen"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "profileSettingsSection", [tracked]);
+	}
+	#profileSettingsSection = (initializeDeferredDecorator(this, "profileSettingsSection"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "createListingModalPayload", [tracked]);
+	}
+	#createListingModalPayload = (initializeDeferredDecorator(this, "createListingModalPayload"), void 0);
+	expandedStackItems = new TrackedMap();
+	static {
+		decorateFieldV2(this.prototype, "isMobileViewport", [tracked], function() {
+			return false;
+		});
+	}
+	#isMobileViewport = (initializeDeferredDecorator(this, "isMobileViewport"), void 0);
+	mobileViewportQuery;
+	isStackItemExpanded(item) {
+		if (this.isMobileViewport) return this._state.submode === Submodes.Interact && Boolean(this._state.stacks[0]?.includes(item));
+		return this.expandedStackItems.get(item.instanceId) ?? false;
+	}
+	setStackItemExpanded(item, value) {
+		if (value) {
+			this.expandedStackItems.clear();
+			this.expandedStackItems.set(item.instanceId, true);
+		} else this.expandedStackItems.delete(item.instanceId);
+		this.schedulePersist();
+	}
+	onMobileViewportChange = (event) => {
+		this.isMobileViewport = event.matches;
+	};
+	get hasAnyStackItemExpanded() {
+		return this._state.stacks.some((stack) => {
+			const top = stack[stack.length - 1];
+			return top && this.isStackItemExpanded(top);
+		});
+	}
+	static {
+		decorateFieldV2(this.prototype, "expandedCardHeaderElement", [tracked], function() {
+			return null;
+		});
+	}
+	#expandedCardHeaderElement = (initializeDeferredDecorator(this, "expandedCardHeaderElement"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "cardService", [service]);
+	}
+	#cardService = (initializeDeferredDecorator(this, "cardService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "codeSemanticsService", [service]);
+	}
+	#codeSemanticsService = (initializeDeferredDecorator(this, "codeSemanticsService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "errorDisplay", [service]);
+	}
+	#errorDisplay = (initializeDeferredDecorator(this, "errorDisplay"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "loaderService", [service]);
+	}
+	#loaderService = (initializeDeferredDecorator(this, "loaderService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "messageService", [service]);
+	}
+	#messageService = (initializeDeferredDecorator(this, "messageService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "monacoService", [service]);
+	}
+	#monacoService = (initializeDeferredDecorator(this, "monacoService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realm", [service]);
+	}
+	#realm = (initializeDeferredDecorator(this, "realm"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "realmServer", [service]);
+	}
+	#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "recentCardsService", [service]);
+	}
+	#recentCardsService = (initializeDeferredDecorator(this, "recentCardsService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "recentFilesService", [service]);
+	}
+	#recentFilesService = (initializeDeferredDecorator(this, "recentFilesService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "router", [service]);
+	}
+	#router = (initializeDeferredDecorator(this, "router"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "session", [service]);
+	}
+	#session = (initializeDeferredDecorator(this, "session"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network = (initializeDeferredDecorator(this, "network"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "matrixService", [service]);
+	}
+	#matrixService = (initializeDeferredDecorator(this, "matrixService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "store", [service]);
+	}
+	#store = (initializeDeferredDecorator(this, "store"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "playgroundPanelService", [service]);
+	}
+	#playgroundPanelService = (initializeDeferredDecorator(this, "playgroundPanelService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "specPanelService", [service]);
+	}
+	#specPanelService = (initializeDeferredDecorator(this, "specPanelService"), void 0);
+	constructor(owner) {
+		super(owner);
+		this.session.register(this);
+		let moduleInspectorHistory = src_default.localStorage.getItem(ModuleInspectorSelections);
+		this.moduleInspectorHistory = new TrackedObject(moduleInspectorHistory ? JSON.parse(moduleInspectorHistory) : {});
+		this.mobileViewportQuery = isTesting() ? void 0 : globalThis.matchMedia?.("(max-width: 30rem)");
+		if (this.mobileViewportQuery) {
+			this.isMobileViewport = this.mobileViewportQuery.matches;
+			this.mobileViewportQuery.addEventListener("change", this.onMobileViewportChange);
+		}
+	}
+	willDestroy() {
+		super.willDestroy();
+		this.mobileViewportQuery?.removeEventListener("change", this.onMobileViewportChange);
+	}
+	toggleProfileSettings = () => {
+		this.profileSettingsOpen = !this.profileSettingsOpen;
+		if (!this.profileSettingsOpen) this.profileSettingsSection = void 0;
+	};
+	openProfileSettings = (section) => {
+		this.profileSettingsSection = section;
+		this.profileSettingsOpen = true;
+	};
+	get state() {
+		return {
+			stacks: this._state.stacks,
+			submode: this._state.submode,
+			codePath: this._state.codePath,
+			hostModeStack: this._state.hostModeStack,
+			hostModePrimaryCard: this._state.hostModePrimaryCard,
+			fileView: this._state.fileView,
+			openDirs: this._state.openDirs,
+			codeSelection: this._state.codeSelection,
+			fieldSelection: this._state.fieldSelection,
+			aiAssistantOpen: this._state.aiAssistantOpen,
+			moduleInspector: this._state.moduleInspector,
+			newFileDropdownOpen: this._state.newFileDropdownOpen,
+			cardPreviewFormat: this._state.cardPreviewFormat,
+			workspaceChooserOpened: this._state.workspaceChooserOpened
+		};
+	}
+	get aiAssistantOpen() {
+		return this._state.aiAssistantOpen;
+	}
+	openAiAssistant = () => {
+		this._state.aiAssistantOpen = true;
+		src_default.localStorage.setItem(AiAssistantOpen, "true");
+		this.schedulePersist();
+	};
+	closeAiAssistant = () => {
+		this._state.aiAssistantOpen = false;
+		src_default.localStorage.setItem(AiAssistantOpen, "false");
+		this.schedulePersist();
+	};
+	showCreateListingModal = (payload) => {
+		this.createListingModalPayload = payload;
+	};
+	dismissCreateListingModal = () => {
+		this.createListingModalPayload = void 0;
+	};
+	setNewFileDropdownOpen = () => {
+		this._state.newFileDropdownOpen = true;
+		this.schedulePersist();
+	};
+	setNewFileDropdownClosed = () => {
+		this._state.newFileDropdownOpen = false;
+		this.schedulePersist();
+	};
+	resetState() {
+		this.getOpenCards.cancelAll();
+		this.setCardTitleTask.cancelAll();
+		this._state = new TrackedObject({
+			stacks: new TrackedArray([]),
+			submode: Submodes.Interact,
+			codePath: null,
+			hostModePrimaryCard: null,
+			hostModeStack: new TrackedArray([]),
+			openDirs: new TrackedMap(),
+			aiAssistantOpen: readPersistedAiAssistantOpen(),
+			moduleInspector: DEFAULT_MODULE_INSPECTOR_VIEW,
+			newFileDropdownOpen: false,
+			cardPreviewFormat: "isolated",
+			workspaceChooserOpened: true
+		});
+		this.cachedRealmURL = null;
+		this.openFileSubscribers = [];
+		this.cardTitles = new TrackedMap();
+		this.moduleInspectorHistory = {};
+		this.profileSettingsOpen = false;
+		this.profileSettingsSection = void 0;
+		this.createListingModalPayload = void 0;
+		this.expandedStackItems.clear();
+		src_default.localStorage.removeItem(ModuleInspectorSelections);
+		this.schedulePersist();
+	}
+	restore(rawState) {
+		this._state = this.deserialize(rawState);
+	}
+	addItemToStack(item) {
+		let stackIndex = item.stackIndex;
+		if (!this._state.stacks[stackIndex]) this._state.stacks[stackIndex] = new TrackedArray([]);
+		if (item.id && this._state.stacks[stackIndex].find((i) => i.id === item.id)) return;
+		this._state.stacks[stackIndex].push(item);
+		if (item.id) this.recentCardsService.add(item.id);
+		this.schedulePersist();
+	}
+	replaceCardOnStack(oldId, newId, stackIndex, format = "edit") {
+		if (!this._state.stacks[stackIndex]) throw new Error(`Stack ${stackIndex} does not exist`);
+		let normalizedOldId = oldId.replace(/\.json$/, "");
+		let item = this.findCardInStack(normalizedOldId, stackIndex);
+		let newItem = item.clone({
+			id: newId,
+			format
+		});
+		this.replaceItemInStack(item, newItem);
+		return newItem;
+	}
+	async deleteCard(cardId) {
+		if (takesFileDeleteRoute(void 0, cardId, this.store)) {
+			await this.deleteFile(cardId);
+			return;
+		}
+		let cardRealmUrl = (await this.network.authedFetch(cardId)).headers.get("X-Boxel-Realm-Url");
+		if (!cardRealmUrl) throw new Error(`Could not determine the realm for card "${cardId}"`);
+		await this.store.delete(cardId);
+		let items = [];
+		for (let stack of this._state.stacks || []) items.push(...stack.filter((i) => i.id && removeCardJsonExtension(i.id) === cardId));
+		for (let item of items) this.trimItemsFromStack(item);
+		let cardPath = new RealmPaths(ri(cardRealmUrl)).local(rri(`${cardId}.json`));
+		this.recentFilesService.removeRecentFile(cardPath);
+		this.recentCardsService.remove(cardId);
+	}
+	async deleteFile(fileId) {
+		let fileRealm = this.realm.realmOf(rri(fileId));
+		if (!fileRealm) fileRealm = (await this.network.authedFetch(fileId)).headers.get("X-Boxel-Realm-Url");
+		if (!fileRealm) throw new Error(`Could not determine the realm for file "${fileId}"`);
+		await this.store.delete(fileId, { type: "file-meta" });
+		let items = [];
+		for (let stack of this._state.stacks || []) items.push(...stack.filter((i) => i.id === fileId));
+		for (let item of items) this.trimItemsFromStack(item);
+		let realmPaths = new RealmPaths(ri(fileRealm));
+		this.recentFilesService.removeRecentFile(realmPaths.local(rri(fileId)));
+	}
+	async copySource(fromUrl, toUrl) {
+		await this.cardService.copySource(new URL(fromUrl), new URL(toUrl));
+	}
+	trimItemsFromStack(item) {
+		let stackIndex = item.stackIndex;
+		let stack = this._state.stacks[stackIndex];
+		if (!stack) return;
+		let itemIndex = stack.indexOf(item);
+		if (itemIndex === -1) return;
+		stack.splice(itemIndex);
+		if (this.stackIsEmpty(stackIndex) && this._state.stacks.length >= 1) {
+			this._state.stacks.splice(stackIndex, 1);
+			this._state.stacks.filter((_, stackIndex) => stackIndex >= item.stackIndex).forEach((stack, realStackIndex) => {
+				stack.forEach((stackItem) => {
+					if (stackItem.stackIndex !== realStackIndex) stackItem.stackIndex = realStackIndex;
+				});
+			});
+		}
+		if (this._state.stacks.length === 0) {
+			const realmURL = this.getRealmURLFromItemId(item.id);
+			if (isRealmIndexCardId(rri(item.id), ri(realmURL), this.network.virtualNetwork)) this._state.workspaceChooserOpened = true;
+			else {
+				const indexCardId = `${realmURL}index`;
+				const indexCardItem = this.createStackItem(indexCardId, 0);
+				this.addItemToStack(indexCardItem);
+			}
+		}
+		this.schedulePersist();
+	}
+	popItemFromStack(stackIndex) {
+		let stack = this._state.stacks[stackIndex];
+		if (!stack) throw new Error(`No stack at index ${stackIndex}`);
+		let item = stack.pop();
+		if (!item) throw new Error(`No items in stack at index ${stackIndex}`);
+		this.schedulePersist();
+		return item;
+	}
+	replaceItemInStack(item, newItem) {
+		let stackIndex = item.stackIndex;
+		let itemIndex = this._state.stacks[stackIndex].indexOf(item);
+		if (newItem.stackIndex !== stackIndex) throw new Error("cannot move stack item to different stack--this can destabilize contained card pointers");
+		this._state.stacks[stackIndex].splice(itemIndex, 1, newItem);
+		this.schedulePersist();
+	}
+	findCardInStackSafe(card, stackIndex) {
+		try {
+			return this.findCardInStack(card, stackIndex);
+		} catch (err) {
+			if (err instanceof Error && err.message.includes("Could not find card")) return;
+			throw err;
+		}
+	}
+	findCardInStack(card, stackIndex) {
+		let stack = this._state.stacks[stackIndex];
+		if (!stack) throw new Error(`Stack ${stackIndex} does not exist`);
+		let cardId = typeof card === "string" ? card : card.id;
+		let normalizedId = cardId?.replace(/\.json$/, "");
+		let localId$1 = typeof card === "string" ? void 0 : card[localId];
+		let item = stack.find((stackItem) => stackItem.id === normalizedId || stackItem.id === cardId || localId$1 && stackItem.id === localId$1);
+		if (!item) throw new Error(`Could not find card ${cardId ?? "(unknown id)"} in stack ${stackIndex}`);
+		return item;
+	}
+	setItemFormat(item, format, opts) {
+		if (item.type === "file") return;
+		let formatChanged = item.format !== format;
+		item.format = format;
+		if (opts && "request" in opts) item.request = opts.request;
+		if (opts && "useBaseTemplate" in opts) item.useBaseTemplate = opts.useBaseTemplate;
+		if (formatChanged) item.markInteracted();
+		this.schedulePersist();
+	}
+	editCardOnStack(stackIndex, card, opts) {
+		let item = this.findCardInStack(card, stackIndex);
+		if (item.type === "file") return;
+		this.setItemFormat(item, "edit", {
+			request: new Deferred(),
+			useBaseTemplate: opts?.useBaseTemplate
+		});
+	}
+	viewCardOnStack(stackIndex, card, opts) {
+		let item = this.findCardInStack(card, stackIndex);
+		if (item.type === "file") return;
+		this.setItemFormat(item, "isolated", {
+			request: new Deferred(),
+			useBaseTemplate: opts?.useBaseTemplate
+		});
+	}
+	clearStackAndAdd(stackIndex, newItem) {
+		let itemsToPopCount = this._state.stacks[stackIndex].length;
+		for (let i = 0; i < itemsToPopCount; i++) this.popItemFromStack(stackIndex);
+		this.addItemToStack(newItem);
+	}
+	numberOfStacks() {
+		return this._state.stacks.length;
+	}
+	rightMostStack() {
+		if (this.numberOfStacks() > 0) return this._state.stacks[this._state.stacks.length - 1];
+	}
+	topMostStackItems() {
+		return this._state.stacks.filter((stack) => stack.length > 0).map((stack) => stack[stack.length - 1]);
+	}
+	mostRecentlyInteractedTopItem() {
+		let topItems = this.topMostStackItems();
+		if (topItems.length === 0) return void 0;
+		return topItems.reduce((a, b) => b.lastInteractedAt > a.lastInteractedAt ? b : a);
+	}
+	addToHostModeStack(cardId) {
+		unwindOrPush(this._state.hostModeStack, cardId, this._state.hostModePrimaryCard);
+		this.schedulePersist();
+	}
+	removeFromHostModeStack(cardId) {
+		if (removeTopmost(this._state.hostModeStack, cardId)) this.schedulePersist();
+	}
+	get hostModeStack() {
+		return this._state.hostModeStack;
+	}
+	setHostModePrimaryCard(cardId) {
+		if (cardId && !isLocalId(cardId)) this._state.hostModePrimaryCard = cardId.replace(/\.json$/, "");
+		else if (!cardId) this._state.hostModePrimaryCard = null;
+		this._state.hostModeStack.splice(0, this._state.hostModeStack.length);
+		this.schedulePersist();
+	}
+	get hostModePrimaryCard() {
+		return this._state.hostModePrimaryCard ?? null;
+	}
+	getRealmURLFromItemId(itemId) {
+		try {
+			return this.realm.realmOf(rri(itemId)) ?? this.realmURL;
+		} catch (error) {
+			return this.realmURL;
+		}
+	}
+	get isViewingCardInCodeMode() {
+		return this._state.submode === Submodes.Code && this._state.codePath?.endsWith(".json");
+	}
+	/**
+	* Determines if we're currently viewing a card in the playground panel
+	*/
+	get isViewingCardInPlaygroundPanel() {
+		return this._state.submode === Submodes.Code && this.moduleInspectorPanel === "preview" && !!this.playgroundPanelSelection?.cardId;
+	}
+	/**
+	* Gets the current format being viewed for focus pill display
+	*/
+	get currentViewingFormat() {
+		if (this.isViewingCardInCodeMode) return this._state.cardPreviewFormat ?? "isolated";
+		else if (this.isViewingCardInPlaygroundPanel) return this.playgroundPanelSelection?.format ?? "isolated";
+	}
+	getOpenCardIds() {
+		if (this._state.submode === Submodes.Code) {
+			let openCardsInCodeMode = [];
+			if (this.playgroundPanelSelection) openCardsInCodeMode.push(this.playgroundPanelSelection.cardId);
+			if (this.isViewingCardInCodeMode) {
+				let cardId = rri(this._state.codePath.replace(/\.json$/, ""));
+				if (!openCardsInCodeMode.includes(cardId)) openCardsInCodeMode.push(cardId);
+			}
+			return openCardsInCodeMode;
+		} else return this.topMostStackItems().filter((stackItem) => stackItem).map((stackItem) => stackItem.id).filter(Boolean);
+	}
+	getOpenCards = buildTask(() => ({
+		context: this,
+		generator: function* () {
+			let cardIds = this.getOpenCardIds();
+			if (!cardIds) return;
+			return (yield Promise.all(cardIds.map((id) => this.store.get(id)))).filter(Boolean).filter(isCardInstance);
+		}
+	}), null, "getOpenCards", "restartable");
+	stackIsEmpty(stackIndex) {
+		return this._state.stacks[stackIndex].length === 0;
+	}
+	shiftStack(stack, destinationIndex) {
+		[...stack].forEach((item) => {
+			this.popItemFromStack(item.stackIndex);
+			this.addItemToStack(item.clone({ stackIndex: destinationIndex }));
+		});
+		return this.schedulePersist();
+	}
+	updateSubmode(submode) {
+		this._state.submode = submode;
+		this.schedulePersist();
+	}
+	async updateModuleInspectorView(view) {
+		this._state.moduleInspector = view;
+		this.moduleInspectorHistory[this._state.codePath ?? ""] = view;
+		src_default.localStorage.setItem(ModuleInspectorSelections, JSON.stringify(this.moduleInspectorHistory));
+		this.schedulePersist();
+	}
+	async updateCodePathWithSelection({ codeRef, localName, fieldName, onLocalSelection }) {
+		if (codeRef && isResolvedCodeRef(codeRef)) {
+			this._state.codeSelection = codeRef.name;
+			await this.updateCodePath(codeRef.module);
+		} else if (codeRef && "type" in codeRef && codeRef.type === "fieldOf" && "card" in codeRef && isResolvedCodeRef(codeRef.card)) {
+			this._state.fieldSelection = codeRef.field;
+			this._state.codeSelection = codeRef.card.name;
+			await this.updateCodePath(codeRef.card.module);
+		} else if (localName && onLocalSelection) {
+			this._state.codeSelection = localName;
+			this._state.fieldSelection = fieldName;
+			this.schedulePersist();
+			onLocalSelection(localName, fieldName);
+		}
+	}
+	get codePathRelativeToRealm() {
+		if (this._state.codePath && this.realmURL) {
+			let realmPath = new RealmPaths(ri(this.network.virtualNetwork.unresolveURL(this.realmURL)));
+			let codePath = this._state.codePath;
+			if (realmPath.inRealm(codePath)) try {
+				return realmPath.local(codePath);
+			} catch (err) {
+				if (err.status === 404) return;
+				throw err;
+			}
+		}
+	}
+	get codePathURL() {
+		let codePath = this._state.codePath;
+		return codePath ? this.network.virtualNetwork.toURL(codePath) : null;
+	}
+	toCodePathRRI(codePath) {
+		return this.network.virtualNetwork.unresolveURL(this.network.virtualNetwork.toURL(codePath).href);
+	}
+	onFileSelected = async (entryPath) => {
+		let fileUrl = new RealmPaths(ri(this.realmURL)).fileRRI(entryPath);
+		await this.updateCodePath(fileUrl);
+	};
+	async updateCodePath(codePath, moduleInspectorView) {
+		let codePathURL = typeof codePath === "string" ? this.network.virtualNetwork.toURL(codePath) : codePath;
+		let canonicalCodePath = await this.determineCanonicalCodePath(codePathURL);
+		this._state.codePath = canonicalCodePath ? this.toCodePathRRI(canonicalCodePath.href) : null;
+		this.updateOpenDirsForNestedPath();
+		this.schedulePersist();
+		moduleInspectorView = moduleInspectorView ?? this.moduleInspectorHistory[this._state.codePath ?? ""] ?? "schema";
+		this.updateModuleInspectorView(moduleInspectorView);
+		this.specPanelService.setSelection(null);
+	}
+	persistModuleInspectorView(codePath, moduleInspector) {
+		if (codePath) {
+			this.moduleInspectorHistory[this.network.virtualNetwork.unresolveURL(codePath)] = moduleInspector;
+			src_default.localStorage.setItem(ModuleInspectorSelections, JSON.stringify(this.moduleInspectorHistory));
+		}
+	}
+	async determineCanonicalCodePath(codePath) {
+		if (!codePath) return codePath;
+		let response;
+		try {
+			response = await this.network.authedFetch(codePath, {
+				method: "HEAD",
+				headers: { Accept: SupportedMimeType.CardSource }
+			});
+			if (response.ok) return new URL(response.url);
+			return codePath;
+		} catch (_e) {
+			return codePath;
+		}
+	}
+	replaceCodePath(codePath) {
+		this._state.codePath = codePath ? this.toCodePathRRI(codePath.href) : null;
+		this.router.replaceWith("index-root", { queryParams: { operatorModeState: this.serialize() } });
+	}
+	setCardTitle(url, title) {
+		this.setCardTitleTask.perform(url, title);
+	}
+	setCardTitleTask = buildTask(() => ({
+		context: this,
+		generator: function* (url, title) {
+			yield Promise.resolve();
+			this.cardTitles.set(url, title);
+		}
+	}), null, "setCardTitleTask", null);
+	get title() {
+		if (this._state.submode === Submodes.Code) return `${this.codePathRelativeToRealm} in ${this.realm.info(this.realmURL).name}`;
+		else {
+			let itemForTitle = this.topMostStackItems().pop();
+			return (itemForTitle?.id ? this.cardTitles.get(itemForTitle.id) : "Boxel") ?? "Boxel";
+		}
+	}
+	static {
+		decorateMethodV2(this.prototype, "title", [cached]);
+	}
+	updateOpenDirsForNestedPath() {
+		let localPath = this.codePathRelativeToRealm;
+		if (localPath) {
+			let segments = localPath.split("/").slice(0, -1).filter(Boolean);
+			let accumulator = [];
+			for (let segment of segments) {
+				accumulator.push(segment);
+				let dirPath = `${accumulator.join("/")}/`;
+				if (!this.currentRealmOpenDirs.includes(dirPath)) this.toggleOpenDir(dirPath);
+			}
+		}
+	}
+	get currentRealmOpenDirs() {
+		if (this.realmURL) {
+			let currentRealmOpenDirs = this.openDirs.get(this.realmURL);
+			if (currentRealmOpenDirs) return currentRealmOpenDirs;
+		}
+		return new TrackedArray([]);
+	}
+	updateFileView(fileView) {
+		this._state.fileView = fileView;
+		this.schedulePersist();
+	}
+	updateCardPreviewFormat(format) {
+		this._state.cardPreviewFormat = format;
+		this.schedulePersist();
+	}
+	clearStacks() {
+		this._state.stacks.splice(0);
+		this.schedulePersist();
+	}
+	handleCardIdAssignment(localId) {
+		if (this._state.stacks.find((stack) => stack.find((item) => item.id === localId))) this.schedulePersist();
+	}
+	schedulePersist() {
+		scheduleOnce("afterRender", this, this.persist);
+	}
+	persist() {
+		if (this.isDestroyed) return;
+		this.operatorModeController.operatorModeState = this.serialize();
+		document.title = this.title;
+	}
+	rawStateWithSavedCardsOnly() {
+		let trail = [this._state.hostModePrimaryCard, ...this._state.hostModeStack.map((item) => item)].filter(Boolean);
+		let state = {
+			stacks: [],
+			submode: this._state.submode,
+			codePath: this._state.codePath ?? void 0,
+			trail,
+			fileView: this._state.fileView?.toString(),
+			openDirs: Object.fromEntries(this._state.openDirs.entries()),
+			codeSelection: this._state.codeSelection,
+			fieldSelection: this._state.fieldSelection,
+			moduleInspector: this._state.moduleInspector,
+			cardPreviewFormat: this._state.cardPreviewFormat
+		};
+		if (this._state.aiAssistantOpen) state.aiAssistantOpen = this._state.aiAssistantOpen;
+		if (this._state.workspaceChooserOpened) state.workspaceChooserOpened = this._state.workspaceChooserOpened;
+		for (let stack of this._state.stacks) {
+			let serializedStack = [];
+			for (let item of stack) {
+				if (item.format !== "isolated" && item.format !== "edit" && item.format !== "head") throw new Error(`Unknown format for card on stack ${item.format}`);
+				if (item.id) {
+					let instance = this.store.peek(item.id) ?? this.store.peek(item.id, { type: "file-meta" });
+					if (!isLocalId(item.id) || instance?.id) serializedStack.push({
+						id: instance?.id ?? item.id,
+						format: item.format,
+						type: item.type === "card" ? void 0 : item.type,
+						useBaseTemplate: item.useBaseTemplate ?? void 0
+					});
+				}
+			}
+			state.stacks.push(serializedStack);
+		}
+		let expandedStackItem = this.serializedExpandedStackItem;
+		if (expandedStackItem) state.expandedStackItem = expandedStackItem;
+		return state;
+	}
+	serialize() {
+		return wrapper_default(this.rawStateWithSavedCardsOnly());
+	}
+	createStackItem(id, stackIndex, format = "isolated", relationshipContext, type) {
+		return new StackItem({
+			id,
+			stackIndex,
+			format,
+			relationshipContext,
+			type
+		});
+	}
+	deserialize(rawState) {
+		this.expandedStackItems.clear();
+		let openDirs = new TrackedMap(Object.entries(rawState.openDirs ?? {}).map(([realmURL, dirs]) => [realmURL, new TrackedArray(dirs)]));
+		let newState = new TrackedObject({
+			stacks: new TrackedArray([]),
+			submode: rawState.submode ?? Submodes.Interact,
+			codePath: rawState.codePath ? this.toCodePathRRI(rawState.codePath) : null,
+			hostModePrimaryCard: rawState.trail?.[0]?.replace(/\.json$/, "") ?? null,
+			hostModeStack: new TrackedArray(rawState.trail?.slice(1, rawState.trail?.length).map((item) => item.replace(/\.json$/, "")) ?? []),
+			fileView: rawState.fileView ?? "inspector",
+			openDirs,
+			codeSelection: rawState.codeSelection,
+			fieldSelection: rawState.fieldSelection,
+			aiAssistantOpen: rawState.aiAssistantOpen ?? readPersistedAiAssistantOpen(),
+			moduleInspector: rawState.moduleInspector ?? "schema",
+			cardPreviewFormat: rawState.cardPreviewFormat ?? "isolated",
+			workspaceChooserOpened: rawState.workspaceChooserOpened ?? false
+		});
+		if (rawState.codePath && rawState.moduleInspector) this.persistModuleInspectorView(rawState.codePath, rawState.moduleInspector);
+		let stackIndex = 0;
+		for (let stack of rawState.stacks) {
+			let newStack = new TrackedArray([]);
+			for (let item of stack) {
+				let { format } = item;
+				newStack.push(new StackItem({
+					id: item.id,
+					format,
+					stackIndex,
+					type: item.type,
+					useBaseTemplate: item.useBaseTemplate,
+					opening: new StackItemOpening(true)
+				}));
+			}
+			newState.stacks.push(newStack);
+			stackIndex++;
+		}
+		let expandedStackItem = rawState.expandedStackItem;
+		if (expandedStackItem) {
+			let item = newState.stacks[expandedStackItem.stackIndex]?.find((candidate) => candidate.id === expandedStackItem.id);
+			if (item) this.expandedStackItems.set(item.instanceId, true);
+		}
+		return newState;
+	}
+	get serializedExpandedStackItem() {
+		for (let [stackIndex, stack] of this._state.stacks.entries()) for (let item of stack) if (item.id && this.expandedStackItems.has(item.instanceId)) return {
+			id: item.id,
+			stackIndex
+		};
+	}
+	get openDirs() {
+		return this._state.openDirs ?? new TrackedMap();
+	}
+	toggleOpenDir = (entryPath) => {
+		if (!this.realmURL) return;
+		let dirPath = normalizeDirPath(entryPath);
+		let dirs = this.currentRealmOpenDirs.slice();
+		let index = dirs.indexOf(dirPath);
+		if (index !== -1) dirs.splice(index, 1);
+		else dirs.push(dirPath);
+		this.openDirs.set(this.realmURL, new TrackedArray(dirs));
+		this.schedulePersist();
+	};
+	get readyFile() {
+		if (isReady(this.openFile.current)) return this.openFile.current;
+		throw new Error(`cannot access file contents ${this._state.codePath} before file is open`);
+	}
+	get openFileIsReady() {
+		return isReady(this.openFile.current);
+	}
+	get realmURL() {
+		let { submode } = this._state;
+		if (submode === Submodes.Code) {
+			if (isReady(this.openFile.current)) return this.readyFile.realmURL;
+		}
+		if (submode === Submodes.Interact) {
+			let stack = this.rightMostStack();
+			if (stack) {
+				let cardId = stack[0]?.id && this.realmServer.availableRealmIndexCardIds.includes(stack[0]?.id) ? stack[0].id : stack[stack.length - 1]?.id;
+				if (cardId) {
+					let realm = this.realm.url(cardId);
+					if (realm) return realm;
+				}
+			}
+		}
+		if (submode === Submodes.Host) {
+			if (this._state.hostModePrimaryCard) {
+				let cardId = this._state.hostModePrimaryCard.replace(/\.json$/, "");
+				let realm = this.realm.url(cardId);
+				if (realm) return realm;
+			}
+		}
+		if (this.cachedRealmURL) return this.cachedRealmURL.href;
+		return this.realm.defaultReadableRealm.path;
+	}
+	static {
+		decorateMethodV2(this.prototype, "realmURL", [cached]);
+	}
+	get currentRealmInfo() {
+		return this.realm.info(this.realmURL);
+	}
+	codeSubmodeOffered = (url) => {
+		return this.realm.canRead(url && !isLocalId(url) ? url : this.realmURL);
+	};
+	getWritableRealmURL = (preferredURLs = []) => {
+		let foundURL = [
+			...preferredURLs,
+			this.realmURL,
+			this.cachedRealmURL?.href
+		].filter(Boolean).find((url) => this.realm.canWrite(url));
+		if (foundURL) return new URL(this.realm.url(foundURL));
+		if (this.realm.defaultWritableRealm) return new URL(this.realm.defaultWritableRealm.path);
+	};
+	subscribeToOpenFileStateChanges(subscriber) {
+		this.openFileSubscribers.push(subscriber);
+	}
+	unsubscribeFromOpenFileStateChanges(subscriber) {
+		let subscriberIndex = this.openFileSubscribers.indexOf(subscriber);
+		if (subscriberIndex > -1) this.openFileSubscribers.splice(subscriberIndex, 1);
+	}
+	openFile = maybe(this, (context) => {
+		let codePath = this.codePathURL;
+		if (!codePath) return;
+		return file(context, () => ({
+			url: codePath.href,
+			onStateChange: (state) => {
+				if (state === "ready") {
+					this.cachedRealmURL = new URL(this.readyFile.realmURL);
+					this.updateOpenDirsForNestedPath();
+				}
+				this.openFileSubscribers.forEach((subscriber) => subscriber.onStateChange(state));
+			},
+			onRedirect: (url) => {
+				if (!url) return;
+				this.replaceCodePath(new URL(url));
+			}
+		}));
+	});
+	openCardInInteractMode(id, format = "isolated", type = "card") {
+		this.clearStacks();
+		let realmHref;
+		if (isLocalId(id)) {
+			let instance = this.store.peek(id);
+			if (instance && isCardInstance(instance)) realmHref = instance[realmURL]?.href;
+		} else realmHref = this.realm.url(id) ?? void 0;
+		if (!realmHref) realmHref = this.realm.defaultReadableRealm.path;
+		if (!realmHref.endsWith("/")) realmHref = realmHref + "/";
+		let indexItem = new StackItem({
+			id: `${realmHref}index`,
+			stackIndex: 0,
+			format: "isolated",
+			type: "card"
+		});
+		let newItem = new StackItem({
+			id,
+			stackIndex: 0,
+			format,
+			type
+		});
+		this.addItemToStack(indexItem);
+		this.addItemToStack(newItem);
+		this.updateSubmode(Submodes.Interact);
+	}
+	openWorkspaceChooser() {
+		this._state.workspaceChooserOpened = true;
+		this.schedulePersist();
+	}
+	closeWorkspaceChooser() {
+		this._state.workspaceChooserOpened = false;
+		this.schedulePersist();
+	}
+	openWorkspace = async (realmUrl) => {
+		if (!realmUrl.endsWith("/")) realmUrl = realmUrl + "/";
+		let id = rri(`${realmUrl}index`);
+		let stackItem = new StackItem({
+			id,
+			format: "isolated",
+			stackIndex: 0,
+			type: "card"
+		});
+		this.clearStacks();
+		this.addItemToStack(stackItem);
+		let lastOpenedFile = this.recentFilesService.recentFiles.find((file) => file.realmURL.href === realmUrl);
+		await this.updateCodePath(lastOpenedFile ? new URL(`${lastOpenedFile.realmURL}${lastOpenedFile.filePath}`) : id);
+		this.updateSubmode(Submodes.Interact);
+		this._state.workspaceChooserOpened = false;
+		this.cachedRealmURL = new URL(realmUrl);
+	};
+	get workspaceChooserOpened() {
+		return this.state.workspaceChooserOpened ?? false;
+	}
+	set workspaceChooserOpened(workspaceChooserOpened) {
+		this._state.workspaceChooserOpened = workspaceChooserOpened;
+		this.schedulePersist();
+	}
+	get operatorModeController() {
+		return getOwner$1(this).lookup("controller:index");
+	}
+	get moduleInspectorPanel() {
+		return JSON.parse(src_default.localStorage.getItem("code-mode-panel-selections") ?? "{}")[this._state.codePath ?? ""] ?? "schema";
+	}
+	get playgroundPanelSelection() {
+		if (this.moduleInspectorPanel === "preview") {
+			let playgroundSelections = this.playgroundPanelService.playgroundSelections ?? {};
+			let selectedCodeRefUrl = this.codeSemanticsService.selectedCodeRef ? internalKeyFor(this.codeSemanticsService.selectedCodeRef, void 0, this.network.virtualNetwork) : null;
+			if (selectedCodeRefUrl && playgroundSelections[selectedCodeRefUrl]) return playgroundSelections[selectedCodeRefUrl];
+		}
+	}
+	async getSummaryForAIBot(openCardIdsSet = new Set([...this.getOpenCardIds()])) {
+		let codeMode = void 0;
+		if (this._state.workspaceChooserOpened) {
+			let userWorkspaces = this.realmServer.userRealmIdentifiers.map((url) => ({
+				url,
+				name: this.realm.info(url).name,
+				type: "user-workspace"
+			}));
+			let catalogWorkspaces = this.realmServer.catalogRealmIdentifiers.map((url) => ({
+				url,
+				name: this.realm.info(url).name,
+				type: "catalog-workspace"
+			}));
+			let result = {
+				agentId: this.matrixService.agentId,
+				submode: "workspace-chooser",
+				debug: this.operatorModeController.debug,
+				openCardIds: [],
+				realmPrefixes: this.realmPrefixes,
+				workspaces: [...userWorkspaces, ...catalogWorkspaces]
+			};
+			let errorsDisplayed = this.errorDisplay.getDisplayedErrors();
+			if (errorsDisplayed.length) result.errorsDisplayed = errorsDisplayed;
+			return result;
+		}
+		if (this._state.submode === Submodes.Code) {
+			codeMode = { currentFile: this._state.codePath ?? void 0 };
+			let selection = this.monacoService.getSelection();
+			if (selection) codeMode.selectionRange = {
+				startLine: selection.startLineNumber,
+				startColumn: selection.startColumn,
+				endLine: selection.endLineNumber,
+				endColumn: selection.endColumn
+			};
+			if (this.isViewingCardInCodeMode) {
+				codeMode.moduleInspectorPanel = "preview";
+				codeMode.previewPanelSelection = {
+					cardId: rri(this._state.codePath.replace(/\.json$/, "")),
+					format: this.currentViewingFormat ?? "isolated"
+				};
+			} else {
+				codeMode.moduleInspectorPanel = this.moduleInspectorPanel;
+				codeMode.previewPanelSelection = this.playgroundPanelSelection ? {
+					cardId: this.playgroundPanelSelection.cardId,
+					format: this.currentViewingFormat
+				} : void 0;
+				codeMode.selectedCodeRef = this.codeSemanticsService.selectedCodeRef;
+				codeMode.inheritanceChain = await this.codeSemanticsService.getInheritanceChain();
+				if (this.moduleInspectorPanel === "spec" && this.specPanelService.specSelection) codeMode.activeSpecId = this.specPanelService.specSelection;
+			}
+		}
+		let openCardIds = this.makeRemoteIdsList([...openCardIdsSet]);
+		let realmUrl = this.realmURL;
+		let realmPermissions = {
+			canRead: this.realm.canRead(realmUrl),
+			canWrite: this.realm.canWrite(realmUrl)
+		};
+		let result = {
+			agentId: this.matrixService.agentId,
+			submode: this._state.submode,
+			debug: this.operatorModeController.debug,
+			openCardIds,
+			realmPrefixes: this.realmPrefixes,
+			realmUrl,
+			realmPermissions,
+			codeMode
+		};
+		let errorsDisplayed = this.errorDisplay.getDisplayedErrors();
+		if (errorsDisplayed.length) result.errorsDisplayed = errorsDisplayed;
+		return result;
+	}
+	get realmPrefixes() {
+		let { virtualNetwork } = this.network;
+		return Object.fromEntries(virtualNetwork.knownRealms().map((prefix) => [prefix, virtualNetwork.toURLHref(prefix)]));
+	}
+	makeRemoteIdsList(ids) {
+		return ids.map((id) => {
+			if (!id) return;
+			if (isLocalId(id)) {
+				let maybeInstance = this.store.peek(id);
+				if (maybeInstance && isCardInstance(maybeInstance) && maybeInstance.id) return maybeInstance.id;
+				else return;
+			}
+			return id;
+		}).filter(Boolean);
+	}
+};
+//#endregion
+export { normalized_dir_path_exports as a, isReady as c, normalizeDirPath as i, codeSubmodeUnavailable as n, maybe_exports as o, operator_mode_state_service_exports as r, file_exports as s, DEFAULT_MODULE_INSPECTOR_VIEW as t };