@powerhousedao/connect 6.0.0-dev.25 → 6.0.0-dev.250

package/dist/sidebar-CqF9WSUF.js

@@ -0,0 +1,1474 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="4e5cbc2f-6a75-53b4-8004-9174c5444d0e")}catch(e){}}();
+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-4rfcgnb9.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-Btp8ZXVH.js";
+import { t as serviceWorkerManager } from "./registerServiceWorker-CMRF2LWE.js";
+import { driveCollectionId, getRevisionFromDate, logout, openRenown, setPHAppConfig, setPHDocumentEditorConfig, setRevisionHistoryVisible, setSelectedDrive, setSelectedNode, showPHModal, useAppModuleById, useDefaultAppModule, useDocumentById, useDocumentModelModuleById, useDocumentOperations, useDrives, useEditorModuleById, useFallbackEditorModule, useNodeParentFolderById, usePHModal, usePackageDiscoveryService, 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, useNavigationType } 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, Modal, PowerhouseButton } from "@powerhousedao/design-system";
+import { ErrorBoundary } from "react-error-boundary";
+import { PGlite } from "@electric-sql/pglite";
+import { twMerge } from "tailwind-merge";
+import { PackageInstallModal } from "@powerhousedao/design-system/connect/index";
+import { redo, undo } from "@powerhousedao/shared/document-model";
+//#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/useFailedInstallations.ts
+const emptyArray$1 = [];
+function useFailedInstallations() {
+	const discoveryService = usePackageDiscoveryService();
+	return useSyncExternalStore((cb) => discoveryService?.subscribeFailed(cb) ?? (() => {}), () => discoveryService?.getFailedInstallations() ?? emptyArray$1);
+}
+//#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();
+	const cacheRef = useRef(emptyArray);
+	return useSyncExternalStore((cb) => discoveryService?.subscribePending(cb) ?? (() => {}), useCallback(() => {
+		if (!discoveryService) return emptyArray;
+		const next = discoveryService.getPendingInstallations() ?? emptyArray;
+		const prev = cacheRef.current;
+		if (next === prev || next.length === prev.length && next.every((p, i) => p === prev[i])) return prev;
+		cacheRef.current = next;
+		return next;
+	}, [discoveryService]));
+}
+//#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 text-sm font-medium text-gray-700 underline select-none hover:text-gray-700",
+						children: "Show details"
+					}), /* @__PURE__ */ jsx("pre", {
+						className: "mt-2 max-h-48 overflow-auto rounded-sm bg-gray-100 p-3 text-xs",
+						children: errorDetails
+					})]
+				}),
+				/* @__PURE__ */ jsx(PowerhouseButton, {
+					type: "button",
+					onClick: resetErrorBoundary,
+					className: "mt-4 px-3 py-1.5 text-base 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-sm 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-sm 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-ZK9-BWMB.js").then((m) => ({ default: m.AddDriveModal })));
+const ClearStorageModal = lazy(() => import("./ClearStorageModal-Bfb3ube7.js").then((m) => ({ default: m.ClearStorageModal })));
+const CookiesPolicyModal = lazy(() => import("./CookiesPolicyModal-DiXQV82b.js").then((m) => ({ default: m.CookiesPolicyModal })));
+const CreateDocumentModal$1 = lazy(() => import("./CreateDocumentModal-BhJh4nWt.js").then((m) => ({ default: m.CreateDocumentModal })));
+const DebugSettingsModal = lazy(() => import("./DebugSettingsModal-pSFieIFj.js").then((m) => ({ default: m.DebugSettingsModal })));
+const DeleteDriveModal = lazy(() => import("./DeleteDriveModal-CbuIdjKY.js").then((m) => ({ default: m.DeleteDriveModal })));
+const DeleteItemModal = lazy(() => import("./DeleteItemModal-9ErYlauT.js").then((m) => ({ default: m.DeleteItemModal })));
+const DisclaimerModal = lazy(() => import("./DisclaimerModal-CfDeiBz8.js").then((m) => ({ default: m.DisclaimerModal })));
+const DriveSettingsModal$1 = lazy(() => import("./DriveSettingsModal-DEk05PS7.js").then((m) => ({ default: m.DriveSettingsModal })));
+const DownloadDocumentWithErrorsModal = lazy(() => import("./DownloadDocumentWithErrorsModal-KZGWQ4J7.js").then((m) => ({ default: m.DownloadDocumentWithErrorsModal })));
+const SettingsModal$1 = lazy(() => import("./SettingsModal-BXe0C8Gj.js").then((m) => ({ default: m.SettingsModal })));
+const UpgradeDriveModal = lazy(() => import("./UpgradeDriveModal-BwI5E5k3.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-DV7lUbNo.js").then((m) => ({ default: m.InspectorModal }))),
+	settings: SettingsModal$1,
+	upgradeDrive: UpgradeDriveModal,
+	missingPackage: lazy(() => import("./MissingPackageModal-BM4HV-ct.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-ihBI3uL5.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/missing-model-banner.tsx
+const reasonLabels = {
+	"no-registry": "No package registry is configured.",
+	"not-in-registry": "No matching package found in the registry.",
+	"registry-error": "Couldn't reach the package registry.",
+	"install-failed": "Package failed to install.",
+	dismissed: "Installation was dismissed."
+};
+function canRetry(reason) {
+	return reason !== "no-registry";
+}
+function MissingModelBanner() {
+	const failed = useFailedInstallations();
+	const [open, setOpen] = useState(false);
+	if (failed.length === 0) return null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("div", {
+		className: "flex items-center justify-between gap-3 bg-amber-100 px-4 py-2 text-sm text-amber-900",
+		children: [/* @__PURE__ */ jsx("span", { children: failed.length === 1 ? "1 document type couldn't load (missing model)." : `${failed.length} document types couldn't load (missing models).` }), /* @__PURE__ */ jsx("button", {
+			type: "button",
+			onClick: () => setOpen(true),
+			className: "rounded-md border border-amber-300 bg-white px-3 py-1 text-amber-900 hover:bg-amber-50",
+			children: "View"
+		})]
+	}), /* @__PURE__ */ jsx(MissingModelDetailsModal, {
+		open,
+		failed,
+		onClose: () => setOpen(false)
+	})] });
+}
+function MissingModelDetailsModal(props) {
+	const { open, failed, onClose } = props;
+	const discoveryService = usePackageDiscoveryService();
+	const [retrying, setRetrying] = useState(() => /* @__PURE__ */ new Set());
+	async function handleRetry(documentType) {
+		if (!discoveryService) return;
+		setRetrying((prev) => new Set(prev).add(documentType));
+		try {
+			await discoveryService.retryInstallation(documentType);
+		} finally {
+			setRetrying((prev) => {
+				const next = new Set(prev);
+				next.delete(documentType);
+				return next;
+			});
+		}
+	}
+	return /* @__PURE__ */ jsx(Modal, {
+		open,
+		onOpenChange: (isOpen) => {
+			if (!isOpen) onClose();
+		},
+		contentProps: { className: "rounded-3xl" },
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "w-[520px] max-w-[90vw] p-6",
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: "border-b border-slate-100 pb-2 text-2xl font-bold text-gray-800",
+					children: "Missing document models"
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "my-4 text-sm text-gray-600",
+					children: "The following document types couldn't be loaded. Documents using them won't display until the underlying package is installed."
+				}),
+				failed.length === 0 ? /* @__PURE__ */ jsx("div", {
+					className: "rounded-xl bg-slate-50 p-4 text-sm text-gray-600",
+					children: "No outstanding failures."
+				}) : /* @__PURE__ */ jsx("div", {
+					className: "flex max-h-[60vh] flex-col gap-3 overflow-y-auto",
+					children: failed.map((entry) => {
+						const isRetrying = retrying.has(entry.documentType);
+						const retryDisabled = !canRetry(entry.reason) || isRetrying;
+						return /* @__PURE__ */ jsxs("div", {
+							className: "rounded-xl bg-slate-50 p-4",
+							children: [
+								/* @__PURE__ */ jsx("div", {
+									className: "mb-1 font-mono text-sm font-semibold text-gray-800",
+									children: entry.documentType
+								}),
+								/* @__PURE__ */ jsx("div", {
+									className: "mb-2 text-xs text-gray-600",
+									children: reasonLabels[entry.reason]
+								}),
+								entry.packageNames.length > 0 ? /* @__PURE__ */ jsxs("div", {
+									className: "mb-2 text-xs text-gray-500",
+									children: [
+										"Package",
+										entry.packageNames.length > 1 ? "s" : "",
+										":",
+										" ",
+										entry.packageNames.join(", ")
+									]
+								}) : null,
+								entry.error ? /* @__PURE__ */ jsx("div", {
+									className: "mb-2 font-mono text-xs wrap-break-word text-red-700",
+									children: entry.error.message
+								}) : null,
+								/* @__PURE__ */ jsx("div", {
+									className: "flex justify-end",
+									children: /* @__PURE__ */ jsx("button", {
+										type: "button",
+										onClick: () => void handleRetry(entry.documentType),
+										disabled: retryDisabled,
+										title: canRetry(entry.reason) ? void 0 : "No registry is configured; nothing to retry against.",
+										className: twMerge("min-h-[32px] rounded-xl px-3 py-1 text-sm font-semibold text-white transition-all hover:scale-105", retryDisabled ? "cursor-not-allowed bg-gray-300 hover:scale-100" : "bg-gray-800 active:opacity-75"),
+										children: isRetrying ? "Retrying..." : "Try install again"
+									})
+								})
+							]
+						}, entry.documentType);
+					})
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "mt-4 flex justify-end",
+					children: /* @__PURE__ */ jsx("button", {
+						type: "button",
+						onClick: onClose,
+						className: "min-h-[36px] rounded-xl border border-slate-200 bg-white px-4 py-2 text-sm font-semibold text-slate-800 hover:bg-slate-50",
+						children: "Close"
+					})
+				})
+			]
+		})
+	});
+}
+//#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(MissingModelBanner, {}),
+		/* @__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 pt-10 pb-16 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/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, {})
+			})
+		}]
+	}];
+}
+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-CqF9WSUF.js.map
+//# debugId=4e5cbc2f-6a75-53b4-8004-9174c5444d0e