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

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

@@ -0,0 +1,884 @@
+import { r as __exportAll } from "./chunk-CGdGNDIi.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-CYyqkz5q-z3Y1hsJm.js";
+import { Br as logger, It as SupportedMimeType, ca as Deferred, la as ri, ua as rri } from "./runtime-common-C7uLt5dN.js";
+import { A as ensureTrailingSlash, k as RealmPaths } from "./dompurify-runtime-DnZEeRZb.js";
+import { t as config } from "./environment-DTzm0NP_.js";
+import { r as setOwner } from "./owner-DGWjbd-X.js";
+import { t as getOwner } from "./owner-CqZ4C0QN.js";
+import { Ci as associateDestroyableChild, r as service, t as Service } from "./service-DJ87xpDt.js";
+import { n as registerDestructor } from "./destroyable-C10vUaMw.js";
+import { s as assertNever } from "./card-prerender-ClYlSOBU.js";
+import { t as isTesting } from "./runtime-BSthmflw.js";
+import { l as didCancel, s as buildTask, u as rawTimeout } from "./dist-BMY_e58l.js";
+import { n as tracked, t as cached } from "./tracking-Dv1Q4IKh.js";
+import { a as waitForPromise, t as buildWaiter } from "./dist-DNuvI2rD.js";
+import { i as TrackedSet, n as TrackedObject, r as TrackedArray } from "./dist-DLRXwlqz.js";
+import { p as SessionLocalStorageKey, v as src_default } from "./local-storage-keys-wtjuKtZY.js";
+import { n as clearServiceWorkerTokens, o as syncAllTokensToServiceWorker, s as syncTokenToServiceWorker } from "./auth-service-worker-registration-PwmXROKm.js";
+//#region app/services/realm.ts
+var realm_exports = /* @__PURE__ */ __exportAll({
+	UNKNOWN_REALM_NAME: () => UNKNOWN_REALM_NAME,
+	claimsFromRawToken: () => claimsFromRawToken,
+	default: () => RealmService,
+	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 RealmResource = class {
+	static {
+		decorateFieldV2(this.prototype, "matrixService", [service]);
+	}
+	#matrixService;
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network;
+	static {
+		decorateFieldV2(this.prototype, "messageService", [service]);
+	}
+	#messageService;
+	static {
+		decorateFieldV2(this.prototype, "realmServer", [service]);
+	}
+	#realmServer;
+	static {
+		decorateFieldV2(this.prototype, "info", [tracked]);
+	}
+	#info;
+	static {
+		decorateFieldV2(this.prototype, "realmPermissions", [tracked]);
+	}
+	#realmPermissions;
+	static {
+		decorateFieldV2(this.prototype, "auth", [tracked], function() {
+			return { type: "anonymous" };
+		});
+	}
+	#auth;
+	static {
+		decorateFieldV2(this.prototype, "_isPublishing", [tracked], function() {
+			return false;
+		});
+	}
+	#_isPublishing;
+	constructor(realmURL, token, realmService) {
+		this.#matrixService = (initializeDeferredDecorator(this, "matrixService"), void 0);
+		this.#network = (initializeDeferredDecorator(this, "network"), void 0);
+		this.#messageService = (initializeDeferredDecorator(this, "messageService"), void 0);
+		this.#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
+		this.#info = (initializeDeferredDecorator(this, "info"), void 0);
+		this.#realmPermissions = (initializeDeferredDecorator(this, "realmPermissions"), void 0);
+		this.indexingWaiterToken = null;
+		this.#auth = (initializeDeferredDecorator(this, "auth"), void 0);
+		this.#_isPublishing = (initializeDeferredDecorator(this, "_isPublishing"), void 0);
+		this._publishingRealms = new TrackedArray();
+		this._unPublishingRealms = new TrackedArray();
+		this.loginTask = buildTask(() => ({
+			context: this,
+			generator: function* () {
+				let sessionWaiterToken = sessionWaiter.beginAsync();
+				try {
+					let token = yield this.matrixService.createRealmSession(new URL(this.realmURL));
+					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);
+		this.fetchInfoTask = buildTask(() => ({
+			context: this,
+			generator: function* () {
+				try {
+					if (this.info) return;
+					yield this.realmService.waitForBulkInfoIfNeeded();
+					if (this.info) return;
+					let headers = {
+						Accept: SupportedMimeType.RealmInfo,
+						...this.auth.type === "logged-in" ? { Authorization: `Bearer ${this.token}` } : {}
+					};
+					let response;
+					try {
+						response = yield 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 = yield 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 = yield waitForPromise(response.json());
+					let realmData = Array.isArray(json.data) ? json.data[0] : json.data;
+					let info = {
+						url: realmData.id,
+						...realmData.attributes
+					};
+					let isPublic = Boolean(response.headers.get("x-boxel-realm-public-readable") || response.headers.get("x-boxel-realms-public-readable"));
+					this.info = new TrackedObject({
+						...info,
+						isIndexing: false,
+						isPublic
+					});
+				} finally {
+					this.fetchingInfo = void 0;
+				}
+			}
+		}), null, "fetchInfoTask", "drop");
+		this.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");
+		this.setRealmPermissionTask = buildTask(() => ({
+			context: this,
+			generator: function* (userId, permissions) {
+				yield this.loginTask.perform();
+				let headers = {
+					Accept: SupportedMimeType.Permissions,
+					Authorization: `Bearer ${this.token}`
+				};
+				let response = yield this.network.authedFetch(`${this.realmURL}_permissions`, {
+					method: "PATCH",
+					headers,
+					body: JSON.stringify({ data: {
+						type: "permissions",
+						id: this.url,
+						attributes: { permissions: { [userId]: permissions } }
+					} })
+				});
+				if (response.status !== 200) throw new Error(`Failed to set realm permissions for '${userId}:${permissions ? permissions.join() : "null"}' in realm ${this.url}: ${response.status}`);
+				let json = yield waitForPromise(response.json());
+				this.realmPermissions = json.data.attributes.permissions;
+			}
+		}), null, "setRealmPermissionTask", "restartable");
+		this.tokenRefresher = buildTask(() => ({
+			context: this,
+			generator: function* () {
+				if (globalThis.__boxelRenderContext || !this.claims) return;
+				let refreshMs = 0;
+				if (this.claims.sessionRoom) {
+					let expirationMs = this.claims.exp * 1e3;
+					refreshMs = Math.max(expirationMs - Date.now() - 300 * 1e3, 0);
+				}
+				yield rawTimeout(refreshMs);
+				if (!this.loggingIn) {
+					this.loggingIn = this.loginTask.perform();
+					yield this.loggingIn;
+				}
+			}
+		}), null, "tokenRefresher", "restartable");
+		this.isUnpublishingAnyRealms = () => {
+			return this._unPublishingRealms.length > 0;
+		};
+		this.isUnpublishingRealm = (publishedRealmURL) => {
+			return this._unPublishingRealms.includes(publishedRealmURL);
+		};
+		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 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");
+	}
+	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();
+					break;
+				case "full":
+				case "copy":
+				case "incremental":
+					this.info.isIndexing = false;
+					if (this.indexingWaiterToken) {
+						indexingWaiter.endAsync(this.indexingWaiterToken);
+						this.indexingWaiterToken = null;
+					}
+					break;
+				default: throw assertNever(data);
+			}
+		}) };
+	}
+	logout() {
+		this.clearRealmSession();
+		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();
+	}
+	async fetchInfo() {
+		if (!this.fetchingInfo) this.fetchingInfo = this.fetchInfoTask.perform();
+		try {
+			await this.fetchingInfo;
+		} catch (error) {
+			if (!didCancel(error)) throw error;
+		}
+	}
+	async setRealmInfoProperty(property, value) {
+		await this.loginTask.perform();
+		let headers = {
+			Accept: SupportedMimeType.JSON,
+			Authorization: `Bearer ${this.token}`
+		};
+		let response = await this.network.authedFetch(`${this.realmURL}_config`, {
+			method: "PATCH",
+			headers,
+			body: JSON.stringify({ data: {
+				type: "realm-config",
+				id: this.url,
+				attributes: { [property]: value }
+			} })
+		});
+		if (response.status !== 200) throw new Error(`Failed to set realm config property '${property}' for realm ${this.url}: ${response.status}`);
+		let json = await waitForPromise(response.json());
+		let isPublic = Boolean(response.headers.get("x-boxel-realm-public-readable"));
+		let updatedInfo = new TrackedObject({
+			url: json.data.id,
+			...json.data.attributes,
+			isIndexing: this.info?.isIndexing ?? false,
+			isPublic
+		});
+		this.info = updatedInfo;
+	}
+	async fetchRealmPermissions() {
+		return await this.fetchRealmPermissionsTask.perform();
+	}
+	async fetchPrivateDependencyReport() {
+		await this.loginTask.perform();
+		let headers = {
+			Accept: SupportedMimeType.JSONAPI,
+			Authorization: `Bearer ${this.token}`
+		};
+		let response = await this.network.authedFetch(`${this.realmURL}_publishability`, { headers });
+		if (response.status !== 200) throw new Error(`Failed to check private dependencies for ${this.realmURL}: ${response.status}`);
+		let attributes = (await waitForPromise(response.json())).data.attributes;
+		return {
+			publishable: attributes.publishable,
+			realmURL: attributes.realmURL,
+			violations: attributes.violations ?? [],
+			warningTypes: attributes.warningTypes ?? []
+		};
+	}
+	async setRealmPermission(userId, permissions) {
+		return await this.setRealmPermissionTask.perform(userId, permissions);
+	}
+	async publish(urls) {
+		if (this._isPublishing) return;
+		try {
+			this._isPublishing = true;
+			const publishPromises = urls.map(async (url) => {
+				if (this._publishingRealms.includes(url)) return;
+				this._publishingRealms.push(url);
+				try {
+					return await this.realmServer.publishRealm(this.url, url);
+				} catch (error) {
+					console.error(`Error publishing to URL ${url}:`, error);
+					throw error;
+				} finally {
+					this._publishingRealms.splice(this._publishingRealms.indexOf(url), 1);
+				}
+			});
+			const results = await Promise.allSettled(publishPromises);
+			if (this.info) {
+				let lastPublishedAt = results.reduce((acc, result) => {
+					if (result.status === "fulfilled" && result.value) acc[result.value.data.attributes.publishedRealmURL] = result.value.data.attributes.lastPublishedAt;
+					return acc;
+				}, {});
+				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;
+	}
+	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);
+			return;
+		} finally {
+			this._unPublishingRealms.splice(this._unPublishingRealms.indexOf(url), 1);
+		}
+	}
+};
+var RealmService = class extends Service {
+	static {
+		decorateFieldV2(this.prototype, "realmServer", [service]);
+	}
+	#realmServer;
+	static {
+		decorateFieldV2(this.prototype, "matrixService", [service]);
+	}
+	#matrixService;
+	static {
+		decorateFieldV2(this.prototype, "network", [service]);
+	}
+	#network;
+	static {
+		decorateFieldV2(this.prototype, "reset", [service]);
+	}
+	#reset;
+	static {
+		decorateFieldV2(this.prototype, "identifyRealmTracker", [tracked], function() {
+			return 0;
+		});
+	}
+	#identifyRealmTracker;
+	constructor(owner) {
+		super(owner);
+		this.#realmServer = (initializeDeferredDecorator(this, "realmServer"), void 0);
+		this.#matrixService = (initializeDeferredDecorator(this, "matrixService"), void 0);
+		this.#network = (initializeDeferredDecorator(this, "network"), void 0);
+		this.#reset = (initializeDeferredDecorator(this, "reset"), void 0);
+		this._realms = this.restoreSessions();
+		this.currentKnownRealms = new TrackedSet();
+		this.reauthentications = /* @__PURE__ */ new Map();
+		this.#identifyRealmTracker = (initializeDeferredDecorator(this, "identifyRealmTracker"), void 0);
+		this.info = (url) => {
+			if (this.network.virtualNetwork.isRegisteredPrefix(url)) url = this.network.virtualNetwork.toURL(url).href;
+			let resource = this.knownRealm(url, { tracked: false });
+			if (!resource) {
+				this.identifyRealm.perform(url);
+				this.identifyRealmTracker;
+				return {
+					name: UNKNOWN_REALM_NAME,
+					backgroundURL: null,
+					iconURL: null,
+					showAsCatalog: null,
+					visibility: "private",
+					publishable: null,
+					isIndexing: false,
+					isPublic: false,
+					lastPublishedAt: null
+				};
+			}
+			if (!resource.info) {
+				resource.fetchInfo();
+				return {
+					name: UNKNOWN_REALM_NAME,
+					backgroundURL: null,
+					iconURL: null,
+					showAsCatalog: null,
+					visibility: "private",
+					publishable: null,
+					isIndexing: false,
+					isPublic: false,
+					lastPublishedAt: null
+				};
+			} else return resource.info;
+		};
+		this.isPublic = (url) => {
+			return this.knownRealm(url)?.isPublic ?? false;
+		};
+		this.canRead = (url) => {
+			return this.knownRealm(url)?.canRead ?? false;
+		};
+		this.canWrite = (url) => {
+			return this.knownRealm(url)?.canWrite ?? false;
+		};
+		this.isRealmOwner = (url) => {
+			return this.knownRealm(url)?.isRealmOwner ?? false;
+		};
+		this.url = (url) => {
+			return this.knownRealm(url)?.url;
+		};
+		this.permissions = (url) => {
+			let self = this;
+			return {
+				get canRead() {
+					return self.canRead(url);
+				},
+				get canWrite() {
+					return self.canWrite(url);
+				}
+			};
+		};
+		this.meta = (url) => {
+			let self = this;
+			return {
+				get info() {
+					return self.info(url);
+				},
+				get canWrite() {
+					return self.canWrite(url);
+				}
+			};
+		};
+		this.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;
+		};
+		this.isUnpublishingAnyRealms = (realmURL) => {
+			return this.getOrCreateRealmResource(realmURL).isUnpublishingAnyRealms();
+		};
+		this.isUnpublishingRealm = (realmURL, publishedRealmURL) => {
+			return this.getOrCreateRealmResource(realmURL).isUnpublishingRealm(publishedRealmURL);
+		};
+		this.isPublishing = (realmURL) => {
+			return this.getOrCreateRealmResource(realmURL).isPublishing;
+		};
+		this.publishingRealms = (realmURL) => {
+			return this.getOrCreateRealmResource(realmURL).publishingRealms;
+		};
+		this.identifyRealm = buildTask(() => ({
+			context: this,
+			generator: function* (url) {
+				if (this.knownRealm(url, { tracked: false })) return;
+				let realmURL = (yield this.network.authedFetch(url, { method: "HEAD" })).headers.get("x-boxel-realm-url");
+				if (realmURL) {
+					this.getOrCreateRealmResource(realmURL);
+					this.identifyRealmTracker = 0;
+				}
+			}
+		}), {
+			maxConcurrency: 1,
+			enqueue: true
+		}, "identifyRealm", null);
+		this.reset.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++;
+	}
+	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.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;
+		}
+	}
+	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() {
+		let tokens = SessionStorage.getAll();
+		if (!tokens) return;
+		for (let [realmURL, token] of Object.entries(tokens)) {
+			let resource = this.getOrCreateRealmResource(realmURL, token);
+			if (token && resource.token !== token) resource.token = token;
+		}
+	}
+	async allUsersPermissions(url) {
+		if (this.network.virtualNetwork.isRegisteredPrefix(url)) url = this.network.virtualNetwork.toURL(url).href;
+		let resource = this.knownRealm(url);
+		if (!resource) await this.identifyRealm.perform(url);
+		return await resource?.fetchRealmPermissions();
+	}
+	async setPermissions(url, userId, permissions) {
+		await this.knownRealm(url)?.setRealmPermission(userId, permissions);
+	}
+	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);
+	}
+	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;
+		for (const realm of this.realms.keys()) if (new RealmPaths(new URL(realm)).inRealm(id)) return ri(realm);
+	}
+	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]);
+	}
+	logout() {
+		for (let realm of this.realms.values()) realm.logout();
+		this.bulkInfoPromise = void 0;
+		clearServiceWorkerTokens();
+	}
+	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}`);
+	}
+	knownRealm(url, { tracked = true } = {}) {
+		if (!url) {
+			if (tracked) this.currentKnownRealms.size;
+			return;
+		}
+		for (let [key, value] of this.realms) if (url.startsWith(key)) return value;
+		if (tracked) this.currentKnownRealms.has(url);
+	}
+	async reauthenticate(realmURL) {
+		let inProgressAuthentication = this.reauthentications.get(realmURL);
+		if (inProgressAuthentication) return inProgressAuthentication;
+		let deferred = new Deferred();
+		this.reauthentications.set(realmURL, deferred.promise);
+		let resource = this.getOrCreateRealmResource(realmURL);
+		resource.logout();
+		await resource.login();
+		let result = resource.token;
+		deferred.fulfill(result);
+		try {
+			return result;
+		} 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) {
+		let resource = 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);
+			this.currentKnownRealms.add(realmURL);
+		}
+		return resource;
+	}
+	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 i, UNKNOWN_REALM_NAME as n, claimsFromRawToken as r, RealmService as t };