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

package/bundled-test-harness/assets/realm-CaK5mkT-.js

@@ -1,2852 +0,0 @@
-import { i as __name, r as __exportAll } from "./chunk-Rp0pCe6z.js";
-import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { An as X_BOXEL_LOGGING_CORRELATION_ID_HEADER, Co as SupportedMimeType, Et as joinDMRoom, Gs as publishRealm, Ks as unpublishRealm, Rc as Deferred, Tt as RealmAuthClient, Us as ReadinessTimeoutError, Ws as fetchPublishabilityReport, X as realmServerAuthorizationMiddleware, Za as fetcher, at as getMatrixUsername, br as REALMS_LIST_UPDATED_EVENT_TYPE, ks as logger, qs as waitForReady } from "./runtime-common-BTaLJEw-.js";
-import { T as rri, a as RealmPaths, s as ensureTrailingSlash, w as ri } from "./paths-C9-NYXnM.js";
-import { O as baseRealm } from "./constants-Icc0nFW-.js";
-import { i as v4 } from "./esm-browser-CIYLo70w.js";
-import { t as config } from "./environment-DIUJgBKt.js";
-import { r as setOwner } from "./owner-CP0__uFm.js";
-import { t as getOwner } from "./owner-BT6cj890.js";
-import { wn as associateDestroyableChild } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { r as service, t as Service } from "./service-LFpJ8EEP.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 { d as RealmServerSessionLocalStorageKey, h as SessionLocalStorageKey } from "./local-storage-keys-CS7XLz7J.js";
-import { n as clearServiceWorkerTokens, o as syncAllTokensToServiceWorker, s as syncTokenToServiceWorker } from "./auth-service-worker-registration-DUIv5x-m.js";
-import { l as didCancel, m as rawTimeout, n as buildTask } from "./async-arrow-runtime-STsj7E8Y.js";
-import { a as TrackedMap, i as TrackedSet, n as TrackedObject, r as TrackedArray } from "./dist-B9tGPKZz.js";
-import { n as tracked, t as cached } from "./tracking-800VJb8b.js";
-import "./dist-DEVZvbin.js";
-import { a as waitForPromise, t as buildWaiter } from "./dist-CSQ-y1Ft.js";
-import { a as realmURLDisplayText, o as resolvedRealmURLHref } from "./realm-utils-C4Js9BAW.js";
-import { n as reportFromRejectionEvent, t as reportFromErrorEvent } from "./error-report-BdUCQetr.js";
-import { n as normalizeEndpoint, t as codeRefURL } from "./client-telemetry-labels-Bu3IpYiW.js";
-import { n as maxTokenRefreshBackoffSec, t as TokenRefreshSchedule } from "./token-refresh-schedule-D8OzMzA2.js";
-//#region app/lib/client-telemetry-env.ts
-function now() {
-	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-}
-function isDocumentHidden() {
-	return typeof document !== "undefined" && document.visibilityState === "hidden";
-}
-function byteLength(s) {
-	try {
-		return new TextEncoder().encode(s).length;
-	} catch {
-		return s.length;
-	}
-}
-function supportedEntryTypes() {
-	return PerformanceObserver.supportedEntryTypes ?? [];
-}
-function nextTick() {
-	return new Promise((resolve) => setTimeout(resolve, 0));
-}
-function isRenderContext() {
-	return Boolean(globalThis.__boxelRenderContext);
-}
-//#endregion
-//#region app/services/client-telemetry.ts
-var client_telemetry_exports = /* @__PURE__ */ __exportAll({
-	createServerRequestTimingMiddleware: () => createServerRequestTimingMiddleware,
-	default: () => ClientTelemetryService
-});
-var FLUSH_INTERVAL_MS = 1e3;
-var KEEPALIVE_INTERVAL_MS = 25e3;
-var HEARTBEAT_INTERVAL_MS = 100;
-var CARD_LOAD_WATCHDOG_MS = 3e4;
-var WEDGE_GAP_MS = 1e4;
-var WEDGE_CORROBORATION_GRACE_MS = 120;
-var WEDGE_CORROBORATION_RETRIES = 2;
-var MAX_BUFFERED_EVENTS = 400;
-var MAX_EVENTS_PER_FLUSH = 400;
-var MAX_FLUSH_BODY_BYTES = 60 * 1024;
-var MAX_LOADED_IDS = 50;
-var MAX_SLOWEST_LOADS = 10;
-var MAX_ERROR_EVENTS_PER_FLUSH = 12;
-var MAX_FOLDED_SIGNATURES = 500;
-var MAX_LOAF_SCRIPTS = 10;
-var MAX_PROFILER_STACKS = 12;
-var MAX_PROFILER_FRAMES = 32;
-var MAX_LOAF_HISTORY = 100;
-var MAX_PROFILER_SAMPLES = 400;
-var PROFILER_SAMPLE_INTERVAL_MS = 50;
-var PROFILER_HARVEST_INTERVAL_MS = 2e3;
-var ClientTelemetryService = class extends Service {
-	static {
-		decorateFieldV2(this.prototype, "realmServer", [service]);
-	}
-	#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "matrixService", [service]);
-	}
-	#matrixService = (initializeDeferredDecorator(this, "matrixService"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "session", [service]);
-	}
-	#session = (initializeDeferredDecorator(this, "session"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "store", [service]);
-	}
-	#store = (initializeDeferredDecorator(this, "store"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "operatorModeStateService", [service]);
-	}
-	#operatorModeStateService = (initializeDeferredDecorator(this, "operatorModeStateService"), void 0);
-	#sessionId = v4();
-	#matrixUserId = null;
-	#buffer = [];
-	#started = false;
-	#testOptIn = false;
-	#flushTimer;
-	#heartbeatTimer;
-	#profilerHarvestTimer;
-	#loafObserver;
-	#longtaskObserver;
-	#profiler;
-	#profilerSampled;
-	#visibilityHandler;
-	#pagehideHandler;
-	#errorHandler;
-	#rejectionHandler;
-	#lastKeepaliveAt = now();
-	#maxGapSinceKeepalive = 0;
-	#lastHeartbeatAt = now();
-	#loafHistory = [];
-	#longtaskHistory = [];
-	#profilerSamples = [];
-	#lastLoadGeneration = 0;
-	#cardLoadWindowOpen = false;
-	#errorDedup = /* @__PURE__ */ new Map();
-	#foldedSignatures = /* @__PURE__ */ new Set();
-	#errorEventsSinceFlush = 0;
-	#reportingError = false;
-	constructor(owner) {
-		super(owner);
-		this.session.register(this);
-		this.start();
-		registerDestructor(this, () => this.teardown());
-	}
-	teardown() {
-		try {
-			this.#flush("teardown");
-		} finally {
-			this.stop();
-		}
-	}
-	get isEnabled() {
-		return this.#started;
-	}
-	enableForTest() {
-		this.#testOptIn = true;
-		this.start();
-	}
-	drainBufferForTest() {
-		let events = this.#buffer;
-		this.#buffer = [];
-		this.#forgetErrorEvents(events);
-		return events;
-	}
-	sessionStarted() {
-		this.#captureMatrixUserId();
-		this.start();
-	}
-	resetState() {
-		try {
-			this.#flush("reset");
-		} finally {
-			this.#buffer = [];
-			this.#matrixUserId = null;
-			this.stop();
-		}
-	}
-	recordEvent(evt) {
-		if (!this.#started) return;
-		try {
-			this.#push({
-				...evt,
-				ts: Date.now()
-			});
-		} catch (e) {
-			console.error("client-telemetry recordEvent failed", e);
-		}
-	}
-	recordServerRequestTiming(req, response, durationMs, retried) {
-		if (!this.#started) return;
-		try {
-			let realm = response.headers.get("x-boxel-realm-url") || null;
-			let searchCache = response.headers.get("x-boxel-live-search-cache");
-			let contentLength = response.headers.get("content-length");
-			let respBytes = contentLength ? Number(contentLength) : 0;
-			let endpoint = normalizeEndpoint(req.url, req.method);
-			if (retried) for (let i = this.#buffer.length - 1; i >= 0; i--) {
-				let ev = this.#buffer[i];
-				if (ev.event_type === "server-request" && ev.endpoint === endpoint && ev.status === 401) {
-					this.#buffer.splice(i, 1);
-					break;
-				}
-			}
-			this.recordEvent({
-				event_type: "server-request",
-				endpoint,
-				method: req.method,
-				status: response.status,
-				duration_ms: Math.round(durationMs),
-				resp_bytes: Number.isFinite(respBytes) ? respBytes : 0,
-				correlation_id: req.headers.get("x-boxel-logging-correlation-id") || null,
-				retried,
-				realm,
-				...searchCache ? { search_cache: searchCache } : {}
-			});
-		} catch (e) {
-			console.error("client-telemetry recordServerRequestTiming failed", e);
-		}
-	}
-	recordDeserialize(args) {
-		if (!this.#started) return;
-		try {
-			let { durationMs, doc, resource } = args;
-			let stamped = doc?.[Symbol.for("boxel-doc-response-bytes")];
-			let docBytes = typeof stamped === "number" ? stamped : 0;
-			let included = doc?.included;
-			let realm = typeof resource?.meta?.realmURL === "string" ? resource.meta.realmURL : null;
-			this.recordEvent({
-				event_type: "deserialize",
-				duration_ms: Math.round(durationMs),
-				doc_bytes: docBytes,
-				included_count: Array.isArray(included) ? included.length : 0,
-				card_type: codeRefURL(resource?.meta?.adoptsFrom, resource?.id),
-				realm
-			});
-		} catch (e) {
-			console.error("client-telemetry recordDeserialize failed", e);
-		}
-	}
-	start() {
-		if (this.#started || !this.#isAllowed()) return;
-		this.#started = true;
-		this.#captureMatrixUserId();
-		this.#lastLoadGeneration = this.#safeLoadGeneration();
-		let n = now();
-		this.#lastKeepaliveAt = n;
-		this.#lastHeartbeatAt = n;
-		this.#maxGapSinceKeepalive = 0;
-		this.#startFlushLoop();
-		this.#startHeartbeat();
-		this.#startWedgeObservers();
-		this.#startProfiler();
-		this.#attachLifecycleListeners();
-	}
-	stop() {
-		if (!this.#started) return;
-		this.#started = false;
-		if (this.#flushTimer !== void 0) {
-			clearInterval(this.#flushTimer);
-			this.#flushTimer = void 0;
-		}
-		if (this.#heartbeatTimer !== void 0) {
-			clearInterval(this.#heartbeatTimer);
-			this.#heartbeatTimer = void 0;
-		}
-		if (this.#profilerHarvestTimer !== void 0) {
-			clearInterval(this.#profilerHarvestTimer);
-			this.#profilerHarvestTimer = void 0;
-		}
-		if (this.#loafObserver) {
-			try {
-				this.#loafObserver.disconnect();
-			} catch {}
-			this.#loafObserver = void 0;
-		}
-		if (this.#longtaskObserver) {
-			try {
-				this.#longtaskObserver.disconnect();
-			} catch {}
-			this.#longtaskObserver = void 0;
-		}
-		if (this.#profiler) {
-			let p = this.#profiler;
-			this.#profiler = void 0;
-			Promise.resolve().then(() => p.stop()).catch(() => {});
-		}
-		this.#detachLifecycleListeners();
-		this.#loafHistory = [];
-		this.#longtaskHistory = [];
-		this.#profilerSamples = [];
-		this.#cardLoadWindowOpen = false;
-		this.#errorDedup.clear();
-		this.#foldedSignatures.clear();
-		this.#errorEventsSinceFlush = 0;
-	}
-	#isAllowed() {
-		if (isRenderContext()) return false;
-		if (isTesting() && !this.#testOptIn) return false;
-		if (typeof window === "undefined" || typeof setInterval !== "function") return false;
-		return true;
-	}
-	#captureMatrixUserId() {
-		try {
-			this.#matrixUserId = this.matrixService.userId ?? null;
-		} catch {
-			this.#matrixUserId = null;
-		}
-	}
-	#safeLoadGeneration() {
-		try {
-			return this.store.loadGeneration ?? 0;
-		} catch {
-			return 0;
-		}
-	}
-	#startFlushLoop() {
-		this.#flushTimer = setInterval(() => {
-			try {
-				this.#onFlushTick();
-			} catch (e) {
-				console.error("client-telemetry flush tick failed", e);
-			}
-		}, FLUSH_INTERVAL_MS);
-	}
-	#onFlushTick() {
-		if (this.#buffer.some((e) => e.event_type !== "keepalive")) {
-			this.#flush("signal");
-			this.#lastKeepaliveAt = now();
-			this.#maxGapSinceKeepalive = 0;
-			return;
-		}
-		let elapsed = now() - this.#lastKeepaliveAt;
-		if (elapsed >= KEEPALIVE_INTERVAL_MS) {
-			this.recordEvent({
-				event_type: "keepalive",
-				window_ms: Math.round(elapsed),
-				max_gap_ms: Math.round(this.#maxGapSinceKeepalive)
-			});
-			this.#lastKeepaliveAt = now();
-			this.#maxGapSinceKeepalive = 0;
-			this.#flush("keepalive");
-		}
-	}
-	#flush(_reason) {
-		if (this.#buffer.length === 0) return;
-		let token;
-		try {
-			token = this.realmServer.token;
-		} catch {
-			token = void 0;
-		}
-		if (!token) return;
-		let origin;
-		try {
-			origin = this.realmServer.url.origin;
-		} catch {
-			return;
-		}
-		let chunk = this.#buffer.slice(0, MAX_EVENTS_PER_FLUSH);
-		let body = this.#buildBody(chunk);
-		while (chunk.length > 1 && byteLength(body) > MAX_FLUSH_BODY_BYTES) {
-			chunk = chunk.slice(0, Math.ceil(chunk.length / 2));
-			body = this.#buildBody(chunk);
-		}
-		this.#buffer.splice(0, chunk.length);
-		this.#closeErrorWindow(chunk);
-		try {
-			globalThis.fetch(`${origin}/_client-telemetry`, {
-				method: "POST",
-				keepalive: true,
-				headers: {
-					Authorization: `Bearer ${token}`,
-					"Content-Type": "application/json"
-				},
-				body
-			}).catch(() => {});
-		} catch {}
-	}
-	#buildBody(events) {
-		let appVersion = typeof config.APP?.version === "string" ? config.APP.version : void 0;
-		return JSON.stringify({
-			v: 1,
-			session_id: this.#sessionId,
-			matrix_user_id: this.#matrixUserId,
-			env: config.hostedEnvironment,
-			...appVersion ? { app_version: appVersion } : {},
-			events
-		});
-	}
-	#push(evt) {
-		this.#buffer.push(evt);
-		if (this.#buffer.length > MAX_BUFFERED_EVENTS) this.#forgetErrorEvents(this.#buffer.splice(0, this.#buffer.length - MAX_BUFFERED_EVENTS));
-	}
-	#forgetErrorEvents(departed) {
-		if (this.#errorDedup.size > 0 && departed.length > 0) {
-			let gone = new Set(departed);
-			for (let [key, evt] of this.#errorDedup) if (gone.has(evt)) this.#errorDedup.delete(key);
-		}
-		this.#errorEventsSinceFlush = this.#errorDedup.size;
-	}
-	#onWindowError(event) {
-		if (!(event instanceof ErrorEvent)) return;
-		this.#reportError(() => reportFromErrorEvent(event));
-	}
-	#onUnhandledRejection(event) {
-		this.#reportError(() => reportFromRejectionEvent(event));
-	}
-	#reportError(buildReport) {
-		if (!this.#started || this.#reportingError || isRenderContext()) return;
-		this.#reportingError = true;
-		try {
-			let { signature, ...fields } = buildReport();
-			let key = signature;
-			let folded = 0;
-			let pending = this.#errorDedup.get(signature);
-			if (pending) {
-				pending.dedup_count++;
-				return;
-			}
-			if (this.#errorEventsSinceFlush >= MAX_ERROR_EVENTS_PER_FLUSH - 1) {
-				let overflow = this.#errorDedup.get(OVERFLOW_ERROR_KEY);
-				if (overflow) {
-					overflow.dedup_count++;
-					if (!this.#foldedSignatures.has(signature) && this.#foldedSignatures.size < MAX_FOLDED_SIGNATURES) {
-						this.#foldedSignatures.add(signature);
-						overflow.folded_signatures = this.#foldedSignatures.size;
-					}
-					return;
-				}
-				key = OVERFLOW_ERROR_KEY;
-				this.#foldedSignatures.clear();
-				this.#foldedSignatures.add(signature);
-				folded = 1;
-			}
-			let evt = {
-				event_type: "client-error",
-				ts: Date.now(),
-				...fields,
-				dedup_count: 1,
-				folded_signatures: folded,
-				realm: this.#currentCardContext().realm
-			};
-			this.#push(evt);
-			this.#errorDedup.set(key, evt);
-			this.#errorEventsSinceFlush++;
-		} catch (e) {
-			console.error("client-telemetry error report failed", e);
-		} finally {
-			this.#reportingError = false;
-		}
-	}
-	#closeErrorWindow(sent) {
-		this.#errorDedup.delete(OVERFLOW_ERROR_KEY);
-		this.#foldedSignatures.clear();
-		this.#forgetErrorEvents(sent);
-	}
-	#startHeartbeat() {
-		this.#lastHeartbeatAt = now();
-		this.#heartbeatTimer = setInterval(() => {
-			try {
-				this.#onHeartbeat();
-			} catch (e) {
-				console.error("client-telemetry heartbeat failed", e);
-			}
-		}, HEARTBEAT_INTERVAL_MS);
-	}
-	#onHeartbeat() {
-		let n = now();
-		let gap = n - this.#lastHeartbeatAt;
-		this.#lastHeartbeatAt = n;
-		if (isDocumentHidden()) return;
-		if (gap > this.#maxGapSinceKeepalive) this.#maxGapSinceKeepalive = gap;
-		if (gap >= WEDGE_GAP_MS) {
-			let windowStart = n - gap;
-			setTimeout(() => this.#emitWedge(windowStart, n, gap), 0);
-		}
-		this.#pollCardLoad();
-	}
-	#emitWedge(windowStart, windowEnd, gap, retriesLeft = WEDGE_CORROBORATION_RETRIES) {
-		if (!this.#started) return;
-		let loafInWindow = this.#loafHistory.filter((e) => e.startTime >= windowStart && e.startTime <= windowEnd);
-		let longtasksInWindow = this.#longtaskHistory.filter((e) => e.startTime >= windowStart && e.startTime <= windowEnd);
-		if (Boolean(this.#loafObserver || this.#longtaskObserver) && loafInWindow.length === 0 && longtasksInWindow.length === 0) {
-			if (retriesLeft > 0) setTimeout(() => this.#emitWedge(windowStart, windowEnd, gap, retriesLeft - 1), WEDGE_CORROBORATION_GRACE_MS);
-			return;
-		}
-		let blockedMs = 0;
-		let scripts = [];
-		for (let entry of loafInWindow) {
-			blockedMs += entry.blockingDuration || 0;
-			for (let s of entry.scripts) scripts.push({
-				source_url: String(s.sourceURL ?? s.name ?? ""),
-				function_name: String(s.sourceFunctionName ?? ""),
-				char_position: Number(s.sourceCharPosition ?? -1),
-				invoker: String(s.invoker ?? ""),
-				blocking_duration_ms: Math.round(Number(s.duration ?? 0))
-			});
-		}
-		if (loafInWindow.length === 0) for (let entry of longtasksInWindow) blockedMs += entry.duration || 0;
-		scripts.sort((a, b) => b.blocking_duration_ms - a.blocking_duration_ms);
-		let topFrame = scripts[0];
-		let topFrames = scripts.slice(0, 3).map((s) => `${s.function_name || "(anonymous)"} @ ${s.source_url || "?"}:${s.char_position}`).join("  |  ");
-		let longtaskCount = loafInWindow.length > 0 ? loafInWindow.length : longtasksInWindow.length;
-		let profilerStacks = this.#profilerSamplesInWindow(windowStart, windowEnd);
-		this.recordEvent({
-			event_type: "wedge",
-			duration_ms: Math.round(gap),
-			worst_gap_ms: Math.round(gap),
-			blocked_ms: Math.round(blockedMs),
-			longtask_count: longtaskCount,
-			top_frame_function: topFrame?.function_name ?? "",
-			top_frame_url: topFrame?.source_url ?? "",
-			top_frame_char: topFrame?.char_position ?? -1,
-			top_frame_blocked_ms: topFrame?.blocking_duration_ms ?? 0,
-			top_frames: topFrames,
-			loaf_scripts: scripts.slice(0, MAX_LOAF_SCRIPTS),
-			...profilerStacks.length > 0 ? { profiler_stacks: profilerStacks.slice(0, MAX_PROFILER_STACKS) } : {}
-		});
-	}
-	#pollCardLoad() {
-		let gen = this.#safeLoadGeneration();
-		if (gen < this.#lastLoadGeneration) {
-			this.#lastLoadGeneration = gen;
-			this.#cardLoadWindowOpen = false;
-			return;
-		}
-		if (gen > this.#lastLoadGeneration) {
-			let startGeneration = this.#lastLoadGeneration;
-			this.#lastLoadGeneration = gen;
-			if (!this.#cardLoadWindowOpen) this.#openCardLoadWindow(startGeneration);
-		}
-	}
-	#openCardLoadWindow(startGeneration) {
-		this.#cardLoadWindowOpen = true;
-		let startedAt = now();
-		let { cardId, realm } = this.#currentCardContext();
-		this.#awaitCardLoad(startGeneration, startedAt, cardId, realm);
-	}
-	async #awaitCardLoad(startGeneration, startedAt, cardId, realm) {
-		try {
-			await Promise.race([this.store.loaded(), new Promise((resolve) => setTimeout(resolve, CARD_LOAD_WATCHDOG_MS))]);
-			let loadingMs = now() - startedAt;
-			await nextTick();
-			let settleMs = now() - startedAt;
-			let endGeneration = this.#safeLoadGeneration();
-			let numLoads = Math.max(0, endGeneration - startGeneration);
-			let recent = this.#recentCardDocLoads().filter((r) => (r.generation ?? 0) > startGeneration);
-			let loadedIds = recent.map((r) => r.url).slice(0, MAX_LOADED_IDS);
-			let slowest = [...recent].sort((a, b) => b.ms - a.ms).slice(0, MAX_SLOWEST_LOADS).map((r) => ({
-				id: r.url,
-				ms: Math.round(r.ms),
-				outcome: r.outcome ?? "ok"
-			}));
-			this.recordEvent({
-				event_type: "card-load",
-				card_id: cardId,
-				realm,
-				loading_ms: Math.round(loadingMs),
-				settle_ms: Math.round(settleMs),
-				num_loads: numLoads,
-				loaded_ids: loadedIds,
-				slowest_loads: slowest
-			});
-		} catch (e) {
-			console.error("client-telemetry card-load window failed", e);
-		} finally {
-			this.#cardLoadWindowOpen = false;
-		}
-	}
-	#currentCardContext() {
-		let cardId = "";
-		let realm = null;
-		try {
-			let items = this.operatorModeStateService.topMostStackItems();
-			cardId = items[items.length - 1]?.id ?? "";
-		} catch {
-			cardId = "";
-		}
-		try {
-			realm = this.operatorModeStateService.realmURL ?? null;
-		} catch {
-			realm = null;
-		}
-		return {
-			cardId,
-			realm
-		};
-	}
-	#recentCardDocLoads() {
-		try {
-			return this.store.recentCardDocLoads();
-		} catch {
-			return [];
-		}
-	}
-	#startWedgeObservers() {
-		if (typeof PerformanceObserver === "undefined") return;
-		let supported = supportedEntryTypes();
-		if (supported.includes("long-animation-frame")) try {
-			this.#loafObserver = new PerformanceObserver((list) => {
-				for (let entry of list.getEntries()) {
-					let e = entry;
-					this.#loafHistory.push({
-						startTime: e.startTime,
-						duration: e.duration,
-						blockingDuration: e.blockingDuration ?? 0,
-						scripts: Array.isArray(e.scripts) ? e.scripts : []
-					});
-				}
-				if (this.#loafHistory.length > MAX_LOAF_HISTORY) this.#loafHistory.splice(0, this.#loafHistory.length - MAX_LOAF_HISTORY);
-			});
-			this.#loafObserver.observe({
-				type: "long-animation-frame",
-				buffered: true
-			});
-		} catch {
-			this.#loafObserver = void 0;
-		}
-		else if (supported.includes("longtask")) try {
-			this.#longtaskObserver = new PerformanceObserver((list) => {
-				for (let entry of list.getEntries()) this.#longtaskHistory.push({
-					startTime: entry.startTime,
-					duration: entry.duration
-				});
-				if (this.#longtaskHistory.length > MAX_LOAF_HISTORY) this.#longtaskHistory.splice(0, this.#longtaskHistory.length - MAX_LOAF_HISTORY);
-			});
-			this.#longtaskObserver.observe({
-				type: "longtask",
-				buffered: true
-			});
-		} catch {
-			this.#longtaskObserver = void 0;
-		}
-	}
-	#profilerSampledIn() {
-		if (this.#profilerSampled === void 0) {
-			let cfg = config;
-			if (cfg.clientTelemetryProfiler === false) this.#profilerSampled = false;
-			else {
-				let rate = typeof cfg.clientTelemetryProfilerSampleRate === "number" ? cfg.clientTelemetryProfilerSampleRate : config.environment === "production" ? .05 : 1;
-				this.#profilerSampled = rate >= 1 ? true : rate <= 0 ? false : Math.random() < rate;
-			}
-		}
-		return this.#profilerSampled;
-	}
-	#startProfiler() {
-		if (!this.#profilerSampledIn()) return;
-		let ProfilerCtor = globalThis.Profiler;
-		if (typeof ProfilerCtor !== "function") return;
-		if (!this.#spawnProfiler(ProfilerCtor)) return;
-		this.#profilerHarvestTimer = setInterval(() => {
-			this.#harvestProfiler(ProfilerCtor);
-		}, PROFILER_HARVEST_INTERVAL_MS);
-	}
-	#spawnProfiler(ProfilerCtor) {
-		try {
-			this.#profiler = new ProfilerCtor({
-				sampleInterval: PROFILER_SAMPLE_INTERVAL_MS,
-				maxBufferSize: 1e4
-			});
-			return true;
-		} catch {
-			this.#profiler = void 0;
-			return false;
-		}
-	}
-	async #harvestProfiler(ProfilerCtor) {
-		if (!this.#profiler) return;
-		let old = this.#profiler;
-		this.#spawnProfiler(ProfilerCtor);
-		try {
-			let trace = await old.stop();
-			this.#ingestProfilerTrace(trace);
-		} catch {}
-	}
-	#ingestProfilerTrace(trace) {
-		if (!this.#started) return;
-		let t = trace;
-		if (!t?.samples || !t.stacks || !t.frames) return;
-		let { frames, stacks, samples } = t;
-		for (let sample of samples) {
-			let stackFrames = [];
-			let stackId = sample.stackId;
-			let guard = 0;
-			while (stackId != null && guard++ < MAX_PROFILER_FRAMES) {
-				let stack = stacks[stackId];
-				if (!stack) break;
-				let frame = frames[stack.frameId];
-				stackFrames.push(frame?.name || "(anonymous)");
-				stackId = stack.parentId;
-			}
-			this.#profilerSamples.push({
-				sample_ms: sample.timestamp,
-				frames: stackFrames
-			});
-		}
-		if (this.#profilerSamples.length > MAX_PROFILER_SAMPLES) this.#profilerSamples.splice(0, this.#profilerSamples.length - MAX_PROFILER_SAMPLES);
-	}
-	#profilerSamplesInWindow(windowStart, windowEnd) {
-		return this.#profilerSamples.filter((s) => s.sample_ms >= windowStart && s.sample_ms <= windowEnd);
-	}
-	#attachLifecycleListeners() {
-		if (typeof window === "undefined" || !window.addEventListener) return;
-		this.#pagehideHandler = () => this.#flush("pagehide");
-		this.#visibilityHandler = () => {
-			if (typeof document === "undefined") return;
-			if (document.visibilityState === "hidden") this.#flush("hidden");
-			else {
-				this.#lastHeartbeatAt = now();
-				this.#lastLoadGeneration = this.#safeLoadGeneration();
-			}
-		};
-		this.#errorHandler = (event) => this.#onWindowError(event);
-		this.#rejectionHandler = (event) => this.#onUnhandledRejection(event);
-		window.addEventListener("pagehide", this.#pagehideHandler);
-		window.addEventListener("visibilitychange", this.#visibilityHandler);
-		window.addEventListener("error", this.#errorHandler);
-		window.addEventListener("unhandledrejection", this.#rejectionHandler);
-	}
-	#detachLifecycleListeners() {
-		if (typeof window === "undefined" || !window.removeEventListener) return;
-		if (this.#pagehideHandler) {
-			window.removeEventListener("pagehide", this.#pagehideHandler);
-			this.#pagehideHandler = void 0;
-		}
-		if (this.#visibilityHandler) {
-			window.removeEventListener("visibilitychange", this.#visibilityHandler);
-			this.#visibilityHandler = void 0;
-		}
-		if (this.#errorHandler) {
-			window.removeEventListener("error", this.#errorHandler);
-			this.#errorHandler = void 0;
-		}
-		if (this.#rejectionHandler) {
-			window.removeEventListener("unhandledrejection", this.#rejectionHandler);
-			this.#rejectionHandler = void 0;
-		}
-	}
-};
-var requestAttemptCounts = /* @__PURE__ */ new WeakMap();
-function isMatrixRequest(req) {
-	try {
-		return new URL(req.url).pathname.startsWith("/_matrix/");
-	} catch {
-		return false;
-	}
-}
-function readsCorrelationId(owner, req) {
-	if (isMatrixRequest(req)) return false;
-	let url;
-	try {
-		url = new URL(req.url);
-	} catch {
-		return false;
-	}
-	if (typeof window !== "undefined" && url.origin === window.location.origin) return true;
-	let network = owner.lookup("service:network");
-	let real = (virtual) => {
-		try {
-			return network?.virtualNetwork.mapURL(virtual, "virtual-to-real");
-		} catch {
-			return;
-		}
-	};
-	let servesThis = (candidate) => Boolean(candidate && (candidate.origin === url.origin || real(candidate)?.origin === url.origin));
-	if (servesThis(owner.lookup("service:realm-server")?.url)) return true;
-	if (URL.canParse(config.resolvedBaseRealmURL) && new URL(config.resolvedBaseRealmURL).origin === url.origin) return true;
-	let realm = owner.lookup("service:realm");
-	try {
-		if (realm?.realmOf(url)) return true;
-	} catch {}
-	for (let key of realm?.realms.keys() ?? []) {
-		let realmURL;
-		try {
-			realmURL = URL.canParse(key) ? new URL(key) : network?.virtualNetwork.toURL(key);
-		} catch {
-			continue;
-		}
-		if (servesThis(realmURL)) return true;
-	}
-	return false;
-}
-function createServerRequestTimingMiddleware(owner) {
-	return async (req, next) => {
-		if (isRenderContext()) return next(req);
-		let telemetry;
-		try {
-			telemetry = owner.lookup("service:client-telemetry");
-		} catch {
-			return next(req);
-		}
-		if (!telemetry?.isEnabled) return next(req);
-		let attempt = (requestAttemptCounts.get(req) ?? 0) + 1;
-		requestAttemptCounts.set(req, attempt);
-		if (readsCorrelationId(owner, req) && !req.headers.get("x-boxel-logging-correlation-id")) try {
-			req.headers.set(X_BOXEL_LOGGING_CORRELATION_ID_HEADER, v4());
-		} catch {}
-		let start = now();
-		let response = await next(req);
-		telemetry.recordServerRequestTiming(req, response, now() - start, attempt > 1);
-		return response;
-	};
-}
-var OVERFLOW_ERROR_KEY = "overflow";
-//#endregion
-//#region app/utils/assert-never.ts
-var assert_never_exports = /* @__PURE__ */ __exportAll({ assertNever: () => assertNever });
-function assertNever(value) {
-	return /* @__PURE__ */ new Error(`should never happen ${value}`);
-}
-//#endregion
-//#region app/services/realm-server.ts
-var realm_server_exports = /* @__PURE__ */ __exportAll({
-	default: () => RealmServerService,
-	realmClaimsFromRawToken: () => realmClaimsFromRawToken
-});
-var { hostsOwnAssets, resolvedBaseRealmURL } = config;
-var REALM_EVENT_ROOMS_FIRST_RETRY_MS = 2e3;
-var REALM_EVENT_ROOMS_MAX_RETRY_MS = 6e4;
-var REALM_EVENT_ROOMS_PER_REQUEST = 100;
-var RealmServerService = class extends Service {
-	static {
-		decorateFieldV2(this.prototype, "messageService", [service]);
-	}
-	#messageService = (initializeDeferredDecorator(this, "messageService"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "network", [service]);
-	}
-	#network = (initializeDeferredDecorator(this, "network"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "session", [service]);
-	}
-	#session = (initializeDeferredDecorator(this, "session"), 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);
-	auth = { type: "anonymous" };
-	client;
-	availableRealms = new TrackedArray([{
-		type: "base",
-		url: baseRealm.url
-	}]);
-	userCatalogPickList = new TrackedArray([]);
-	archivedRealmsList = new TrackedArray([]);
-	archivedRealmsFetched = false;
-	unreachableRealmServersList = new TrackedArray([]);
-	_ready = new Deferred();
-	eventSubscribers = /* @__PURE__ */ new Map();
-	realmEventRoomsPending = /* @__PURE__ */ new Set();
-	realmEventRoomsRequested = /* @__PURE__ */ new Set();
-	realmEventRoomsRetryMs = REALM_EVENT_ROOMS_FIRST_RETRY_MS;
-	constructor(owner) {
-		super(owner);
-		this.session.register(this);
-		this.fetchCatalogRealms();
-		this.messageService.onFirstSubscription((realm) => this.joinRealmEventRoom(realm));
-		this.subscribeEvent(REALMS_LIST_UPDATED_EVENT_TYPE, async () => {
-			this.reaskRealmEventRooms();
-		});
-	}
-	get ready() {
-		return this._ready.promise;
-	}
-	get canFetch() {
-		return this.client !== void 0 || this.auth.type === "logged-in";
-	}
-	resetState() {
-		let catalogRealms = this.availableRealms.filter((realm) => realm.type === "catalog");
-		this.logout();
-		this.availableRealms = new TrackedArray([{
-			type: "base",
-			url: baseRealm.url
-		}, ...catalogRealms]);
-		this.archivedRealmsList.splice(0, this.archivedRealmsList.length);
-		this.archivedRealmsFetched = false;
-		this.unreachableRealmServersList.splice(0, this.unreachableRealmServersList.length);
-		this.joinRealmEventRoomsTask.cancelAll();
-		this.retryRealmEventRoomsTask.cancelAll();
-		this.realmEventRoomsPending.clear();
-		this.realmEventRoomsRequested.clear();
-		this.realmEventRoomsRetryMs = REALM_EVENT_ROOMS_FIRST_RETRY_MS;
-		this._ready = new Deferred();
-		this._ready.fulfill();
-	}
-	get hasClient() {
-		return Boolean(this.client);
-	}
-	setClient(client) {
-		this.client = client;
-		let stored = src_default.localStorage.getItem(sessionLocalStorageKey) || void 0;
-		let storedUser = stored ? realmClaimsFromRawToken(stored)?.user : void 0;
-		let userId = client.getUserId();
-		if (stored && userId && storedUser !== userId) stored = void 0;
-		this.token = stored;
-	}
-	async createStripeSession(email) {
-		let url = new URL(`${this.url.href}_stripe-session`);
-		url.searchParams.set("email", email);
-		let response = await this.network.fetch(url.href, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${this.token}`
-			}
-		});
-		if (!response.ok) {
-			let err = `Could not create Stripe session: ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-		return response;
-	}
-	async createRealm(args) {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_create-realm`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${this.token}`
-			},
-			body: JSON.stringify({ data: {
-				type: "realm",
-				attributes: args
-			} })
-		});
-		if (!response.ok) {
-			let err = `Could not create realm with endpoint '${args.endpoint}': ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-		let { data: { id: realmURL } } = await response.json();
-		return new URL(realmURL);
-	}
-	async deleteRealm(realmURL) {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_delete-realm`, {
-			method: "DELETE",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${this.token}`
-			},
-			body: JSON.stringify({ data: {
-				type: "realm",
-				id: realmURL
-			} })
-		});
-		if (!response.ok) {
-			let err = `Could not delete realm '${realmURL}': ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-	}
-	async archiveRealm(realmURL) {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_archive-realm`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": SupportedMimeType.JSONAPI,
-				Authorization: `Bearer ${this.token}`
-			},
-			body: JSON.stringify({ data: {
-				type: "realm",
-				id: realmURL
-			} })
-		});
-		if (!response.ok) {
-			let err = `Could not archive realm '${realmURL}': ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-		let identifier = ri(realmURL);
-		await this.setAvailableRealmIdentifiers(this.userRealmIdentifiers.filter((url) => url !== identifier));
-		try {
-			await this.fetchArchivedRealms({ force: true });
-		} catch (err) {
-			console.error(`Failed to refresh archived realms after archiving`, err);
-		}
-	}
-	async unarchiveRealm(realmURL) {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_unarchive-realm`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": SupportedMimeType.JSONAPI,
-				Authorization: `Bearer ${this.token}`
-			},
-			body: JSON.stringify({ data: {
-				type: "realm",
-				id: realmURL
-			} })
-		});
-		if (!response.ok) {
-			let err = `Could not restore realm '${realmURL}': ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-		let identifier = ri(realmURL);
-		let index = this.archivedRealmsList.findIndex((realm) => ri(realm.url) === identifier);
-		if (index >= 0) this.archivedRealmsList.splice(index, 1);
-		await this.setAvailableRealmIdentifiers([identifier, ...this.userRealmIdentifiers]);
-	}
-	endSecureWindowSessions() {
-		let token = this.token;
-		if (!token) return;
-		this.network.fetch(`${this.url.href}_secure-sessions?client=window`, {
-			method: "DELETE",
-			headers: { Authorization: `Bearer ${token}` },
-			keepalive: true,
-			signal: AbortSignal.timeout(secureWindowSignOutTimeoutMs)
-		}).then((response) => {
-			if (!response.ok) console.warn(`Could not sign the secure window out: ${response.status}`);
-		}).catch((e) => {
-			console.warn(`Could not sign the secure window out: ${e}`);
-		});
-	}
-	logout() {
-		this.loginTask.cancelAll();
-		this.tokenRefresher.cancelAll();
-		this.refreshSchedule.reset();
-		this.token = void 0;
-		this.client = void 0;
-		this.loggingIn = void 0;
-		this.reauthenticating = void 0;
-		this.auth = { type: "anonymous" };
-		this.availableRealms.splice(0, this.availableRealms.length, {
-			type: "base",
-			url: baseRealm.url
-		});
-		this.userCatalogPickList.splice(0, this.userCatalogPickList.length);
-		this.unreachableRealmServersList.splice(0, this.unreachableRealmServersList.length);
-		src_default.localStorage.removeItem(sessionLocalStorageKey);
-	}
-	async fetchTokensForAccessibleRealms() {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_realm-auth?include-public=true`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${this.token}`
-			}
-		});
-		if (!response.ok) {
-			let responseText = await response.text();
-			if (config.environment === "development" && responseText.includes("User in JWT not found")) console.error("\x1B[1m\x1B[31m%s\x1B[0m", "Failed to login to realms due to missing entry in the users table. It is likely the user setup is incomplete - run pnpm register-all in matrix package");
-			throw new Error(`Failed to fetch tokens for accessible realms: ${response.status} - ${responseText}`);
-		}
-		return response.json();
-	}
-	async fetchUserRealmsFromTrustedServers(trustedServerURLs) {
-		if (trustedServerURLs.length === 0) return [];
-		this.assertOwnRealmServer(trustedServerURLs);
-		await this.login();
-		let results = await Promise.allSettled(trustedServerURLs.map((serverURL) => this.fetchUserRealmsFromServer(serverURL)));
-		let realmURLs = [];
-		results.forEach((result, index) => {
-			let normalizedServerURL = ensureTrailingSlash(trustedServerURLs[index]);
-			if (result.status === "fulfilled") {
-				realmURLs.push(...result.value);
-				this.markRealmServerReachable(normalizedServerURL);
-			} else {
-				this.markRealmServerUnreachable(normalizedServerURL);
-				console.error(`Failed to fetch user realms from trusted server ${normalizedServerURL}`, result.reason);
-			}
-		});
-		return [...new Set(realmURLs)];
-	}
-	async fetchUserRealmsFromServer(serverURL) {
-		let normalizedServerURL = ensureTrailingSlash(serverURL);
-		let response = await this.network.fetch(`${normalizedServerURL}_realm-auth?include-public=false`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${this.token}`
-			}
-		});
-		if (!response.ok) {
-			let responseText = await response.text();
-			throw new Error(`Failed to fetch user realms from trusted server ${normalizedServerURL}: ${response.status} - ${responseText}`);
-		}
-		let tokens = await response.json();
-		return Object.keys(tokens);
-	}
-	get unreachableRealmServers() {
-		return [...this.unreachableRealmServersList];
-	}
-	static {
-		decorateMethodV2(this.prototype, "unreachableRealmServers", [cached]);
-	}
-	markRealmServerUnreachable(serverURL) {
-		if (!this.unreachableRealmServersList.includes(serverURL)) this.unreachableRealmServersList.push(serverURL);
-	}
-	markRealmServerReachable(serverURL) {
-		let index = this.unreachableRealmServersList.indexOf(serverURL);
-		if (index >= 0) this.unreachableRealmServersList.splice(index, 1);
-	}
-	get availableRealmIdentifiers() {
-		return this.availableRealms.map((r) => ri(r.url));
-	}
-	static {
-		decorateMethodV2(this.prototype, "availableRealmIdentifiers", [cached]);
-	}
-	assertOwnRealmServer(realmServerURLs) {
-		let normalizedOwnRealmServerURL = this.normalizeRealmServerURL(this.realmServer.url.href);
-		let normalizedRealmServerURLs = [...new Set(realmServerURLs.map((url) => this.normalizeRealmServerURL(url)))];
-		if (realmServerURLs.length === 0) throw new Error(`Unable to determine realm server to use`);
-		if (normalizedRealmServerURLs.length > 1 || normalizedRealmServerURLs[0] !== normalizedOwnRealmServerURL) throw new Error(`Multi-realm server support is not yet implemented: don't know how to provide auth token for different realm servers: ${normalizedRealmServerURLs.join()} (own realm server: ${normalizedOwnRealmServerURL})`);
-	}
-	getRealmServersForRealms(realms) {
-		let sessionTokens = this.readSessionTokens();
-		let realmServerURLs = /* @__PURE__ */ new Set();
-		for (let realmURL of realms) {
-			let normalizedRealmURL = ensureTrailingSlash(realmURL);
-			let resolvedRealmURL = resolvedRealmURLHref(this.network.virtualNetwork, normalizedRealmURL);
-			if (isTesting() && new URL(resolvedRealmURL).origin === "http://test-realm") continue;
-			let [token] = this.sessionTokensFor(sessionTokens, realmURL);
-			if (!token) continue;
-			let claims = realmClaimsFromRawToken(token);
-			if (claims?.realmServerURL) realmServerURLs.add(this.normalizeRealmServerURL(claims.realmServerURL));
-		}
-		if (realmServerURLs.size === 0) realmServerURLs.add(this.normalizeRealmServerURL(this.url.href));
-		return [...realmServerURLs];
-	}
-	readSessionTokens() {
-		let sessionStr = src_default.localStorage.getItem("boxel-session") ?? "{}";
-		try {
-			return JSON.parse(sessionStr);
-		} catch {
-			return {};
-		}
-	}
-	normalizeRealmServerURL(url) {
-		let normalizedURL = ensureTrailingSlash(url);
-		if (isTesting()) {
-			if (new URL(normalizedURL).origin === "http://test-realm") return ensureTrailingSlash(new URL(resolvedBaseRealmURL).origin);
-		}
-		return normalizedURL;
-	}
-	get userRealmIdentifiers() {
-		return this.availableRealms.filter((r) => r.type === "user").map((r) => ri(r.url));
-	}
-	static {
-		decorateMethodV2(this.prototype, "userRealmIdentifiers", [cached]);
-	}
-	get catalogRealmIdentifiers() {
-		return this.availableRealms.filter((r) => r.type === "catalog").map((r) => ri(r.url));
-	}
-	static {
-		decorateMethodV2(this.prototype, "catalogRealmIdentifiers", [cached]);
-	}
-	get userCatalogPicks() {
-		return [...this.userCatalogPickList];
-	}
-	get userCatalogRealmIdentifiers() {
-		return this.availableRealms.filter((r) => r.type === "user-catalog").map((r) => ri(r.url));
-	}
-	static {
-		decorateMethodV2(this.prototype, "userCatalogRealmIdentifiers", [cached]);
-	}
-	get displayedCatalogRealmIdentifiers() {
-		return [...this.catalogRealmIdentifiers, ...this.userCatalogRealmIdentifiers];
-	}
-	static {
-		decorateMethodV2(this.prototype, "displayedCatalogRealmIdentifiers", [cached]);
-	}
-	get archivedRealms() {
-		return [...this.archivedRealmsList];
-	}
-	static {
-		decorateMethodV2(this.prototype, "archivedRealms", [cached]);
-	}
-	get isArchivedRealmsFetched() {
-		return this.archivedRealmsFetched;
-	}
-	get availableRealmIndexCardIds() {
-		return this.availableRealmIdentifiers.map((url) => `${url}index`);
-	}
-	static {
-		decorateMethodV2(this.prototype, "availableRealmIndexCardIds", [cached]);
-	}
-	async authenticateToAllAccessibleRealms() {
-		let tokens = await this.fetchTokensForAccessibleRealms();
-		await this.ensureJoinedSessionRoom(tokens);
-		for (let [realmURL, token] of Object.entries(tokens)) this.realm.getOrCreateRealmResource(realmURL, token);
-		this.joinRealmEventRoomsTask.perform();
-	}
-	joinRealmEventRoom(realmIdentifier) {
-		let realmURL = ensureTrailingSlash(resolvedRealmURLHref(this.network.virtualNetwork, realmIdentifier));
-		if (this.realmEventRoomsRequested.has(realmURL)) return;
-		this.realmEventRoomsRequested.add(realmURL);
-		this.realmEventRoomsPending.add(realmURL);
-		this.joinRealmEventRoomsTask.perform();
-	}
-	reaskRealmEventRooms() {
-		this.realmEventRoomsRequested.clear();
-		for (let realm of this.messageService.subscribedRealms()) this.joinRealmEventRoom(realm);
-	}
-	joinRealmEventRoomsTask = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			yield rawTimeout(0);
-			let client = this.client;
-			if (!client || this.realmEventRoomsPending.size === 0) return;
-			let realms = [...this.realmEventRoomsPending].slice(0, REALM_EVENT_ROOMS_PER_REQUEST);
-			for (let realm of realms) this.realmEventRoomsPending.delete(realm);
-			try {
-				yield this.login();
-				let response = yield this.network.fetch(`${this.url.href}_realm-event-rooms`, {
-					method: "POST",
-					headers: {
-						Accept: SupportedMimeType.JSON,
-						"Content-Type": "application/json",
-						Authorization: `Bearer ${this.token}`
-					},
-					body: JSON.stringify({ realms })
-				});
-				let { rooms } = response.ok || response.status === 503 ? yield response.json() : {};
-				for (let roomId of new Set(Object.values(rooms ?? {}))) yield client.joinRoom(roomId);
-				if (!response.ok) throw new Error(`${response.status} from _realm-event-rooms`);
-				this.realmEventRoomsRetryMs = REALM_EVENT_ROOMS_FIRST_RETRY_MS;
-				if (this.realmEventRoomsPending.size > 0) this.joinRealmEventRoomsTask.perform();
-			} catch (e) {
-				for (let realm of realms) this.realmEventRoomsPending.add(realm);
-				console.warn(`Unable to join the realm event rooms of ${realms}`, e);
-				let retryMs = this.realmEventRoomsRetryMs;
-				this.realmEventRoomsRetryMs = Math.min(retryMs * 2, REALM_EVENT_ROOMS_MAX_RETRY_MS);
-				this.retryRealmEventRoomsTask.perform(retryMs);
-			}
-		}
-	}), { keepLatest: true }, "joinRealmEventRoomsTask", null);
-	retryRealmEventRoomsTask = buildTask(() => ({
-		context: this,
-		generator: function* (ms) {
-			yield rawTimeout(ms);
-			this.joinRealmEventRoomsTask.perform();
-		}
-	}), null, "retryRealmEventRoomsTask", "restartable");
-	async ensureJoinedSessionRoom(tokens) {
-		if (!this.client) throw new Error(`Cannot check joined rooms without matrix client`);
-		let { joined_rooms } = await this.client.getJoinedRooms();
-		let joinedRoomSet = new Set(joined_rooms ?? []);
-		for (let [_realmURL, token] of Object.entries(tokens)) {
-			let { sessionRoom } = claimsFromRawToken$1(token);
-			if (!joinedRoomSet.has(sessionRoom)) {
-				await joinDMRoom(this.client, sessionRoom);
-				joinedRoomSet.add(sessionRoom);
-			}
-		}
-	}
-	async setAvailableRealmIdentifiers(userRealmIdentifiers) {
-		await this._ready.promise;
-		this.removeEntries("user", "user-catalog");
-		userRealmIdentifiers.forEach((userRealmIdentifier) => {
-			if (!this.availableRealms.find((r) => r.url === userRealmIdentifier)) this.availableRealms.push({
-				type: "user",
-				url: userRealmIdentifier
-			});
-		});
-		this.addUserCatalogEntries();
-	}
-	setUserCatalogRealmIdentifiers(userCatalogRealmIdentifiers) {
-		this.userCatalogPickList.splice(0, this.userCatalogPickList.length, ...userCatalogRealmIdentifiers);
-		this.removeEntries("user-catalog");
-		this.addUserCatalogEntries();
-	}
-	removeEntries(...types) {
-		for (let i = this.availableRealms.length - 1; i >= 0; i--) if (types.includes(this.availableRealms[i].type)) this.availableRealms.splice(i, 1);
-	}
-	addUserCatalogEntries() {
-		for (let url of this.userCatalogPickList) if (!this.availableRealms.find((r) => r.url === url)) this.availableRealms.push({
-			type: "user-catalog",
-			url
-		});
-	}
-	async fetchPublicRealms() {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_public-realms`, { headers: {
-			Accept: SupportedMimeType.JSONAPI,
-			Authorization: `Bearer ${this.token}`
-		} });
-		if (!response.ok) throw new Error(`Failed to fetch public realms for realm server ${this.url.origin}: ${response.status}`);
-		let { data } = await response.json();
-		return data.map(({ id, attributes }) => ({
-			url: id,
-			...attributes
-		}));
-	}
-	async fetchCatalogRealms() {
-		if (this.catalogRealmIdentifiers.length > 0) return;
-		let response = await this.network.fetch(`${this.url.origin}/_catalog-realms`);
-		if (response.status !== 200) throw new Error(`Failed to fetch public realms for realm server ${this.url.origin}: ${response.status}`);
-		let { data } = await response.json();
-		this.removeEntries("user-catalog");
-		data.forEach((publicRealm) => {
-			if (!this.availableRealms.find((r) => r.url === publicRealm.id)) this.availableRealms.push({
-				type: "catalog",
-				url: publicRealm.id
-			});
-		});
-		this.addUserCatalogEntries();
-		this._ready.fulfill();
-	}
-	async fetchArchivedRealms(opts) {
-		if (this.archivedRealmsFetched && !opts?.force) return;
-		await this.login();
-		let response = await this.network.fetch(`${this.url.origin}/_archived-realms`, { headers: {
-			Accept: SupportedMimeType.JSONAPI,
-			Authorization: `Bearer ${this.token}`
-		} });
-		if (!response.ok) throw new Error(`Failed to fetch archived realms for realm server ${this.url.origin}: ${response.status}`);
-		let { data } = await response.json();
-		let archived = (data ?? []).filter((entry) => Boolean(entry?.id)).map((entry) => ({
-			url: ensureTrailingSlash(entry.id),
-			name: entry.attributes?.name ?? entry.id,
-			iconURL: entry.attributes?.iconURL ?? null,
-			backgroundURL: entry.attributes?.backgroundURL ?? null,
-			archivedAt: entry.attributes?.archivedAt ?? null
-		}));
-		this.archivedRealmsList.splice(0, this.archivedRealmsList.length, ...archived);
-		this.archivedRealmsFetched = true;
-	}
-	async fetchRealmInfos(realmUrls) {
-		if (realmUrls.length === 0) return {
-			data: [],
-			publicReadableRealms: /* @__PURE__ */ new Set()
-		};
-		let uniqueRealmUrls = Array.from(new Set(realmUrls));
-		let realmServerURLs = this.getRealmServersForRealms(uniqueRealmUrls);
-		this.assertOwnRealmServer(realmServerURLs);
-		let [realmServerURL] = realmServerURLs;
-		await this.login();
-		let infoURL = new URL("_federated-info", realmServerURL);
-		let response = await this.authedFetch(infoURL.href, {
-			method: "QUERY",
-			headers: {
-				Accept: SupportedMimeType.RealmInfo,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({ realms: uniqueRealmUrls })
-		});
-		if (!response.ok) {
-			let responseText = await response.text();
-			throw new Error(`Failed to fetch federated realm info: ${response.status} - ${responseText}`);
-		}
-		let publicReadableRealms = /* @__PURE__ */ new Set();
-		let publicReadableHeader = response.headers.get("x-boxel-realms-public-readable");
-		if (publicReadableHeader) for (let value of publicReadableHeader.split(",")) {
-			let trimmed = value.trim();
-			if (trimmed) publicReadableRealms.add(ensureTrailingSlash(trimmed));
-		}
-		return {
-			data: (await response.json()).data ?? [],
-			publicReadableRealms
-		};
-	}
-	async fetchRealmIndexCounts(realmUrls) {
-		if (realmUrls.length === 0) return [];
-		let uniqueRealmUrls = Array.from(new Set(realmUrls));
-		let realmServerURLs = this.getRealmServersForRealms(uniqueRealmUrls);
-		this.assertOwnRealmServer(realmServerURLs);
-		let [realmServerURL] = realmServerURLs;
-		await this.login();
-		let countsURL = new URL("_federated-index-counts", realmServerURL);
-		let response = await this.authedFetch(countsURL.href, {
-			method: "QUERY",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({ realms: uniqueRealmUrls })
-		});
-		if (!response.ok) {
-			let responseText = await response.text();
-			throw new Error(`Failed to fetch realm index counts: ${response.status} - ${responseText}`);
-		}
-		return (await response.json()).data ?? [];
-	}
-	async fetchCardTypeSummaries(realmUrls, options) {
-		if (realmUrls.length === 0) return {
-			data: [],
-			meta: { page: { total: 0 } }
-		};
-		let uniqueRealmUrls = Array.from(new Set(realmUrls));
-		let realmServerURLs = this.getRealmServersForRealms(uniqueRealmUrls);
-		this.assertOwnRealmServer(realmServerURLs);
-		let [realmServerURL] = realmServerURLs;
-		await this.login();
-		let typesURL = new URL("_federated-types", realmServerURL);
-		let body = { realms: uniqueRealmUrls };
-		if (options?.searchKey) body.searchKey = options.searchKey;
-		if (options?.page) body.page = options.page;
-		let response = await this.authedFetch(typesURL.href, {
-			method: "QUERY",
-			headers: {
-				Accept: SupportedMimeType.CardTypeSummary,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify(body)
-		});
-		if (!response.ok) {
-			let responseText = await response.text();
-			throw new Error(`Failed to fetch federated card type summaries: ${response.status} - ${responseText}`);
-		}
-		let json = await response.json();
-		return {
-			data: json.data ?? [],
-			meta: json.meta ?? { page: { total: 0 } }
-		};
-	}
-	async handleEvent(event) {
-		let claims = await this.getClaims();
-		if (event.room_id !== claims.sessionRoom || !event.content) return;
-		let realmServerEvent = JSON.parse(event.content.body);
-		let subscribers = this.eventSubscribers.get(realmServerEvent.eventType);
-		if (subscribers) await Promise.all(subscribers.map(async (subscriber) => {
-			try {
-				await subscriber(realmServerEvent.data);
-			} catch (err) {
-				console.error(`realm-server event subscriber for ${realmServerEvent.eventType} failed`, err);
-			}
-		}));
-	}
-	subscribeEvent(eventType, subscriber) {
-		if (!this.eventSubscribers.has(eventType)) this.eventSubscribers.set(eventType, []);
-		this.eventSubscribers.get(eventType).push(subscriber);
-	}
-	get url() {
-		if (isTesting()) return new URL(config.realmServerURL);
-		let url;
-		if (hostsOwnAssets) url = new URL(resolvedBaseRealmURL).origin;
-		else url = globalThis.location.origin;
-		return new URL(url);
-	}
-	async getClaims() {
-		if (!this.claims) await this.login();
-		if (!this.claims) throw new Error("Failed to get realm server token claims");
-		return this.claims;
-	}
-	get claims() {
-		if (this.auth.type === "logged-in") return this.auth.claims;
-	}
-	get token() {
-		if (this.auth.type === "logged-in") return this.auth.token;
-	}
-	set token(value) {
-		if (value) this.auth = {
-			type: "logged-in",
-			token: value,
-			claims: claimsFromRawToken$1(value)
-		};
-		else this.auth = { type: "anonymous" };
-		src_default.localStorage.setItem(sessionLocalStorageKey, value ?? "");
-		this.tokenRefresher.perform();
-	}
-	tokenRefresher = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			if (!this.claims || !this.token) return;
-			let { exp } = this.claims;
-			let refreshMs = this.refreshSchedule.refreshDelayMs(this.token, exp, (delayMs) => console.error(`RealmServerService - the session minted by ${this.url.href} expires at ${(/* @__PURE__ */ new Date(exp * 1e3)).toISOString()}, too soon to schedule a refresh; minting again in ${delayMs / 1e3}s`));
-			yield this.waitForTokenRefresh(refreshMs);
-			if (!this.loggingIn) {
-				this.loggingIn = this.loginTask.perform();
-				yield this.loggingIn;
-			}
-		}
-	}), null, "tokenRefresher", "restartable");
-	waitForTokenRefresh(ms) {
-		return rawTimeout(ms);
-	}
-	refreshSchedule = new TokenRefreshSchedule();
-	loggingIn;
-	async login() {
-		if (this.auth.type === "logged-in") return;
-		if (!this.loggingIn) this.loggingIn = this.loginTask.perform();
-		await this.loggingIn;
-	}
-	loginTask = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			try {
-				if (!this.client) throw new Error(`Cannot login to realm server without matrix client`);
-				let token = yield new RealmAuthClient(this.url, this.client, this.network.authedFetch.bind(this.network), { authWithRealmServer: true }).getJWT();
-				this.refreshSchedule.minted(token);
-				this.token = token;
-			} catch (e) {
-				if (!this.client) throw e;
-				console.error(`RealmServerService - failed to login to realm: ${e.message}`, e);
-				this.token = void 0;
-			} finally {
-				this.loggingIn = void 0;
-			}
-		}
-	}), null, "loginTask", null);
-	async authedFetch(url, options = {}) {
-		const headers = new Headers(options.headers);
-		headers.set("Authorization", `Bearer ${await this.getToken()}`);
-		return await this.network.fetch(url, {
-			...options,
-			headers
-		});
-	}
-	maybeAuthedFetch(url, options = {}) {
-		const headers = new Headers(options.headers);
-		if (this.token) headers.set("Authorization", `Bearer ${this.token}`);
-		return this.network.fetch(url, {
-			...options,
-			headers
-		});
-	}
-	maybeAuthedFetchForRealms(url, realms, options = {}) {
-		return this.fetcherForRealms(realms)(url, options);
-	}
-	fetcherForRealms(realms) {
-		let timingMiddleware = this.serverRequestTimingMiddleware ??= createServerRequestTimingMiddleware(getOwner(this));
-		return fetcher(this.network.fetch, [realmServerAuthorizationMiddleware(this, realms), timingMiddleware], this.network.virtualNetwork);
-	}
-	serverRequestTimingMiddleware;
-	tokenForRealms(realms) {
-		let sessionToken = this.token;
-		if (sessionToken && !isTokenExpired(sessionToken)) return sessionToken;
-		return this.getRealmTokenForRealms(realms);
-	}
-	async reauthenticateRealmServer(rejectedToken) {
-		if (this.reauthenticating) return this.reauthenticating;
-		if (rejectedToken && this.token && this.token !== rejectedToken) return this.token;
-		if (!this.hasClient) return;
-		this.reauthenticating = (async () => {
-			try {
-				if (!this.loggingIn) this.loggingIn = this.loginTask.perform();
-				await this.loggingIn;
-				return this.token;
-			} catch (e) {
-				console.error(`RealmServerService - failed to reauthenticate to realm server: ${e.message}`, e);
-				return;
-			} finally {
-				this.reauthenticating = void 0;
-			}
-		})();
-		return this.reauthenticating;
-	}
-	reauthenticating;
-	async requestForward(args) {
-		await this.login();
-		let { timeoutMs, signal: callerSignal, ...forwardedRequest } = args;
-		let deadline;
-		let deadlineTimer;
-		if (timeoutMs != null && timeoutMs > 0) {
-			deadline = new AbortController();
-			deadlineTimer = setTimeout(() => deadline.abort(), timeoutMs);
-		}
-		let signal = deadline && callerSignal ? AbortSignal.any([deadline.signal, callerSignal]) : deadline?.signal ?? callerSignal;
-		let responded = false;
-		try {
-			const response = await this.network.fetch(`${this.url.href}_request-forward`, {
-				method: "POST",
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json",
-					Authorization: `Bearer ${this.token}`
-				},
-				body: JSON.stringify(forwardedRequest),
-				signal
-			});
-			responded = true;
-			clearTimeout(deadlineTimer);
-			deadlineTimer = void 0;
-			if (!response.ok) {
-				const errorText = await response.text();
-				throw new Error(`Request forward failed: ${response.status} - ${errorText}`);
-			}
-			return response;
-		} catch (e) {
-			if (!responded && deadline?.signal.aborted) throw new Error(`Request forward timed out after ${timeoutMs}ms`);
-			throw e;
-		} finally {
-			clearTimeout(deadlineTimer);
-		}
-	}
-	async registerBot(username) {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_bot-registration`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/vnd.api+json",
-				Authorization: `Bearer ${this.token}`
-			},
-			body: JSON.stringify({ data: {
-				type: "bot-registration",
-				attributes: { username }
-			} })
-		});
-		if (!response.ok) {
-			let err = `Could not register bot: ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-		return { botRegistrationId: (await response.json()).data.id };
-	}
-	async unregisterBot(botRegistrationId) {
-		await this.login();
-		if (!botRegistrationId) throw new Error("botRegistrationId is required");
-		let response = await this.network.fetch(`${this.url.href}_bot-registration`, {
-			method: "DELETE",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/vnd.api+json",
-				Authorization: `Bearer ${this.token}`
-			},
-			body: JSON.stringify({ data: {
-				type: "bot-registration",
-				id: botRegistrationId
-			} })
-		});
-		if (!response.ok) {
-			let err = `Could not unregister bot: ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-	}
-	async getBotRegistrations() {
-		await this.login();
-		let response = await this.network.fetch(`${this.url.href}_bot-registrations`, {
-			method: "GET",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				Authorization: `Bearer ${this.token}`
-			}
-		});
-		if (!response.ok) {
-			let err = `Could not fetch bot registrations: ${response.status} - ${await response.text()}`;
-			console.error(err);
-			throw new Error(err);
-		}
-		return (await response.json()).data.map((entry) => ({
-			botRegistrationId: entry.id,
-			username: entry.attributes.username,
-			createdAt: entry.attributes.createdAt
-		}));
-	}
-	get realmClient() {
-		return {
-			realmServerURL: ensureTrailingSlash(this.url.href),
-			config: {
-				spaceDomain: config.publishedRealmBoxelSpaceDomain,
-				siteDomain: config.publishedRealmBoxelSiteDomain
-			},
-			authedFetch: (url, init) => this.authedFetch(url, init)
-		};
-	}
-	async publishRealm(sourceRealmURL, publishedRealmURL) {
-		await this.login();
-		return publishRealm(this.realmClient, {
-			sourceRealmURL,
-			publishedRealmURL
-		});
-	}
-	async unpublishRealm(publishedRealmURL) {
-		await this.login();
-		return unpublishRealm(this.realmClient, { publishedRealmURL });
-	}
-	async waitForRealmReady(publishedRealmURL, opts) {
-		await this.login();
-		return waitForReady(this.realmClient, {
-			publishedRealmURL,
-			timeoutMs: opts?.timeoutMs,
-			pollIntervalMs: opts?.pollIntervalMs,
-			onProgress: opts?.onProgress,
-			awaitPrerenderHtml: true
-		});
-	}
-	async checkDomainAvailability(subdomain) {
-		await this.login();
-		let url = new URL(`${this.url.href}_check-boxel-domain-availability`);
-		url.searchParams.set("subdomain", subdomain);
-		let response = await this.realmServer.authedFetch(url.href, {
-			method: "GET",
-			headers: { Accept: "application/json" }
-		});
-		if (!response.ok) {
-			let errorText = await response.text();
-			throw new Error(`Check site name availability failed: ${response.status} - ${errorText}`);
-		}
-		return await response.json();
-	}
-	async fetchBoxelClaimedDomain(sourceRealmURL) {
-		await this.login();
-		let url = new URL(`${this.url.href}_boxel-claimed-domains`);
-		url.searchParams.set("source_realm_url", sourceRealmURL);
-		let response = await this.authedFetch(url.href, {
-			method: "GET",
-			headers: { Accept: SupportedMimeType.JSONAPI }
-		});
-		if (response.status === 404) return null;
-		if (!response.ok) {
-			let errorText = await response.text();
-			throw new Error(`Fetch claimed domain failed: ${response.status} - ${errorText}`);
-		}
-		let { data: { id, attributes } } = await response.json();
-		return {
-			id,
-			hostname: attributes.hostname,
-			subdomain: attributes.subdomain,
-			sourceRealmURL: attributes.sourceRealmURL
-		};
-	}
-	async allocateUnlistedPath(sourceRealmURL, options = {}) {
-		await this.login();
-		let response = await this.authedFetch(`${this.url.href}_unlisted-realm-path`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({
-				sourceRealmURL,
-				regenerate: options.regenerate ?? false
-			})
-		});
-		if (!response.ok) {
-			let errorText = await response.text();
-			throw new Error(`Allocate unlisted link failed: ${response.status} - ${errorText}`);
-		}
-		let { data: { attributes } } = await response.json();
-		return {
-			sourceRealmURL: attributes.sourceRealmURL,
-			slug: attributes.slug
-		};
-	}
-	async deleteBoxelClaimedDomain(claimedDomainId) {
-		await this.login();
-		let response = await this.authedFetch(`${this.url.href}_boxel-claimed-domains/${claimedDomainId}`, { method: "DELETE" });
-		if (response.status === 204) return;
-		if (!response.ok) {
-			let errorText = await response.text();
-			throw new Error(`Delete claimed domain failed: ${response.status} - ${errorText}`);
-		}
-	}
-	async claimBoxelDomain(sourceRealmURL, hostname) {
-		const requestBody = { data: {
-			type: "claimed-domain",
-			attributes: {
-				source_realm_url: sourceRealmURL,
-				hostname
-			}
-		} };
-		const response = await this.realmServer.authedFetch(`${this.url.href}_boxel-claimed-domains`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify(requestBody)
-		});
-		if (!response.ok) throw new Error(await response.text());
-		return response.json();
-	}
-	async createGitHubPR(params) {
-		await this.login();
-		const response = await this.authedFetch(`${this.url.href}_github-pr`, {
-			method: "POST",
-			headers: {
-				Accept: SupportedMimeType.JSONAPI,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({ data: {
-				type: "github-pr",
-				attributes: params
-			} })
-		});
-		if (!response.ok) {
-			const errorText = await response.text();
-			let errorMessage;
-			try {
-				errorMessage = JSON.parse(errorText).errors?.[0]?.detail || errorText;
-			} catch {
-				errorMessage = errorText;
-			}
-			throw new Error(`GitHub PR creation failed: ${response.status} - ${errorMessage}`);
-		}
-		const { data } = await response.json();
-		return data.attributes;
-	}
-	async getToken() {
-		if (!this.token) await this.login();
-		if (!this.token) throw new Error("Failed to get realm server token");
-		return this.token;
-	}
-	sessionTokensFor(sessionTokens, realm) {
-		let { virtualNetwork } = this.network;
-		let normalized = ensureTrailingSlash(realm);
-		let spellings = new Set([
-			normalized,
-			realm,
-			...virtualNetwork.equivalentURLForms(resolvedRealmURLHref(virtualNetwork, normalized))
-		]);
-		return [...new Set([...spellings].map((spelling) => sessionTokens[spelling]).filter((token) => Boolean(token)))];
-	}
-	getRealmTokenForRealms(realms) {
-		let sessionTokens = this.readSessionTokens();
-		for (let realmURL of realms) {
-			let token = this.sessionTokensFor(sessionTokens, realmURL).find((candidate) => !isTokenExpired(candidate));
-			if (token) return token;
-		}
-	}
-};
-var sessionLocalStorageKey = RealmServerSessionLocalStorageKey;
-var secureWindowSignOutTimeoutMs = 1e4;
-function claimsFromRawToken$1(rawToken) {
-	let [_header, payload] = rawToken.split(".");
-	return JSON.parse(atob(payload));
-}
-__name(claimsFromRawToken$1, "claimsFromRawToken");
-function isTokenExpired(rawToken) {
-	let exp = realmClaimsFromRawToken(rawToken)?.exp;
-	return !Number.isFinite(exp) || exp * 1e3 <= Date.now();
-}
-function realmClaimsFromRawToken(rawToken) {
-	try {
-		let [_header, payload] = rawToken.split(".");
-		return JSON.parse(atob(payload));
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region app/services/realm.ts
-var realm_exports = /* @__PURE__ */ __exportAll({
-	PublishPendingError: () => PublishPendingError,
-	UNKNOWN_REALM_NAME: () => UNKNOWN_REALM_NAME,
-	claimsFromRawToken: () => claimsFromRawToken,
-	default: () => RealmService,
-	maxTokenRefreshBackoffSec: () => maxTokenRefreshBackoffSec,
-	minTokenRefreshIntervalSec: () => 30,
-	tokenRefreshPeriodSec: () => 300
-});
-var log = logger("service:realm");
-var indexingWaiter = buildWaiter("realm:incremental-indexing");
-var sessionWaiter = buildWaiter("realm:session-login");
-var UNKNOWN_REALM_NAME = "Unknown Workspace";
-var INDEX_COUNTS_RETRY_MS = 5e3;
-var PublishPendingError = class extends Error {
-	constructor(options) {
-		super("Published, but the site is taking longer than usual to finish rendering. It goes live when rendering finishes.", options);
-		this.name = "PublishPendingError";
-	}
-};
-var RealmResource = class {
-	static {
-		decorateFieldV2(this.prototype, "matrixService", [service]);
-	}
-	#matrixService = (initializeDeferredDecorator(this, "matrixService"), 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, "realmServer", [service]);
-	}
-	#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "info", [tracked]);
-	}
-	#info = (initializeDeferredDecorator(this, "info"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "realmPermissions", [tracked]);
-	}
-	#realmPermissions = (initializeDeferredDecorator(this, "realmPermissions"), void 0);
-	indexingWaiterToken = null;
-	static {
-		decorateFieldV2(this.prototype, "auth", [tracked], function() {
-			return { type: "anonymous" };
-		});
-	}
-	#auth = (initializeDeferredDecorator(this, "auth"), void 0);
-	subscription;
-	static {
-		decorateFieldV2(this.prototype, "_isPublishing", [tracked], function() {
-			return false;
-		});
-	}
-	#_isPublishing = (initializeDeferredDecorator(this, "_isPublishing"), void 0);
-	_publishingRealms = new TrackedArray();
-	_publishProgress = new TrackedMap();
-	_unPublishingRealms = new TrackedArray();
-	constructor(realmURL, token, realmService) {
-		this.realmURL = realmURL;
-		this.realmService = realmService;
-		this.token = token;
-		registerDestructor(this, () => {
-			if (this.subscription) this.subscription.unsubscribe();
-			if (this.indexingWaiterToken) {
-				indexingWaiter.endAsync(this.indexingWaiterToken);
-				this.indexingWaiterToken = null;
-			}
-		});
-	}
-	get isLoggedIn() {
-		return this.auth.type === "logged-in";
-	}
-	get url() {
-		return this.realmURL;
-	}
-	get token() {
-		if (this.auth.type === "logged-in") return this.auth.token;
-	}
-	set token(value) {
-		if (value) this.auth = {
-			type: "logged-in",
-			token: value,
-			claims: claimsFromRawToken(value)
-		};
-		else this.auth = { type: "anonymous" };
-		SessionStorage.persist(this.realmURL, value);
-		this.tokenRefresher.perform();
-	}
-	get isPublic() {
-		return this.info?.isPublic;
-	}
-	get claims() {
-		if (this.auth.type === "logged-in") return this.auth.claims;
-	}
-	get realmClient() {
-		let userId = this.claims?.user;
-		return {
-			realmServerURL: ensureTrailingSlash(this.realmServer.url.href),
-			config: {
-				spaceDomain: config.publishedRealmBoxelSpaceDomain,
-				siteDomain: config.publishedRealmBoxelSiteDomain
-			},
-			matrixUsername: userId ? getMatrixUsername(userId) : void 0,
-			authedFetch: (url, init) => this.network.authedFetch(url, init)
-		};
-	}
-	get canRead() {
-		return !!this.isPublic || !!this.claims?.permissions?.includes("read");
-	}
-	get canWrite() {
-		return !!this.claims?.permissions?.includes("write");
-	}
-	get isRealmOwner() {
-		return !!this.claims?.permissions?.includes("realm-owner");
-	}
-	loggingIn;
-	refreshSchedule = new TokenRefreshSchedule();
-	async login() {
-		if (this.auth.type === "logged-in") {
-			await this.subscribe();
-			return;
-		}
-		if (!this.loggingIn) this.loggingIn = this.loginTask.perform();
-		await this.loggingIn;
-		await this.subscribe();
-	}
-	async subscribe() {
-		if (this.subscription) return;
-		if (!this.fetchingInfo) await this.fetchInfo();
-		this.subscription = { unsubscribe: this.messageService.subscribe(this.realmURL, (event) => {
-			if (!this.info) {
-				console.warn(`No realm info exists for ${this.realmURL} when trying to set indexing status`);
-				return;
-			}
-			if (event.eventName !== "index") return;
-			let data = event;
-			switch (data.indexType) {
-				case "incremental-index-initiation":
-					this.info.isIndexing = true;
-					if (!this.indexingWaiterToken) this.indexingWaiterToken = indexingWaiter.beginAsync(void 0, this.realmURL);
-					break;
-				case "full":
-				case "incremental":
-					this.info.isIndexing = false;
-					if (this.indexingWaiterToken) {
-						indexingWaiter.endAsync(this.indexingWaiterToken);
-						this.indexingWaiterToken = null;
-					}
-					if (data.indexType === "incremental" && data.invalidations.includes(`${this.realmURL}realm`)) this.refreshInfo();
-					if (data.indexType === "incremental" && this.info) this.info.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-					this.realmService.markIndexCountsStale(this.realmURL);
-					break;
-				default: throw assertNever(data);
-			}
-		}) };
-	}
-	loginTask = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			let sessionWaiterToken = sessionWaiter.beginAsync();
-			try {
-				let token = yield this.matrixService.createRealmSession(new URL(this.realmURL));
-				this.refreshSchedule.minted(token);
-				this.token = token;
-			} catch (e) {
-				console.error(`RealmService - Failed to login to realm: ${e.message}`, e);
-				this.token = void 0;
-				const event = new CustomEvent("boxel-auth-error", { detail: e });
-				globalThis.dispatchEvent(event);
-			} finally {
-				this.loggingIn = void 0;
-				sessionWaiter.endAsync(sessionWaiterToken);
-			}
-		}
-	}), null, "loginTask", null);
-	logout() {
-		this.clearRealmSession();
-		this.refreshSchedule.reset();
-		src_default.localStorage.removeItem(SessionLocalStorageKey);
-		syncTokenToServiceWorker(this.realmURL, void 0);
-	}
-	clearRealmSession() {
-		this.auth = { type: "anonymous" };
-		SessionStorage.remove(this.realmURL);
-		syncTokenToServiceWorker(this.realmURL, void 0);
-		this.loginTask.cancelAll();
-		this.tokenRefresher.cancelAll();
-		this.loggingIn = void 0;
-		this.fetchInfoTask.cancelAll();
-		this.fetchingInfo = void 0;
-		this.fetchRealmPermissionsTask.cancelAll();
-	}
-	fetchingInfo;
-	async fetchInfo() {
-		if (!this.fetchingInfo) this.fetchingInfo = this.fetchInfoTask.perform();
-		try {
-			await this.fetchingInfo;
-		} catch (error) {
-			if (!didCancel(error)) throw error;
-		}
-	}
-	fetchInfoTask = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			try {
-				if (this.info) return;
-				yield this.realmService.waitForBulkInfoIfNeeded();
-				if (this.info) return;
-				yield this.realmService.prefetchRealmInfos([this.realmURL]);
-				if (this.info) return;
-				let { info, isPublic } = yield this.fetchInfoFromServer();
-				this.info = new TrackedObject({
-					...info,
-					isIndexing: false,
-					isPublic
-				});
-			} finally {
-				this.fetchingInfo = void 0;
-			}
-		}
-	}), null, "fetchInfoTask", "drop");
-	async fetchInfoFromServer() {
-		let headers = {
-			Accept: SupportedMimeType.RealmInfo,
-			...this.auth.type === "logged-in" ? { Authorization: `Bearer ${this.token}` } : {}
-		};
-		let response;
-		try {
-			response = await this.network.authedFetch(`${this.realmURL}_info`, {
-				method: "QUERY",
-				headers: {
-					...headers,
-					"Content-Type": "application/json"
-				},
-				body: JSON.stringify({ realms: [this.realmURL] })
-			});
-		} catch (error) {
-			if (isTesting()) console.warn(`[realm-service] realm info fetch failed ${JSON.stringify({
-				realmURL: this.realmURL,
-				error: String(error)
-			})}`);
-			throw error;
-		}
-		if (response.status !== 200) {
-			let responseText = await response.text();
-			if (isTesting()) console.warn(`[realm-service] realm info fetch bad status ${JSON.stringify({
-				realmURL: this.realmURL,
-				status: response.status,
-				responseText
-			})}`);
-			throw new Error(`Failed to fetch realm info for ${this.realmURL}: ${response.status}`);
-		}
-		let json = await waitForPromise(response.json());
-		let realmData = Array.isArray(json.data) ? json.data[0] : json.data;
-		return {
-			info: {
-				url: realmData.id,
-				...realmData.attributes
-			},
-			isPublic: Boolean(response.headers.get("x-boxel-realm-public-readable") || response.headers.get("x-boxel-realms-public-readable"))
-		};
-	}
-	refreshInfo() {
-		return this.refreshInfoTask.perform();
-	}
-	refreshInfoTask = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			if (!this.info) {
-				yield this.fetchInfo();
-				return;
-			}
-			let { info, isPublic } = yield this.fetchInfoFromServer();
-			Object.assign(this.info, info, {
-				isPublic,
-				lastPublishedAt: this.info.lastPublishedAt
-			});
-		}
-	}), null, "refreshInfoTask", "restartable");
-	async fetchRealmPermissions() {
-		return await this.fetchRealmPermissionsTask.perform();
-	}
-	fetchRealmPermissionsTask = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			if (this.realmPermissions !== void 0) return this.realmPermissions;
-			yield this.loginTask.perform();
-			let headers = {
-				Accept: SupportedMimeType.Permissions,
-				Authorization: `Bearer ${this.token}`
-			};
-			let response = yield this.network.authedFetch(`${this.realmURL}_permissions`, { headers });
-			if (response.status === 403) {
-				this.realmPermissions = null;
-				return;
-			} else if (response.status !== 200) throw new Error(`Failed to fetch realm permissions for ${this.realmURL}: ${response.status}`);
-			let json = yield waitForPromise(response.json());
-			this.realmPermissions = json.data.attributes.permissions;
-			return this.realmPermissions;
-		}
-	}), null, "fetchRealmPermissionsTask", "drop");
-	async fetchPrivateDependencyReport() {
-		await this.loginTask.perform();
-		return waitForPromise(fetchPublishabilityReport(this.realmClient, { realmURL: this.realmURL }));
-	}
-	tokenRefresher = buildTask(() => ({
-		context: this,
-		generator: function* () {
-			if (globalThis.__boxelRenderContext || !this.claims || !this.token) return;
-			let { exp } = this.claims;
-			let refreshMs = this.refreshSchedule.refreshDelayMs(this.token, exp, (delayMs) => console.error(`RealmService - the session minted for ${this.realmURL} expires at ${(/* @__PURE__ */ new Date(exp * 1e3)).toISOString()}, too soon to schedule a refresh; minting again in ${delayMs / 1e3}s`));
-			yield this.realmService.waitForTokenRefresh(refreshMs);
-			if (!this.loggingIn) {
-				this.loggingIn = this.loginTask.perform();
-				yield this.loggingIn;
-			}
-		}
-	}), null, "tokenRefresher", "restartable");
-	async publish(urls) {
-		if (this._isPublishing) return;
-		try {
-			this._isPublishing = true;
-			let accepted = [];
-			const publishPromises = urls.map(async (url) => {
-				if (this._publishingRealms.includes(url)) return;
-				this._publishingRealms.push(url);
-				try {
-					let result = await this.realmServer.publishRealm(this.url, url);
-					accepted.push(result);
-					try {
-						await this.realmServer.waitForRealmReady(result.publishedRealmURL, { onProgress: (progress) => this._publishProgress.set(url, progress) });
-					} catch (error) {
-						if (error instanceof ReadinessTimeoutError && error.stage === "prerender-html" && !error.stalled) throw new PublishPendingError({ cause: error });
-						throw error;
-					}
-					return result;
-				} catch (error) {
-					console.error(`Error publishing to URL ${url}:`, error);
-					throw error;
-				} finally {
-					this._publishingRealms.splice(this._publishingRealms.indexOf(url), 1);
-					this._publishProgress.delete(url);
-				}
-			});
-			const results = await Promise.allSettled(publishPromises);
-			if (this.info) {
-				let lastPublishedAt = Object.fromEntries(accepted.map((result) => [result.publishedRealmURL, result.lastPublishedAt]));
-				this.info = {
-					...this.info,
-					lastPublishedAt: {
-						...this.info.lastPublishedAt && typeof this.info.lastPublishedAt === "object" ? this.info.lastPublishedAt : {},
-						...lastPublishedAt
-					}
-				};
-			}
-			return results;
-		} catch (error) {
-			console.error(`Error publishing to URLs ${urls}:`, error);
-			return;
-		} finally {
-			this._isPublishing = false;
-		}
-	}
-	get isPublishing() {
-		return this._isPublishing;
-	}
-	get isPublishingToAnyRealms() {
-		return this._publishingRealms.length > 0;
-	}
-	get publishingRealms() {
-		return this._publishingRealms;
-	}
-	publishProgress(publishedRealmURL) {
-		return this._publishProgress.get(publishedRealmURL);
-	}
-	async unpublish(url) {
-		if (this._unPublishingRealms.includes(url)) return;
-		try {
-			this._unPublishingRealms.push(url);
-			await this.realmServer.unpublishRealm(url);
-			if (this.info && this.info.lastPublishedAt && typeof this.info.lastPublishedAt === "object") {
-				delete this.info.lastPublishedAt[url];
-				this.info = { ...this.info };
-			}
-		} catch (error) {
-			console.error(`Error unpublishing from URL ${url}:`, error);
-			throw error;
-		} finally {
-			this._unPublishingRealms.splice(this._unPublishingRealms.indexOf(url), 1);
-		}
-	}
-	isUnpublishingAnyRealms = () => {
-		return this._unPublishingRealms.length > 0;
-	};
-	isUnpublishingRealm = (publishedRealmURL) => {
-		return this._unPublishingRealms.includes(publishedRealmURL);
-	};
-};
-var RealmService = class extends Service {
-	static {
-		decorateFieldV2(this.prototype, "realmServer", [service]);
-	}
-	#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "matrixService", [service]);
-	}
-	#matrixService = (initializeDeferredDecorator(this, "matrixService"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "network", [service]);
-	}
-	#network = (initializeDeferredDecorator(this, "network"), void 0);
-	static {
-		decorateFieldV2(this.prototype, "session", [service]);
-	}
-	#session = (initializeDeferredDecorator(this, "session"), void 0);
-	_realms = this.restoreSessions();
-	currentKnownRealms = new TrackedSet();
-	reauthentications = /* @__PURE__ */ new Map();
-	bulkInfoPromise;
-	indexCountsByRealm = new TrackedMap();
-	inFlightIndexCounts = /* @__PURE__ */ new Set();
-	staleIndexCounts = /* @__PURE__ */ new Set();
-	static {
-		decorateFieldV2(this.prototype, "indexCountsEpoch", [tracked], function() {
-			return 0;
-		});
-	}
-	#indexCountsEpoch = (initializeDeferredDecorator(this, "indexCountsEpoch"), void 0);
-	realmPathsCache = /* @__PURE__ */ new Map();
-	realmOfCache = /* @__PURE__ */ new Map();
-	lastRestoredSessionsString = null;
-	static {
-		decorateFieldV2(this.prototype, "identifyRealmTracker", [tracked], function() {
-			return 0;
-		});
-	}
-	#identifyRealmTracker = (initializeDeferredDecorator(this, "identifyRealmTracker"), void 0);
-	constructor(owner) {
-		super(owner);
-		this.session.register(this);
-	}
-	get realms() {
-		return this._realms;
-	}
-	resetState() {
-		this.logout();
-		this._realms = /* @__PURE__ */ new Map();
-		this.currentKnownRealms = new TrackedSet();
-		this.reauthentications.clear();
-		this.bulkInfoPromise = void 0;
-		this.identifyRealmTracker++;
-		this.realmPathsCache.clear();
-		this.realmOfCache.clear();
-		this.lastRestoredSessionsString = null;
-	}
-	async waitForBulkInfoIfNeeded() {
-		if (this.bulkInfoPromise) await this.bulkInfoPromise;
-	}
-	async ensureRealmMeta(realmURL) {
-		await this.getOrCreateRealmResource(realmURL).fetchInfo();
-	}
-	async login(realmURL) {
-		await this.getOrCreateRealmResource(realmURL).login();
-	}
-	async prefetchRealmInfos(realmUrls) {
-		let uniqueRealmUrls = Array.from(new Set(realmUrls));
-		if (uniqueRealmUrls.length === 0) return;
-		if (!this.realmServer.hasClient) return;
-		if (this.bulkInfoPromise) await this.bulkInfoPromise;
-		let missingRealmUrls = uniqueRealmUrls.filter((realmURL) => {
-			return !this.knownRealm(realmURL, { tracked: false })?.info;
-		});
-		if (missingRealmUrls.length === 0) return;
-		let bulkPromise = (async () => {
-			try {
-				let { data, publicReadableRealms } = await this.realmServer.fetchRealmInfos(missingRealmUrls);
-				let publicReadableSet = new Set(Array.from(publicReadableRealms).map((realmURL) => ensureTrailingSlash(realmURL)));
-				for (let entry of data) {
-					let realmURL = ensureTrailingSlash(entry.id);
-					this.applyRealmInfo(entry.id, entry.attributes, publicReadableSet.has(realmURL));
-				}
-			} catch (error) {
-				log.warn(`Failed to prefetch realm info: ${error}`);
-			}
-		})();
-		this.bulkInfoPromise = bulkPromise;
-		try {
-			await bulkPromise;
-		} finally {
-			if (this.bulkInfoPromise === bulkPromise) this.bulkInfoPromise = void 0;
-		}
-	}
-	indexCounts(realmURL) {
-		return this.indexCountsByRealm.get(ensureTrailingSlash(String(realmURL)));
-	}
-	get indexCountsRevision() {
-		return this.indexCountsEpoch;
-	}
-	markIndexCountsStale(realmURL) {
-		let key = ensureTrailingSlash(realmURL);
-		if (!this.indexCountsByRealm.has(key) && !this.inFlightIndexCounts.has(key)) return;
-		this.staleIndexCounts.add(key);
-		this.indexCountsEpoch++;
-	}
-	loadIndexCounts(realmURLs) {
-		let wanted = Array.from(new Set(realmURLs.map((realmURL) => ensureTrailingSlash(realmURL)))).filter((realmURL) => (!this.indexCountsByRealm.has(realmURL) || this.staleIndexCounts.has(realmURL)) && !this.inFlightIndexCounts.has(realmURL));
-		if (wanted.length === 0) return;
-		for (let realmURL of wanted) {
-			this.staleIndexCounts.delete(realmURL);
-			this.inFlightIndexCounts.add(realmURL);
-		}
-		(async () => {
-			try {
-				let data = await this.realmServer.fetchRealmIndexCounts(wanted);
-				if (this.isDestroyed) return;
-				let returned = /* @__PURE__ */ new Set();
-				for (let entry of data) {
-					let key = ensureTrailingSlash(entry.id);
-					returned.add(key);
-					this.indexCountsByRealm.set(key, entry.attributes);
-				}
-				for (let realmURL of wanted) if (!returned.has(realmURL)) this.staleIndexCounts.add(realmURL);
-			} catch (error) {
-				log.warn(`Failed to fetch realm index counts: ${error}`);
-				if (!this.isDestroyed) for (let realmURL of wanted) this.staleIndexCounts.add(realmURL);
-			} finally {
-				if (!this.isDestroyed) {
-					for (let realmURL of wanted) this.inFlightIndexCounts.delete(realmURL);
-					if (wanted.some((realmURL) => this.staleIndexCounts.has(realmURL))) this.scheduleIndexCountsRetry();
-				}
-			}
-		})();
-	}
-	indexCountsRetryTimer;
-	scheduleIndexCountsRetry() {
-		if (this.indexCountsRetryTimer != null || this.isDestroyed) return;
-		this.indexCountsRetryTimer = setTimeout(() => {
-			this.indexCountsRetryTimer = void 0;
-			if (this.isDestroyed || this.staleIndexCounts.size === 0) return;
-			this.indexCountsEpoch++;
-		}, INDEX_COUNTS_RETRY_MS);
-	}
-	willDestroy() {
-		super.willDestroy();
-		if (this.indexCountsRetryTimer != null) {
-			clearTimeout(this.indexCountsRetryTimer);
-			this.indexCountsRetryTimer = void 0;
-		}
-	}
-	applyRealmInfo(realmURL, info, isPublic) {
-		let resource = this.getOrCreateRealmResource(realmURL);
-		let isIndexing = resource.info?.isIndexing ?? false;
-		resource.info = new TrackedObject({
-			url: realmURL,
-			...info,
-			isIndexing,
-			isPublic
-		});
-	}
-	restoreSessionsFromStorage({ startingVisit = false } = {}) {
-		let sessionsString = src_default.localStorage.getItem(SessionLocalStorageKey);
-		if (!startingVisit && sessionsString === this.lastRestoredSessionsString) return;
-		if (!sessionsString && !startingVisit) {
-			this.lastRestoredSessionsString = sessionsString;
-			return;
-		}
-		let tokens = sessionsString ? JSON.parse(sessionsString) : {};
-		this.lastRestoredSessionsString = sessionsString;
-		if (startingVisit) this.dropSessionsNotCarriedBy(tokens);
-		for (let [realmURL, token] of Object.entries(tokens)) {
-			let resource = this.getOrCreateRealmResource(realmURL, token, { exact: true });
-			if (token && resource.token !== token) resource.token = token;
-		}
-	}
-	dropSessionsNotCarriedBy(tokens) {
-		let vn = this.network.virtualNetwork;
-		let carried = new Set(Object.keys(tokens).map((realmURL) => vn.unresolveURL(realmURL)));
-		let stale = [...this._realms].filter(([realmURL, resource]) => resource.token && !carried.has(vn.unresolveURL(realmURL))).map(([realmURL]) => realmURL);
-		for (let realmURL of stale) this.removeRealm(realmURL);
-	}
-	info = (url) => {
-		url = this.toLookupURL(url);
-		let resource = this.knownRealm(url, { tracked: false });
-		if (!resource) {
-			this.identifyRealm.perform(url).catch((error) => this.swallowBackgroundInfoError(url, "identify", error));
-			this.identifyRealmTracker;
-			return {
-				name: UNKNOWN_REALM_NAME,
-				backgroundURL: null,
-				iconURL: null,
-				showAsCatalog: null,
-				visibility: "private",
-				publishable: null,
-				isIndexing: false,
-				isPublic: false,
-				lastPublishedAt: null,
-				createdAt: null,
-				updatedAt: null
-			};
-		}
-		if (!resource.info) {
-			resource.fetchInfo().catch((error) => this.swallowBackgroundInfoError(url, "fetchInfo", error));
-			return {
-				name: UNKNOWN_REALM_NAME,
-				backgroundURL: null,
-				iconURL: null,
-				showAsCatalog: null,
-				visibility: "private",
-				publishable: null,
-				isIndexing: false,
-				isPublic: false,
-				lastPublishedAt: null,
-				createdAt: null,
-				updatedAt: null
-			};
-		} else return resource.info;
-	};
-	swallowBackgroundInfoError(url, op, error) {
-		if (didCancel(error)) return;
-		log.warn(`background realm-info ${op} failed for ${url}: ${error}`);
-		if (isTesting() && op === "identify") console.warn(`[realm-service] background realm-info load failed ${JSON.stringify({
-			realmURL: url,
-			op,
-			error: String(error)
-		})}`);
-	}
-	async allUsersPermissions(url) {
-		url = this.toLookupURL(url);
-		let resource = this.knownRealm(url);
-		if (!resource) await this.identifyRealm.perform(url);
-		return await resource?.fetchRealmPermissions();
-	}
-	removeRealm(url) {
-		let resource = this._realms.get(url);
-		if (resource) resource.clearRealmSession();
-		else {
-			SessionStorage.remove(url);
-			syncTokenToServiceWorker(url, void 0);
-		}
-		this._realms.delete(url);
-		this.currentKnownRealms.delete(url);
-	}
-	isPublic = (url) => {
-		return this.knownRealm(url)?.isPublic ?? false;
-	};
-	canRead = (url) => {
-		return this.knownRealm(url)?.canRead ?? false;
-	};
-	canWrite = (url) => {
-		return this.knownRealm(url)?.canWrite ?? false;
-	};
-	isRealmOwner = (url) => {
-		return this.knownRealm(url)?.isRealmOwner ?? false;
-	};
-	url = (url) => {
-		return this.knownRealm(url)?.url;
-	};
-	permissions = (url) => {
-		let self = this;
-		return {
-			get canRead() {
-				return self.canRead(url);
-			},
-			get canWrite() {
-				return self.canWrite(url);
-			}
-		};
-	};
-	meta = (url) => {
-		let self = this;
-		return {
-			get info() {
-				return self.info(url);
-			},
-			get canWrite() {
-				return self.canWrite(url);
-			}
-		};
-	};
-	get allRealmsInfo() {
-		const realmsMeta = Object.create(null);
-		for (const [url, _resource] of this.realms.entries()) realmsMeta[url] = this.meta(url);
-		return realmsMeta;
-	}
-	realmOf(input) {
-		let id = input instanceof URL ? rri(input.href) : input;
-		let cached = this.realmOfCache.get(id);
-		if (cached !== void 0) {
-			if (this.realms.has(cached)) return ri(cached);
-			this.realmOfCache.delete(id);
-		}
-		let best = this.knownRealmKey(id);
-		if (best !== void 0) {
-			this.realmOfCache.set(id, best);
-			return ri(best);
-		}
-	}
-	realmURLOf(urlInRealm) {
-		this.identifyRealmTracker;
-		return this.knownRealmKey(this.toLookupURL(urlInRealm));
-	}
-	realmURLTextOf = (urlInRealm) => {
-		let realmURL = this.realmURLOf(urlInRealm);
-		return realmURL ? realmURLDisplayText(this.network.virtualNetwork, realmURL) : void 0;
-	};
-	realmForSessionRoomId(sessionRoomId) {
-		return Array.from(this.realms.values()).find((r) => r.claims?.sessionRoom === sessionRoomId);
-	}
-	get defaultWritableRealm() {
-		let maybePersonalRealm = `${this.realmServer.url.href}${this.matrixService.userName}/personal/`;
-		if (Object.keys(this.allRealmsInfo).find((r) => r === maybePersonalRealm)) return {
-			path: maybePersonalRealm,
-			info: this.allRealmsInfo[maybePersonalRealm].info
-		};
-		let first = Object.entries(this.allRealmsInfo).filter(([, i]) => i.canWrite).sort(([, i], [, j]) => i.info.name.localeCompare(j.info.name))[0];
-		if (!first) {
-			log.debug(`No writable realms found, known realms and writability: ${Object.keys(this.allRealmsInfo).map((realmUrl) => `${realmUrl}: ${this.allRealmsInfo[realmUrl].canWrite}`).join(", ")}`);
-			return null;
-		}
-		return {
-			path: first[0],
-			info: first[1].info
-		};
-	}
-	static {
-		decorateMethodV2(this.prototype, "defaultWritableRealm", [cached]);
-	}
-	get defaultReadableRealm() {
-		if (this.defaultWritableRealm) return this.defaultWritableRealm;
-		let allRealmsInfoEntries = Object.entries(this.allRealmsInfo);
-		if (allRealmsInfoEntries.length > 0) {
-			let firstMeta = allRealmsInfoEntries[0];
-			return {
-				path: firstMeta[0],
-				info: firstMeta[1].info
-			};
-		}
-		return {
-			path: config.resolvedBaseRealmURL,
-			info: this.info(config.resolvedBaseRealmURL)
-		};
-	}
-	static {
-		decorateMethodV2(this.prototype, "defaultReadableRealm", [cached]);
-	}
-	token = (url) => {
-		let resource = this.knownRealm(url, { tracked: false });
-		if (!resource && globalThis.__boxelRenderContext && !isTesting()) {
-			this.restoreSessionsFromStorage();
-			resource = this.knownRealm(url, { tracked: false });
-		}
-		return resource?.token;
-	};
-	logout() {
-		for (let realm of this.realms.values()) realm.logout();
-		this.bulkInfoPromise = void 0;
-		clearServiceWorkerTokens();
-	}
-	dropSessionsNotFor(userId) {
-		for (let resource of this.realms.values()) {
-			let user = resource.claims?.user;
-			if (user && user !== userId) resource.clearRealmSession();
-		}
-		for (let [realmURL, token] of Object.entries(SessionStorage.getAll() ?? {})) {
-			let user = token ? realmClaimsFromRawToken(token)?.user : void 0;
-			if (user && user !== userId) {
-				SessionStorage.remove(realmURL);
-				syncTokenToServiceWorker(realmURL, void 0);
-			}
-		}
-		this.lastRestoredSessionsString = null;
-	}
-	waitForTokenRefresh(ms) {
-		return rawTimeout(ms);
-	}
-	async publish(realmURL, publishedRealmURLs) {
-		return await this.getOrCreateRealmResource(realmURL).publish(publishedRealmURLs);
-	}
-	async fetchPrivateDependencyReport(realmURL) {
-		return await this.getOrCreateRealmResource(realmURL).fetchPrivateDependencyReport();
-	}
-	async unpublish(realmURL, publishedRealmURL) {
-		return await this.getOrCreateRealmResource(realmURL).unpublish(publishedRealmURL);
-	}
-	async cancelIndexingJob(realmURL) {
-		let normalizedRealmURL = ensureTrailingSlash(realmURL);
-		let resource = this.getOrCreateRealmResource(normalizedRealmURL);
-		await resource.login();
-		let headers = new Headers({ Accept: SupportedMimeType.JSON });
-		if (resource.token) headers.set("Authorization", `Bearer ${resource.token}`);
-		let response = await this.network.fetch(`${normalizedRealmURL}_cancel-indexing-job`, {
-			method: "POST",
-			headers
-		});
-		if (response.status === 204) return;
-		let errorText = await response.text();
-		throw new Error(`Cancel indexing job failed: ${response.status} - ${errorText}`);
-	}
-	beginIndexingAnimation(resource) {
-		let wasIndexing = resource.info?.isIndexing ?? false;
-		if (resource.info) resource.info.isIndexing = true;
-		return wasIndexing;
-	}
-	restoreIndexingAnimation(resource, wasIndexing) {
-		if (resource.info) resource.info.isIndexing = wasIndexing;
-	}
-	async reindex(realmURL) {
-		let normalizedRealmURL = ensureTrailingSlash(realmURL);
-		let resource = this.getOrCreateRealmResource(normalizedRealmURL);
-		await resource.login();
-		await resource.fetchInfo();
-		let wasIndexing = this.beginIndexingAnimation(resource);
-		try {
-			let headers = new Headers({ Accept: SupportedMimeType.JSON });
-			if (resource.token) headers.set("Authorization", `Bearer ${resource.token}`);
-			let response = await this.network.fetch(`${normalizedRealmURL}_reindex`, {
-				method: "POST",
-				headers
-			});
-			if (response.status === 204) return;
-			let errorText = await response.text();
-			throw new Error(`Reindex realm failed: ${response.status} - ${errorText}`);
-		} catch (error) {
-			this.restoreIndexingAnimation(resource, wasIndexing);
-			throw error;
-		}
-	}
-	async fullReindex(realmURL) {
-		let normalizedRealmURL = ensureTrailingSlash(realmURL);
-		let resource = this.getOrCreateRealmResource(normalizedRealmURL);
-		await resource.login();
-		await resource.fetchInfo();
-		let wasIndexing = this.beginIndexingAnimation(resource);
-		try {
-			let headers = new Headers({ Accept: SupportedMimeType.JSON });
-			if (resource.token) headers.set("Authorization", `Bearer ${resource.token}`);
-			let response = await this.network.fetch(`${normalizedRealmURL}_full-reindex`, {
-				method: "POST",
-				headers
-			});
-			if (response.status === 204) return;
-			let errorText = await response.text();
-			throw new Error(`Full reindex realm failed: ${response.status} - ${errorText}`);
-		} catch (error) {
-			this.restoreIndexingAnimation(resource, wasIndexing);
-			throw error;
-		}
-	}
-	async invalidateUrls(realmURL, urls) {
-		let normalizedRealmURL = ensureTrailingSlash(realmURL);
-		let resource = this.getOrCreateRealmResource(normalizedRealmURL);
-		await resource.login();
-		let headers = new Headers({
-			Accept: SupportedMimeType.JSONAPI,
-			"Content-Type": SupportedMimeType.JSONAPI
-		});
-		if (resource.token) headers.set("Authorization", `Bearer ${resource.token}`);
-		let dedupedUrls = [...new Set(urls)];
-		let response = await this.network.fetch(`${normalizedRealmURL}_invalidate`, {
-			method: "POST",
-			headers,
-			body: JSON.stringify({ data: {
-				type: "invalidation-request",
-				attributes: { urls: dedupedUrls }
-			} })
-		});
-		if (response.status === 204) return;
-		let errorText = await response.text();
-		throw new Error(`Invalidate urls failed: ${response.status} - ${errorText}`);
-	}
-	isUnpublishingAnyRealms = (realmURL) => {
-		return this.getOrCreateRealmResource(realmURL).isUnpublishingAnyRealms();
-	};
-	isUnpublishingRealm = (realmURL, publishedRealmURL) => {
-		return this.getOrCreateRealmResource(realmURL).isUnpublishingRealm(publishedRealmURL);
-	};
-	isPublishing = (realmURL) => {
-		return this.getOrCreateRealmResource(realmURL).isPublishing;
-	};
-	publishingRealms = (realmURL) => {
-		return this.getOrCreateRealmResource(realmURL).publishingRealms;
-	};
-	publishProgress = (realmURL, publishedRealmURL) => {
-		return this.getOrCreateRealmResource(realmURL).publishProgress(publishedRealmURL);
-	};
-	toLookupURL(url) {
-		let vn = this.network.virtualNetwork;
-		return vn.isRegisteredPrefix(url) ? vn.toURL(url).href : url;
-	}
-	knownRealmKey(id) {
-		let vn = this.network.virtualNetwork;
-		let normalizedId = vn.unresolveURL(id);
-		let best;
-		let bestLength = -1;
-		for (let key of this.realms.keys()) {
-			let normalizedKey = vn.unresolveURL(key);
-			if (normalizedKey.length > bestLength && this.contains(normalizedKey, normalizedId)) {
-				best = key;
-				bestLength = normalizedKey.length;
-			}
-		}
-		return best;
-	}
-	contains(realm, id) {
-		let paths = this.realmPathsCache.get(realm);
-		if (!paths) {
-			paths = new RealmPaths(ri(realm));
-			this.realmPathsCache.set(realm, paths);
-		}
-		return paths.inRealm(id);
-	}
-	knownRealm(url, { tracked = true } = {}) {
-		if (!url) {
-			if (tracked) this.currentKnownRealms.size;
-			return;
-		}
-		let key = this.knownRealmKey(url);
-		if (key) return this.realms.get(key);
-		if (tracked) this.currentKnownRealms.has(url);
-	}
-	async reauthenticate(realmURL) {
-		let inProgressAuthentication = this.reauthentications.get(realmURL);
-		if (inProgressAuthentication) return inProgressAuthentication;
-		let deferred = new Deferred();
-		deferred.promise.catch(() => {});
-		this.reauthentications.set(realmURL, deferred.promise);
-		try {
-			let resource = this.getOrCreateRealmResource(realmURL);
-			resource.clearRealmSession();
-			await resource.login();
-			let result = resource.token;
-			deferred.fulfill(result);
-			return result;
-		} catch (e) {
-			deferred.reject(e);
-			throw e;
-		} finally {
-			this.reauthentications.delete(realmURL);
-		}
-	}
-	createRealmResource(realmURL, token) {
-		let resource = new RealmResource(realmURL, token, this);
-		setOwner(resource, getOwner(this));
-		associateDestroyableChild(this, resource);
-		return resource;
-	}
-	getOrCreateRealmResource(realmURL, token = void 0, { exact = false } = {}) {
-		let resource = exact ? this.registeredRealm(realmURL) : this.knownRealm(realmURL, { tracked: false });
-		if (resource && !resource?.token && token) resource.token = token;
-		if (!resource) {
-			resource = this.createRealmResource(realmURL, token);
-			this._realms.set(realmURL, resource);
-			let normalizedRealm = this.network.virtualNetwork.unresolveURL(realmURL);
-			for (let id of this.realmOfCache.keys()) if (this.contains(normalizedRealm, this.network.virtualNetwork.unresolveURL(id))) this.realmOfCache.delete(id);
-			this.currentKnownRealms.add(realmURL);
-		}
-		return resource;
-	}
-	registeredRealm(realmURL) {
-		let vn = this.network.virtualNetwork;
-		let identity = vn.unresolveURL(realmURL);
-		for (let [key, resource] of this._realms) if (key === realmURL || vn.unresolveURL(key) === identity) return resource;
-	}
-	identifyRealm = buildTask(() => ({
-		context: this,
-		generator: function* (url) {
-			if (this.knownRealm(url, { tracked: false })) return;
-			let realmURL = (yield this.network.authedFetch(url, {
-				method: "HEAD",
-				headers: { Accept: SupportedMimeType.CardJson }
-			})).headers.get("x-boxel-realm-url");
-			if (realmURL) {
-				this.getOrCreateRealmResource(realmURL);
-				this.identifyRealmTracker = 0;
-			}
-		}
-	}), {
-		maxConcurrency: 1,
-		enqueue: true
-	}, "identifyRealm", null);
-	restoreSessions() {
-		let sessions = /* @__PURE__ */ new Map();
-		let tokens = SessionStorage.getAll();
-		if (tokens) {
-			syncAllTokensToServiceWorker(tokens);
-			for (let [realmURL, token] of Object.entries(tokens)) {
-				let resource = this.createRealmResource(realmURL, token);
-				sessions.set(realmURL, resource);
-			}
-		}
-		return sessions;
-	}
-};
-function claimsFromRawToken(rawToken) {
-	let [_header, payload] = rawToken.split(".");
-	return JSON.parse(atob(payload));
-}
-var SessionStorage = {
-	getAll() {
-		let sessionsString = src_default.localStorage.getItem(SessionLocalStorageKey);
-		if (sessionsString) return JSON.parse(sessionsString);
-	},
-	persist(realmURL, token) {
-		let sessionStr = src_default.localStorage.getItem("boxel-session") ?? "{}";
-		let session = JSON.parse(sessionStr);
-		if (session[realmURL] !== token) {
-			session[realmURL] = token;
-			src_default.localStorage.setItem(SessionLocalStorageKey, JSON.stringify(session));
-		}
-		syncTokenToServiceWorker(realmURL, token);
-	},
-	remove(realmURL) {
-		let sessionStr = src_default.localStorage.getItem("boxel-session") ?? "{}";
-		let session = JSON.parse(sessionStr);
-		if (realmURL in session) {
-			delete session[realmURL];
-			src_default.localStorage.setItem(SessionLocalStorageKey, JSON.stringify(session));
-		}
-	}
-};
-//#endregion
-export { realm_exports as a, assert_never_exports as c, claimsFromRawToken as i, client_telemetry_exports as l, RealmService as n, realm_server_exports as o, UNKNOWN_REALM_NAME as r, assertNever as s, PublishPendingError as t, createServerRequestTimingMiddleware as u };