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

package/bundled-test-harness/assets/run-realm-code-CbXk6bnK.js

@@ -0,0 +1,1600 @@
+import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { $s as uint8ArrayToBase64, Ho as isRelativePath, Po as isCardInstance, Qa as clearReplacedArrayFieldMeta, dc as coerceErrorMessage, fo as assertQuery, lc as isBinaryContentType, ms as logger, na as searchEntryWireQueryFromQuery, no as resourceIdentity, rs as isResolvedCodeRef, sc as validateWriteSize, uo as SupportedMimeType } from "./runtime-common-ClpqhbwG.js";
+import { _ as isPrefixForm, s as ensureTrailingSlash, v as ri, y as rri } from "./paths-BYHDgqsT.js";
+import { B as cloneDeep, I as mergeWith } from "./lodash-DnaZ_rzx.js";
+import { r as service } from "./service-LFpJ8EEP.js";
+import { i as loadSkillSource } from "./skill-tools-NZxKP9oK.js";
+import { t as HostBaseTool } from "./host-base-tool-BybIRY3B.js";
+import { t as UpdateRoomSkillsTool } from "./update-room-skills-r535xnMn.js";
+import { t as SetActiveLLMTool } from "./set-active-llm-CJQbDBe3.js";
+import { n as deleteWorkspace, t as createWorkspace } from "./workspaces-DMfkSB8a.js";
+import { t as LintAndFixTool } from "./lint-and-fix-Bke1wxM-.js";
+import { t as SwitchSubmodeTool } from "./switch-submode-CuA0Zfjn.js";
+import { t as OpenWorkspaceTool } from "./open-workspace-QX74PaWD.js";
+import { t as ShowCardTool } from "./show-card-Dwfk332M.js";
+import { t as PreviewFormatTool } from "./preview-format-CiSo4kEa.js";
+import { a as uploadedImages, i as resolveViewTarget, n as captureDeadline, o as workspaceOf, r as captureForAgent, t as UPLOAD_RESERVE_MS } from "./visual-capture-BpfLvlFK.js";
+import { t as pruneEmptyQueryParts } from "./prune-empty-query-B7Sj33nA.js";
+import { n as composeSearchEntriesQuery, r as searchEntrySummaries } from "./search-entries-DPFRNoDW.js";
+import { t as ShowFileTool } from "./show-file-DLdFPHMR.js";
+//#region app/lib/generate-image.ts
+var OPENROUTER_CHAT_URL = "https://openrouter.ai/api/v1/chat/completions";
+var IMAGE_EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/jpg": "jpg",
+	"image/webp": "webp",
+	"image/gif": "gif",
+	"image/svg+xml": "svg",
+	"image/avif": "avif"
+};
+var IMAGE_EXTENSION_RE = /\.(png|jpe?g|webp|gif|svg|avif)$/i;
+var IMAGE_FILE_EXTENSIONS = [...new Set(Object.values(IMAGE_EXTENSIONS))];
+function imageExtension(mimeType) {
+	return IMAGE_EXTENSIONS[mimeType] ?? "png";
+}
+async function generateImage({ prompt, sourceImageDataUrl, model }, send) {
+	let response = await send({
+		url: OPENROUTER_CHAT_URL,
+		requestBody: JSON.stringify({
+			model: model?.trim() || "google/gemini-2.5-flash-image",
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: prompt
+				}, ...sourceImageDataUrl ? [{
+					type: "image_url",
+					image_url: { url: sourceImageDataUrl }
+				}] : []]
+			}]
+		})
+	});
+	if (!response.ok) throw new Error(`Failed to generate an image: ${response.statusText}`);
+	let message = (await response.json()).choices?.[0]?.message;
+	let dataUrl = Array.isArray(message?.images) ? message.images.map((image) => image?.image_url?.url).find((url) => typeof url === "string" && url.startsWith("data:image/")) : void 0;
+	if (!dataUrl) {
+		let detail = typeof message?.content === "string" && message.content ? message.content : "No image was generated in the response.";
+		throw new Error(`Image generation failed: ${detail}`);
+	}
+	let commaIndex = dataUrl.indexOf(",");
+	if (commaIndex === -1) throw new Error("Generated image data URL is malformed: missing comma separator.");
+	let mimeMatch = dataUrl.slice(0, commaIndex).match(/^data:([^;]+);base64$/);
+	if (!mimeMatch) throw new Error("Generated image data URL has an unrecognisable MIME type.");
+	return {
+		mimeType: mimeMatch[1],
+		base64: dataUrl.slice(commaIndex + 1)
+	};
+}
+async function sourceImageDataUrl(url, fetchImage) {
+	if (url.startsWith("data:image/")) return url;
+	let response = await fetchImage(url);
+	if (!response.ok) throw new Error(`Failed to fetch source image ${url}: ${response.status} ${response.statusText}`);
+	return `data:${response.headers.get("content-type") ?? "image/png"};base64,${uint8ArrayToBase64(new Uint8Array(await response.arrayBuffer()))}`;
+}
+//#endregion
+//#region app/lib/realm-runner/captures.ts
+var MAX_CAPTURES = 3;
+var CAPTURE_MARGIN_MS = 3e3;
+var MIN_CAPTURE_BUDGET_MS = UPLOAD_RESERVE_MS + 5e3;
+var RealmCaptures = class {
+	taken = [];
+	runEndsAt = Number.POSITIVE_INFINITY;
+	refusedAfterClose = 0;
+	closed = false;
+	inFlight = new AbortController();
+	constructor(captureURL) {
+		this.captureURL = captureURL;
+	}
+	close() {
+		this.closed = true;
+		this.inFlight.abort();
+	}
+	async take(url, path, rawOptions) {
+		if (this.taken.length >= MAX_CAPTURES) throw new Error(`realm.capture may run at most ${MAX_CAPTURES} times in one run; capture the rest in another run`);
+		let doneBy = this.runEndsAt - CAPTURE_MARGIN_MS;
+		if (doneBy - Date.now() < MIN_CAPTURE_BUDGET_MS) throw new Error(`Not enough time left in this run to capture ${url}; capture it in another run, before slower work`);
+		let viewed = await this.captureURL(url, captureOptions(rawOptions), doneBy, this.inFlight.signal);
+		if (this.closed) {
+			this.refusedAfterClose += 1;
+			throw new Error(`The run has ended; the capture of ${url} was dropped`);
+		}
+		this.taken.push(viewed);
+		return {
+			path,
+			kind: viewed.kind,
+			format: viewed.format,
+			width: viewed.width ?? null,
+			height: viewed.height ?? null,
+			...viewed.note ? { note: viewed.note } : {},
+			attached: true
+		};
+	}
+};
+function captureOptions(raw) {
+	let options = raw && typeof raw === "object" ? raw : {};
+	return {
+		...typeof options.format === "string" ? { format: options.format } : {},
+		...typeof options.viewportWidth === "number" ? { viewportWidth: options.viewportWidth } : {},
+		...typeof options.viewportHeight === "number" ? { viewportHeight: options.viewportHeight } : {},
+		...options.fullPage === true ? { fullPage: true } : {}
+	};
+}
+//#endregion
+//#region app/lib/realm-runner/room-actions.ts
+var MAX_SKILLS_PER_CALL = 20;
+var RoomActions = class {
+	skills = /* @__PURE__ */ new Map();
+	model;
+	constructor(checks) {
+		this.checks = checks;
+	}
+	get requested() {
+		if (this.skills.size === 0 && this.model === void 0) return;
+		let entries = [...this.skills.entries()];
+		return {
+			skillsToEnable: entries.filter(([, on]) => on).map(([id]) => id),
+			skillsToDisable: entries.filter(([, on]) => !on).map(([id]) => id),
+			...this.model !== void 0 ? { model: this.model } : {}
+		};
+	}
+	async enableSkills(rawIds) {
+		let ids = skillIds("room.enableSkills", rawIds);
+		for (let id of ids) await this.checks.checkSkill(id);
+		for (let id of ids) this.skills.set(id, true);
+		return {
+			enable: ids,
+			appliedAfterRun: true
+		};
+	}
+	disableSkills(rawIds) {
+		let ids = skillIds("room.disableSkills", rawIds);
+		for (let id of ids) this.skills.set(id, false);
+		return {
+			disable: ids,
+			appliedAfterRun: true
+		};
+	}
+	async setModel(model) {
+		if (typeof model !== "string" || model.trim().length === 0) throw new TypeError("room.setModel expects a model id string");
+		model = model.trim();
+		let known = await this.checks.knownModels();
+		if (!known.includes(model)) throw new Error(`Unknown model: ${model}. Models this room can use: ${known.join(", ")}`);
+		this.model = model;
+		return {
+			model,
+			appliedAfterRun: true
+		};
+	}
+};
+function skillIds(method, raw) {
+	let list = typeof raw === "string" ? [raw] : raw;
+	if (!Array.isArray(list) || list.length === 0 || list.some((id) => typeof id !== "string" || id.trim().length === 0)) throw new TypeError(`${method} expects an array of skill id strings`);
+	if (list.length > MAX_SKILLS_PER_CALL) throw new Error(`${method} may name at most ${MAX_SKILLS_PER_CALL} skills in one call`);
+	return [...new Set(list.map((id) => id.trim()))];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jitl+quickjs-wasmfile-release-sync@0.31.0/node_modules/@jitl/quickjs-wasmfile-release-sync/dist/emscripten-module.wasm?url
+var emscripten_module_default = "" + (globalThis.__boxelAssetsURL || "/") + "assets/emscripten-module-NWak2PoB.wasm";
+//#endregion
+//#region app/lib/realm-runner/worker.ts?worker&url
+var worker_default = "" + (globalThis.__boxelAssetsURL || "/") + "assets/worker-DHBEBihX.js";
+//#endregion
+//#region app/lib/realm-runner/runner.ts
+var BOOT_TIMEOUT_MS = 6e4;
+function resolveAssetURL(assetURL) {
+	let assetsURL = globalThis.__boxelAssetsURL;
+	let base = assetsURL ? new URL(assetsURL, window.location.href) : window.location.href;
+	return new URL(assetURL, base);
+}
+function makeRealmWorker(absoluteURL) {
+	if (absoluteURL.origin === window.location.origin) return new Worker(absoluteURL, { type: "module" });
+	let blob = new Blob([`import ${JSON.stringify(absoluteURL.href)};`], { type: "text/javascript" });
+	let blobURL = URL.createObjectURL(blob);
+	try {
+		return new Worker(blobURL, { type: "module" });
+	} finally {
+		URL.revokeObjectURL(blobURL);
+	}
+}
+function runRealmCode(request, onCall, signal) {
+	return new Promise((resolve, reject) => {
+		let workerURL = resolveAssetURL(worker_default);
+		let worker = makeRealmWorker(workerURL);
+		let timer;
+		let settled = false;
+		let onAbort = () => settle(() => reject(signal?.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Realm code was stopped")));
+		let settle = (finish) => {
+			if (settled) return;
+			settled = true;
+			window.clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			worker.terminate();
+			finish();
+		};
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		signal?.addEventListener("abort", onAbort);
+		timer = window.setTimeout(() => {
+			settle(() => reject(/* @__PURE__ */ new Error(`Realm runner did not start within ${BOOT_TIMEOUT_MS}ms (${workerURL.href})`)));
+		}, BOOT_TIMEOUT_MS);
+		let answer = (message) => worker.postMessage(message);
+		worker.onmessage = (event) => {
+			let message = event.data;
+			if (message.type === "call") {
+				let { id, method, args } = message;
+				onCall(method, args).then((value) => answer({
+					type: "callResult",
+					id,
+					value: JSON.stringify(value ?? null)
+				}), (error) => answer({
+					type: "callResult",
+					id,
+					error: error instanceof Error ? error.message : String(error)
+				}));
+				return;
+			}
+			if (message.type === "ready") {
+				window.clearTimeout(timer);
+				timer = window.setTimeout(() => {
+					settle(() => reject(/* @__PURE__ */ new Error(`Realm code exceeded the ${request.timeoutMs}ms time limit`)));
+				}, request.timeoutMs + 1e3);
+				return;
+			}
+			settle(() => {
+				if (message.type === "error") reject(new Error(message.error));
+				else resolve(message.result);
+			});
+		};
+		worker.onerror = (event) => {
+			settle(() => reject(new Error(event.message || `Realm runner worker failed to load from ${workerURL.href}`)));
+		};
+		answer({
+			type: "run",
+			...request,
+			wasmURL: resolveAssetURL(emscripten_module_default).href
+		});
+	});
+}
+//#endregion
+//#region app/tools/run-realm-code.ts
+var run_realm_code_exports = /* @__PURE__ */ __exportAll({
+	RunRealmCodeCommand: () => RunRealmCodeTool,
+	clickRequiredCallsIn: () => clickRequiredCallsIn,
+	default: () => RunRealmCodeTool
+});
+var log = logger("tools:run-realm-code");
+var MAX_CODE_SIZE = 1e5;
+var MAX_FILES = 20;
+var MAX_CARD_UPDATES = 200;
+var MAX_FILE_SIZE = 5e5;
+var MAX_READ_BYTES = MAX_FILE_SIZE * 4;
+var MAX_WORKSPACES = 5;
+var MAX_BINARY_FILE_SIZE = 2e6;
+var MAX_BINARY_BYTES_PER_RUN = 5e6;
+var BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
+var DATA_URL_PREFIX_RE = /^data:[^,]*;base64,/i;
+var MAX_DOWNLOAD_FILE_SIZE = 1e7;
+var MAX_DOWNLOAD_BYTES_PER_RUN = 25e6;
+var DOWNLOAD_TIMEOUT_MS = 2e4;
+var FILE_EXTENSION_RE = /\.[A-Za-z0-9]+$/;
+var DEFAULT_SEARCH_RESULTS = 50;
+var MAX_SEARCH_RESULTS = 100;
+var MAX_SEARCH_RESULT_SIZE = 1e6;
+var DEFAULT_ENTRY_RESULTS = 20;
+var MAX_ENTRY_RESULTS = 50;
+var MAX_ENTRY_RESULT_SIZE = 1e6;
+var RUN_TIMEOUT_MS = 55e3;
+var CALL_DEADLINE_MS = 1e5;
+var MAX_IMAGES = 4;
+var IMAGE_TIMEOUT_MS = 6e4;
+var IMAGE_TIME_BUDGET_MS = 12e4;
+var DownloadTooLarge = class extends Error {};
+var BINARY = Symbol("binary");
+var MAX_UI_ACTIONS = 10;
+var PREVIEW_FORMATS = [
+	"isolated",
+	"embedded",
+	"fitted",
+	"atom",
+	"edit"
+];
+var MAX_INVALIDATE_PATHS = 100;
+var CLICK_REQUIRED_CALLS = {
+	"realm.workspaces.delete": "Deletes a workspace. This cannot be undone.",
+	"realm.fs.delete": "Deletes a file. This cannot be undone.",
+	"realm.images.generate": "Generates images, which uses your credit.",
+	"realm.index.fullReindex": "Indexes the whole workspace again from the start, which can take a long time.",
+	"realm.index.cancelJob": "Cancels the workspace's running index job.",
+	"realm.fs.download": "Downloads a file from an outside URL into the workspace."
+};
+function clickRequiredCallsIn(code) {
+	return new Set(typeof code === "string" ? Object.keys(CLICK_REQUIRED_CALLS).filter((name) => code.includes(name)) : []);
+}
+function notNamedError(name) {
+	return /* @__PURE__ */ new Error(`${name} must be called by that name in the script, so the user confirms the run before it starts`);
+}
+var REQUIRES_WRITE = {
+	"fs.readText": false,
+	"fs.exists": false,
+	"fs.list": false,
+	"fs.replace": true,
+	"fs.writeText": true,
+	"fs.copy": true,
+	"fs.writeBytes": true,
+	"fs.download": true,
+	"cards.search": false,
+	"cards.get": false,
+	"cards.update": true,
+	"entries.search": false,
+	"fs.delete": true,
+	capture: false,
+	"images.generate": true,
+	"workspaces.create": false,
+	"workspaces.delete": false,
+	"room.enableSkills": false,
+	"room.disableSkills": false,
+	"room.setModel": false,
+	"ui.switchSubmode": false,
+	"ui.openFile": false,
+	"ui.previewFormat": false,
+	"ui.openWorkspace": false,
+	"index.invalidate": true,
+	"index.reindex": true,
+	"index.fullReindex": true,
+	"index.cancelJob": true
+};
+var RealmFsSession = class {
+	known = /* @__PURE__ */ new Map();
+	saved = /* @__PURE__ */ new Set();
+	created = /* @__PURE__ */ new Set();
+	deleted = /* @__PURE__ */ new Set();
+	cardUpdates = /* @__PURE__ */ new Map();
+	deletedExisting = /* @__PURE__ */ new Set();
+	createdWorkspaces = [];
+	deletedWorkspaces = [];
+	goneWorkspaces = /* @__PURE__ */ new Set();
+	indexActions = [];
+	binary = /* @__PURE__ */ new Set();
+	binaryDigests = /* @__PURE__ */ new Map();
+	binaryBytes = 0;
+	imagesRequested = 0;
+	imageTimeUsed = 0;
+	downloadedBytes = 0;
+	captures;
+	uiActions = [];
+	refused = 0;
+	queue = Promise.resolve();
+	inFlight = new AbortController();
+	closed = false;
+	constructor(realmURL, readSource, writeFile, saveCards, writeBinaryFile, deleteFile, downloadFile, listDirectory, search, resolveURL, readCard, searchEntries, captureURL, heldByThisRealm, createWorkspace, deleteWorkspace, generateImage, namedCalls, index, mayWrite, cardSizeLimitBytes, room) {
+		this.realmURL = realmURL;
+		this.readSource = readSource;
+		this.writeFile = writeFile;
+		this.saveCards = saveCards;
+		this.writeBinaryFile = writeBinaryFile;
+		this.deleteFile = deleteFile;
+		this.downloadFile = downloadFile;
+		this.listDirectory = listDirectory;
+		this.search = search;
+		this.resolveURL = resolveURL;
+		this.readCard = readCard;
+		this.searchEntries = searchEntries;
+		this.heldByThisRealm = heldByThisRealm;
+		this.createWorkspace = createWorkspace;
+		this.deleteWorkspace = deleteWorkspace;
+		this.generateImage = generateImage;
+		this.namedCalls = namedCalls;
+		this.index = index;
+		this.mayWrite = mayWrite;
+		this.cardSizeLimitBytes = cardSizeLimitBytes;
+		this.room = room;
+		this.captures = new RealmCaptures(captureURL);
+	}
+	get refusedAfterClose() {
+		return this.refused + this.captures.refusedAfterClose;
+	}
+	call(method, args) {
+		let result = this.queue.then(() => {
+			if (this.closed) {
+				this.refused += 1;
+				throw new Error("The run has ended; this realm call was not made");
+			}
+			if (REQUIRES_WRITE[method] && !this.mayWrite) throw new Error(`You can only read this workspace; realm.${method} was not run`);
+			return this.dispatch(method, args);
+		});
+		this.queue = result.catch(() => void 0);
+		return result;
+	}
+	close() {
+		this.closed = true;
+		this.captures.close();
+		this.inFlight.abort();
+	}
+	idle() {
+		return this.queue;
+	}
+	async dispatch(method, args) {
+		switch (method) {
+			case "fs.readText": {
+				let url = this.resolve(method, args[0]);
+				let content = await this.load(url);
+				if (content === void 0) throw new Error(`File not found: ${url}`);
+				return content;
+			}
+			case "fs.exists": {
+				let url = this.resolve(method, args[0]);
+				return await this.lookup(url) !== void 0;
+			}
+			case "fs.list": {
+				let url = this.resolveDirectory(args[0]);
+				let listing = await this.listDirectory(url);
+				if (listing.status === 404) throw new Error(`Directory not found: ${url}`);
+				if (listing.status !== 200) throw new Error(`Unable to list ${url}: ${listing.status}`);
+				let dir = this.relative(url);
+				return listing.entries.map(({ name, kind }) => ({
+					name,
+					path: `${dir}${name}${kind === "directory" ? "/" : ""}`,
+					kind
+				}));
+			}
+			case "fs.replace": {
+				let url = this.resolve(method, args[0]);
+				let [, search, replacement] = args;
+				if (typeof search !== "string" || typeof replacement !== "string") throw new TypeError("realm.fs.replace expects a path, a search string and a replacement string");
+				if (search.length === 0) throw new Error("realm.fs.replace requires a non-empty search string");
+				let current = await this.load(url);
+				if (current === void 0) throw new Error(`File not found: ${url}`);
+				let first = current.indexOf(search);
+				if (first < 0) throw new Error(`Search string was not found in ${url}`);
+				if (current.indexOf(search, first + search.length) >= 0) throw new Error(`Search string matched more than once in ${url}`);
+				await this.save(url, current.slice(0, first) + replacement + current.slice(first + search.length), current);
+				return {
+					path: this.relative(url),
+					matches: 1,
+					saved: true
+				};
+			}
+			case "fs.writeText": {
+				let url = this.resolve(method, args[0]);
+				let content = args[1];
+				if (typeof content !== "string") throw new TypeError("realm.fs.writeText expects a path and a content string");
+				if (await this.lookup(url) !== void 0) throw new Error(`File already exists; use realm.fs.replace to edit it: ${url}`);
+				await this.save(url, content, void 0);
+				return {
+					path: this.relative(url),
+					saved: true
+				};
+			}
+			case "fs.copy": {
+				let from = this.resolve(method, args[0]);
+				let to = this.resolve(method, args[1]);
+				let content = await this.load(from);
+				if (content === void 0) throw new Error(`File not found: ${from}`);
+				if (await this.lookup(to) !== void 0) throw new Error(`File already exists: ${to}`);
+				await this.save(to, content, void 0, { lint: false });
+				return {
+					path: this.relative(to),
+					saved: true
+				};
+			}
+			case "fs.writeBytes": {
+				let url = this.resolve(method, args[0]);
+				let base64 = cleanBase64(args[1]);
+				let size = decodedSize(base64);
+				if (size > MAX_BINARY_FILE_SIZE) throw new Error(`realm.fs.writeBytes accepts at most ${MAX_BINARY_FILE_SIZE} bytes per file: ${url} is ${size} bytes`);
+				if (this.binaryBytes + size > MAX_BINARY_BYTES_PER_RUN) throw new Error(`realm.fs.writeBytes accepts at most ${MAX_BINARY_BYTES_PER_RUN} bytes per run`);
+				if (await this.lookup(url) !== void 0) throw new Error(`File already exists: ${url}`);
+				if (this.closed) {
+					this.refused += 1;
+					throw new Error(`The run has ended; ${url} was not saved`);
+				}
+				let bytes = decodeBase64(base64);
+				await this.writeBinaryFile(url, bytes);
+				this.binaryBytes += bytes.byteLength;
+				this.binaryDigests.set(url, await sha256(bytes));
+				this.known.delete(url);
+				this.binary.add(url);
+				this.markCreated(url);
+				return {
+					path: this.relative(url),
+					size: bytes.byteLength,
+					saved: true
+				};
+			}
+			case "cards.search": return await this.searchCards(args[0]);
+			case "cards.get": {
+				let id = this.resolve(method, args[0]).replace(/\.json$/, "");
+				let { data } = await this.readCard(id);
+				let adoptsFrom = data.meta.adoptsFrom;
+				let relationships = {};
+				for (let [field, value] of Object.entries(data.relationships ?? {})) relationships[field] = value?.links?.self ?? null;
+				return {
+					id,
+					path: `${this.relative(id)}.json`,
+					...isResolvedCodeRef(adoptsFrom) ? { type: {
+						module: adoptsFrom.module,
+						name: adoptsFrom.name
+					} } : {},
+					attributes: data.attributes ?? {},
+					relationships
+				};
+			}
+			case "cards.update": return await this.updateCard(args[0], args[1]);
+			case "entries.search": return await this.searchEntriesFor(args[0], args[1]);
+			case "fs.delete": {
+				if (!this.namedCalls.has("realm.fs.delete")) throw notNamedError("realm.fs.delete");
+				let url = this.resolve(method, args[0]);
+				this.assertNoCardUpdate(url);
+				let content = await this.lookup(url);
+				if (content === void 0) throw new Error(this.deleted.has(url) || this.deletedExisting.has(url) ? `File not found; this run already deleted it: ${url}` : `File not found: ${url}`);
+				if (this.closed) {
+					this.refused += 1;
+					throw new Error(`The run has ended; ${url} was not deleted`);
+				}
+				let digest = this.binaryDigests.get(url);
+				await this.deleteFile(url, content !== BINARY ? { content } : digest !== void 0 ? { sha256: digest } : void 0);
+				let created = this.created.has(url);
+				this.forgetDeleted(url);
+				(created ? this.deleted : this.deletedExisting).add(url);
+				return {
+					path: this.relative(url),
+					deleted: true
+				};
+			}
+			case "fs.download": {
+				if (!this.namedCalls.has("realm.fs.download")) throw notNamedError("realm.fs.download");
+				let sourceUrl = downloadSource(args[0]);
+				let url = this.resolve(method, args[1]);
+				if (!FILE_EXTENSION_RE.test(url.slice(url.lastIndexOf("/") + 1))) throw new Error(`realm.fs.download needs a path with a file extension, so the realm knows the file type: ${url}`);
+				if (await this.lookup(url) !== void 0) throw new Error(`File already exists: ${url}`);
+				let left = MAX_DOWNLOAD_BYTES_PER_RUN - this.downloadedBytes;
+				let maxBytes = Math.min(MAX_DOWNLOAD_FILE_SIZE, left);
+				let bytes;
+				try {
+					bytes = await this.download(sourceUrl, maxBytes);
+				} catch (error) {
+					if (error instanceof DownloadTooLarge) throw new Error(maxBytes < MAX_DOWNLOAD_FILE_SIZE ? `realm.fs.download accepts at most ${MAX_DOWNLOAD_BYTES_PER_RUN} bytes per run: ${sourceUrl} is larger than the ${left} bytes left` : `realm.fs.download accepts at most ${MAX_DOWNLOAD_FILE_SIZE} bytes per file: ${sourceUrl} is larger`);
+					throw error;
+				}
+				this.downloadedBytes += bytes.byteLength;
+				if (bytes.byteLength === 0) throw new Error(`${sourceUrl} returned an empty file`);
+				if (this.closed) {
+					this.refused += 1;
+					throw new Error(`The run has ended; ${url} was not saved`);
+				}
+				await this.writeBinaryFile(url, bytes);
+				this.binaryDigests.set(url, await sha256(bytes));
+				this.known.delete(url);
+				this.binary.add(url);
+				this.markCreated(url);
+				return {
+					path: this.relative(url),
+					size: bytes.byteLength,
+					saved: true
+				};
+			}
+			case "capture": {
+				let { url, path } = this.captureTarget(args[0]);
+				return await this.captures.take(url, path, args[1]);
+			}
+			case "images.generate": return await this.generateAndSaveImage(args[0]);
+			case "workspaces.create": {
+				let options = args[0] ?? {};
+				if (typeof options !== "object" || Array.isArray(options)) throw new TypeError("realm.workspaces.create expects an options object: { name, endpoint }");
+				let { name, endpoint } = options;
+				for (let [key, value] of Object.entries({
+					name,
+					endpoint
+				})) if (value !== void 0 && value !== null && typeof value !== "string") throw new TypeError(`realm.workspaces.create expects ${key} to be a string`);
+				if (this.createdWorkspaces.length >= MAX_WORKSPACES) throw new Error(`Realm code may create at most ${MAX_WORKSPACES} workspaces`);
+				let creating = this.createWorkspace({
+					name: name ?? void 0,
+					endpoint: endpoint ?? void 0
+				});
+				let { signal } = this.inFlight;
+				let created = await new Promise((resolve, reject) => {
+					let onAbort = () => reject(/* @__PURE__ */ new Error("The run has ended; the workspace create was not awaited"));
+					if (signal.aborted) onAbort();
+					signal.addEventListener("abort", onAbort, { once: true });
+					creating.then((workspace) => {
+						if (signal.aborted) log.warn(`Workspace ${workspace.url} was created after the run ended`);
+						resolve(workspace);
+					}, reject).finally(() => {
+						signal.removeEventListener("abort", onAbort);
+					});
+				});
+				this.createdWorkspaces.push(created.url);
+				this.goneWorkspaces.delete(created.url);
+				return created;
+			}
+			case "workspaces.delete": {
+				if (!this.namedCalls.has("realm.workspaces.delete")) throw notNamedError("realm.workspaces.delete");
+				let realmIdentifier = args[0];
+				if (typeof realmIdentifier !== "string" || !realmIdentifier) throw new TypeError("realm.workspaces.delete expects the URL of a workspace");
+				let deleted = await this.deleteWorkspace(realmIdentifier);
+				this.deletedWorkspaces.push(deleted.url);
+				this.goneWorkspaces.add(deleted.url);
+				return {
+					url: deleted.url,
+					deleted: true
+				};
+			}
+			case "room.enableSkills": return await this.room.enableSkills(args[0]);
+			case "room.disableSkills": return this.room.disableSkills(args[0]);
+			case "room.setModel": return await this.room.setModel(args[0]);
+			case "ui.switchSubmode": {
+				let submode = args[0];
+				if (submode !== "interact" && submode !== "code") throw new TypeError("realm.ui.switchSubmode expects 'interact' or 'code'");
+				return this.queueUiAction({
+					action: "switchSubmode",
+					submode
+				});
+			}
+			case "ui.openFile": {
+				let url = this.resolve(method, args[0]);
+				if (!await this.exists(url)) throw new Error(`File not found: ${url}`);
+				return this.queueUiAction({
+					action: "openFile",
+					url
+				});
+			}
+			case "ui.previewFormat": {
+				let [path, format = "isolated"] = args;
+				if (typeof format !== "string" || !PREVIEW_FORMATS.includes(format)) throw new TypeError(`realm.ui.previewFormat expects a card path and one of these formats: ${PREVIEW_FORMATS.join(", ")}`);
+				let url = this.resolve(method, path);
+				let fileURL = url.endsWith(".json") ? url : `${url}.json`;
+				let content = await this.load(fileURL);
+				if (content === void 0) throw new Error(`Card not found: ${fileURL}`);
+				let module;
+				try {
+					module = JSON.parse(content)?.data?.meta?.adoptsFrom?.module;
+				} catch {}
+				if (typeof module !== "string") throw new Error(`Not a card instance: ${fileURL}`);
+				let modulePath = isRelativePath(module) ? new URL(module, fileURL).href : module;
+				if (!/\.(gts|ts)$/.test(modulePath)) modulePath = `${modulePath}.gts`;
+				return this.queueUiAction({
+					action: "previewFormat",
+					cardId: fileURL.slice(0, -5),
+					modulePath,
+					format
+				});
+			}
+			case "ui.openWorkspace": return this.queueUiAction({ action: "openWorkspace" });
+			case "index.invalidate": {
+				let paths = typeof args[0] === "string" ? [args[0]] : args[0];
+				if (!Array.isArray(paths) || paths.length === 0 || paths.length > MAX_INVALIDATE_PATHS) throw new TypeError(`realm.index.invalidate expects a path or an array of 1 to ${MAX_INVALIDATE_PATHS} paths`);
+				let urls = paths.map((path) => this.resolve(method, path));
+				await this.index.invalidate(urls);
+				let invalidated = urls.map((url) => this.relative(url));
+				this.indexActions.push(`invalidate ${invalidated.join(", ")}`);
+				return { invalidated };
+			}
+			case "index.reindex":
+				await this.index.reindex();
+				this.indexActions.push("reindex");
+				return { reindex: "started" };
+			case "index.fullReindex":
+				if (!this.namedCalls.has("realm.index.fullReindex")) throw notNamedError("realm.index.fullReindex");
+				await this.index.fullReindex();
+				this.indexActions.push("fullReindex");
+				return { fullReindex: "started" };
+			case "index.cancelJob":
+				if (!this.namedCalls.has("realm.index.cancelJob")) throw notNamedError("realm.index.cancelJob");
+				await this.index.cancelJob();
+				this.indexActions.push("cancelJob");
+				return { cancelled: true };
+			default: throw new Error(`Unknown realm call: ${String(method)}`);
+		}
+	}
+	get pendingCardUpdates() {
+		return this.cardUpdates.size;
+	}
+	async updateCard(path, attributes) {
+		if (attributes === null || typeof attributes !== "object" || Array.isArray(attributes)) throw new TypeError("realm.cards.update expects a card path and an attributes object");
+		let url = this.resolve("cards.update", path);
+		if (!url.endsWith(".json")) url = `${url}.json`;
+		let pending = this.cardUpdates.get(url);
+		if (!pending) {
+			if (this.cardUpdates.size >= MAX_CARD_UPDATES) throw new Error(`Realm code may update at most ${MAX_CARD_UPDATES} cards`);
+			let expected = await this.cardSource(url);
+			let doc;
+			try {
+				doc = JSON.parse(expected);
+			} catch {}
+			if (!doc?.data || typeof doc.data !== "object" || !doc.data.meta?.adoptsFrom) throw new Error(`Not a card instance: ${url}`);
+			pending = {
+				expected,
+				doc
+			};
+		}
+		let patch = attributes;
+		let doc = cloneDeep(pending.doc);
+		clearReplacedArrayFieldMeta(doc.data.meta, patch);
+		doc.data.attributes = mergeWith(doc.data.attributes ?? {}, patch, (_target, source) => Array.isArray(source) ? source : void 0);
+		try {
+			validateWriteSize(JSON.stringify(doc, null, 2), this.cardSizeLimitBytes, "card");
+		} catch (error) {
+			throw new Error(`Card is too large after this update: ${url}. ${coerceErrorMessage(error, "")}`.trim());
+		}
+		this.cardUpdates.set(url, {
+			expected: pending.expected,
+			doc
+		});
+		return {
+			path: this.relative(url),
+			fields: Object.keys(patch),
+			saves: "after the script finishes"
+		};
+	}
+	async cardSource(url) {
+		if (this.binary.has(url)) throw new Error(`Not a card instance: ${url}`);
+		if (this.known.has(url)) {
+			let content = this.known.get(url);
+			if (content === void 0) throw new Error(`Card not found: ${url}`);
+			return content;
+		}
+		let source = await this.readSource(url);
+		if (source.status === 404) throw new Error(`Card not found: ${url}`);
+		if (source.binary) throw new Error(`Not a card instance: ${url}`);
+		if (source.status !== 200) throw new Error(`Unable to read ${url}: ${source.status}`);
+		if (source.tooLarge || source.content.length > MAX_FILE_SIZE) throw new Error(`File is too large: ${url}`);
+		return source.content;
+	}
+	async saveCardUpdates() {
+		if (this.cardUpdates.size === 0) return;
+		let updates = [...this.cardUpdates].map(([url, { expected, doc }]) => ({
+			url,
+			expected,
+			content: JSON.stringify(doc, null, 2)
+		}));
+		await this.saveCards(updates);
+		this.cardUpdates.clear();
+		for (let { url } of updates) this.saved.add(url);
+	}
+	assertNoCardUpdate(url) {
+		if (this.cardUpdates.has(url)) throw new Error(`${url} has a realm.cards.update that is saved when the script finishes; realm.fs cannot read or change it in the same run`);
+	}
+	resolve(method, path) {
+		if (typeof path !== "string" || path.length === 0) throw new TypeError(`realm.${method} expects a path string`);
+		let url;
+		if (/^[a-z][a-z0-9+.-]*:/i.test(path)) url = new URL(path).href;
+		else {
+			if (path.startsWith("/") || path.includes("\\") || path.split("/").some((part) => part === ".." || part === "." || part === "")) throw new Error(`Path must be relative to the realm root: ${path}`);
+			url = new URL(path, this.realmURL).href;
+		}
+		if (!url.startsWith(this.realmURL) || url === this.realmURL) throw new Error(`Path is outside this realm: ${path}`);
+		return url;
+	}
+	async searchEntriesFor(rawQuery, rawOptions) {
+		if (rawQuery === null || typeof rawQuery !== "object" || Array.isArray(rawQuery)) throw new TypeError("realm.entries.search expects a query object");
+		if ("page" in rawQuery) throw new Error("realm.entries.search does not page; pass { limit } in the options and narrow the query to see other entries");
+		let options = rawOptions ?? {};
+		if (typeof options !== "object" || Array.isArray(options)) throw new TypeError("realm.entries.search expects an options object: { realms, scope, limit }");
+		let { realms, scope, limit } = options;
+		if (realms !== void 0 && (!Array.isArray(realms) || realms.some((realm) => typeof realm !== "string"))) throw new TypeError("realms must be an array of realm URLs or identifiers such as @cardstack/catalog/");
+		if (scope !== void 0 && typeof scope !== "string") throw new TypeError("scope must be one of 'cards', 'files', 'all'");
+		if (limit !== void 0 && (typeof limit !== "number" || !Number.isFinite(limit))) throw new TypeError("limit must be a number");
+		let size = limit === void 0 ? DEFAULT_ENTRY_RESULTS : Math.min(Math.max(Math.floor(limit), 1), MAX_ENTRY_RESULTS);
+		let query = pruneEmptyQueryParts(rawQuery);
+		assertQuery(query);
+		let { rows, total, incomplete } = await searchEntrySummaries(this.searchEntries, query, {
+			scope,
+			limit: size,
+			realms
+		});
+		let resultSize = 0;
+		for (let [index, row] of rows.entries()) {
+			resultSize += JSON.stringify(row).length;
+			if (resultSize > MAX_ENTRY_RESULT_SIZE) throw new Error(index > 0 ? `These entries are too large to return; search again with limit ${index} or less` : `The entry ${row.url} is too large to return from a search`);
+		}
+		return {
+			entries: rows,
+			total,
+			truncated: rows.length < total,
+			incomplete
+		};
+	}
+	resolveDirectory(path) {
+		if (path === void 0 || path === null || path === "") return this.realmURL;
+		if (typeof path === "string" && /^[a-z][a-z0-9+.-]*:/i.test(path)) {
+			let url = new URL(path).href;
+			if ((url.endsWith("/") ? url : `${url}/`) === this.realmURL) return this.realmURL;
+		}
+		let url = this.resolve("fs.list", typeof path === "string" && path.endsWith("/") ? path.slice(0, -1) : path);
+		return url.endsWith("/") ? url : `${url}/`;
+	}
+	queueUiAction(action) {
+		if (this.uiActions.length >= MAX_UI_ACTIONS) throw new Error(`Realm code may ask for at most ${MAX_UI_ACTIONS} realm.ui actions`);
+		this.uiActions.push(action);
+		return {
+			action: action.action,
+			runs: "after the script finishes"
+		};
+	}
+	async generateAndSaveImage(options) {
+		if (!this.namedCalls.has("realm.images.generate")) throw notNamedError("realm.images.generate");
+		if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError("realm.images.generate expects an options object: { prompt, path, sourceImageUrl, llmModel }");
+		let { prompt, path, sourceImageUrl, llmModel } = options;
+		if (typeof prompt !== "string" || !prompt.trim()) throw new TypeError("realm.images.generate requires a prompt string");
+		for (let [key, value] of Object.entries({
+			sourceImageUrl,
+			llmModel
+		})) if (value !== void 0 && value !== null && typeof value !== "string") throw new TypeError(`realm.images.generate expects ${key} to be a string`);
+		let url = this.resolve("images.generate", path);
+		let source = typeof sourceImageUrl === "string" && sourceImageUrl ? /^data:/i.test(sourceImageUrl) ? sourceImageUrl : this.resolve("images.generate", sourceImageUrl) : void 0;
+		if (this.imagesRequested >= MAX_IMAGES) throw new Error(`Realm code may generate at most ${MAX_IMAGES} images`);
+		let timeLeft = IMAGE_TIME_BUDGET_MS - this.imageTimeUsed;
+		if (timeLeft <= 0) throw new Error(`Realm code may spend at most ${IMAGE_TIME_BUDGET_MS / 1e3} s generating images`);
+		if (this.known.size + this.binary.size >= MAX_FILES) throw new Error(`Realm code may touch at most ${MAX_FILES} files`);
+		let base = url.replace(IMAGE_EXTENSION_RE, "");
+		let destinations = [url, ...IMAGE_FILE_EXTENSIONS.map((extension) => `${base}.${extension}`)];
+		let taken = (await Promise.all([...new Set(destinations)].map(async (destination) => await this.exists(destination) ? destination : void 0))).filter((destination) => destination !== void 0);
+		if (taken.length > 0) throw new Error(`File already exists: ${taken.join(", ")}`);
+		this.imagesRequested += 1;
+		let limit = Math.min(IMAGE_TIMEOUT_MS, timeLeft);
+		let timeout = AbortSignal.timeout(limit);
+		let started = Date.now();
+		let image;
+		try {
+			image = await this.generateImage({
+				prompt: prompt.trim(),
+				sourceImageUrl: source,
+				llmModel: llmModel ?? void 0,
+				signal: AbortSignal.any([this.inFlight.signal, timeout])
+			});
+		} catch (error) {
+			if (this.inFlight.signal.aborted) throw new Error("The run has ended; the image request was stopped");
+			if (timeout.aborted) throw new Error(`realm.images.generate did not finish within ${Math.round(limit / 1e3)} s`);
+			throw error;
+		} finally {
+			this.imageTimeUsed += Date.now() - started;
+		}
+		let savedURL = `${base}.${imageExtension(image.mimeType)}`;
+		if (this.closed) {
+			this.refused += 1;
+			throw new Error(`The run has ended; ${savedURL} was not saved`);
+		}
+		let bytes = decodeBase64(image.base64.replace(/\s+/g, ""));
+		await this.writeBinaryFile(savedURL, bytes);
+		this.binaryDigests.set(savedURL, await sha256(bytes));
+		this.known.delete(savedURL);
+		this.binary.add(savedURL);
+		this.markCreated(savedURL);
+		return {
+			path: this.relative(savedURL),
+			contentType: image.mimeType,
+			size: bytes.byteLength,
+			saved: true
+		};
+	}
+	async exists(url) {
+		if (this.known.has(url)) return this.known.get(url) !== void 0;
+		if (this.binary.has(url)) return true;
+		let source = await this.readSource(url);
+		if (source.status !== 200 && source.status !== 404) throw new Error(`Unable to read ${url}: ${source.status}`);
+		return source.status === 200;
+	}
+	cardURL(path) {
+		if (typeof path !== "string") throw new TypeError("`show` must be a card or file path string");
+		return this.resolve("show", path).replace(/\.json$/, "");
+	}
+	captureTarget(path) {
+		if (typeof path === "string" && (/^[a-z][a-z0-9+.-]*:/i.test(path) || isPrefixForm(path))) {
+			let reference = path.trim();
+			return {
+				url: reference,
+				path: reference.startsWith(this.realmURL) && reference !== this.realmURL && this.heldByThisRealm(reference) ? this.relative(reference) : reference
+			};
+		}
+		let url = this.resolve("capture", path);
+		return {
+			url,
+			path: this.relative(url)
+		};
+	}
+	relative(url) {
+		return url.slice(this.realmURL.length);
+	}
+	async searchCards(raw) {
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new TypeError("realm.cards.search expects a query object");
+		if ("realm" in raw || "realms" in raw) throw new Error("realm.cards.search searches only this realm; to search another realm, run code in that realm");
+		let query = pruneEmptyQueryParts(raw);
+		assertQuery(query);
+		let requested = query.page?.size;
+		let size = typeof requested === "number" && Number.isFinite(requested) ? Math.min(Math.max(Math.floor(requested), 1), MAX_SEARCH_RESULTS) : DEFAULT_SEARCH_RESULTS;
+		let wireQuery = searchEntryWireQueryFromQuery(composeSearchEntriesQuery(query, "cards").query, {
+			fields: ["item"],
+			scope: "cards"
+		});
+		wireQuery.page = {
+			...wireQuery.page,
+			size
+		};
+		let doc = await this.search(wireQuery);
+		if (doc.meta.incomplete) throw new Error(`The search in ${this.realmURL} did not answer; no cards were returned`);
+		let items = /* @__PURE__ */ new Map();
+		for (let resource of doc.included ?? []) if (resource.type === "card") items.set(resourceIdentity(resource.type, resource.id), resource);
+		let cards = [];
+		let resultSize = 0;
+		for (let entry of doc.data) {
+			let itemRef = entry.relationships?.item?.data;
+			let item = itemRef && items.get(resourceIdentity(itemRef.type, itemRef.id));
+			let card = entry.id && item ? this.foundCard(entry.id, item) : void 0;
+			if (!card) continue;
+			resultSize += JSON.stringify(card).length;
+			if (resultSize > MAX_SEARCH_RESULT_SIZE) throw new Error(cards.length > 0 ? `This page of cards is too large to return; search again with page.size ${cards.length} or less` : `The card ${card.path} is too large to return from a search; read it with realm.fs.readText`);
+			cards.push(card);
+		}
+		let total = doc.meta.page.total;
+		return {
+			cards,
+			total,
+			truncated: (wireQuery.page.number ?? 0) * size + doc.data.length < total
+		};
+	}
+	foundCard(entryId, item) {
+		let id = this.resolveURL(entryId);
+		if (!id.startsWith(this.realmURL)) return;
+		let file = this.relative(id);
+		let path = file.endsWith(".json") ? file : `${file}.json`;
+		let adoptsFrom = item.meta.adoptsFrom;
+		let type = isResolvedCodeRef(adoptsFrom) ? {
+			module: this.resolveURL(adoptsFrom.module, id),
+			name: adoptsFrom.name
+		} : void 0;
+		let relationships = {};
+		for (let [field, value] of Object.entries(item.relationships ?? {})) {
+			let self = value?.links?.self;
+			relationships[field] = self ? this.resolveURL(self, id) : null;
+		}
+		return {
+			id,
+			path,
+			...type ? { type } : {},
+			attributes: item.attributes ?? {},
+			relationships
+		};
+	}
+	async download(sourceUrl, maxBytes) {
+		if (this.inFlight.signal.aborted) {
+			this.refused += 1;
+			throw new Error(`The run has ended; ${sourceUrl} was not downloaded`);
+		}
+		let stop = new AbortController();
+		let timer = setTimeout(() => stop.abort(/* @__PURE__ */ new Error(`Downloading ${sourceUrl} took longer than ${DOWNLOAD_TIMEOUT_MS / 1e3} s`)), DOWNLOAD_TIMEOUT_MS);
+		let onRunEnd = () => stop.abort(/* @__PURE__ */ new Error(`The run has ended; ${sourceUrl} was not downloaded`));
+		this.inFlight.signal.addEventListener("abort", onRunEnd, { once: true });
+		try {
+			return await new Promise((resolve, reject) => {
+				stop.signal.addEventListener("abort", () => reject(stop.signal.reason), { once: true });
+				this.downloadFile(sourceUrl, maxBytes, stop.signal).then(resolve, reject);
+			});
+		} finally {
+			clearTimeout(timer);
+			this.inFlight.signal.removeEventListener("abort", onRunEnd);
+		}
+	}
+	async load(url) {
+		let content = await this.lookup(url);
+		if (content === BINARY) throw new Error(`${url} is a binary file; realm.fs reads only text`);
+		return content;
+	}
+	async lookup(url) {
+		this.assertNoCardUpdate(url);
+		if (this.known.has(url)) return this.known.get(url);
+		if (this.binary.has(url)) return BINARY;
+		if (this.known.size + this.binary.size >= MAX_FILES) throw new Error(`Realm code may touch at most ${MAX_FILES} files`);
+		let source = await this.readSource(url);
+		if (source.binary) {
+			this.binary.add(url);
+			return BINARY;
+		}
+		if (source.status !== 200 && source.status !== 404) throw new Error(`Unable to read ${url}: ${source.status}`);
+		if (source.tooLarge) throw new Error(`File is too large: ${url}`);
+		let content = source.status === 404 ? void 0 : source.content;
+		if (content !== void 0 && content.length > MAX_FILE_SIZE) throw new Error(`File is too large: ${url}`);
+		this.known.set(url, content);
+		return content;
+	}
+	async save(url, content, expected, options) {
+		if (content.length > MAX_FILE_SIZE) throw new Error(`File is too large after editing: ${url}`);
+		if (this.closed) {
+			this.refused += 1;
+			throw new Error(`The run has ended; ${url} was not saved`);
+		}
+		let saved = await this.writeFile(url, content, expected, options);
+		this.known.set(url, saved);
+		if (expected === void 0) this.markCreated(url);
+		else this.saved.add(url);
+	}
+	markCreated(url) {
+		this.created.add(url);
+		this.saved.add(url);
+		this.deleted.delete(url);
+		this.deletedExisting.delete(url);
+	}
+	forgetDeleted(url) {
+		this.created.delete(url);
+		this.saved.delete(url);
+		this.binary.delete(url);
+		this.binaryDigests.delete(url);
+		this.known.set(url, void 0);
+	}
+};
+function failureReport(session, error) {
+	let message = error instanceof Error ? error.message : String(error);
+	let saved = [...session.saved];
+	log.debug(`run failed: saved=${saved.length} refusedAfterClose=${session.refusedAfterClose}: ${message}`);
+	let trimmed = message.trimEnd();
+	let sentence = /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+	let report = saved.length > 0 ? `${sentence} Files already saved by this run: ${saved.join(", ")}` : `${sentence} No file was saved.`;
+	if (session.deleted.size > 0) report += ` Files this run created and already deleted: ${[...session.deleted].join(", ")}`;
+	if (session.deletedExisting.size > 0) report += ` Files that existed before this run and that it already deleted: ${[...session.deletedExisting].join(", ")}`;
+	if (session.createdWorkspaces.length > 0) report += ` Workspaces already created by this run: ${session.createdWorkspaces.join(", ")}`;
+	if (session.deletedWorkspaces.length > 0) report += ` Workspaces already deleted by this run: ${session.deletedWorkspaces.join(", ")}`;
+	if (session.indexActions.length > 0) report += ` Index actions already started by this run: ${session.indexActions.join("; ")}`;
+	if (session.room.requested) report += " The room changes it asked for were not made.";
+	if (session.uiActions.length > 0) report += " The UI actions it asked for were not done.";
+	if (session.pendingCardUpdates > 0) report += " The card updates it asked for were not saved.";
+	return report;
+}
+var UTF8 = new TextDecoder("utf-8", { fatal: true });
+async function sha256(bytes) {
+	let digest = await crypto.subtle.digest("SHA-256", bytes);
+	return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function downloadSource(value) {
+	if (typeof value !== "string") throw new TypeError("realm.fs.download expects a source URL and a destination path");
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new Error(`realm.fs.download expects an absolute source URL: ${value}`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`realm.fs.download downloads only http and https URLs: ${value}`);
+	return url.href;
+}
+function cleanBase64(value) {
+	if (typeof value !== "string") throw new TypeError("realm.fs.writeBytes expects a path and a base64 string");
+	let base64 = value.replace(DATA_URL_PREFIX_RE, "").replace(/\s+/g, "");
+	if (base64.length === 0) throw new Error("realm.fs.writeBytes requires non-empty content");
+	if (base64.length % 4 === 1 || !BASE64_RE.test(base64)) throw new Error("realm.fs.writeBytes content is not valid base64");
+	return base64;
+}
+function decodedSize(base64) {
+	let padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+	return Math.floor(base64.length * 3 / 4) - padding;
+}
+function decodeBase64(base64) {
+	let binary = atob(base64);
+	let bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+var RunRealmCodeTool = class extends HostBaseTool {
+	static {
+		decorateFieldV2(this.prototype, "cardService", [service]);
+	}
+	#cardService = (initializeDeferredDecorator(this, "cardService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "environmentService", [service]);
+	}
+	#environmentService = (initializeDeferredDecorator(this, "environmentService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "matrixService", [service]);
+	}
+	#matrixService = (initializeDeferredDecorator(this, "matrixService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "operatorModeStateService", [service]);
+	}
+	#operatorModeStateService = (initializeDeferredDecorator(this, "operatorModeStateService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network = (initializeDeferredDecorator(this, "network"), 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, "recentFilesService", [service]);
+	}
+	#recentFilesService = (initializeDeferredDecorator(this, "recentFilesService"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "store", [service]);
+	}
+	#store = (initializeDeferredDecorator(this, "store"), void 0);
+	static {
+		decorateFieldV2(this.prototype, "toolService", [service]);
+	}
+	#toolService = (initializeDeferredDecorator(this, "toolService"), void 0);
+	description = "Run safe Realm code that reads and edits realm source files, finds cards with realm.cards.search, reads cards as JSON data with realm.cards.get, changes card fields with realm.cards.update, finds cards, specs and files across realms with realm.entries.search, can look at cards and files with realm.capture (a path in the realm, or the URL of a card or file in any workspace the user can read), can generate images into the realm with realm.images.generate, can save a file from a URL with realm.fs.download, can create workspaces with realm.workspaces.create, can change the skills and model of this room with room.*, and can refresh the index of the workspace with realm.index.*. In a workspace the user can only read, reads work and each write is refused. Return { show: \"<card path>\" } to open a card in the realm when the run ends.";
+	static actionVerb = "Run";
+	static bindsToInvokingRoom = true;
+	static clickReasonsFor(attributes) {
+		return [...clickRequiredCallsIn(attributes?.code)].map((call) => ({
+			call,
+			reason: CLICK_REQUIRED_CALLS[call]
+		}));
+	}
+	static extraExecuteTimeMsFor(attributes) {
+		return clickRequiredCallsIn(attributes?.code).has("realm.images.generate") ? IMAGE_TIME_BUDGET_MS : 0;
+	}
+	async getInputType() {
+		return (await this.loadToolModule()).RunRealmCodeInput;
+	}
+	requireInputFields = ["code"];
+	async run(input) {
+		if (!input.code || input.code.length > MAX_CODE_SIZE) throw new Error(`Realm code must be between 1 and ${MAX_CODE_SIZE} characters`);
+		let realmInput = input.realm || this.operatorModeStateService.realmURL;
+		let roomId = input.roomId || this.matrixService.currentRoomId;
+		if (!realmInput) throw new Error("Realm code needs a realm to run in");
+		if (!roomId) throw new Error("Realm code needs the room it runs for");
+		let realmURL = this.realmOfInput(rri(realmInput.endsWith("/") ? realmInput : `${realmInput}/`));
+		if (!realmURL || !(this.realm.canRead(realmURL) || this.realm.canWrite(realmURL))) throw new Error(`The current user cannot read or write ${realmInput}`);
+		let namedCalls = clickRequiredCallsIn(input.code);
+		let imageTime = namedCalls.has("realm.images.generate") ? IMAGE_TIME_BUDGET_MS : 0;
+		let runTimeoutMs = RUN_TIMEOUT_MS + imageTime;
+		let callDeadlineMs = CALL_DEADLINE_MS + imageTime;
+		let session = new RealmFsSession(this.realmRootURL(realmURL), (url) => this.readSource(url), (url, content, expected, options) => this.writeFile(roomId, url, content, expected, options), (updates) => this.saveCards(roomId, this.realmRootURL(realmURL), updates), (url, bytes) => this.writeBinaryFile(roomId, url, bytes), (url, expected) => this.deleteFile(url, expected), (url, maxBytes, signal) => this.downloadFile(url, maxBytes, signal), (url) => this.listDirectory(url), (query) => this.store.searchEntries(query, [realmURL], { linksOnly: true }), (reference, base) => this.network.virtualNetwork.resolveURL(reference, base).href, (id) => this.readCard(id), (query, realms) => {
+			this.assertKnownRealmIdentifiers(realms);
+			return this.store.searchEntries(query, realms);
+		}, (url, options, doneBy, signal) => this.captureURL(url, options, doneBy, signal), (reference) => workspaceOf(reference, {
+			network: this.network,
+			realm: this.realm
+		})?.realmURL === this.realmRootURL(realmURL), (workspaceInput) => createWorkspace({
+			matrixService: this.matrixService,
+			realm: this.realm
+		}, workspaceInput), (realmIdentifier) => deleteWorkspace({
+			matrixService: this.matrixService,
+			operatorModeStateService: this.operatorModeStateService,
+			realm: this.realm,
+			realmServer: this.realmServer,
+			recentFilesService: this.recentFilesService
+		}, realmIdentifier), (imageInput) => this.generateImage(imageInput), namedCalls, {
+			invalidate: (urls) => this.realm.invalidateUrls(realmURL, urls),
+			reindex: () => this.realm.reindex(realmURL),
+			fullReindex: () => this.realm.fullReindex(realmURL),
+			cancelJob: () => this.realm.cancelIndexingJob(realmURL)
+		}, this.realm.canWrite(realmURL), this.environmentService.cardSizeLimitBytes, new RoomActions({
+			checkSkill: (id) => this.checkSkill(id),
+			knownModels: () => this.matrixService.pickableModelIds(roomId)
+		}));
+		let runnerResult;
+		let deadline = new AbortController();
+		let deadlineTimer = setTimeout(() => deadline.abort(/* @__PURE__ */ new Error(`Realm code did not finish within ${callDeadlineMs / 1e3} s`)), callDeadlineMs);
+		session.captures.runEndsAt = Date.now() + runTimeoutMs;
+		try {
+			runnerResult = await runRealmCode({
+				code: input.code,
+				realmURL: this.realmRootURL(realmURL),
+				timeoutMs: runTimeoutMs
+			}, (method, args) => session.call(method, args), deadline.signal);
+		} catch (error) {
+			clearTimeout(deadlineTimer);
+			session.close();
+			await session.idle();
+			throw new Error(failureReport(session, error));
+		}
+		clearTimeout(deadlineTimer);
+		session.close();
+		await session.idle();
+		try {
+			await session.saveCardUpdates();
+		} catch (error) {
+			throw new Error(failureReport(session, error));
+		}
+		await this.openCreatedWorkspace(session);
+		let roomChanges = session.room.requested ? await this.changeRoom(roomId, session.room.requested) : [];
+		let shown = await this.showCard(session, runnerResult.scriptResult);
+		let commandModule = await this.loadToolModule();
+		let uiActions = [];
+		for (let action of session.uiActions) uiActions.push(new commandModule.RealmCodeUiActionResult(await this.applyUiAction(action, realmURL)));
+		return new commandModule.RunRealmCodeResult({
+			uiActions,
+			...shown,
+			files: [
+				...[...session.saved].map((fileUrl) => new commandModule.RealmCodeFileResult({
+					fileUrl,
+					status: "saved",
+					detail: session.binary.has(fileUrl) ? "Binary file saved." : "Source saved; correctness validation will run after this tool result."
+				})),
+				...[...session.deleted].map((fileUrl) => new commandModule.RealmCodeFileResult({
+					fileUrl,
+					status: "deleted",
+					detail: "Created by this run and then deleted."
+				})),
+				...[...session.deletedExisting].map((fileUrl) => new commandModule.RealmCodeFileResult({
+					fileUrl,
+					status: "deleted",
+					detail: "Existed before this run; deleted."
+				}))
+			],
+			scriptResult: runnerResult.scriptResult,
+			captures: session.captures.taken.map((viewed) => new commandModule.AttachedImageField({
+				name: viewed.file.name,
+				sourceUrl: viewed.file.sourceUrl,
+				url: viewed.file.url,
+				contentType: viewed.file.contentType,
+				contentHash: viewed.file.contentHash,
+				contentSize: viewed.file.contentSize,
+				width: viewed.width,
+				height: viewed.height
+			})),
+			createdWorkspaces: [...session.createdWorkspaces],
+			deletedWorkspaces: [...session.deletedWorkspaces],
+			indexActions: [...session.indexActions],
+			roomChanges
+		});
+	}
+	async changeRoom(roomId, { skillsToEnable, skillsToDisable, model }) {
+		let changes = [];
+		if (skillsToEnable.length || skillsToDisable.length) try {
+			await new UpdateRoomSkillsTool(this.toolContext).execute({
+				roomId,
+				skillCardIdsToActivate: skillsToEnable,
+				skillCardIdsToDeactivate: skillsToDisable
+			});
+			if (skillsToEnable.length) changes.push(`Enabled skills: ${skillsToEnable.join(", ")}`);
+			if (skillsToDisable.length) changes.push(`Disabled skills: ${skillsToDisable.join(", ")}`);
+		} catch (error) {
+			changes.push(`Skills were not changed: ${coerceErrorMessage(error, "unknown error")}`);
+		}
+		if (model !== void 0) try {
+			await new SetActiveLLMTool(this.toolContext).execute({
+				roomId,
+				model
+			});
+			changes.push(`Model set to ${model}`);
+		} catch (error) {
+			changes.push(`Model was not changed: ${coerceErrorMessage(error, "unknown error")}`);
+		}
+		return changes;
+	}
+	async checkSkill(id) {
+		let source;
+		try {
+			source = await loadSkillSource(this.store, id);
+		} catch (error) {
+			throw new Error(`Unable to load skill ${id}: ${coerceErrorMessage(error, "unknown error")}`);
+		}
+		if (!source) throw new Error(`Not a skill card or skill markdown file: ${id}`);
+	}
+	resultAttachments(result) {
+		return [...(result.files ?? []).flatMap((file) => file?.fileUrl && file.status === "saved" ? [{
+			sourceUrl: file.fileUrl,
+			name: file.fileUrl.split("/").pop()
+		}] : []), ...uploadedImages(result.captures)];
+	}
+	async openCreatedWorkspace(session) {
+		let url = session.createdWorkspaces.filter((created) => !session.goneWorkspaces.has(created)).at(-1);
+		if (!url || session.saved.size > 0) return;
+		try {
+			await this.operatorModeStateService.openWorkspace(url);
+		} catch (error) {
+			log.warn(`Could not open new workspace ${url}`, error);
+		}
+	}
+	async showCard(session, scriptResult) {
+		let value;
+		try {
+			value = JSON.parse(scriptResult);
+		} catch {
+			return {};
+		}
+		if (!value || typeof value !== "object" || Array.isArray(value) || !("show" in value)) return {};
+		let cardId;
+		try {
+			cardId = session.cardURL(value.show);
+			if ((await this.cardService.getSource(rri(`${cardId}.json`))).status !== 200) {
+				if ((await this.cardService.getSource(rri(cardId))).status !== 200) throw new Error(`Not found: ${cardId}`);
+				await new ShowFileTool(this.toolContext).execute({ fileIdentifier: cardId });
+				return { shownCard: cardId };
+			}
+			let card = await this.store.getWithoutCache(cardId);
+			if (!isCardInstance(card)) throw new Error(`${cardId} is not a card instance: ${card.message}`);
+			await new ShowCardTool(this.toolContext).execute({ cardId });
+		} catch (error) {
+			return { showError: `The card was not shown. ${error instanceof Error ? error.message : String(error)}` };
+		}
+		return { shownCard: cardId };
+	}
+	moduleURL(module) {
+		let { virtualNetwork } = this.network;
+		return virtualNetwork.isRegisteredPrefix(module) ? virtualNetwork.toURL(module).href : module;
+	}
+	async applyUiAction(action, realmURL) {
+		let target;
+		try {
+			switch (action.action) {
+				case "switchSubmode":
+					target = action.submode;
+					await new SwitchSubmodeTool(this.toolContext).execute({ submode: action.submode });
+					break;
+				case "openFile":
+					target = action.url;
+					await new SwitchSubmodeTool(this.toolContext).execute({
+						submode: "code",
+						codePath: action.url
+					});
+					break;
+				case "previewFormat":
+					target = `${action.cardId} (${action.format})`;
+					await new PreviewFormatTool(this.toolContext).execute({
+						cardId: action.cardId,
+						format: action.format,
+						modulePath: this.moduleURL(action.modulePath)
+					});
+					break;
+				case "openWorkspace":
+					target = realmURL;
+					await new OpenWorkspaceTool(this.toolContext).execute({ realmIdentifier: realmURL });
+					break;
+			}
+			return {
+				action: action.action,
+				target,
+				status: "done"
+			};
+		} catch (error) {
+			let detail = error instanceof Error ? error.message : String(error);
+			log.debug(`realm.ui.${action.action} failed: ${detail}`);
+			return {
+				action: action.action,
+				target,
+				status: "failed",
+				detail
+			};
+		}
+	}
+	async captureURL(url, options, doneBy, signal) {
+		let services = {
+			loaderService: this.loaderService,
+			matrixService: this.matrixService,
+			network: this.network,
+			realm: this.realm,
+			realmServer: this.realmServer
+		};
+		return await captureForAgent(await resolveViewTarget(url, services, { signal }), options, services, {
+			deadline: captureDeadline(doneBy),
+			signal
+		});
+	}
+	async writeFile(roomId, url, content, expected, options) {
+		if (options?.lint !== false && /\.(gts|ts)$/.test(url)) {
+			let lint = await new LintAndFixTool(this.toolContext).execute({
+				realm: this.realm.realmOf(rri(url)),
+				fileContent: content,
+				filename: new URL(url).pathname.split("/").pop() || "input.gts"
+			});
+			if (lint.lintErrors?.length) throw new Error(`Lint errors in ${url}: ${lint.lintErrors.join("; ")}`);
+			content = lint.output;
+		}
+		let current = await this.readSource(url);
+		if (expected === void 0) {
+			if (current.status !== 404) throw new Error(`File appeared while the script ran: ${url}`);
+		} else if (current.status !== 200 || current.binary || current.content !== expected) throw new Error(`File changed while the script ran: ${url}`);
+		let clientRequestId = this.toolService.trackAiAssistantCardRequest({
+			action: "run-realm-code",
+			roomId,
+			fileUrl: url
+		});
+		await this.cardService.saveSource(rri(url), content, "bot-patch", {
+			resetLoader: /\.(gts|ts)$/.test(url),
+			clientRequestId
+		});
+		return content;
+	}
+	async saveCards(roomId, realmURL, updates) {
+		let changed = (await Promise.all(updates.map(async ({ url, expected }) => {
+			let current = await this.readSource(url);
+			return current.status !== 200 || current.binary || current.content !== expected ? url : void 0;
+		}))).filter((url) => url !== void 0);
+		if (changed.length > 0) throw new Error(`Cards changed while the script ran: ${changed.join(", ")}; no card update was saved`);
+		let clientRequestId;
+		for (let { url } of updates) clientRequestId = this.toolService.trackAiAssistantCardRequest({
+			action: "run-realm-code",
+			roomId,
+			fileUrl: url,
+			clientRequestId
+		});
+		let response = await this.cardService.executeAtomicOperations(updates.map(({ url, content }) => ({
+			op: "update",
+			href: url,
+			data: {
+				type: "source",
+				attributes: { content },
+				meta: {}
+			}
+		})), ri(realmURL), { clientRequestId });
+		if (!Array.isArray(response?.["atomic:results"])) {
+			let detail = response?.errors?.[0]?.detail;
+			throw new Error(`The card updates were not saved: ${detail ?? "the realm refused the write"}`);
+		}
+	}
+	async readSource(url) {
+		let response = await this.network.authedFetch(url, { headers: { Accept: SupportedMimeType.CardSource } });
+		let { status } = response;
+		if (status !== 200) {
+			await response.body?.cancel();
+			return {
+				status,
+				content: "",
+				binary: false
+			};
+		}
+		if (Number(response.headers.get("content-length")) > MAX_READ_BYTES) {
+			await response.body?.cancel();
+			let contentType = response.headers.get("content-type");
+			let binary = !!contentType && isBinaryContentType(contentType);
+			return {
+				status,
+				content: "",
+				binary,
+				tooLarge: !binary
+			};
+		}
+		let bytes = new Uint8Array(await response.arrayBuffer());
+		try {
+			return {
+				status,
+				content: UTF8.decode(bytes),
+				binary: false
+			};
+		} catch {
+			return {
+				status,
+				content: "",
+				binary: true
+			};
+		}
+	}
+	async writeBinaryFile(roomId, url, bytes) {
+		if ((await this.readSource(url)).status !== 404) throw new Error(`File appeared while the script ran: ${url}`);
+		let clientRequestId = this.toolService.trackAiAssistantCardRequest({
+			action: "run-realm-code",
+			roomId,
+			fileUrl: url
+		});
+		if (clientRequestId) this.cardService.clientRequestIds.add(clientRequestId);
+		let response = await this.network.authedFetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/octet-stream",
+				...clientRequestId ? { "X-Boxel-Client-Request-Id": clientRequestId } : {}
+			},
+			body: new Blob([bytes])
+		});
+		if (!response.ok) {
+			let text = "";
+			try {
+				text = (await response.text()).slice(0, 500);
+			} catch {}
+			let wafRule = response.headers.get("x-blocked-by-waf-rule");
+			throw new Error([
+				`Unable to save ${url}: ${response.status} ${response.statusText}`,
+				wafRule ? `WAF rule: ${wafRule}` : null,
+				text || null
+			].filter(Boolean).join(" | "));
+		}
+	}
+	async readCard(id) {
+		let card = await this.store.getWithoutCache(id);
+		if (!isCardInstance(card)) {
+			if (card.awaitingIndex) throw new Error(`Card is not indexed yet: ${id}; read it again in a moment`);
+			throw new Error(card.status === 404 ? `Card not found: ${id}` : `Unable to read card ${id}: ${card.message}`);
+		}
+		let { default: Base64ImageField } = await this.loaderService.loader.import("@cardstack/base/base64-image");
+		return await this.cardService.serializeCard(card, {
+			omitFields: [Base64ImageField],
+			useAbsoluteURL: true,
+			includeComputeds: true
+		});
+	}
+	async deleteFile(url, expected) {
+		if (!(expected === void 0 ? true : "sha256" in expected ? await this.readBinaryDigest(url) === expected.sha256 : await this.readSource(url).then((current) => current.status === 200 && !current.binary && current.content === expected.content))) throw new Error(`File changed while the script ran: ${url}`);
+		await this.cardService.deleteSource(rri(url));
+	}
+	async readBinaryDigest(url) {
+		let response = await this.network.authedFetch(url, { headers: { Accept: SupportedMimeType.CardSource } });
+		if (response.status !== 200 || Number(response.headers.get("content-length")) > MAX_BINARY_FILE_SIZE) {
+			await response.body?.cancel();
+			return;
+		}
+		return await sha256(new Uint8Array(await response.arrayBuffer()));
+	}
+	async generateImage({ prompt, sourceImageUrl, llmModel, signal }) {
+		return await generateImage({
+			prompt,
+			sourceImageDataUrl: sourceImageUrl ? await sourceImageDataUrl(sourceImageUrl, (url) => this.network.authedFetch(url, { signal })) : void 0,
+			model: llmModel
+		}, ({ url, requestBody }) => this.realmServer.requestForward({
+			url,
+			method: "POST",
+			requestBody,
+			signal
+		}));
+	}
+	async downloadFile(sourceUrl, maxBytes, signal) {
+		let response = await this.network.authedFetch(sourceUrl, {
+			method: "GET",
+			signal
+		});
+		if (!response.ok) {
+			await response.body?.cancel().catch(() => void 0);
+			throw new Error(`Unable to download ${sourceUrl}: ${response.status} ${response.statusText}`);
+		}
+		if (Number(response.headers.get("content-length")) > maxBytes) {
+			await response.body?.cancel().catch(() => void 0);
+			throw new DownloadTooLarge();
+		}
+		if (!response.body) {
+			let bytes = new Uint8Array(await response.arrayBuffer());
+			if (bytes.byteLength > maxBytes) throw new DownloadTooLarge();
+			return bytes;
+		}
+		let reader = response.body.getReader();
+		let chunks = [];
+		let total = 0;
+		for (;;) {
+			let { done, value } = await reader.read();
+			if (done || !value) break;
+			total += value.byteLength;
+			if (total > maxBytes) {
+				await reader.cancel().catch(() => void 0);
+				throw new DownloadTooLarge();
+			}
+			chunks.push(value);
+		}
+		let bytes = new Uint8Array(total);
+		let offset = 0;
+		for (let chunk of chunks) {
+			bytes.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return bytes;
+	}
+	async listDirectory(url) {
+		let response = await this.network.authedFetch(url, { headers: { Accept: SupportedMimeType.DirectoryListing } });
+		if (!response.ok) return {
+			status: response.status,
+			entries: []
+		};
+		let { data } = await response.json();
+		return {
+			status: 200,
+			entries: Object.entries(data.relationships ?? {}).map(([name, info]) => ({
+				name: name.replace(/\/$/, ""),
+				kind: info.meta?.kind === "directory" ? "directory" : "file"
+			}))
+		};
+	}
+	realmOfInput(realmId) {
+		let realm = this.realm.realmOf(realmId);
+		if (realm) return realm;
+		try {
+			return this.realm.realmOf(this.network.virtualNetwork.toURL(realmId));
+		} catch {
+			return;
+		}
+	}
+	realmRootURL(realm) {
+		let { virtualNetwork } = this.network;
+		return virtualNetwork.isRegisteredPrefix(realm) ? virtualNetwork.toURL(realm).href : new URL(realm).href;
+	}
+	assertKnownRealmIdentifiers(realms) {
+		let { virtualNetwork } = this.network;
+		let unknown = (realms ?? []).find((realm) => isPrefixForm(realm) && virtualNetwork.prefixKind(ensureTrailingSlash(realm)) !== "realm");
+		if (unknown !== void 0) throw new Error(`Unknown realm identifier "${unknown}". Pass a realm URL, or one of: ${virtualNetwork.knownRealms().join(", ")}`);
+	}
+};
+//#endregion
+export { imageExtension as a, generateImage as i, run_realm_code_exports as n, sourceImageDataUrl as o, runRealmCode as r, RunRealmCodeTool as t };