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

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

@@ -0,0 +1,2858 @@
+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;
+	};
+	canPublish = (url) => {
+		return this.isRealmOwner(url) && this.info(url).publishable === true;
+	};
+	isInfoLoaded = (realm) => {
+		return this.knownRealm(this.toLookupURL(realm))?.info !== void 0;
+	};
+	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 };