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

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

@@ -1,884 +0,0 @@
-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-DXG8cQEv.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 };