@powerhousedao/connect 6.0.0-dev.24 → 6.0.0-dev.240

package/dist/sidebar-DHvt_u7k.js

@@ -0,0 +1,1551 @@
+import { n as defaultPHAppConfig, r as defaultPHDocumentEditorConfig, t as connectConfig } from "./connect.config-Cuh0hj_Q.js";
+import { n as toast, t as ToastContainer } from "./toast-DnODOv28.js";
+import { t as i18n } from "./i18n-DLmohU39.js";
+import { c as subscribeReactorPgMajor, d as createFileDataStore, f as idbError, l as IDB_STORE_NAME, m as readPgVersionFile, p as openIdb, r as getCachedReactorPgMajor, u as PRIMARY_IDB_NAMES } from "./pglite-runtime-C1g-4Jxl.js";
+import { t as serviceWorkerManager } from "./registerServiceWorker-LI8_JXt3.js";
+import { addRemoteDrive, driveCollectionId, getRevisionFromDate, logout, openRenown, setPHAppConfig, setPHDocumentEditorConfig, setRevisionHistoryVisible, setSelectedDrive, setSelectedNode, showPHModal, useAppModuleById, useDefaultAppModule, useDocumentById, useDocumentModelModuleById, useDocumentOperations, useDrives, useEditorModuleById, useFallbackEditorModule, useNodeParentFolderById, usePHModal, usePackageDiscoveryService, useReactorClient, useRevisionHistoryVisible, useSelectedDocument, useSelectedDocumentId, useSelectedDrive, useSelectedDriveSafe, useSelectedFolder, useSelectedTimelineItem, useSyncList, useUser } from "@powerhousedao/reactor-browser";
+import { childLogger } from "document-model";
+import React, { StrictMode, Suspense, lazy, useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { Trans, useTranslation } from "react-i18next";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Outlet, RouterProvider, createBrowserRouter, createRoutesFromChildren, matchRoutes, useLocation, useNavigate, useNavigationType, useParams } from "react-router-dom";
+import { useHotkeys } from "react-hotkeys-hook";
+import { AnimatedLoader, ConnectSidebar, ConnectTooltipProvider, CookieBanner, DefaultEditorLoader, DropZoneWrapper, HomeScreen, HomeScreenAddDriveItem, HomeScreenItem, RevisionHistory, SidebarAddDriveItem, SidebarItem, useEns } from "@powerhousedao/design-system/connect";
+import { GenericDriveExplorer } from "@powerhousedao/powerhouse-vetra-packages/editors";
+import { Icon, PowerhouseButton } from "@powerhousedao/design-system";
+import { ErrorBoundary } from "react-error-boundary";
+import { PGlite } from "@electric-sql/pglite";
+import { PackageInstallModal } from "@powerhousedao/design-system/connect/index";
+import { redo, undo } from "@powerhousedao/shared/document-model";
+import { gql, request } from "graphql-request";
+//#region src/hooks/useAcceptedCookies.ts
+const ACCEPTED_COOKIES_KEY_STORAGE = `${connectConfig.routerBasename}:acceptedCookies`;
+const listeners$3 = /* @__PURE__ */ new Set();
+let cookies = getInitial$1();
+function getInitial$1() {
+	try {
+		const value = localStorage.getItem(ACCEPTED_COOKIES_KEY_STORAGE);
+		return value ? JSON.parse(value) : {
+			analytics: false,
+			marketing: false,
+			functional: false
+		};
+	} catch {
+		return {
+			analytics: false,
+			marketing: false,
+			functional: false
+		};
+	}
+}
+function getCookies() {
+	return cookies;
+}
+function setCookies(setter) {
+	cookies = setter(cookies);
+	localStorage.setItem(ACCEPTED_COOKIES_KEY_STORAGE, JSON.stringify(cookies));
+	listeners$3.forEach((fn) => fn());
+}
+function subscribe$1(fn) {
+	listeners$3.add(fn);
+	return () => listeners$3.delete(fn);
+}
+const useAcceptedCookies = () => {
+	return [useSyncExternalStore(subscribe$1, getCookies, getCookies), setCookies];
+};
+const COOKIE_BANNER_KEY_STORAGE = `${connectConfig.routerBasename}:display-cookie-banner`;
+const listeners$2 = /* @__PURE__ */ new Set();
+let bannerShown = getInitial();
+function getInitial() {
+	try {
+		return localStorage.getItem(COOKIE_BANNER_KEY_STORAGE) !== "false";
+	} catch (error) {
+		console.error(error);
+		return true;
+	}
+}
+function getCookieBannerState() {
+	return bannerShown;
+}
+function setCookieBannerState(state) {
+	bannerShown = state;
+	localStorage.setItem(COOKIE_BANNER_KEY_STORAGE, JSON.stringify(state));
+}
+function subscribe(fn) {
+	listeners$2.add(fn);
+	return () => listeners$2.delete(fn);
+}
+const useCookieBanner = () => {
+	return [useSyncExternalStore(subscribe, getCookieBannerState, getCookieBannerState), setCookieBannerState];
+};
+//#endregion
+//#region src/hooks/useInitSentry.ts
+const logger$2 = childLogger(["sentry"]);
+let clientStarted = false;
+async function getSentry() {
+	return await import("@sentry/react");
+}
+async function initSentry() {
+	connectConfig.sentry;
+	const Sentry = await getSentry();
+	const integrations = [
+		Sentry.httpClientIntegration(),
+		Sentry.extraErrorDataIntegration({ depth: 5 }),
+		Sentry.replayIntegration(),
+		Sentry.captureConsoleIntegration({ levels: ["error"] })
+	];
+	if (connectConfig.sentry.tracing) integrations.push(Sentry.reactRouterV6BrowserTracingIntegration({
+		useEffect: React.useEffect,
+		useLocation,
+		useNavigationType,
+		createRoutesFromChildren,
+		matchRoutes
+	}));
+	Sentry.init({
+		release: connectConfig.sentry.release,
+		dsn: connectConfig.sentry.dsn,
+		environment: connectConfig.sentry.env,
+		integrations,
+		ignoreErrors: [
+			"User is not allowed to create files",
+			"User is not allowed to move documents",
+			"The user aborted a request."
+		],
+		sendDefaultPii: true,
+		tracesSampleRate: 1,
+		replaysSessionSampleRate: .1,
+		replaysOnErrorSampleRate: 1,
+		beforeSend(event, hint) {
+			const error = hint.originalException;
+			if (error instanceof TypeError && error.message.includes("Failed to fetch") && !navigator.onLine) return null;
+			return event;
+		}
+	});
+	clientStarted = true;
+}
+async function closeClient() {
+	if (!clientStarted) return;
+	return (await getSentry()).getClient()?.close();
+}
+function useInitSentry() {
+	const [acceptedCookies] = useAcceptedCookies();
+	const { analytics } = acceptedCookies;
+	useEffect(() => {
+		if (!analytics) {
+			closeClient().catch((error) => logger$2.error("@error", error));
+			return;
+		}
+		if (clientStarted || !connectConfig.sentry.dsn || connectConfig.sentry.dsn === "") return;
+		initSentry().catch((error) => logger$2.error("@error", error));
+	}, [analytics]);
+}
+//#endregion
+//#region src/hooks/usePendingInstallations.ts
+const emptyArray = [];
+function usePendingInstallations() {
+	const discoveryService = usePackageDiscoveryService();
+	return useSyncExternalStore((cb) => discoveryService?.subscribePending(cb) ?? (() => {}), () => discoveryService?.getPendingInstallations() ?? emptyArray);
+}
+//#endregion
+//#region src/hooks/useUndoRedoShortcuts.ts
+const useUndoRedoShortcuts = (props) => {
+	const { undo, redo, canRedo, canUndo } = props;
+	const isMac = window.navigator.userAgent.includes("Mac");
+	let undoShortcut = "ctrl+z";
+	let redoShortcut = "ctrl+y";
+	if (isMac) {
+		undoShortcut = "mod+z";
+		redoShortcut = "mod+shift+z";
+	}
+	useHotkeys(undoShortcut, (event) => {
+		event.preventDefault();
+		if (canUndo) undo();
+	}, {}, [canUndo, undo]);
+	useHotkeys(redoShortcut, (event) => {
+		event.preventDefault();
+		if (canRedo) redo();
+	}, {}, [canRedo, redo]);
+};
+//#endregion
+//#region src/components/analytics.tsx
+function gtag(...args) {
+	window.dataLayer?.push(...args);
+}
+const Analytics = () => {
+	const gaTrackingId = connectConfig.gaTrackingId;
+	const [{ analytics }] = useAcceptedCookies();
+	const useAnalytics = gaTrackingId && analytics;
+	useEffect(() => {
+		if (useAnalytics) {
+			const script = document.createElement("script");
+			script.src = `https://www.googletagmanager.com/gtag/js?id=${gaTrackingId}`;
+			script.async = true;
+			document.head.appendChild(script);
+			window.dataLayer = window.dataLayer || [];
+			gtag("js", /* @__PURE__ */ new Date());
+			gtag("config", gaTrackingId);
+			return () => {
+				document.head.removeChild(script);
+			};
+		}
+	}, [useAnalytics, gaTrackingId]);
+	return null;
+};
+//#endregion
+//#region src/components/document-editor-container.tsx
+function DocumentEditorContainer() {
+	const [selectedDocument] = useSelectedDocument();
+	const parentFolder = useNodeParentFolderById(selectedDocument.header.id);
+	useMemo(() => {
+		return async () => {};
+	}, []);
+	useCallback(() => {
+		setSelectedNode(parentFolder);
+	}, [parentFolder, setSelectedNode]);
+	return /* @__PURE__ */ jsx("div", {
+		id: "document-editor-container",
+		className: "flex-1",
+		"data-document-type": selectedDocument.header.documentType,
+		children: /* @__PURE__ */ jsx(DocumentEditor, { document: selectedDocument })
+	});
+}
+//#endregion
+//#region src/components/editor-loader.tsx
+function EditorLoader(props) {
+	const [showLoading, setShowLoading] = useState(false);
+	useEffect(() => {
+		setTimeout(() => {
+			setShowLoading(true);
+		}, props.loadingTimeout ?? 200);
+	}, [props]);
+	if (!showLoading) return null;
+	const { customEditorLoader, ...defaultProps } = props;
+	if (customEditorLoader) return /* @__PURE__ */ jsx(Fragment, { children: customEditorLoader });
+	return /* @__PURE__ */ jsx(DefaultEditorLoader, { ...defaultProps });
+}
+//#endregion
+//#region src/components/error-boundary.tsx
+const logger$1 = childLogger(["Connect"]);
+function hasCustomFallback(props) {
+	return "fallbackRender" in props;
+}
+function SilentFallback() {
+	return null;
+}
+/**
+* Simple text-based fallback component.
+* Displays a centered message when an error occurs.
+*/
+function TextFallback({ message = "Something went wrong" }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "text-center",
+		children: message
+	});
+}
+/**
+* Detailed fallback component showing full error information.
+* Displays error message with a collapsible details section.
+* Useful for development and debugging purposes.
+*/
+function DetailedFallback({ error, resetErrorBoundary }) {
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	const errorDetails = error instanceof Error ? error.stack ?? String(error.cause) : JSON.stringify(error, null, 2);
+	return /* @__PURE__ */ jsx("div", {
+		className: "z-10 mx-auto flex max-w-[80%] flex-1 items-center justify-center p-6",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "w-full max-w-lg rounded-lg border border-gray-500 bg-white p-6 shadow-sm",
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: "mb-3 flex items-center gap-2",
+					children: [/* @__PURE__ */ jsx(Icon, {
+						name: "Error",
+						className: "size-5 shrink-0"
+					}), /* @__PURE__ */ jsx("h1", {
+						className: "text-lg font-semibold",
+						children: "Something went wrong"
+					})]
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "mb-4 text-sm text-gray-700",
+					children: errorMessage
+				}),
+				errorDetails !== "{}" && /* @__PURE__ */ jsxs("details", {
+					className: "group",
+					children: [/* @__PURE__ */ jsx("summary", {
+						className: "cursor-pointer select-none text-sm font-medium text-gray-700 underline hover:text-gray-700",
+						children: "Show details"
+					}), /* @__PURE__ */ jsx("pre", {
+						className: "mt-2 max-h-48 overflow-auto rounded bg-gray-100 p-3 text-xs",
+						children: errorDetails
+					})]
+				}),
+				/* @__PURE__ */ jsx(PowerhouseButton, {
+					type: "button",
+					onClick: resetErrorBoundary,
+					className: "text-md mt-4 px-3 py-1.5 font-medium",
+					children: "Try again"
+				})
+			]
+		})
+	});
+}
+/**
+* Centered error message fallback component.
+* Displays the error message in a centered, full-size container.
+* Suitable for use as a custom fallbackRender when you need simple error display.
+*/
+function CenteredErrorMessage({ error }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex size-full items-center justify-center",
+		children: /* @__PURE__ */ jsx("h3", {
+			className: "text-lg font-semibold",
+			children: error instanceof Error ? error.message : String(error)
+		})
+	});
+}
+function getFallbackComponent(variant, fallbackMessage) {
+	switch (variant) {
+		case "silent": return SilentFallback;
+		case "text": return () => /* @__PURE__ */ jsx(TextFallback, { message: fallbackMessage });
+		case "detailed": return DetailedFallback;
+		default: return CenteredErrorMessage;
+	}
+}
+/**
+* Unified error boundary component for catching and handling React errors.
+*
+* Built on top of `react-error-boundary`, this component provides:
+* - Automatic error logging with configurable context
+* - Multiple fallback UI variants (silent, text, detailed)
+* - Support for custom fallback render functions
+* - Reset capability via `resetKeys`
+*
+* @example
+* // Using a predefined variant
+* <ErrorBoundary variant="detailed" loggerContext={["Connect", "Editor"]}>
+*   <EditorComponent />
+* </ErrorBoundary>
+*
+* @example
+* // Using a custom message with the text variant
+* <ErrorBoundary variant="text" fallbackMessage="Failed to load drives">
+*   <DrivesList />
+* </ErrorBoundary>
+*
+* @example
+* // Using a custom fallback render
+* <ErrorBoundary
+*   fallbackRender={CenteredErrorMessage}
+*   onError={(error) => trackError(error)}
+* >
+*   <MyComponent />
+* </ErrorBoundary>
+*
+* @example
+* // Silent mode for modals (renders null on error)
+* <ErrorBoundary variant="silent" loggerContext={["Connect", "Modals"]}>
+*   <ModalContent />
+* </ErrorBoundary>
+*/
+function ErrorBoundary$1(props) {
+	const { children, onError, resetKeys, loggerContext } = props;
+	const handleError = (error, info) => {
+		if (error.message.includes("Failed to fetch dynamically imported module") && error.message.includes("node_modules/.vite")) {
+			console.error(error);
+			console.log("Outdated chunk detected, reloading page...");
+			window.location.reload();
+			return;
+		}
+		(loggerContext ? childLogger(loggerContext) : logger$1).error("@error @info", error, info);
+		onError?.(error, info);
+	};
+	return /* @__PURE__ */ jsx(ErrorBoundary, {
+		fallbackRender: hasCustomFallback(props) ? props.fallbackRender : getFallbackComponent(props.variant, props.fallbackMessage),
+		onError: handleError,
+		resetKeys,
+		children
+	});
+}
+//#endregion
+//#region src/components/app-container.tsx
+function AppContainer() {
+	const [selectedDrive] = useSelectedDrive();
+	const selectedDocumentId = useSelectedDocumentId();
+	const app = useAppModuleById(selectedDrive.header.meta?.preferredEditor);
+	const defaultApp = useDefaultAppModule();
+	const AppComponent = app?.Component ?? defaultApp?.Component ?? GenericDriveExplorer.Component;
+	if (!AppComponent) throw new Error("No app component found");
+	return /* @__PURE__ */ jsx(ErrorBoundary$1, {
+		variant: "detailed",
+		resetKeys: [selectedDrive.header.id],
+		loggerContext: ["Connect", "App"],
+		children: /* @__PURE__ */ jsx(Suspense, {
+			fallback: /* @__PURE__ */ jsx(EditorLoader, {}),
+			children: /* @__PURE__ */ jsx(DropZoneWrapper, {
+				className: "flex h-full flex-col overflow-auto",
+				children: /* @__PURE__ */ jsx(AppComponent, { children: selectedDocumentId ? /* @__PURE__ */ jsx(DocumentEditorContainer, {}) : null })
+			})
+		})
+	});
+}
+//#endregion
+//#region src/utils/browser.ts
+function getBasePath() {
+	if (typeof document === "undefined") return "/";
+	return document.querySelector("base")?.getAttribute("href") || "/";
+}
+//#endregion
+//#region src/utils/document-editor-debug-tools.ts
+var DocumentEditorDebugTools = class {
+	document;
+	operations = [];
+	constructor(document) {
+		if (document) this.document = document;
+	}
+	operationsToTableObject(operations) {
+		return operations.map((op) => ({
+			...op,
+			input: JSON.stringify(op.action.input)
+		}));
+	}
+	setDocument(document) {
+		this.document = document;
+	}
+	getDocument() {
+		return this.document;
+	}
+	getOperations() {
+		return this.operations;
+	}
+	pushOperation(operation) {
+		this.operations.push(operation);
+	}
+	operationsTable() {
+		if (!this.document) console.warn("No document");
+		const ops = Object.values(this.document?.operations || {}).filter((array) => array !== void 0).flatMap((array) => array).sort((a, b) => a.index - b.index);
+		console.table(this.operationsToTableObject(ops));
+	}
+	scopeOperationsTable(scope) {
+		if (!this.document) console.warn("No document");
+		const ops = this.document?.operations[scope] || [];
+		console.table(this.operationsToTableObject(ops));
+	}
+	operationsLog() {
+		console.log(this.operations);
+	}
+	operationsLogTable() {
+		console.table(this.operationsToTableObject(this.operations));
+	}
+	clear() {
+		this.operations = [];
+		this.document = void 0;
+	}
+};
+//#endregion
+//#region src/components/migration-status.ts
+let current = null;
+const listeners$1 = /* @__PURE__ */ new Set();
+function setMigrationStatus(status) {
+	current = status;
+	for (const l of listeners$1) l();
+}
+function getMigrationStatus() {
+	return current;
+}
+function subscribeMigrationStatus(cb) {
+	listeners$1.add(cb);
+	return () => {
+		listeners$1.delete(cb);
+	};
+}
+//#endregion
+//#region src/utils/pglite-migration.ts
+const BACKUP_PREFIX = "ph-pglite-backup::";
+const BACKUP_INDEX_KEY = "ph:pglite-backups";
+const BACKUP_RETENTION_MS = 720 * 60 * 60 * 1e3;
+const LEGACY_DUMPERS = { 16: async () => {
+	const [{ PGlite: LegacyPGlite }, { pgDump }] = await Promise.all([import("pglite-legacy-02"), import("pglite-tools-legacy-02/pg_dump")]);
+	return async (idbName) => {
+		const pg = new LegacyPGlite(`idb://${idbName.replace(/^\/pglite\//, "")}`);
+		try {
+			await pg.waitReady;
+			return await (await pgDump({ pg })).text();
+		} finally {
+			await pg.close();
+		}
+	};
+} };
+function deleteIdb(name, timeoutMs = 15e3) {
+	return new Promise((resolve, reject) => {
+		const req = indexedDB.deleteDatabase(name);
+		let settled = false;
+		const done = (fn) => {
+			if (settled) return;
+			settled = true;
+			fn();
+		};
+		const timer = setTimeout(() => done(() => reject(/* @__PURE__ */ new Error(`IDB delete timed out for ${name} after ${timeoutMs}ms`))), timeoutMs);
+		req.onsuccess = () => done(() => {
+			clearTimeout(timer);
+			resolve();
+		});
+		req.onerror = () => done(() => {
+			clearTimeout(timer);
+			reject(idbError(req, `IDB delete failed for ${name}`));
+		});
+	});
+}
+async function clearFileData(name) {
+	const db = await openIdb(name, 21, createFileDataStore);
+	try {
+		await new Promise((resolve, reject) => {
+			const tx = db.transaction(IDB_STORE_NAME, "readwrite");
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(idbError(tx, `FILE_DATA clear failed for ${name}`));
+			tx.onabort = () => reject(idbError(tx, `FILE_DATA clear aborted for ${name}`));
+			tx.objectStore(IDB_STORE_NAME).clear();
+		});
+	} finally {
+		db.close();
+	}
+}
+async function cloneFileData(sourceName, destName) {
+	const source = await openIdb(sourceName, 21, createFileDataStore);
+	try {
+		const dest = await openIdb(destName, 21, createFileDataStore);
+		try {
+			const readStore = source.transaction(IDB_STORE_NAME, "readonly").objectStore(IDB_STORE_NAME);
+			const entries = await new Promise((resolve, reject) => {
+				const out = [];
+				const req = readStore.openCursor();
+				req.onerror = () => reject(idbError(req, `FILE_DATA read cursor failed for ${sourceName}`));
+				req.onsuccess = () => {
+					const cursor = req.result;
+					if (!cursor) return resolve(out);
+					out.push({
+						key: cursor.key,
+						value: cursor.value
+					});
+					cursor.continue();
+				};
+			});
+			await new Promise((resolve, reject) => {
+				const writeTx = dest.transaction(IDB_STORE_NAME, "readwrite");
+				writeTx.oncomplete = () => resolve();
+				writeTx.onerror = () => reject(idbError(writeTx, `FILE_DATA write failed for ${destName}`));
+				writeTx.onabort = () => reject(idbError(writeTx, `FILE_DATA write aborted for ${destName}`));
+				const writeStore = writeTx.objectStore(IDB_STORE_NAME);
+				writeStore.clear();
+				for (const { key, value } of entries) writeStore.put(value, key);
+			});
+		} finally {
+			dest.close();
+		}
+	} finally {
+		source.close();
+	}
+}
+function readBackupIndex() {
+	try {
+		const raw = localStorage.getItem(BACKUP_INDEX_KEY);
+		if (!raw) return [];
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) ? parsed : [];
+	} catch {
+		return [];
+	}
+}
+function writeBackupIndex(records) {
+	try {
+		localStorage.setItem(BACKUP_INDEX_KEY, JSON.stringify(records));
+	} catch {}
+}
+function registerBackup(rec) {
+	writeBackupIndex([...readBackupIndex(), rec]);
+}
+function forgetBackup(name) {
+	writeBackupIndex(readBackupIndex().filter((r) => r.name !== name));
+}
+async function janitor() {
+	const cutoff = Date.now() - BACKUP_RETENTION_MS;
+	const keep = [];
+	for (const rec of readBackupIndex()) {
+		if (rec.createdAt >= cutoff) {
+			keep.push(rec);
+			continue;
+		}
+		try {
+			await deleteIdb(rec.name);
+		} catch (err) {
+			console.warn(`Failed to delete expired pglite backup ${rec.name}`, err);
+			keep.push(rec);
+		}
+	}
+	writeBackupIndex(keep);
+}
+function publishPhase(idbName, phase) {
+	setMigrationStatus({
+		idbName,
+		phase
+	});
+}
+async function migrateIdbIfNeeded(idbName) {
+	const major = await readPgVersionFile(idbName);
+	if (major === null || major === 17) return;
+	const loader = LEGACY_DUMPERS[major];
+	if (!loader) throw new Error(`Unsupported legacy PGlite data dir: PG_VERSION=${major} for ${idbName}`);
+	const backupName = `${BACKUP_PREFIX}${idbName}::${(/* @__PURE__ */ new Date()).toISOString()}`;
+	const backupRec = {
+		name: backupName,
+		idbName,
+		createdAt: Date.now()
+	};
+	publishPhase(idbName, "clone");
+	await cloneFileData(idbName, backupName);
+	registerBackup(backupRec);
+	let sql;
+	try {
+		publishPhase(idbName, "dump");
+		sql = await (await loader())(idbName);
+	} catch (err) {
+		await deleteIdb(backupName).catch(() => {});
+		forgetBackup(backupName);
+		throw err;
+	}
+	try {
+		await clearFileData(idbName);
+		publishPhase(idbName, "restore");
+		const pg = new PGlite(`idb://${idbName.replace(/^\/pglite\//, "")}`, { relaxedDurability: false });
+		try {
+			await pg.waitReady;
+			console.info(`[pglite-migration] Dump preamble (first 500 chars):\n${sql.slice(0, 500)}`);
+			try {
+				await pg.exec("SET standard_conforming_strings = off;");
+			} catch (gucErr) {
+				console.warn("[pglite-migration] Could not force standard_conforming_strings=off", gucErr);
+			}
+			try {
+				await pg.exec(sql);
+			} catch (execErr) {
+				logRestoreFailure(idbName, sql, execErr);
+				throw execErr;
+			}
+		} finally {
+			await pg.close();
+		}
+	} catch (err) {
+		await rollbackFromBackup(idbName, backupName, err);
+		throw err;
+	}
+}
+function logRestoreFailure(idbName, sql, err) {
+	const errObj = err;
+	const position = typeof errObj.position === "string" ? parseInt(errObj.position, 10) : typeof errObj.position === "number" ? errObj.position : NaN;
+	console.error(`[pglite-migration] Restore failed for ${idbName}`, {
+		message: errObj.message,
+		code: errObj.code,
+		severity: errObj.severity,
+		detail: errObj.detail,
+		where: errObj.where,
+		position: errObj.position,
+		sqlLength: sql.length
+	});
+	if (Number.isFinite(position) && position > 0) {
+		const zeroBased = position - 1;
+		const start = Math.max(0, zeroBased - 200);
+		const end = Math.min(sql.length, zeroBased + 200);
+		const before = sql.slice(start, zeroBased);
+		const at = sql.slice(zeroBased, zeroBased + 1);
+		const after = sql.slice(zeroBased + 1, end);
+		console.error(`[pglite-migration] SQL context around position ${position}:\n${before}»${at}«${after}`);
+		const lineStart = sql.lastIndexOf("\n", zeroBased) + 1;
+		const lineEnd = sql.indexOf("\n", zeroBased);
+		const line = sql.slice(lineStart, lineEnd === -1 ? sql.length : lineEnd);
+		console.error(`[pglite-migration] Failing line (truncated to 500 chars):\n${line.slice(0, 500)}`);
+	} else console.error(`[pglite-migration] No position info. First 2000 chars of dump:\n${sql.slice(0, 2e3)}`);
+}
+async function rollbackFromBackup(idbName, backupName, originalError) {
+	try {
+		await clearFileData(idbName).catch(() => {});
+		await cloneFileData(backupName, idbName);
+	} catch (rollbackErr) {
+		console.error(`PGlite migration failed AND rollback failed for ${idbName}. Primary error:`, originalError, "Rollback error:", rollbackErr);
+		return;
+	}
+	await deleteIdb(backupName).catch(() => {});
+	forgetBackup(backupName);
+}
+async function migrateAllLocked() {
+	for (const idbName of PRIMARY_IDB_NAMES) await migrateIdbIfNeeded(idbName);
+	setMigrationStatus(null);
+}
+async function migrateAllIfNeeded() {
+	janitor().catch((err) => console.warn("PGlite backup janitor failed", err));
+	if (!(typeof navigator !== "undefined" && "locks" in navigator && typeof navigator.locks.request === "function")) {
+		await migrateAllLocked();
+		return;
+	}
+	await navigator.locks.request("ph-pglite-migration", { mode: "exclusive" }, async () => {
+		await migrateAllLocked();
+	});
+}
+//#endregion
+//#region src/components/app-skeleton.tsx
+const LOADER_DELAY = 250;
+const PHASE_LABEL = {
+	clone: "Backing up local database…",
+	dump: "Exporting data from previous version…",
+	restore: "Restoring data into the new database…"
+};
+const MigrationOverlay = () => {
+	const status = useSyncExternalStore(subscribeMigrationStatus, getMigrationStatus, () => null);
+	if (!status) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: "absolute inset-0 z-20 flex items-center justify-center",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "rounded-lg bg-white/90 px-6 py-4 text-sm text-gray-900 shadow-lg",
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "font-medium",
+				children: "Upgrading local database…"
+			}), /* @__PURE__ */ jsx("div", {
+				className: "text-gray-600",
+				children: PHASE_LABEL[status.phase]
+			})]
+		})
+	});
+};
+const Loader = ({ delay = LOADER_DELAY }) => {
+	const isSSR = typeof window === "undefined";
+	const showInitialLoader = typeof document !== "undefined" && document.body.getAttribute("data-show-loader") === "true";
+	const [showLoading, setShowLoading] = useState(!delay || showInitialLoader);
+	useEffect(() => {
+		const id = setTimeout(() => {
+			setShowLoading(true);
+		}, delay);
+		return () => clearTimeout(id);
+	}, []);
+	return /* @__PURE__ */ jsxs("div", {
+		className: `skeleton-loader absolute inset-0 z-10 flex items-center justify-center ${showLoading ? "" : "hidden"}`,
+		children: [/* @__PURE__ */ jsx("div", {
+			className: "animate-pulse overflow-hidden rounded-full shadow-lg",
+			children: /* @__PURE__ */ jsx(AnimatedLoader, {})
+		}), isSSR ? /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: `setTimeout(() => {
+                        document.querySelector('.skeleton-loader')?.classList.remove('hidden');
+                        document.body.setAttribute('data-show-loader', 'true');
+                    }, ${delay})` } }) : null]
+	});
+};
+const AppSkeleton = (props) => {
+	const isSSR = typeof window === "undefined";
+	const isHomeScreen = !isSSR && window.location.pathname === getBasePath();
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex h-screen overflow-hidden",
+		children: [
+			/* @__PURE__ */ jsx(ConnectSidebar, {
+				className: "animate-pulse",
+				onLogin: void 0,
+				onDisconnect: void 0,
+				onClickSettings: void 0,
+				address: void 0
+			}),
+			/* @__PURE__ */ jsx(HomeScreen, {
+				containerClassName: isSSR || !isHomeScreen ? "hidden home-screen" : void 0,
+				children: props.children ?? null
+			}),
+			isSSR ? /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: `
+                    const baseEl = document.querySelector('base');
+                    const href = baseEl?.getAttribute('href');
+                    const basePath = href || '/';
+                    if (window.location.pathname === basePath) {
+                        document.querySelector('.home-screen')?.classList.remove('hidden')
+                    }` } }) : null,
+			!props.children ? /* @__PURE__ */ jsx(Loader, {}) : null,
+			/* @__PURE__ */ jsx(MigrationOverlay, {})
+		]
+	});
+};
+//#endregion
+//#region src/components/migration-banner.tsx
+let dismissed = false;
+const listeners = /* @__PURE__ */ new Set();
+function notify() {
+	for (const l of listeners) l();
+}
+function dismiss() {
+	dismissed = true;
+	notify();
+}
+function subscribeDismissed(cb) {
+	listeners.add(cb);
+	return () => {
+		listeners.delete(cb);
+	};
+}
+function getDismissed() {
+	return dismissed;
+}
+const MigrationBanner = () => {
+	const isDismissed = useSyncExternalStore(subscribeDismissed, getDismissed, () => false);
+	const major = useSyncExternalStore(subscribeReactorPgMajor, getCachedReactorPgMajor, () => void 0);
+	const [migrating, setMigrating] = useState(false);
+	const [error, setError] = useState(null);
+	if (major === void 0 || major === null || major === 17) return null;
+	if (isDismissed) return null;
+	const handleMigrate = () => {
+		setError(null);
+		setMigrating(true);
+		migrateAllIfNeeded().then(() => {
+			window.location.reload();
+		}).catch((err) => {
+			setError(err instanceof Error ? err.message : String(err));
+			setMigrating(false);
+		});
+	};
+	return /* @__PURE__ */ jsx("div", {
+		className: "absolute inset-x-0 top-0 z-30 flex justify-center p-3",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex max-w-3xl items-center gap-3 rounded-lg border border-yellow-500 bg-yellow-400 px-4 py-3 text-sm text-gray-900 shadow-lg",
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex-1",
+					children: [
+						/* @__PURE__ */ jsxs("div", {
+							className: "font-semibold",
+							children: [
+								"Your local database uses Postgres ",
+								major,
+								"."
+							]
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "text-gray-800",
+							children: [
+								"Migrate to Postgres ",
+								17,
+								" to pick up the latest features. Your data will be backed up first."
+							]
+						}),
+						error && /* @__PURE__ */ jsxs("div", {
+							className: "mt-2 font-medium text-red-900",
+							children: ["Migration failed: ", error]
+						})
+					]
+				}),
+				/* @__PURE__ */ jsx("button", {
+					type: "button",
+					disabled: migrating,
+					onClick: handleMigrate,
+					className: "rounded bg-gray-900 px-3 py-1 text-sm font-medium text-white hover:bg-gray-800 disabled:opacity-50",
+					children: migrating ? "Migrating…" : "Migrate now"
+				}),
+				/* @__PURE__ */ jsx("button", {
+					type: "button",
+					disabled: migrating,
+					onClick: dismiss,
+					className: "rounded border border-gray-900 bg-transparent px-3 py-1 text-sm font-medium text-gray-900 hover:bg-gray-900/10 disabled:opacity-50",
+					children: "Dismiss"
+				})
+			]
+		})
+	});
+};
+//#endregion
+//#region src/components/modal/modals-container.tsx
+const AddDriveModal$1 = lazy(() => import("./AddDriveModal-B9BPORvo.js").then((m) => ({ default: m.AddDriveModal })));
+const ClearStorageModal = lazy(() => import("./ClearStorageModal-K1H6NgT6.js").then((m) => ({ default: m.ClearStorageModal })));
+const CookiesPolicyModal = lazy(() => import("./CookiesPolicyModal-CnVx2R_8.js").then((m) => ({ default: m.CookiesPolicyModal })));
+const CreateDocumentModal$1 = lazy(() => import("./CreateDocumentModal-TtG7E62x.js").then((m) => ({ default: m.CreateDocumentModal })));
+const DebugSettingsModal = lazy(() => import("./DebugSettingsModal-Cm61I2LB.js").then((m) => ({ default: m.DebugSettingsModal })));
+const DeleteDriveModal = lazy(() => import("./DeleteDriveModal-Cb43NeNu.js").then((m) => ({ default: m.DeleteDriveModal })));
+const DeleteItemModal = lazy(() => import("./DeleteItemModal-Brq4QKdd.js").then((m) => ({ default: m.DeleteItemModal })));
+const DisclaimerModal = lazy(() => import("./DisclaimerModal-Dk6PpkZU.js").then((m) => ({ default: m.DisclaimerModal })));
+const DriveSettingsModal$1 = lazy(() => import("./DriveSettingsModal-Bnug5LXo.js").then((m) => ({ default: m.DriveSettingsModal })));
+const DownloadDocumentWithErrorsModal = lazy(() => import("./DownloadDocumentWithErrorsModal-B8ZKi2Xy.js").then((m) => ({ default: m.DownloadDocumentWithErrorsModal })));
+const SettingsModal$1 = lazy(() => import("./SettingsModal-DOEWGn1K.js").then((m) => ({ default: m.SettingsModal })));
+const UpgradeDriveModal = lazy(() => import("./UpgradeDriveModal-CBLALaaQ.js").then((m) => ({ default: m.UpgradeDriveModal })));
+const modalComponents = {
+	addDrive: AddDriveModal$1,
+	clearStorage: ClearStorageModal,
+	cookiesPolicy: CookiesPolicyModal,
+	createDocument: CreateDocumentModal$1,
+	debugSettings: DebugSettingsModal,
+	deleteDrive: DeleteDriveModal,
+	deleteItem: DeleteItemModal,
+	disclaimer: DisclaimerModal,
+	driveSettings: DriveSettingsModal$1,
+	downloadDocumentWithErrors: DownloadDocumentWithErrorsModal,
+	inspector: lazy(() => import("./InspectorModal-EDrjiXPs.js").then((m) => ({ default: m.InspectorModal }))),
+	settings: SettingsModal$1,
+	upgradeDrive: UpgradeDriveModal,
+	missingPackage: lazy(() => import("./MissingPackageModal-BfblPbd8.js").then((m) => ({ default: m.ConnectMissingPackageModal })))
+};
+const ModalsContainer = lazy(async () => {
+	return { default: () => {
+		const phModal = usePHModal();
+		if (!phModal?.type) return null;
+		const ModalComponent = modalComponents[phModal.type];
+		return ModalComponent ? /* @__PURE__ */ jsx(ErrorBoundary$1, {
+			variant: "silent",
+			loggerContext: ["Connect", "Modals"],
+			children: /* @__PURE__ */ jsx(Suspense, {
+				fallback: null,
+				children: /* @__PURE__ */ jsx(ModalComponent, {})
+			})
+		}) : null;
+	} };
+});
+//#endregion
+//#region src/components/app-loader.tsx
+const AppLoader = (props) => {
+	const Load = lazy(() => import("./load-BJYAMdHd.js").then((m) => m.loadComponent(props.localPackage)));
+	return /* @__PURE__ */ jsx(StrictMode, { children: /* @__PURE__ */ jsxs(ErrorBoundary$1, {
+		fallbackRender: (props) => /* @__PURE__ */ jsx(AppSkeleton, { children: /* @__PURE__ */ jsx(DetailedFallback, { ...props }) }),
+		resetKeys: [props.localPackage],
+		loggerContext: ["Connect"],
+		children: [
+			/* @__PURE__ */ jsx(Suspense, {
+				fallback: /* @__PURE__ */ jsx(AppSkeleton, {}),
+				name: "AppLoader",
+				children: /* @__PURE__ */ jsx(Load, {
+					...props,
+					children: /* @__PURE__ */ jsx(App, {})
+				})
+			}),
+			/* @__PURE__ */ jsx(Suspense, {
+				name: "CookieBanner",
+				children: /* @__PURE__ */ jsx(CookieBanner$1, {})
+			}),
+			/* @__PURE__ */ jsx(Suspense, {
+				name: "ModalsContainer",
+				children: /* @__PURE__ */ jsx(ModalsContainer, {})
+			}),
+			/* @__PURE__ */ jsx(MigrationBanner, {})
+		]
+	}) });
+};
+//#endregion
+//#region src/context/sentry-provider.tsx
+const SentryProvider = ({ children }) => {
+	useInitSentry();
+	return children;
+};
+//#endregion
+//#region src/components/package-install-prompt.tsx
+function PackageInstallPrompt() {
+	const pendingInstallations = usePendingInstallations();
+	const discoveryService = usePackageDiscoveryService();
+	if (!discoveryService || pendingInstallations.length === 0) return null;
+	return /* @__PURE__ */ jsx(PackageInstallModal, {
+		pendingInstallations: pendingInstallations.flatMap((p) => p.packageNames.map((packageName) => ({
+			documentType: p.documentType,
+			packageName
+		}))),
+		onInstall: (packageName) => discoveryService.approveInstallation(packageName),
+		onDismiss: (packageName) => discoveryService.dismissInstallation(packageName)
+	});
+}
+//#endregion
+//#region src/components/app.tsx
+const App = () => {
+	useEffect(() => {
+		const handlePreloadError = (event) => {
+			const payload = event.payload;
+			const failedUrl = (payload instanceof Error ? payload.message : String(payload ?? "")).match(/https?:\/\/[^\s"']+/)?.[0];
+			if (failedUrl && !failedUrl.startsWith(window.location.origin)) {
+				console.debug(`[Connect] Skipping reload — vite:preloadError for off-origin URL: ${failedUrl}`);
+				return;
+			}
+			console.log("Outdated chunks detected, reloading page...");
+			window.location.reload();
+		};
+		window.addEventListener("vite:preloadError", handlePreloadError);
+		return () => {
+			window.removeEventListener("vite:preloadError", handlePreloadError);
+		};
+	}, []);
+	useEffect(() => {
+		if (import.meta.env.MODE === "development") window.documentEditorDebugTools = new DocumentEditorDebugTools();
+		else serviceWorkerManager.registerServiceWorker(false);
+	}, []);
+	return /* @__PURE__ */ jsxs(SentryProvider, { children: [
+		/* @__PURE__ */ jsx(ToastContainer, { position: "bottom-right" }),
+		/* @__PURE__ */ jsx(Router, {}),
+		/* @__PURE__ */ jsx(PackageInstallPrompt, {}),
+		/* @__PURE__ */ jsx(Analytics, {})
+	] });
+};
+//#endregion
+//#region src/components/cookie-banner.tsx
+const isCookieAccepted = (cookies, id) => {
+	return cookies.some((cookie) => cookie.id === id && cookie.value);
+};
+const CookieBanner$1 = () => {
+	const { t } = useTranslation(void 0, {
+		useSuspense: true,
+		i18n
+	});
+	const [showBanner, setShowBanner] = useCookieBanner();
+	const [, setAcceptedCookies] = useAcceptedCookies();
+	const cookiesInput = [{
+		id: "analytics-cookie",
+		label: t("cookieBanner.cookies.analytics"),
+		value: true
+	}];
+	const handleAccept = (cookies) => {
+		setShowBanner(false);
+		if (isCookieAccepted(cookies, "analytics-cookie")) setAcceptedCookies((acceptedCookies) => ({
+			...acceptedCookies,
+			analytics: true
+		}));
+	};
+	const handleReject = () => {
+		setShowBanner(false);
+		setAcceptedCookies(() => ({
+			analytics: false,
+			functional: false,
+			marketing: false
+		}));
+	};
+	if (!showBanner) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "absolute inset-0 z-[10000] backdrop-blur-sm",
+		children: [/* @__PURE__ */ jsx("div", { className: "absolute inset-0 bg-black opacity-15" }), /* @__PURE__ */ jsx("div", {
+			className: "absolute inset-x-0 bottom-0 flex justify-center bg-white px-10 pb-16 pt-10 shadow-lg",
+			children: /* @__PURE__ */ jsx(CookieBanner, {
+				className: "max-w-[1024px]",
+				cookies: cookiesInput,
+				onSubmit: handleAccept,
+				onReject: handleReject,
+				submitLabel: t("cookieBanner.accept"),
+				rejectLabel: t("cookieBanner.reject"),
+				children: /* @__PURE__ */ jsx("p", {
+					className: "font-semibold text-gray-500",
+					children: /* @__PURE__ */ jsx(Trans, {
+						i18nKey: "cookieBanner.message",
+						components: { a: /* @__PURE__ */ jsx("a", {
+							onClick: () => showPHModal({ type: "cookiesPolicy" }),
+							className: "cursor-pointer text-gray-900 hover:underline"
+						}, "cookieBanner.message-link") }
+					}, "cookieBanner.message")
+				})
+			})
+		})]
+	});
+};
+//#endregion
+//#region src/components/drive-icon.tsx
+function DriveIcon({ drive }) {
+	const remotes = useSyncList();
+	const isRemoteDrive = useMemo(() => {
+		if (!drive) return false;
+		return remotes.some((remote) => remote.collectionId === driveCollectionId("main", drive.header.id));
+	}, [remotes, drive]);
+	const driveIconSrc = drive?.state.global.icon;
+	if (driveIconSrc) return /* @__PURE__ */ jsx("img", {
+		src: driveIconSrc,
+		alt: drive.header.name,
+		height: 32,
+		width: 32
+	});
+	if (!isRemoteDrive) return /* @__PURE__ */ jsx(Icon, {
+		name: "Hdd",
+		size: 32
+	});
+	return /* @__PURE__ */ jsx(Icon, {
+		name: "Server",
+		size: 32
+	});
+}
+//#endregion
+//#region src/components/editors.tsx
+function EditorError({ message }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex size-full items-center justify-center",
+		children: /* @__PURE__ */ jsx("h3", {
+			className: "text-lg font-semibold",
+			children: message
+		})
+	});
+}
+const DocumentEditor = (props) => {
+	const { document: initialDocument } = props;
+	const selectedTimelineItem = useSelectedTimelineItem();
+	const revisionHistoryVisible = useRevisionHistoryVisible();
+	const [document, dispatch] = useDocumentById(initialDocument.header.id);
+	const documentId = document?.header.id ?? void 0;
+	const documentName = document?.header.name ?? void 0;
+	const documentType = document?.header.documentType ?? void 0;
+	const preferredEditor = document?.header.meta?.preferredEditor ?? void 0;
+	const { globalOperations, localOperations, isLoading: isLoadingOperations, refetch: refetchOperations } = useDocumentOperations(documentId);
+	useEffect(() => {
+		if (revisionHistoryVisible) refetchOperations();
+	}, [revisionHistoryVisible, refetchOperations]);
+	const globalRevisionNumber = document?.header.revision.global ?? 0;
+	const localRevisionNumber = document?.header.revision.local ?? 0;
+	const documentModelModule = useDocumentModelModuleById(documentType);
+	const preferredEditorModule = useEditorModuleById(preferredEditor);
+	const fallbackEditorModule = useFallbackEditorModule(documentType);
+	const editorModule = preferredEditorModule ?? fallbackEditorModule;
+	const isLoadingDocument = !document;
+	const isLoadingEditor = editorModule && documentType && !editorModule.documentTypes.includes(documentType) && !editorModule.documentTypes.includes("*");
+	const canUndo = globalRevisionNumber > 0 || localRevisionNumber > 0;
+	const canRedo = !!document?.clipboard.length;
+	const addUndoAction = () => dispatch(undo());
+	const addRedoAction = () => dispatch(redo());
+	useUndoRedoShortcuts({
+		undo: addUndoAction,
+		redo: addRedoAction,
+		canUndo,
+		canRedo
+	});
+	useEffect(() => {
+		return () => {
+			window.documentEditorDebugTools?.clear();
+		};
+	}, []);
+	const [editorError, setEditorError] = useState(void 0);
+	useEffect(() => {
+		if (editorError && editorError.documentId !== documentId) setEditorError(void 0);
+	}, [editorError, documentId]);
+	const handleEditorError = (error, info) => {
+		setEditorError({
+			error,
+			documentId,
+			info
+		});
+	};
+	if (isLoadingEditor) return /* @__PURE__ */ jsx(EditorLoader, { message: "Loading editor" });
+	if (isLoadingDocument) return /* @__PURE__ */ jsx(EditorLoader, { message: "Loading document" });
+	if (!documentModelModule) return /* @__PURE__ */ jsx(EditorError, { message: /* @__PURE__ */ jsxs("div", {
+		className: "text-center leading-10",
+		children: [/* @__PURE__ */ jsxs("p", { children: [
+			"Unable to open the document because the document model \"",
+			documentType,
+			"\" is not supported."
+		] }), /* @__PURE__ */ jsxs("p", { children: [
+			"Go to the",
+			" ",
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				className: "cursor-pointer underline",
+				onClick: () => {
+					showPHModal({ type: "settings" });
+				},
+				children: "package manager"
+			}),
+			" ",
+			"to install this document model"
+		] })]
+	}) });
+	if (!editorModule) return /* @__PURE__ */ jsx(EditorError, { message: /* @__PURE__ */ jsxs("div", {
+		className: "text-center leading-10",
+		children: [/* @__PURE__ */ jsx("p", { children: "Unable to open the document because no editor has been found" }), /* @__PURE__ */ jsxs("p", { children: [
+			"Go to the",
+			" ",
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				className: "cursor-pointer underline",
+				onClick: () => {
+					showPHModal({ type: "settings" });
+				},
+				children: "package manager"
+			}),
+			" ",
+			"an editor for the \"$",
+			documentType,
+			"\" document type"
+		] })]
+	}) });
+	const EditorComponent = editorModule.Component;
+	return /* @__PURE__ */ jsx("div", {
+		className: "relative h-full",
+		id: "document-editor-context",
+		"data-editor": editorModule.config.id,
+		"data-document-type": documentType,
+		children: revisionHistoryVisible ? isLoadingOperations ? /* @__PURE__ */ jsx(EditorLoader, { message: "Loading operations" }) : /* @__PURE__ */ jsx(RevisionHistory, {
+			documentTitle: documentName ?? "",
+			documentId: documentId ?? "",
+			globalOperations,
+			localOperations,
+			onClose: () => setRevisionHistoryVisible(false),
+			documentState: document.state,
+			onCopyState: () => {
+				toast("Copied document state to clipboard", { type: "success" });
+			},
+			onCopyDocId: () => {
+				toast("Copied document ID to clipboard", { type: "success" });
+			}
+		}, documentId) : /* @__PURE__ */ jsx(Suspense, {
+			fallback: /* @__PURE__ */ jsx(EditorLoader, { message: "Loading editor" }),
+			name: "EditorLoader",
+			children: /* @__PURE__ */ jsx(ErrorBoundary$1, {
+				fallbackRender: CenteredErrorMessage,
+				resetKeys: [documentId],
+				onError: handleEditorError,
+				loggerContext: ["Connect", "DocumentEditor"],
+				children: !editorError?.error && /* @__PURE__ */ jsx(EditorComponent, {
+					context: {
+						readMode: !!selectedTimelineItem,
+						selectedTimelineRevision: getRevisionFromDate(selectedTimelineItem?.startDate, selectedTimelineItem?.endDate, globalOperations)
+					},
+					documentId: document.header.id
+				}, documentId)
+			})
+		})
+	});
+};
+//#endregion
+//#region src/components/root.tsx
+function Root() {
+	return /* @__PURE__ */ jsx("div", {
+		className: "h-screen",
+		children: /* @__PURE__ */ jsx("div", {
+			className: `flex h-screen items-stretch overflow-auto`,
+			role: "presentation",
+			tabIndex: 0,
+			children: /* @__PURE__ */ jsxs(Suspense, {
+				name: "Root",
+				children: [/* @__PURE__ */ jsx(Sidebar, {}), /* @__PURE__ */ jsx("div", {
+					className: "relative flex-1 overflow-auto",
+					children: /* @__PURE__ */ jsx(Outlet, {})
+				})]
+			})
+		})
+	});
+}
+//#endregion
+//#region src/pages/content.tsx
+function Content() {
+	const [selectedDrive] = useSelectedDriveSafe();
+	const selectedFolder = useSelectedFolder();
+	const selectedDocumentId = useSelectedDocumentId();
+	useEffect(() => {
+		if (!selectedDocumentId) setPHDocumentEditorConfig(defaultPHDocumentEditorConfig);
+	}, [selectedDocumentId]);
+	useEffect(() => {
+		if (!selectedDrive) setPHAppConfig(defaultPHAppConfig);
+	}, [selectedDrive]);
+	return /* @__PURE__ */ jsx(ContentContainer, { children: !selectedDocumentId && !selectedDrive && !selectedFolder ? /* @__PURE__ */ jsx(HomeScreenContainer, {}) : /* @__PURE__ */ jsx(AppContainer, {}) });
+}
+function ContentContainer({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex h-full flex-col overflow-auto",
+		id: "content-view",
+		children
+	});
+}
+function DriveItem({ drive }) {
+	const description = useAppModuleById(drive.header.meta?.preferredEditor)?.config.name || "Drive Explorer App";
+	return /* @__PURE__ */ jsx(HomeScreenItem, {
+		title: drive.state.global.name || drive.header.name,
+		description,
+		icon: /* @__PURE__ */ jsx(DriveIcon, { drive }),
+		onClick: () => setSelectedDrive(drive)
+	}, drive.header.id);
+}
+function HomeScreenContainer() {
+	const drives = useDrives();
+	const config = connectConfig;
+	return /* @__PURE__ */ jsxs(HomeScreen, { children: [drives?.map((drive) => {
+		return /* @__PURE__ */ jsx(DriveItem, { drive }, drive.header.id);
+	}), config.drives.addDriveEnabled && /* @__PURE__ */ jsx(HomeScreenAddDriveItem, {})] });
+}
+//#endregion
+//#region src/pages/demo/atlas-import.tsx
+const REACTOR_URL = "https://apps.powerhouse.io/sky-atlas/staging/switchboard";
+const MIN_LOADING_TIME = 2e3;
+function useReactorUrl() {
+	const { search } = useLocation();
+	return useMemo(() => {
+		const url = new URLSearchParams(search).get("reactorUrl") ?? REACTOR_URL;
+		return url.endsWith("/") ? url : `${url}/`;
+	}, [search]);
+}
+async function forkAtlas(docId, reactorUrl) {
+	const document = gql`
+    mutation ForkAtlas($docId: PHID) {
+      ForkAtlas(docId: $docId)
+    }
+  `;
+	return await request(`${reactorUrl}graphql`, document, { docId });
+}
+function AtlasImport() {
+	const status = useRef("initial");
+	const reactor = useReactorClient();
+	const { documentId } = useParams();
+	const reactorUrl = useReactorUrl();
+	const navigate = useNavigate();
+	const [driveId, setDriveId] = useState(void 0);
+	const [error, setError] = useState(void 0);
+	const [loading, setLoading] = useState(true);
+	const hasError = status.current === "error";
+	useEffect(() => {
+		if (error) {
+			console.error("Error forking Atlas:", error);
+			toast("Error forking Atlas", { type: "error" });
+		}
+	}, [error]);
+	async function forkAtlasDocument(documentId) {
+		const driveId = (await forkAtlas(documentId, reactorUrl)).ForkAtlas;
+		status.current = "forked";
+		setDriveId(driveId);
+	}
+	const redirectToDrive = useCallback(() => {
+		if (driveId && !loading) navigate(`/d/${driveId}`, { replace: true });
+	}, [
+		driveId,
+		navigate,
+		loading
+	]);
+	const addForkDrive = useCallback(async (driveId) => {
+		console.log("Adding remote drive:", driveId);
+		const driveUrl = `${reactorUrl}d/${driveId}`;
+		try {
+			const addedDrive = await addRemoteDrive(driveUrl);
+			status.current = "done";
+			console.log("Added remote drive:", addedDrive);
+			setTimeout(() => {
+				setLoading(false);
+			}, MIN_LOADING_TIME);
+		} catch (error) {
+			status.current = "error";
+			setLoading(false);
+			setError(error);
+		}
+	}, [
+		addRemoteDrive,
+		navigate,
+		reactorUrl
+	]);
+	useEffect(() => {
+		if (!documentId || status.current !== "initial") return;
+		status.current = "forking";
+		forkAtlasDocument(documentId).catch((error) => {
+			status.current = "error";
+			setError(error);
+		});
+	}, [documentId, status]);
+	useEffect(() => {
+		if (!driveId || !reactor || status.current !== "forked") return;
+		status.current = "addingDrive";
+		new Promise((resolve) => {
+			setTimeout(resolve, 500);
+		}).then(() => addForkDrive(driveId)).catch((error) => {
+			status.current = "error";
+			setError(error);
+		});
+	}, [
+		driveId,
+		reactor,
+		status
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex size-full justify-center gap-x-4 bg-gray-50",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "w-full max-w-[850px] rounded-2xl bg-white p-6 drop-shadow-sm",
+			children: [/* @__PURE__ */ jsx("h1", {
+				className: "text-lg font-medium text-gray-900",
+				children: "Welcome to the Atlas Explorer"
+			}), /* @__PURE__ */ jsx("div", {
+				className: "mt-4 rounded-xl border border-gray-200 bg-gray-50 p-6",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "flex min-h-80 flex-col items-center justify-center rounded-2xl bg-slate-50",
+					children: [
+						/* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsxs("svg", {
+							width: "28",
+							height: "32",
+							viewBox: "0 0 28 32",
+							fill: "none",
+							xmlns: "http://www.w3.org/2000/svg",
+							children: [
+								/* @__PURE__ */ jsx("path", {
+									fillRule: "evenodd",
+									clipRule: "evenodd",
+									d: "M0.05092 23.7286L0.000163347 23.9993L0 23.9995L0.207853 24.067L27.6823 24.067L27.9995 23.9995L27.9161 23.6913L14.2182 0.209032L13.9998 0L13.749 0.246353L0.05092 23.7286ZM20.9994 11.9999L7.0003 11.9999L13.9998 23.999L20.9994 11.9999Z",
+									fill: "url(#paint0_radial_319_20865)"
+								}),
+								/* @__PURE__ */ jsx("path", {
+									d: "M14 0L0 23.9998V7.99993L14 0Z",
+									fill: "url(#paint1_linear_319_20865)"
+								}),
+								/* @__PURE__ */ jsx("path", {
+									d: "M28 24L7.82013e-05 24L14 31.9999L28 24Z",
+									fill: "url(#paint2_linear_319_20865)"
+								}),
+								/* @__PURE__ */ jsx("path", {
+									d: "M14 0L28 23.9998V7.99993L14 0Z",
+									fill: "url(#paint3_linear_319_20865)"
+								}),
+								/* @__PURE__ */ jsxs("defs", { children: [
+									/* @__PURE__ */ jsxs("radialGradient", {
+										id: "paint0_radial_319_20865",
+										cx: "0",
+										cy: "0",
+										r: "1",
+										gradientUnits: "userSpaceOnUse",
+										gradientTransform: "translate(13.9994 16.0344) rotate(-89.9988) scale(16.0344 16.201)",
+										children: [/* @__PURE__ */ jsx("stop", {
+											offset: "0.181008",
+											stopColor: "#FFCD6B"
+										}), /* @__PURE__ */ jsx("stop", {
+											offset: "1",
+											stopColor: "#EB5EDF"
+										})]
+									}),
+									/* @__PURE__ */ jsxs("linearGradient", {
+										id: "paint1_linear_319_20865",
+										x1: "-0.031454",
+										y1: "24.041",
+										x2: "13.801",
+										y2: "-0.142908",
+										gradientUnits: "userSpaceOnUse",
+										children: [/* @__PURE__ */ jsx("stop", { stopColor: "#4331E9" }), /* @__PURE__ */ jsx("stop", {
+											offset: "1",
+											stopColor: "#A273FF"
+										})]
+									}),
+									/* @__PURE__ */ jsxs("linearGradient", {
+										id: "paint2_linear_319_20865",
+										x1: "-0.0310093",
+										y1: "24",
+										x2: "28.0444",
+										y2: "24",
+										gradientUnits: "userSpaceOnUse",
+										children: [/* @__PURE__ */ jsx("stop", { stopColor: "#A273FF" }), /* @__PURE__ */ jsx("stop", {
+											offset: "1",
+											stopColor: "#4331E9"
+										})]
+									}),
+									/* @__PURE__ */ jsxs("linearGradient", {
+										id: "paint3_linear_319_20865",
+										x1: "28.0315",
+										y1: "24.041",
+										x2: "14.199",
+										y2: "-0.142908",
+										gradientUnits: "userSpaceOnUse",
+										children: [/* @__PURE__ */ jsx("stop", { stopColor: "#A273FF" }), /* @__PURE__ */ jsx("stop", {
+											offset: "1",
+											stopColor: "#4331E9"
+										})]
+									})
+								] })
+							]
+						}) }),
+						hasError ? /* @__PURE__ */ jsx("div", {
+							className: "mt-3 text-sm text-gray-800",
+							children: "Error forking Atlas scope. Please try again."
+						}) : /* @__PURE__ */ jsx("div", {
+							className: "mt-3 text-sm text-gray-500",
+							children: "Forking Atlas scope..."
+						}),
+						/* @__PURE__ */ jsx(PowerhouseButton, {
+							onClick: hasError ? window.location.reload.bind(window.location) : redirectToDrive,
+							size: "small",
+							color: "light",
+							className: "mt-4 h-9 border border-gray-200 bg-white px-3 text-gray-600",
+							children: hasError ? "Retry" : loading ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("svg", {
+								className: "animate-spin",
+								width: "16",
+								height: "16",
+								viewBox: "0 0 16 16",
+								fill: "none",
+								xmlns: "http://www.w3.org/2000/svg",
+								children: [/* @__PURE__ */ jsx("path", {
+									d: "M15.6867 8.03333C15.4933 7.83999 15.1733 7.83999 14.98 8.03333L14.6733 8.34001V8C14.6733 4.32 11.68 1.32666 7.99999 1.32666C5.96666 1.32666 4.06666 2.23999 2.79333 3.82666C2.61999 4.03999 2.65332 4.35999 2.87332 4.52665C3.08666 4.69999 3.40666 4.66666 3.57332 4.44666C4.65999 3.09332 6.27332 2.31999 7.99999 2.31999C11.1267 2.31999 13.6733 4.86666 13.6733 7.99333V8.32666L13.3667 8.02002C13.1733 7.82669 12.8533 7.82669 12.66 8.02002C12.4667 8.21335 12.4667 8.53335 12.66 8.72668L13.82 9.88668C13.8667 9.93334 13.92 9.96666 13.98 9.99333C14.04 10.02 14.1067 10.0333 14.1733 10.0333C14.24 10.0333 14.3 10.02 14.3667 9.99333C14.4267 9.96666 14.48 9.93334 14.5267 9.88668L15.6867 8.72668C15.88 8.54668 15.88 8.22666 15.6867 8.03333Z",
+									fill: "#6C7275"
+								}), /* @__PURE__ */ jsx("path", {
+									d: "M13.1267 11.4666C12.9133 11.2933 12.5933 11.3266 12.4267 11.5466C11.34 12.9 9.72665 13.6733 7.99998 13.6733C4.87332 13.6733 2.32665 11.1266 2.32665 7.99996V7.66663L2.63332 7.97331C2.73332 8.07331 2.85999 8.11996 2.98665 8.11996C3.11332 8.11996 3.23999 8.07331 3.33999 7.97331C3.53332 7.77998 3.53332 7.45998 3.33999 7.26664L2.17998 6.10661C2.13332 6.05994 2.07998 6.02663 2.01998 5.99996C1.89998 5.94663 1.75998 5.94663 1.63998 5.99996C1.57998 6.02663 1.52665 6.05994 1.47999 6.10661L0.319988 7.26664C0.126654 7.45998 0.126654 7.77998 0.319988 7.97331C0.513321 8.16664 0.833319 8.16664 1.02665 7.97331L1.33332 7.66663V7.99996C1.33332 11.68 4.32665 14.6733 8.00665 14.6733C10.04 14.6733 11.94 13.76 13.2133 12.1733C13.38 11.96 13.3467 11.64 13.1267 11.4666Z",
+									fill: "#6C7275"
+								})]
+							}), "Loading"] }) : "Continue"
+						})
+					]
+				})
+			})]
+		})
+	});
+}
+//#endregion
+//#region src/components/router.tsx
+function createRouter(routes) {
+	const routerBasename = connectConfig.routerBasename;
+	return createBrowserRouter(routes, {
+		basename: routerBasename,
+		future: {
+			v7_fetcherPersist: true,
+			v7_relativeSplatPath: true
+		}
+	});
+}
+function createRoutes() {
+	return [{
+		element: /* @__PURE__ */ jsx(Suspense, {
+			name: "RouteRoot",
+			children: /* @__PURE__ */ jsx(Root, {})
+		}),
+		children: [{
+			index: true,
+			path: "d?/:driveId?/*?",
+			element: /* @__PURE__ */ jsx(Suspense, {
+				name: "Drive",
+				children: /* @__PURE__ */ jsx(Content, {})
+			})
+		}, {
+			path: "import/:documentId",
+			element: /* @__PURE__ */ jsx(Suspense, {
+				name: "AtlasImport",
+				children: /* @__PURE__ */ jsx(AtlasImport, {})
+			})
+		}]
+	}];
+}
+const router = createRouter(createRoutes());
+const Router = () => {
+	return /* @__PURE__ */ jsx(RouterProvider, { router });
+};
+//#endregion
+//#region src/components/sidebar.tsx
+function Sidebar() {
+	const user = useUser();
+	const drives = useDrives();
+	const [selectedDrive] = useSelectedDriveSafe();
+	const connectDebug = localStorage.getItem("CONNECT_DEBUG") === "true";
+	const ensName = user?.ens?.name || user?.profile?.username || void 0;
+	const avatarUrl = user?.ens?.avatarUrl || user?.profile?.userImage || void 0;
+	const ensInfo = useEns(!avatarUrl ? user?.address : void 0);
+	const onClickSettings = () => {
+		showPHModal({ type: "settings" });
+	};
+	const onAddDriveClick = () => {
+		showPHModal({ type: "addDrive" });
+	};
+	const etherscanUrl = user?.address ? `https://etherscan.io/address/${user.address}` : "";
+	return /* @__PURE__ */ jsx(ConnectTooltipProvider, { children: /* @__PURE__ */ jsx(ConnectSidebar, {
+		id: "sidebar",
+		onClick: () => setSelectedDrive(void 0),
+		onClickSettings,
+		address: user?.address,
+		onLogin: openRenown,
+		onDisconnect: logout,
+		ensName: ensName || ensInfo.data?.ens,
+		avatarUrl: avatarUrl || ensInfo.data?.avatar_small || ensInfo.data?.avatar_url || void 0,
+		etherscanUrl,
+		showDebug: connectDebug,
+		onDebugClick: () => showPHModal({ type: "debugSettings" }),
+		children: /* @__PURE__ */ jsxs(ErrorBoundary$1, {
+			variant: "text",
+			fallbackMessage: "There was an error loading drives",
+			loggerContext: ["Connect", "Sidebar"],
+			children: [drives?.map((drive, index) => /* @__PURE__ */ jsx(SidebarItem, {
+				title: drive.header.name,
+				onClick: () => setSelectedDrive(drive),
+				active: selectedDrive?.header.id === drive.header.id,
+				icon: /* @__PURE__ */ jsx(DriveIcon, { drive })
+			}, index)), connectConfig.drives.addDriveEnabled && /* @__PURE__ */ jsx(SidebarAddDriveItem, { onClick: onAddDriveClick })]
+		})
+	}) });
+}
+//#endregion
+export { AppLoader as t };
+
+//# sourceMappingURL=sidebar-DHvt_u7k.js.map