@powerhousedao/connect-core 6.2.3-dev.82 → 6.2.3-dev.84

package/dist/runtime-LvAkxbdf.js

@@ -0,0 +1,609 @@
+import { getRuntimeConfig } from "./runtime-config.js";
+import { n as resolveRuntimeFlag, t as isRuntimeFlagEnabled } from "./runtime-flag-DvxW_SD4.js";
+import { n as setDriveRelister } from "./backend-auth-gate-DNKg_v4Y.js";
+import { bindPHStoreToWindow, createPHStore, getActivePHStore, getDrives, getFullReactorClient, getPHStore, recordBackendAuthError, setBackendAuth, setDrives, setFullReactorClient } from "@powerhousedao/reactor-browser";
+import { logger } from "document-model";
+import { switchboardOfDrive } from "@powerhousedao/shared/host-tokens";
+import { DriveCollectionId } from "@powerhousedao/reactor";
+import { driveDocumentType } from "@powerhousedao/shared/document-drive";
+//#region src/runtime/multi-reactor-flag.ts
+function isMultiReactorEnabled() {
+	return getRuntimeConfig().connect.instance?.multiReactor ?? false;
+}
+//#endregion
+//#region src/runtime/reactor-worker-flag.ts
+const REACTOR_WORKER_QUERY_KEY = "reactorWorker";
+const REACTOR_WORKER_STORAGE_KEY = "ph:reactorWorker";
+function resolveReactorWorkerEnabled(input) {
+	return resolveRuntimeFlag(input);
+}
+function isReactorWorkerEnabled() {
+	return isRuntimeFlagEnabled({
+		queryKey: REACTOR_WORKER_QUERY_KEY,
+		storageKey: REACTOR_WORKER_STORAGE_KEY,
+		readConfigFlag: () => getRuntimeConfig().connect.instance?.reactorWorker ?? false
+	});
+}
+//#endregion
+//#region src/runtime/reactor-client-mode.ts
+const MODES = /* @__PURE__ */ new Set([
+	"in-process",
+	"worker",
+	"remote",
+	"router"
+]);
+const REACTOR_CLIENT_QUERY_KEY = "reactorClient";
+const REACTOR_CLIENT_STORAGE_KEY = "ph:reactorClient";
+const asMode = (value) => value && MODES.has(value) ? value : void 0;
+function fromTab() {
+	if (typeof window === "undefined") return void 0;
+	let query;
+	try {
+		query = asMode(new URLSearchParams(window.location.search).get(REACTOR_CLIENT_QUERY_KEY));
+	} catch {
+		return;
+	}
+	try {
+		if (query) {
+			window.localStorage.setItem(REACTOR_CLIENT_STORAGE_KEY, query);
+			return query;
+		}
+		return asMode(window.localStorage.getItem(REACTOR_CLIENT_STORAGE_KEY));
+	} catch {
+		return query;
+	}
+}
+function resolveReactorClientMode() {
+	const override = fromTab();
+	if (override) return override;
+	const configured = getRuntimeConfig().connect.instance?.reactorClient;
+	if (configured && MODES.has(configured)) return configured;
+	if (isMultiReactorEnabled()) return "router";
+	if (isReactorWorkerEnabled()) return "worker";
+	return "in-process";
+}
+//#endregion
+//#region src/runtime/app-reactor-client.ts
+const REMOTE_BACKEND_NAME = "switchboard-remote";
+const loadMultiReactor = () => import("./multi-reactor-Dvwv69u1.js");
+function planReactorClient(mode = resolveReactorClientMode()) {
+	const needsLocalReactor = mode !== "remote";
+	return {
+		mode,
+		multiReactor: mode === "router",
+		needsLocalReactor,
+		localAsWorker: needsLocalReactor && (mode === "worker" || mode === "router" && isReactorWorkerEnabled())
+	};
+}
+/** Builds the local reactor the plan needs, then selects the app's client. */
+async function createAppReactorClient(options) {
+	const { localReactor, ...params } = options;
+	const plan = options.plan ?? planReactorClient();
+	let module;
+	if (plan.needsLocalReactor) {
+		if (!localReactor) throw new Error(`reactorClient mode "${plan.mode}" needs a local reactor; pass localReactor`);
+		module = await localReactor(plan);
+	}
+	const { client, router } = await selectClient({
+		...params,
+		mode: plan.mode,
+		module
+	});
+	return {
+		plan,
+		module,
+		client,
+		router
+	};
+}
+/**
+* Pick the client for the resolved mode:
+*  - `in-process` / `worker`: the local client, router module never loaded.
+*  - `router`: the local reactor plus remote backends.
+*  - `remote`: a remote-only router — a full IReactorClient that proxies to
+*    the Switchboard over GraphQL with NO local reactor (no PGlite).
+*/
+async function selectAppReactorClient(params) {
+	return (await selectClient(params)).client;
+}
+/** The app's client, and the router when it is one. */
+async function selectClient(params) {
+	if (params.mode === "remote") {
+		setFullReactorClient(void 0);
+		const remote = await buildRemoteOnly(params);
+		setFullReactorClient(remote);
+		return {
+			client: remote,
+			router: remote
+		};
+	}
+	if (params.mode !== "router") {
+		if (getPHStore()?.fullReactorClient) setFullReactorClient(void 0);
+		return { client: requireModule(params).client };
+	}
+	setFullReactorClient(void 0);
+	const routed = await buildRouter(params);
+	setFullReactorClient(routed);
+	return routed ? {
+		client: routed,
+		router: routed
+	} : { client: requireModule(params).client };
+}
+function requireModule(params) {
+	if (!params.module) throw new Error(`reactorClient mode "${params.mode}" needs a local reactor, but none was built`);
+	return params.module;
+}
+/**
+* A Switchboard that cannot answer must not fail boot: list the tab's drives.
+*
+* A Switchboard that REFUSES the caller (401/403) must not fail boot either:
+* the refusal is recorded (`backendAuth`) so the root view shows the sign-in
+* gate, and the drive list is empty until the user is someone the backend
+* accepts. A remote-only client has no local drives to fall back on.
+*/
+async function getAppDrives(client, local) {
+	if (client === local) try {
+		const drives = await getDrives(local);
+		setBackendAuth(void 0);
+		return drives;
+	} catch (error) {
+		if (recordBackendAuthError(error, "switchboard")) {
+			logger.warn("The Switchboard refused this caller; showing the sign-in gate: @error", error);
+			return [];
+		}
+		throw error;
+	}
+	try {
+		const drives = await getDrives(client);
+		setBackendAuth(void 0);
+		return drives;
+	} catch (error) {
+		if (recordBackendAuthError(error, "switchboard")) logger.warn("A remote backend refused this caller; listing the local reactor's drives: @error", error);
+		else logger.warn("Could not list drives through the router; listing the local reactor's: @error", error);
+		return getDrives(local);
+	}
+}
+/**
+* The boot refresh of the drives store. It lists through `getAppDrives`
+* whichever client is in use, so a Switchboard that refuses the caller is
+* recorded for the sign-in gate here too: the remote-only client is its own
+* `local`, and a bare `refreshReactorDataClient` would let the 401 escape
+* and fail the boot before the gate can render.
+*/
+async function refreshAppDrives(client, local) {
+	setDrives(await getAppDrives(client, local));
+}
+/**
+* Lists the drives again as the caller the tab now is, through the clients
+* boot left in the store: after a sign-in landing or a sign-out that followed
+* a backend's refusal. Nothing to do before boot has set a client.
+*/
+async function relistAppDrives() {
+	const client = getFullReactorClient();
+	if (!client) return;
+	await refreshAppDrives(client, getPHStore()?.reactorClientModule?.client ?? client);
+}
+setDriveRelister(relistAppDrives);
+/** The switchboards to route to: the host's remote backends, else the default drive's. */
+function switchboardRemotes(params) {
+	const listed = params.remoteBackends?.length ? params.remoteBackends : params.remoteDriveUrl ? [{
+		name: REMOTE_BACKEND_NAME,
+		url: params.remoteDriveUrl
+	}] : [];
+	const remotes = [];
+	const unparsed = [];
+	for (const { name, url } of listed) {
+		const graphqlUrl = switchboardOfDrive(url)?.graphql;
+		if (graphqlUrl) remotes.push({
+			name,
+			graphqlUrl
+		});
+		else unparsed.push(url);
+	}
+	return {
+		remotes,
+		unparsed
+	};
+}
+async function buildRouter(params) {
+	const { remotes, unparsed } = switchboardRemotes(params);
+	for (const url of unparsed) logger.warn("multiReactor is on but the remote drive URL @url does not parse; skipping it", url);
+	if (remotes.length === 0) {
+		logger.warn("multiReactor is on but no remote drive URL is configured; using the local reactor only");
+		return;
+	}
+	let multiReactor;
+	try {
+		multiReactor = await (params.loadRouter ?? loadMultiReactor)();
+	} catch (error) {
+		logger.error("Could not load the multi-reactor router: @error", error);
+		return;
+	}
+	logger.info("Multi-reactor routing to @urls", remotes.map((remote) => remote.graphqlUrl).join(", "));
+	return multiReactor.buildMultiReactorClient({
+		module: requireModule(params),
+		remotes,
+		collections: params.collections,
+		signer: params.signer,
+		documentModelModules: params.documentModelModules
+	});
+}
+/**
+* The `remote` mode: a remote-only router — a full IReactorClient that proxies
+* to the Switchboard over GraphQL with NO local backend, so no local reactor
+* and no PGlite are ever built. A missing/unparseable remote URL is a hard
+* config error here (unlike `router`, there is no local reactor to fall back
+* to).
+*/
+async function buildRemoteOnly(params) {
+	const { remotes, unparsed } = switchboardRemotes(params);
+	if (unparsed.length > 0) throw new Error(`reactorClient "remote": the remote drive URL "${unparsed[0]}" does not resolve to a Switchboard GraphQL endpoint`);
+	if (remotes.length === 0) throw new Error("reactorClient \"remote\" needs a remote drive URL — declare a remote backend / default drive the client can proxy to");
+	const multiReactor = await (params.loadRouter ?? loadMultiReactor)();
+	logger.info("Remote reactor client → @urls", remotes.map((remote) => remote.graphqlUrl).join(", "));
+	return multiReactor.buildMultiReactorClient({
+		module: void 0,
+		remotes,
+		collections: params.collections,
+		signer: params.signer,
+		documentModelModules: params.documentModelModules
+	});
+}
+//#endregion
+//#region src/runtime/drive-placement.ts
+/** The router backend of the reactor in this browser. */
+const LOCAL_BACKEND_NAME = "connect-local";
+function keepsLocalCopy(drive) {
+	return !("url" in drive) || drive.sync !== false;
+}
+/** Remote default drives with a backend, then collections. */
+function switchboardDrives(config) {
+	const drives = [];
+	for (const drive of config.drives?.defaultDrives ?? []) {
+		if (!("url" in drive) || !drive.backend) continue;
+		const slug = switchboardOfDrive(drive.url)?.slug;
+		if (slug === void 0) continue;
+		drives.push({
+			slug,
+			url: drive.url,
+			remote: drive.backend,
+			configured: drive.sync === false ? drive.backend : LOCAL_BACKEND_NAME,
+			collection: false
+		});
+	}
+	const remotes = config.instance?.remoteBackends ?? [];
+	for (const [slug, entry] of Object.entries(config.instance?.collections ?? {})) {
+		const remote = remotes.find((r) => r.name === entry.backend);
+		const base = remote && switchboardOfDrive(remote.url)?.base;
+		if (!base || drives.some((drive) => drive.slug === slug)) continue;
+		drives.push({
+			slug,
+			url: `${base}/d/${encodeURIComponent(slug)}`,
+			remote: entry.backend,
+			configured: entry.sync === false ? entry.backend : LOCAL_BACKEND_NAME,
+			collection: true
+		});
+	}
+	return drives;
+}
+/** Stale: no such drive, a backend it can't open on, back to config, or a changed config value. */
+function applyPlacementEntries(drives, entries) {
+	const applied = [];
+	const stale = [];
+	for (const entry of entries) {
+		const drive = drives.find((d) => d.slug === entry.slug);
+		(drive !== void 0 && entry.configWas === drive.configured && entry.backend !== drive.configured && (entry.backend === drive.remote || entry.backend === "connect-local") ? applied : stale).push(entry);
+	}
+	return {
+		applied,
+		stale
+	};
+}
+/** A served slug names a declared one as is, or hashed (`<slug>-<8 hex>`). */
+function servesSlug(declared, served) {
+	return served === declared || served.startsWith(`${declared}-`) && /^[0-9a-f]{8}$/.test(served.slice(declared.length + 1));
+}
+function withinDeadline(work, timeoutMs) {
+	let timer;
+	const deadline = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`no answer in ${timeoutMs} ms`)), timeoutMs);
+	});
+	return Promise.race([work, deadline]).finally(() => clearTimeout(timer));
+}
+/** An unreachable drive keeps only the slug in its address. */
+async function resolveSwitchboardDrives(drives, fetchInfo, { timeoutMs = 5e3, findServed } = {}) {
+	return Promise.all(drives.map(async (drive) => {
+		try {
+			const { id, slug } = await withinDeadline(fetchInfo(drive.url), timeoutMs);
+			return {
+				...drive,
+				id,
+				servedSlug: slug
+			};
+		} catch (error) {
+			if (drive.collection && findServed) try {
+				const served = await withinDeadline(findServed(drive), timeoutMs);
+				if (served) return {
+					...drive,
+					id: served.id,
+					servedSlug: served.slug
+				};
+			} catch (findError) {
+				logger.warn("Could not find drive @slug on @remote: @error", drive.slug, drive.remote, findError);
+			}
+			logger.warn("Could not read drive @url; routing it by its address only: @error", drive.url, error);
+			const slug = switchboardOfDrive(drive.url)?.slug;
+			return slug === void 0 ? drive : {
+				...drive,
+				servedSlug: slug
+			};
+		}
+	}));
+}
+/** The address the drive is served at. */
+function servedUrl(drive) {
+	const at = switchboardOfDrive(drive.url);
+	return at && drive.servedSlug && drive.servedSlug !== at.slug ? `${at.base}/d/${encodeURIComponent(drive.servedSlug)}` : drive.url;
+}
+/** The keys a placement is installed under: the id and the served slug. */
+function placementKeys(drive) {
+	return [drive.id, drive.servedSlug].filter((key) => key !== void 0 && key !== "");
+}
+/** Drops the sync remote of every given drive; its local data is left unread. */
+async function removeLocalCopies(sync, resolved) {
+	for (const drive of resolved) {
+		if (!drive.id) continue;
+		const collectionId = DriveCollectionId.forDrive(drive.id);
+		const remotes = sync.list().filter((remote) => remote.meta.collectionId.equals(collectionId));
+		for (const remote of remotes) await sync.remove(remote.meta.name);
+	}
+}
+//#endregion
+//#region src/runtime/drive-placements.ts
+/** A collection by its declared slug among its switchboard's drives, e.g. one served hashed. */
+async function findServedDrive(router, drive) {
+	const backend = router.backends.find((b) => b.name === drive.remote);
+	if (!backend) return void 0;
+	const { results } = await backend.api.find({ type: driveDocumentType });
+	const served = results.find((doc) => doc.header.slug && servesSlug(drive.slug, doc.header.slug));
+	return served && {
+		id: served.header.id,
+		slug: served.header.slug
+	};
+}
+/** Where a drive opens given its stored move, if any: the move, else the host config. */
+function effectiveBackend(drive, entry) {
+	return entry?.backend ?? drive.configured;
+}
+/** A drive opening on `backend` reads its copy here, which must arrive first. */
+function needsCopy(backend) {
+	return backend === LOCAL_BACKEND_NAME;
+}
+/** A copy has caught up once every scope is at least at the source's revision. */
+function caughtUp(local, source) {
+	return Object.entries(source).every(([scope, revision]) => (local[scope] ?? -1) >= revision);
+}
+/** Config placement plus this browser's moves: store, then sync remote, then router. */
+var DrivePlacements = class DrivePlacements {
+	drives;
+	store;
+	sync;
+	applied = /* @__PURE__ */ new Map();
+	resolved = [];
+	router;
+	busy = /* @__PURE__ */ new Map();
+	attached = false;
+	listeners = /* @__PURE__ */ new Set();
+	snapshot = /* @__PURE__ */ new Map();
+	constructor(drives, applied, store, sync) {
+		this.drives = drives;
+		this.store = store;
+		this.sync = sync;
+		for (const entry of applied) this.applied.set(entry.slug, entry);
+	}
+	/** Reads the store and drops the entries the config has overtaken (O2). */
+	static async load(drives, store, sync) {
+		let entries = [];
+		try {
+			entries = await store.list();
+		} catch (error) {
+			logger.warn("Could not read this browser's drive moves: @error", error);
+		}
+		const { applied, stale } = applyPlacementEntries(drives, entries);
+		for (const entry of stale) store.delete(entry.slug).catch((error) => {
+			logger.warn("Could not drop drive move @slug: @error", entry.slug, error);
+		});
+		return new DrivePlacements(drives, applied, store, sync);
+	}
+	/** Where `drive` opens in this browser: a move, else the config. */
+	backendOf(drive) {
+		return effectiveBackend(drive, this.applied.get(drive.slug));
+	}
+	/** Whether a remote default drive at `url` keeps a copy here. */
+	keepsCopy(url) {
+		const drive = this.drives.find((d) => d.url === url);
+		return !drive || this.backendOf(drive) === "connect-local";
+	}
+	/** Drives that open on their switchboard with no copy here. */
+	placed() {
+		return this.drives.filter((drive) => this.backendOf(drive) !== LOCAL_BACKEND_NAME);
+	}
+	/** Collections this browser keeps a copy of; default drives are added with the others. */
+	keptCollections() {
+		return this.resolved.filter((drive) => drive.collection && drive.id !== void 0 && this.backendOf(drive) === "connect-local");
+	}
+	/** Installs both layers for every drive the router can be told about. */
+	attach(router, resolved) {
+		this.router = router;
+		this.resolved = [...resolved];
+		this.attached = true;
+		for (const drive of this.resolved) this.install(drive);
+		this.notify();
+	}
+	/**
+	* Attaches, follows the moves other tabs made since `load`, then brings
+	* the sync remotes in line; returns the collections to keep a copy of.
+	*/
+	async start(router, resolved, syncsDrives) {
+		this.attach(router, resolved);
+		await this.reload();
+		if (!syncsDrives) return [];
+		const placed = new Set(this.placed().map((drive) => drive.slug));
+		await removeLocalCopies(this.sync, this.resolved.filter((drive) => placed.has(drive.slug) && !this.busy.has(drive.slug)));
+		return this.keptCollections();
+	}
+	/** The drive's placement in this browser; undefined for a drive the host does not place on a switchboard. */
+	placementOf(driveId) {
+		return this.snapshot.get(driveId);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	/** Opens the drive on `backend` in this browser: its switchboard, or a copy here. */
+	async move(driveId, backend) {
+		const drive = this.resolved.find((d) => d.id === driveId);
+		if (!drive?.id) throw new Error(`Drive ${driveId} is not on a switchboard this app links`);
+		if (backend !== drive.remote && backend !== "connect-local") throw new Error(`Drive ${drive.slug} can't open on ${backend}`);
+		if (this.busy.has(drive.slug) || this.backendOf(drive) === backend) return;
+		const previous = this.applied.get(drive.slug);
+		const entry = backend === drive.configured ? void 0 : {
+			slug: drive.slug,
+			backend,
+			configWas: drive.configured
+		};
+		const id = drive.id;
+		this.busy.set(drive.slug, backend);
+		this.notify();
+		try {
+			await this.record(drive.slug, entry);
+			if (needsCopy(backend)) try {
+				await this.sync.add(servedUrl(drive), id);
+				await this.sync.untilCopied(id, drive.remote);
+			} catch (error) {
+				await this.record(drive.slug, previous);
+				await removeLocalCopies(this.sync, [drive]);
+				throw error;
+			}
+			else try {
+				await removeLocalCopies(this.sync, [drive]);
+			} catch (error) {
+				await this.record(drive.slug, previous);
+				throw error;
+			}
+			this.install(drive);
+		} finally {
+			this.busy.delete(drive.slug);
+			this.notify();
+		}
+	}
+	/** Back to where the host config opens the drive. */
+	reset(driveId) {
+		const drive = this.resolved.find((d) => d.id === driveId);
+		return drive ? this.move(driveId, drive.configured) : Promise.resolve();
+	}
+	/** Re-reads the store after another tab moved a drive; true when something changed. */
+	async reload() {
+		if (!this.attached) return false;
+		const next = await this.readMoves();
+		if (!next) return false;
+		const changed = this.drives.filter((drive) => !this.busy.has(drive.slug) && effectiveBackend(drive, next.get(drive.slug)) !== this.backendOf(drive));
+		if (changed.length === 0) return false;
+		await Promise.all(changed.map((drive) => this.follow(drive, next.get(drive.slug))));
+		this.notify();
+		return true;
+	}
+	/** A copy kept by another tab is routed here only once it has arrived. */
+	async follow(drive, entry) {
+		const resolved = this.resolved.find((d) => d.slug === drive.slug);
+		if (needsCopy(effectiveBackend(drive, entry)) && resolved?.id) {
+			this.busy.set(drive.slug, LOCAL_BACKEND_NAME);
+			this.notify();
+			try {
+				await this.sync.untilCopied(resolved.id, resolved.remote);
+			} catch (error) {
+				logger.warn("Drive @slug was not copied into this browser; leaving it where it opens: @error", drive.slug, error);
+				return;
+			} finally {
+				this.busy.delete(drive.slug);
+			}
+			const latest = await this.readMoves();
+			if (!latest) return;
+			entry = latest.get(drive.slug);
+		}
+		if (entry) this.applied.set(drive.slug, entry);
+		else this.applied.delete(drive.slug);
+		if (resolved) this.install(resolved);
+	}
+	async readMoves() {
+		let entries;
+		try {
+			entries = await this.store.list();
+		} catch (error) {
+			logger.warn("Could not read this browser's drive moves: @error", error);
+			return;
+		}
+		const { applied } = applyPlacementEntries(this.drives, entries);
+		return new Map(applied.map((entry) => [entry.slug, entry]));
+	}
+	async record(slug, entry) {
+		if (entry) {
+			await this.store.put(entry);
+			this.applied.set(slug, entry);
+		} else {
+			await this.store.delete(slug);
+			this.applied.delete(slug);
+		}
+	}
+	install(drive) {
+		const router = this.router;
+		if (!router) return;
+		const configured = drive.configured === drive.remote ? drive.remote : void 0;
+		const runtime = this.applied.get(drive.slug)?.backend;
+		for (const key of placementKeys(drive)) {
+			router.setConfiguredPlacement(key, configured);
+			router.setPlacement(key, runtime);
+		}
+	}
+	notify() {
+		const snapshot = /* @__PURE__ */ new Map();
+		for (const drive of this.resolved) {
+			if (!drive.id) continue;
+			const backend = this.backendOf(drive);
+			snapshot.set(drive.id, {
+				drive,
+				backend,
+				moved: backend !== drive.configured,
+				busy: this.busy.has(drive.slug),
+				...this.busy.has(drive.slug) ? { movingTo: this.busy.get(drive.slug) } : {}
+			});
+		}
+		this.snapshot = snapshot;
+		for (const listener of [...this.listeners]) listener();
+	}
+};
+//#endregion
+//#region src/runtime/ph-store.ts
+/** The app's PH store: the active one, else a new one bound to `window.ph`.
+* Values set on `window.ph` before carry over. */
+function getConnectPHStore() {
+	const active = getActivePHStore();
+	if (active) return active;
+	const store = createPHStore();
+	bindPHStoreToWindow(store);
+	return store;
+}
+//#endregion
+//#region src/runtime/local-package.ts
+/** Starts loading the project's package; a loader runs once, here. */
+function loadLocalPackage(source) {
+	const pkg = typeof source === "function" ? source() : source;
+	if (pkg instanceof Promise) pkg.catch(() => void 0);
+	return pkg;
+}
+//#endregion
+export { isMultiReactorEnabled as A, REACTOR_CLIENT_QUERY_KEY as C, REACTOR_WORKER_STORAGE_KEY as D, REACTOR_WORKER_QUERY_KEY as E, isReactorWorkerEnabled as O, selectAppReactorClient as S, resolveReactorClientMode as T, createAppReactorClient as _, effectiveBackend as a, refreshAppDrives as b, LOCAL_BACKEND_NAME as c, placementKeys as d, removeLocalCopies as f, switchboardDrives as g, servesSlug as h, caughtUp as i, resolveReactorWorkerEnabled as k, applyPlacementEntries as l, servedUrl as m, getConnectPHStore as n, findServedDrive as o, resolveSwitchboardDrives as p, DrivePlacements as r, needsCopy as s, loadLocalPackage as t, keepsLocalCopy as u, getAppDrives as v, REACTOR_CLIENT_STORAGE_KEY as w, relistAppDrives as x, planReactorClient as y };
+
+//# sourceMappingURL=runtime-LvAkxbdf.js.map