@powerhousedao/reactor-browser 6.0.0-dev.23 → 6.0.0-dev.230

package/dist/index.js

@@ -0,0 +1,3249 @@
+import { C as uploadOperations, S as queueOperations, _ as clearGlobal, a as setDocumentCache, b as dispatchActions, c as useDocuments, d as useGetDocuments, f as DocumentCache, g as getAnalyticsStore, h as createAnalyticsStore, i as addDocumentCacheEventHandler, l as useGetDocument, m as readPromiseState, n as useDocumentsByIds, o as useDocument, p as addPromiseState, r as useDispatch, s as useDocumentCache, t as useDocumentById, u as useGetDocumentAsync, v as getGlobal, x as queueActions, y as setGlobal } from "./document-by-id-CDLUqru5.js";
+import { n as GetDocumentWithOperationsDocument, r as PropagationMode, t as createClient } from "./client-DfoxBz8A.js";
+import { t as makePHEventFunctions } from "./make-ph-event-functions-Cr4GqOTT.js";
+import { A as useLoginStatus, C as RENOWN_CHAIN_ID, D as addRenownEventHandler, E as VERIFIABLE_CREDENTIAL_EIP712_TYPE, F as setLoading, I as useLoading, M as useUser, N as addLoadingEventHandler, O as setRenown, P as loading, S as ISSUER_TYPE, T as RENOWN_URL, _ as openRenown, a as RenownAuthButton, b as CREDENTIAL_TYPES, c as ChevronDownIcon, d as RenownLogo, f as SpinnerIcon, g as logout, h as login, i as initRenownCrypto, j as useRenown, k as useDid, l as CopyIcon, m as useRenownAuth, n as useRenownInit, o as RenownUserButton, p as UserIcon, r as initConnectCrypto, s as RenownLoginButton, t as Renown, u as DisconnectIcon, v as CREDENTIAL_SCHEMA_EIP712_TYPE, w as RENOWN_NETWORK_ID, x as DOMAIN_TYPE, y as CREDENTIAL_SUBJECT_TYPE } from "./renown-CV_45Xc1.js";
+import { n as useRelationalQuery, r as useRelationalDb, t as createProcessorQuery } from "./relational-jwreqDwz.js";
+import { documentModelDocumentModelModule, logger } from "document-model";
+import { baseLoadFromInput, baseSaveToFileHandle, createPresignedHeader, createZip, documentModelDocumentType, generateId, replayDocument, setName, validateInitialState, validateModules, validateStateSchemaName } from "@powerhousedao/shared/document-model";
+import { DriveDocumentSchema, addFolder as addFolder$1, copyNode, driveCreateDocument, generateNodesCopy, handleTargetNameCollisions, isFileNode, isFolderNode, moveNode, setAvailableOffline, setSharingType, updateNode } from "@powerhousedao/shared/document-drive";
+import { ChannelScheme, DocumentChangeType, DocumentIntegrityService, DuplicateManifestError, DuplicateModuleError, GqlRequestChannel, InMemoryQueue, IntervalPollTimer, ModuleNotFoundError, PollBehavior, REACTOR_SCHEMA, REACTOR_SCHEMA as REACTOR_SCHEMA$1, ReactorBuilder, ReactorClientBuilder, RelationalDbProcessor, SyncOperationStatus, SyncStatus, driveCollectionId, driveCollectionId as driveCollectionId$1, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
+import { filter, forEach, forEachObj, funnel, isIncludedIn, isStrictEqual, isTruthy, map, mapToObj, pipe, prop, unique } from "remeda";
+import { z } from "zod";
+import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import slug from "slug";
+import * as lzString from "lz-string";
+//#region src/errors.ts
+var UnsupportedDocumentTypeError = class extends Error {
+	constructor(documentType) {
+		super(`Document type ${documentType} is not supported`);
+		this.name = "UnsupportedDocumentTypeError";
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "UnsupportedDocumentTypeError";
+	}
+};
+var DocumentModelNotFoundError = class extends Error {
+	documentType;
+	name = "DocumentModelNotFoundError";
+	constructor(documentType) {
+		super(`Document model module for type ${documentType} not found`);
+		this.documentType = documentType;
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "DocumentModelNotFoundError";
+	}
+};
+var DocumentTypeMismatchError = class extends Error {
+	constructor(documentId, expectedType, actualType) {
+		super(`Document ${documentId} is not of type ${expectedType}. Actual type: ${actualType}`);
+	}
+};
+var NoSelectedDocumentError = class extends Error {
+	constructor() {
+		super("There is no selected document. Did you mean to call 'useSelectedDocumentSafe' instead?");
+	}
+};
+//#endregion
+//#region src/utils/documents.ts
+function isDocumentTypeSupported(documentType, supportedDocuments) {
+	if (!supportedDocuments?.length) return true;
+	return supportedDocuments.some((pattern) => {
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -2);
+			return documentType.startsWith(prefix + "/");
+		}
+		if (pattern.endsWith("*") && !pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -1);
+			return documentType.startsWith(prefix);
+		}
+		return pattern === documentType;
+	});
+}
+//#endregion
+//#region src/utils/user.ts
+function getUserPermissions() {
+	const user = window.ph?.renown?.user;
+	const allowList = window.ph?.allowList;
+	if (!allowList) return {
+		isAllowedToCreateDocuments: true,
+		isAllowedToEditDocuments: true
+	};
+	return {
+		isAllowedToCreateDocuments: allowList.includes(user?.address ?? ""),
+		isAllowedToEditDocuments: allowList.includes(user?.address ?? "")
+	};
+}
+//#endregion
+//#region src/actions/document.ts
+const BASE_STATE_KEYS = new Set(["auth"]);
+const NON_DOMAIN_SCOPES = new Set(["auth", "document"]);
+async function isDocumentInLocation(document, driveId, parentFolder) {
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) return { isDuplicate: false };
+	let drive;
+	try {
+		drive = await reactorClient.get(driveId);
+	} catch {
+		return { isDuplicate: false };
+	}
+	const nodeById = drive.state.global.nodes.find((node) => node.id === document.header.id);
+	if (nodeById && nodeById.parentFolder === (parentFolder ?? null)) return {
+		isDuplicate: true,
+		duplicateType: "id",
+		nodeId: nodeById.id
+	};
+	const nodeByNameAndType = drive.state.global.nodes.find((node) => isFileNode(node) && node.name === document.header.name && node.documentType === document.header.documentType && node.parentFolder === (parentFolder ?? null));
+	if (nodeByNameAndType) return {
+		isDuplicate: true,
+		duplicateType: "name",
+		nodeId: nodeByNameAndType.id
+	};
+	return { isDuplicate: false };
+}
+function getDocumentTypeIcon(document) {
+	switch (document.header.documentType) {
+		case "powerhouse/document-model": return "document-model";
+		case "powerhouse/app": return "app";
+		case "powerhouse/document-editor": return "editor";
+		case "powerhouse/subgraph": return "subgraph";
+		case "powerhouse/package": return "package";
+		case "powerhouse/processor": {
+			const processorType = document.state.global?.type;
+			if (processorType === "analytics") return "analytics-processor";
+			if (processorType === "relational") return "relational-processor";
+			if (processorType === "codegen") return "codegen-processor";
+			return;
+		}
+		default: return;
+	}
+}
+async function downloadFile(document, fileName) {
+	(await createZip(document)).generateAsync({ type: "blob" }).then((blob) => {
+		const link = window.document.createElement("a");
+		link.style.display = "none";
+		link.href = URL.createObjectURL(blob);
+		link.download = fileName;
+		window.document.body.appendChild(link);
+		link.click();
+		window.document.body.removeChild(link);
+	}).catch(logger.error);
+}
+async function getDocumentExtension(document) {
+	const documentType = document.header.documentType;
+	let rawExtension;
+	if (documentType === documentModelDocumentType) rawExtension = document.state.global?.extension;
+	else {
+		const reactorClient = window.ph?.reactorClient;
+		if (reactorClient) {
+			const { results: documentModelModules } = await reactorClient.getDocumentModelModules();
+			rawExtension = documentModelModules.find((m) => m.documentModel.global.id === documentType)?.utils.fileExtension;
+		}
+	}
+	return (rawExtension ?? "").replace(/^\.+|\.+$/g, "");
+}
+/**
+* Fetches all operations for a document using cursor-based pagination.
+* The reactor client handles multi-scope cursors transparently via
+* composite cursors, so all scopes are fetched in a single paginated stream.
+*/
+async function fetchDocumentOperations(reactorClient, document, pageSize = 100) {
+	const scopes = Object.keys(document.state).filter((k) => !BASE_STATE_KEYS.has(k));
+	const operations = {};
+	for (const scope of scopes) operations[scope] = [];
+	let cursor = "";
+	do {
+		const page = await reactorClient.getOperations(document.header.id, { scopes }, void 0, {
+			cursor,
+			limit: pageSize
+		});
+		for (const op of page.results) {
+			const scope = op.action.scope ?? "global";
+			if (operations[scope]) operations[scope].push(op);
+		}
+		cursor = page.nextCursor ?? "";
+	} while (cursor);
+	return operations;
+}
+function extractInitialState(documentScopeOps) {
+	const upgradeOp = documentScopeOps.find((op) => op.action.type === "UPGRADE_DOCUMENT");
+	if (!upgradeOp) throw new Error("No UPGRADE_DOCUMENT operation found — document is invalid");
+	const input = upgradeOp.action.input;
+	const initialState = input.initialState ?? input.state;
+	if (!initialState) throw new Error("UPGRADE_DOCUMENT operation has no initialState — document is invalid");
+	return initialState;
+}
+function filterDomainOperations(operations) {
+	return Object.fromEntries(Object.entries(operations).filter(([scope]) => !NON_DOMAIN_SCOPES.has(scope)));
+}
+async function exportFile(document, suggestedName) {
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const operations = await fetchDocumentOperations(reactorClient, document);
+	const initialState = extractInitialState(operations["document"] ?? []);
+	const documentWithOps = {
+		...document,
+		operations,
+		initialState
+	};
+	const extension = await getDocumentExtension(documentWithOps);
+	const baseName = suggestedName || documentWithOps.header.name || "Untitled";
+	const name = extension ? `${baseName}.${extension}.phd` : `${baseName}.phd`;
+	if (!window.showSaveFilePicker) return await downloadFile(documentWithOps, name);
+	try {
+		const fileHandle = await window.showSaveFilePicker({ suggestedName: name });
+		await baseSaveToFileHandle(documentWithOps, fileHandle);
+		return fileHandle;
+	} catch (e) {
+		if (!(e instanceof DOMException && e.name === "AbortError")) throw e;
+	}
+}
+async function loadFile(path) {
+	const baseDocument = await baseLoadFromInput(path, (state) => state, { checkHashes: true });
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const { results: documentModelModules } = await reactorClient.getDocumentModelModules();
+	const documentModelModule = documentModelModules.find((module) => module.documentModel.global.id === baseDocument.header.documentType);
+	if (!documentModelModule) throw new DocumentModelNotFoundError(baseDocument.header.documentType);
+	return documentModelModule.utils.loadFromInput(path);
+}
+async function addDocument(driveId, name, documentType, parentFolder, document, id, preferredEditor) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const documentModelModule = await reactorClient.getDocumentModelModule(documentType);
+	const newDocument = document ?? documentModelModule.utils.createDocument();
+	newDocument.header.name = name;
+	if (preferredEditor) newDocument.header.meta = {
+		...newDocument.header.meta,
+		preferredEditor
+	};
+	let newDoc;
+	try {
+		newDoc = await reactorClient.drives.addFile(driveId, newDocument, parentFolder);
+	} catch (e) {
+		logger.error("Error adding document", e);
+		throw new Error("There was an error adding document");
+	}
+	return {
+		id: newDoc.header.id,
+		name: newDoc.header.name,
+		documentType,
+		parentFolder: parentFolder ?? null,
+		kind: "file"
+	};
+}
+async function addFile(file, driveId, name, parentFolder) {
+	logger.verbose(`addFile(drive: ${driveId}, name: ${name}, folder: ${parentFolder})`);
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create files");
+	const document = await loadFile(file);
+	let duplicateId = false;
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	try {
+		await reactorClient.get(document.header.id);
+		duplicateId = true;
+	} catch {}
+	const documentId = duplicateId ? generateId() : document.header.id;
+	const header = createPresignedHeader(documentId, document.header.documentType);
+	header.lastModifiedAtUtcIso = document.header.createdAtUtcIso;
+	header.meta = document.header.meta;
+	header.name = name || document.header.name;
+	const initialDocument = {
+		...document,
+		header,
+		state: document.initialState,
+		operations: Object.keys(document.operations).reduce((acc, key) => {
+			acc[key] = [];
+			return acc;
+		}, {})
+	};
+	await addDocument(driveId, name || document.header.name, document.header.documentType, parentFolder, initialDocument, documentId, document.header.meta?.preferredEditor);
+	await uploadOperations(documentId, filterDomainOperations(document.operations), queueOperations);
+}
+async function addFileWithProgress(file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict) {
+	logger.verbose(`addFileWithProgress(drive: ${driveId}, name: ${name}, folder: ${parentFolder})`);
+	const reactor = window.ph?.reactorClient;
+	if (!reactor) return;
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create files");
+	try {
+		onProgress?.({
+			stage: "loading",
+			progress: 0
+		});
+		let document;
+		try {
+			document = await loadFile(file);
+		} catch (loadError) {
+			const discoveryService = window.ph?.packageDiscoveryService;
+			if (discoveryService && DocumentModelNotFoundError.isError(loadError)) {
+				retryAfterDiscovery(discoveryService, loadError.documentType, file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict);
+				return;
+			}
+			throw loadError;
+		}
+		const duplicateCheck = await isDocumentInLocation(document, driveId, parentFolder);
+		if (duplicateCheck.isDuplicate && !resolveConflict) {
+			onProgress?.({
+				stage: "conflict",
+				progress: 0,
+				duplicateType: duplicateCheck.duplicateType
+			});
+			return;
+		}
+		if (duplicateCheck.isDuplicate && resolveConflict === "replace" && duplicateCheck.nodeId) await deleteNode(driveId, duplicateCheck.nodeId);
+		const documentType = getDocumentTypeIcon(document);
+		if (documentType) onProgress?.({
+			stage: "loading",
+			progress: 10,
+			documentType
+		});
+		else onProgress?.({
+			stage: "loading",
+			progress: 10
+		});
+		if (!isDocumentTypeSupported(document.header.documentType, documentTypes)) {
+			onProgress?.({
+				stage: "unsupported-document-type",
+				progress: 100,
+				error: `Document type ${document.header.documentType} is not supported`
+			});
+			throw new UnsupportedDocumentTypeError(document.header.documentType);
+		}
+		await reactor.getDocumentModelModule(document.header.documentType);
+		onProgress?.({
+			stage: "initializing",
+			progress: 10
+		});
+		let duplicateId = false;
+		try {
+			await reactor.get(document.header.id);
+			duplicateId = true;
+		} catch {}
+		const documentId = duplicateId ? generateId() : document.header.id;
+		const header = createPresignedHeader(documentId, document.header.documentType);
+		header.lastModifiedAtUtcIso = document.header.createdAtUtcIso;
+		header.meta = document.header.meta;
+		header.name = name || document.header.name;
+		const initialDocument = {
+			...document,
+			header,
+			state: document.initialState,
+			operations: Object.keys(document.operations).reduce((acc, key) => {
+				acc[key] = [];
+				return acc;
+			}, {})
+		};
+		const fileNode = await addDocument(driveId, name || document.header.name, document.header.documentType, parentFolder, initialDocument, documentId, document.header.meta?.preferredEditor);
+		if (!fileNode) throw new Error("There was an error adding file");
+		onProgress?.({
+			stage: "initializing",
+			progress: 20
+		});
+		await reactor.get(documentId);
+		console.log("Document created, starting upload of operations");
+		await uploadOperations(documentId, filterDomainOperations(document.operations), queueOperations, { onProgress: (uploadProgress) => {
+			if (uploadProgress.totalOperations && uploadProgress.uploadedOperations !== void 0) {
+				const uploadPercent = uploadProgress.totalOperations > 0 ? uploadProgress.uploadedOperations / uploadProgress.totalOperations : 0;
+				const overallProgress = 20 + Math.round(uploadPercent * 80);
+				onProgress?.({
+					stage: "uploading",
+					progress: overallProgress,
+					totalOperations: uploadProgress.totalOperations,
+					uploadedOperations: uploadProgress.uploadedOperations
+				});
+			}
+		} });
+		onProgress?.({
+			stage: "complete",
+			progress: 100,
+			fileNode
+		});
+		return fileNode;
+	} catch (error) {
+		if (!UnsupportedDocumentTypeError.isError(error)) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			onProgress?.({
+				stage: "failed",
+				progress: 100,
+				error: errorMessage
+			});
+		}
+		throw error;
+	}
+}
+async function retryAfterDiscovery(discoveryService, documentType, file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict) {
+	if (!discoveryService) return;
+	try {
+		await discoveryService.load(documentType);
+	} catch {
+		onProgress?.({
+			stage: "unsupported-document-type",
+			progress: 100,
+			error: `Document type ${documentType} is not supported`
+		});
+		return;
+	}
+	await addFileWithProgress(file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict);
+}
+async function addFolder(driveId, name, parentFolder) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create folders");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	await reactorClient.get(driveId);
+	const folderId = generateId();
+	const node = (await reactorClient.execute(driveId, "main", [addFolder$1({
+		id: folderId,
+		name,
+		parentFolder
+	})])).state.global.nodes.find((node) => node.id === folderId);
+	if (!node || !isFolderNode(node)) throw new Error("There was an error adding folder");
+	return node;
+}
+async function deleteNode(driveId, nodeId) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to delete documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	await reactorClient.drives.removeNode(driveId, nodeId);
+}
+async function renameNode(driveId, nodeId, name) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to rename documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	if ((await reactorClient.execute(nodeId, "main", [setName({ name })])).header.name !== name) throw new Error("There was an error renaming the node");
+	const node = (await reactorClient.execute(driveId, "main", [updateNode({
+		id: nodeId,
+		name
+	})])).state.global.nodes.find((n) => n.id === nodeId);
+	if (!node) throw new Error("There was an error renaming node in the drive");
+	return node;
+}
+async function renameDriveNode(driveId, nodeId, name) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to rename documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	if ((await reactorClient.execute(nodeId, "main", [setName({ name })])).header.name !== name) throw new Error("There was an error renaming the node");
+	await reactorClient.execute(driveId, "main", [updateNode({
+		id: nodeId,
+		name
+	})]);
+	return (await reactorClient.get(driveId)).state.global.nodes.find((n) => n.id === nodeId);
+}
+async function moveNode$1(driveId, src, target) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to move documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	return await reactorClient.execute(driveId, "main", [moveNode({
+		srcFolder: src.id,
+		targetParentFolder: target?.id
+	})]);
+}
+async function _duplicateDocument(reactor, document, newId = generateId()) {
+	const documentModule = await reactor.getDocumentModelModule(document.header.documentType);
+	return replayDocument(document.initialState, document.operations, documentModule.reducer, createPresignedHeader(newId, document.header.documentType));
+}
+async function copyNode$1(driveId, src, target) {
+	const reactor = window.ph?.reactorClient;
+	if (!reactor) return;
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to copy documents");
+	const drive = await reactor.get(driveId);
+	const copyNodesInput = generateNodesCopy({
+		srcId: src.id,
+		targetParentFolder: target?.id,
+		targetName: src.name
+	}, () => generateId(), drive.state.global.nodes);
+	const resolvedNamesMap = /* @__PURE__ */ new Map();
+	for (const copyNodeInput of copyNodesInput) {
+		const node = drive.state.global.nodes.find((n) => n.id === copyNodeInput.srcId);
+		if (node) {
+			const resolvedName = handleTargetNameCollisions({
+				nodes: drive.state.global.nodes,
+				srcName: copyNodeInput.targetName || node.name,
+				srcKind: isFileNode(node) ? "file" : "folder",
+				targetParentFolder: copyNodeInput.targetParentFolder || null
+			});
+			resolvedNamesMap.set(copyNodeInput.targetId, resolvedName);
+		}
+	}
+	const fileNodesToCopy = copyNodesInput.filter((copyNodeInput) => {
+		const node = drive.state.global.nodes.find((node) => node.id === copyNodeInput.srcId);
+		return node !== void 0 && isFileNode(node);
+	});
+	for (const fileNodeToCopy of fileNodesToCopy) try {
+		const duplicatedDocument = await _duplicateDocument(reactor, await reactor.get(fileNodeToCopy.srcId), fileNodeToCopy.targetId);
+		const resolvedName = resolvedNamesMap.get(fileNodeToCopy.targetId);
+		if (resolvedName) duplicatedDocument.header.name = resolvedName;
+		await reactor.drives.addFile(driveId, duplicatedDocument, target?.id);
+	} catch (e) {
+		logger.error(`Error copying document ${fileNodeToCopy.srcId}: ${String(e)}`);
+	}
+	return await queueActions(drive, copyNodesInput.map((copyNodeInput) => copyNode(copyNodeInput)));
+}
+//#endregion
+//#region src/actions/drive.ts
+async function addDrive(input, preferredEditor) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create drives");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const driveDoc = driveCreateDocument({ global: {
+		name: input.global.name || "",
+		icon: input.global.icon ?? null,
+		nodes: []
+	} });
+	if (preferredEditor) driveDoc.header.meta = { preferredEditor };
+	return await reactorClient.create(driveDoc);
+}
+async function addRemoteDrive(url, driveId, options) {
+	if (!window.ph?.reactorClient) throw new Error("ReactorClient not initialized");
+	const sync = window.ph?.reactorClientModule?.reactorModule?.syncModule?.syncManager;
+	if (!sync) throw new Error("Sync not initialized");
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to resolve drive info from ${url}`);
+	const driveInfo = await response.json();
+	const resolvedDriveId = driveId ?? driveInfo.id;
+	const collectionId = driveCollectionId$1("main", resolvedDriveId);
+	if (sync.list().find((remote) => remote.collectionId === collectionId)) return resolvedDriveId;
+	const remoteName = crypto.randomUUID();
+	await sync.add(remoteName, collectionId, {
+		type: "gql",
+		parameters: { url: driveInfo.graphqlEndpoint }
+	}, void 0, options?.pollBehavior ? { pollBehavior: options.pollBehavior } : void 0);
+	return resolvedDriveId;
+}
+async function deleteDrive(driveId) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to delete drives");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	await reactorClient.deleteDocument(driveId);
+}
+async function renameDrive(driveId, name) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to rename drives");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	return await reactorClient.rename(driveId, name);
+}
+async function setDriveAvailableOffline(driveId, availableOffline) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to change drive availability");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	return await reactorClient.execute(driveId, "main", [setAvailableOffline({ availableOffline })]);
+}
+async function setDriveSharingType(driveId, sharingType) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to change drive sharing type");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	return await reactorClient.execute(driveId, "main", [setSharingType({ type: sharingType })]);
+}
+//#endregion
+//#region src/constants.ts
+const DEFAULT_DRIVE_EDITOR_ID = "powerhouse/generic-drive-explorer";
+const COMMON_PACKAGE_ID = "powerhouse/common";
+//#endregion
+//#region src/document-model.ts
+const baseDocumentModelsMap = { DocumentModel: documentModelDocumentModelModule };
+const baseDocumentModels = Object.values(baseDocumentModelsMap);
+//#endregion
+//#region src/graphql/adapters.ts
+function phDocumentFromQuery(document, documentSchema) {
+	const phDocument = {
+		header: phDocumentHeaderFromQuery(document),
+		state: phDocumentStateFromQuery(document),
+		initialState: phDocumentStateFromQuery(document),
+		operations: phDocumentOperationsFromGetDocumentWithOperationsQuery(document),
+		clipboard: []
+	};
+	if (documentSchema !== void 0) documentSchema.parse(phDocument);
+	return phDocument;
+}
+function phDocumentsFromQuery(items, documentSchema) {
+	return pipe(items, map((document) => phDocumentFromQuery(document, documentSchema)));
+}
+function phDocumentHeaderFromQuery(queryDocument) {
+	return {
+		branch: "main",
+		id: queryDocument.id,
+		name: queryDocument.name,
+		documentType: queryDocument.documentType,
+		createdAtUtcIso: queryDocument.createdAtUtcIso instanceof Date ? queryDocument.createdAtUtcIso.toUTCString() : queryDocument.createdAtUtcIso,
+		lastModifiedAtUtcIso: queryDocument.lastModifiedAtUtcIso instanceof Date ? queryDocument.lastModifiedAtUtcIso.toUTCString() : queryDocument.lastModifiedAtUtcIso,
+		slug: queryDocument.slug ?? ""
+	};
+}
+function phDocumentStateFromQuery(queryDocument, documentSchema) {
+	if (documentSchema !== void 0) return documentSchema.shape.state.parse(queryDocument.state);
+	return queryDocument.state;
+}
+function phDocumentOperationsFromGetDocumentWithOperationsQuery(queryDocument) {
+	if (queryDocument.operations === null || queryDocument.operations === void 0) return { global: [] };
+	return { global: [...queryDocument.operations.items] };
+}
+function identifierFromMutateDocumentOperationVariables(variables) {
+	return z.object({ documentIdentifier: z.string() }).parse(variables).documentIdentifier;
+}
+//#endregion
+//#region src/graphql/constants.ts
+const DEFAULT_DRIVE_ID = "powerhouse";
+const DEFAULT_SWITCHBOARD_URL = "http://localhost:4001/graphql";
+const graphqlEventsToSyncDrive = [
+	"CreateEmptyDocument",
+	"CreateDocument",
+	"AddChildren",
+	"RemoveChildren",
+	"MoveChildren",
+	"DeleteDocument",
+	"DeleteDocuments"
+];
+const graphqlDocumentEvents = [
+	"MutateDocument",
+	"MutateDocumentAsync",
+	"DeleteDocument"
+];
+const graphqlDocumentsEvents = ["DeleteDocuments"];
+//#endregion
+//#region src/graphql/fetchers.ts
+async function reactorGraphqlFetchDocument(identifier, documentSchema) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	try {
+		const document = (await client.GetDocument({ identifier })).document?.document;
+		if (!document) return void 0;
+		return phDocumentFromQuery(document, documentSchema);
+	} catch (error) {
+		return;
+	}
+}
+async function reactorGraphqlBatchFetchDocuments(identifiers) {
+	if (!window.ph?.reactorGraphQLClient) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	const promises = map(identifiers, (identifier) => reactorGraphqlFetchDocument(identifier));
+	return await Promise.all(promises);
+}
+//#endregion
+//#region src/graphql/batch.ts
+/**
+* A reference implementation for an async batching utility function built on
+* top of the `funnel` general purpose execution utility function. It will
+* accumulate all params passed to an async `call` method within the defined
+* burst duration and then use an async executor to process them in one
+* invocation. It then extracts an individual result for each call which is
+* used to resolve the original call.
+*
+* This allows synchronizing multiple async calls while keeping each call site
+* isolated from the rest (for example, as react components).
+*
+* This reference implementation can be copied into your project as-is, or you
+* can use it as the basis for a more complex implementation with additional
+* features.
+*
+* @param callback - The main function that takes a batch and returns an
+* aggregated response. The typing for the it's parameters will derive the
+* typing for the extractor and the `call` method.
+* @param extractor - A function that takes the aggregated response and extracts
+* from it the result for each individual call. The function is called with both
+* the index in the batch, and the params passed to the `call` method. This
+* allows handling APIs that return batch results as both objects and arrays.
+* @param maxBurstDurationMs - The period of time where the batcher would
+* collect params before triggering the executor. When set to 0 the batcher
+* does not incur any additional delays to the execution and would trigger at
+* the next tick, just like a regular async function would. This is also the
+* default value.
+* @returns A Funnel object with the `call` method augmented to support async
+* response.
+*/
+function batch(callback, extractor, maxBurstDurationMs = 0) {
+	const batchFunnel = funnel((requests) => {
+		callback(requests.map(({ params }) => params)).then((response) => {
+			for (const [index, { params, promiseCallbacks: [resolve, reject] }] of requests.entries()) try {
+				resolve(extractor(response, index, ...params));
+			} catch (error) {
+				reject(error);
+			}
+		}).catch((error) => {
+			for (const { promiseCallbacks: [, reject] } of requests) reject(error);
+		});
+	}, {
+		reducer: (requests, request) => [...requests ?? [], request],
+		maxBurstDurationMs,
+		triggerAt: "end"
+	});
+	return {
+		...batchFunnel,
+		call: (...params) => new Promise((...promiseCallbacks) => {
+			batchFunnel.call({
+				promiseCallbacks,
+				params
+			});
+		})
+	};
+}
+//#endregion
+//#region src/graphql/document-fetcher.ts
+function makeDocumentsById(documents = []) {
+	return pipe(documents, filter(isTruthy), mapToObj((document) => [document.header.id, document]));
+}
+var DocumentFetcher = class {
+	batchGetDocuments;
+	constructor() {
+		this.batchGetDocuments = batch(async (requests) => {
+			return makeDocumentsById(await reactorGraphqlBatchFetchDocuments(unique(map(requests, ([id]) => id))));
+		}, (documentsById, _, id) => {
+			return prop(documentsById, id);
+		});
+	}
+	get(id) {
+		return this.batchGetDocuments.call(id);
+	}
+	getBatch(ids) {
+		return Promise.all(map(ids, (id) => this.get(id)));
+	}
+};
+//#endregion
+//#region src/graphql/graphql-client-document-cache.ts
+var GraphQLClientDocumentCache = class {
+	fetcher;
+	documents = /* @__PURE__ */ new Map();
+	batchPromises = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Map();
+	constructor() {
+		this.fetcher = new DocumentFetcher();
+		window.addEventListener("MutateDocument", (event) => {
+			this.handleDocumentMutated(event.detail.identifier).catch(console.error);
+		});
+		window.addEventListener("MutateDocumentAsync", (event) => {
+			this.handleDocumentMutated(event.detail.identifier).catch(console.error);
+		});
+	}
+	get(id, refetch) {
+		const current = this.documents.get(id);
+		if (current) {
+			if (current.status === "pending") return current;
+			if (!refetch) return current;
+		}
+		const promise = addPromiseState(this.fetcher.get(id).then((document) => {
+			this.invalidateBatchesContaining(id);
+			return document;
+		}));
+		this.documents.set(id, promise);
+		return promise;
+	}
+	getBatch(ids) {
+		const key = ids.join(",");
+		const cached = this.batchPromises.get(key);
+		const currentPromises = ids.map((id) => this.get(id));
+		if (cached) {
+			if (currentPromises.every((promise, index) => promise === cached.promises[index])) return cached.promise;
+		}
+		const states = currentPromises.map((promise) => readPromiseState(promise));
+		if (states.every((state) => state.status === "fulfilled")) {
+			const values = states.map((state) => state.value);
+			const batchPromise = Promise.resolve(values);
+			batchPromise.status = "fulfilled";
+			batchPromise.value = values;
+			this.batchPromises.set(key, {
+				promises: currentPromises,
+				promise: batchPromise
+			});
+			return batchPromise;
+		}
+		const batchPromise = addPromiseState(Promise.all(currentPromises));
+		this.batchPromises.set(key, {
+			promises: currentPromises,
+			promise: batchPromise
+		});
+		return batchPromise;
+	}
+	invalidateBatchesContaining(documentId) {
+		for (const key of this.batchPromises.keys()) if (key.split(",").includes(documentId)) this.batchPromises.delete(key);
+	}
+	subscribe(id, callback) {
+		const ids = Array.isArray(id) ? id : [id];
+		for (const documentId of ids) {
+			const listeners = this.listeners.get(documentId) ?? [];
+			this.listeners.set(documentId, [...listeners, callback]);
+		}
+		return () => {
+			for (const documentId of ids) {
+				const listeners = this.listeners.get(documentId) ?? [];
+				this.listeners.set(documentId, listeners.filter((listener) => listener !== callback));
+			}
+		};
+	}
+	notify(id) {
+		const listeners = this.listeners.get(id) ?? [];
+		for (const listener of listeners) listener();
+	}
+	async handleDocumentMutated(id) {
+		this.invalidateBatchesContaining(id);
+		await this.get(id);
+		this.notify(id);
+	}
+	handleDocumentDeleted(id) {
+		this.documents.delete(id);
+		this.invalidateBatchesContaining(id);
+		this.notify(id);
+	}
+	handleDocumentsDeleted(ids) {
+		forEach(ids, (id) => this.handleDocumentDeleted(id));
+	}
+};
+//#endregion
+//#region src/graphql/mutators.ts
+async function reactorGraphqlCreateDocument(document, parentIdentifier = DEFAULT_DRIVE_ID) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.CreateDocument({
+		document,
+		parentIdentifier
+	});
+}
+async function reactorGraphqlDeleteDocument(identifier) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.DeleteDocument({ identifier });
+}
+async function reactorGraphqlDeleteDocuments(identifiers) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.DeleteDocuments({ identifiers });
+}
+async function reactorGraphqlMutateDocument(documentIdentifier, ...actions) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.MutateDocument({
+		documentIdentifier,
+		actions
+	});
+}
+//#endregion
+//#region src/hooks/config/editor.ts
+const isExternalControlsEnabledEventFunctions = makePHEventFunctions("isExternalControlsEnabled");
+/** Sets whether external controls are enabled for a given editor. */
+const setIsExternalControlsEnabled = isExternalControlsEnabledEventFunctions.setValue;
+/** Gets whether external controls are enabled for a given editor. */
+const useIsExternalControlsEnabled = isExternalControlsEnabledEventFunctions.useValue;
+/** Adds an event handler for when the external controls enabled state changes. */
+const addIsExternalControlsEnabledEventHandler = isExternalControlsEnabledEventFunctions.addEventHandler;
+const isDragAndDropEnabledEventFunctions = makePHEventFunctions("isDragAndDropEnabled");
+/** Sets whether drag and drop is enabled for a given app. */
+const setIsDragAndDropEnabled = isDragAndDropEnabledEventFunctions.setValue;
+/** Gets whether drag and drop is enabled for a given app. */
+const useIsDragAndDropEnabled = isDragAndDropEnabledEventFunctions.useValue;
+/** Adds an event handler for when the drag and drop enabled state changes. */
+const addIsDragAndDropEnabledEventHandler = isDragAndDropEnabledEventFunctions.addEventHandler;
+const allowedDocumentTypesEventFunctions = makePHEventFunctions("allowedDocumentTypes");
+/** Sets the allowed document types for a given app. */
+const setAllowedDocumentTypes = allowedDocumentTypesEventFunctions.setValue;
+/** Defines the document types a drive supports.
+*
+* Defaults to all of the document types registered in the reactor.
+*/
+function useAllowedDocumentTypes() {
+	return allowedDocumentTypesEventFunctions.useValue();
+}
+/** Adds an event handler for when the allowed document types for a given app changes. */
+const addAllowedDocumentTypesEventHandler = allowedDocumentTypesEventFunctions.addEventHandler;
+const phAppConfigSetters = {
+	allowedDocumentTypes: setAllowedDocumentTypes,
+	isDragAndDropEnabled: setIsDragAndDropEnabled
+};
+const phDocumentEditorConfigSetters = { isExternalControlsEnabled: setIsExternalControlsEnabled };
+const phAppConfigHooks = {
+	allowedDocumentTypes: useAllowedDocumentTypes,
+	isDragAndDropEnabled: useIsDragAndDropEnabled
+};
+const phDocumentEditorConfigHooks = { isExternalControlsEnabled: useIsExternalControlsEnabled };
+//#endregion
+//#region src/hooks/config/connect.ts
+const { useValue: useRouterBasename, setValue: setRouterBasename, addEventHandler: addRouterBasenameEventHandler } = makePHEventFunctions("routerBasename");
+const { useValue: useVersion, setValue: setVersion, addEventHandler: addVersionEventHandler } = makePHEventFunctions("version");
+const { useValue: useRequiresHardRefresh, setValue: setRequiresHardRefresh, addEventHandler: addRequiresHardRefreshEventHandler } = makePHEventFunctions("requiresHardRefresh");
+const { useValue: useWarnOutdatedApp, setValue: setWarnOutdatedApp, addEventHandler: addWarnOutdatedAppEventHandler } = makePHEventFunctions("warnOutdatedApp");
+const { useValue: useStudioMode, setValue: setStudioMode, addEventHandler: addStudioModeEventHandler } = makePHEventFunctions("studioMode");
+const { useValue: useBasePath, setValue: setBasePath, addEventHandler: addBasePathEventHandler } = makePHEventFunctions("basePath");
+const { useValue: useVersionCheckInterval, setValue: setVersionCheckInterval, addEventHandler: addVersionCheckIntervalEventHandler } = makePHEventFunctions("versionCheckInterval");
+const { useValue: useCliVersion, setValue: setCliVersion, addEventHandler: addCliVersionEventHandler } = makePHEventFunctions("cliVersion");
+const { useValue: useFileUploadOperationsChunkSize, setValue: setFileUploadOperationsChunkSize, addEventHandler: addFileUploadOperationsChunkSizeEventHandler } = makePHEventFunctions("fileUploadOperationsChunkSize");
+const { useValue: useIsDocumentModelSelectionSettingsEnabled, setValue: setIsDocumentModelSelectionSettingsEnabled, addEventHandler: addIsDocumentModelSelectionSettingsEnabledEventHandler } = makePHEventFunctions("isDocumentModelSelectionSettingsEnabled");
+const { useValue: useGaTrackingId, setValue: setGaTrackingId, addEventHandler: addGaTrackingIdEventHandler } = makePHEventFunctions("gaTrackingId");
+const { useValue: useDefaultDrivesUrl, setValue: setDefaultDrivesUrl, addEventHandler: addDefaultDrivesUrlEventHandler } = makePHEventFunctions("defaultDrivesUrl");
+const { useValue: useDrivesPreserveStrategy, setValue: setDrivesPreserveStrategy, addEventHandler: addDrivesPreserveStrategyEventHandler } = makePHEventFunctions("drivesPreserveStrategy");
+const { useValue: useIsLocalDrivesEnabled, setValue: setIsLocalDrivesEnabled, addEventHandler: addIsLocalDrivesEnabledEventHandler } = makePHEventFunctions("isLocalDrivesEnabled");
+const { useValue: useIsAddDriveEnabled, setValue: setIsAddDriveEnabled, addEventHandler: addIsAddDriveEnabledEventHandler } = makePHEventFunctions("isAddDriveEnabled");
+const { useValue: useIsPublicDrivesEnabled, setValue: setIsPublicDrivesEnabled, addEventHandler: addIsPublicDrivesEnabledEventHandler } = makePHEventFunctions("isPublicDrivesEnabled");
+const { useValue: useIsAddPublicDrivesEnabled, setValue: setIsAddPublicDrivesEnabled, addEventHandler: addIsAddPublicDrivesEnabledEventHandler } = makePHEventFunctions("isAddPublicDrivesEnabled");
+const { useValue: useIsDeletePublicDrivesEnabled, setValue: setIsDeletePublicDrivesEnabled, addEventHandler: addIsDeletePublicDrivesEnabledEventHandler } = makePHEventFunctions("isDeletePublicDrivesEnabled");
+const { useValue: useIsCloudDrivesEnabled, setValue: setIsCloudDrivesEnabled, addEventHandler: addIsCloudDrivesEnabledEventHandler } = makePHEventFunctions("isCloudDrivesEnabled");
+const { useValue: useIsAddCloudDrivesEnabled, setValue: setIsAddCloudDrivesEnabled, addEventHandler: addIsAddCloudDrivesEnabledEventHandler } = makePHEventFunctions("isAddCloudDrivesEnabled");
+const { useValue: useIsDeleteCloudDrivesEnabled, setValue: setIsDeleteCloudDrivesEnabled, addEventHandler: addIsDeleteCloudDrivesEnabledEventHandler } = makePHEventFunctions("isDeleteCloudDrivesEnabled");
+const { useValue: useLocalDrivesEnabled, setValue: setLocalDrivesEnabled, addEventHandler: addLocalDrivesEnabledEventHandler } = makePHEventFunctions("isLocalDrivesEnabled");
+const { useValue: useIsAddLocalDrivesEnabled, setValue: setIsAddLocalDrivesEnabled, addEventHandler: addIsAddLocalDrivesEnabledEventHandler } = makePHEventFunctions("isAddLocalDrivesEnabled");
+const { useValue: useIsDeleteLocalDrivesEnabled, setValue: setIsDeleteLocalDrivesEnabled, addEventHandler: addIsDeleteLocalDrivesEnabledEventHandler } = makePHEventFunctions("isDeleteLocalDrivesEnabled");
+const { useValue: useIsEditorDebugModeEnabled, setValue: setIsEditorDebugModeEnabled, addEventHandler: addIsEditorDebugModeEnabledEventHandler } = makePHEventFunctions("isEditorDebugModeEnabled");
+const { useValue: useIsEditorReadModeEnabled, setValue: setIsEditorReadModeEnabled, addEventHandler: addIsEditorReadModeEnabledEventHandler } = makePHEventFunctions("isEditorReadModeEnabled");
+const { useValue: useIsAnalyticsDatabaseWorkerEnabled, setValue: setIsAnalyticsDatabaseWorkerEnabled, addEventHandler: addIsAnalyticsDatabaseWorkerEnabledEventHandler } = makePHEventFunctions("isAnalyticsDatabaseWorkerEnabled");
+const { useValue: useIsDiffAnalyticsEnabled, setValue: setIsDiffAnalyticsEnabled, addEventHandler: addIsDiffAnalyticsEnabledEventHandler } = makePHEventFunctions("isDiffAnalyticsEnabled");
+const { useValue: useIsDriveAnalyticsEnabled, setValue: setIsDriveAnalyticsEnabled, addEventHandler: addIsDriveAnalyticsEnabledEventHandler } = makePHEventFunctions("isDriveAnalyticsEnabled");
+const { useValue: useRenownUrl, setValue: setRenownUrl, addEventHandler: addRenownUrlEventHandler } = makePHEventFunctions("renownUrl");
+const { useValue: useRenownNetworkId, setValue: setRenownNetworkId, addEventHandler: addRenownNetworkIdEventHandler } = makePHEventFunctions("renownNetworkId");
+const { useValue: useRenownChainId, setValue: setRenownChainId, addEventHandler: addRenownChainIdEventHandler } = makePHEventFunctions("renownChainId");
+const { useValue: useSentryRelease, setValue: setSentryRelease, addEventHandler: addSentryReleaseEventHandler } = makePHEventFunctions("sentryRelease");
+const { useValue: useSentryDsn, setValue: setSentryDsn, addEventHandler: addSentryDsnEventHandler } = makePHEventFunctions("sentryDsn");
+const { useValue: useSentryEnv, setValue: setSentryEnv, addEventHandler: addSentryEnvEventHandler } = makePHEventFunctions("sentryEnv");
+const { useValue: useIsSentryTracingEnabled, setValue: setIsSentryTracingEnabled, addEventHandler: addIsSentryTracingEnabledEventHandler } = makePHEventFunctions("isSentryTracingEnabled");
+const { useValue: useIsExternalProcessorsEnabled, setValue: setIsExternalProcessorsEnabled, addEventHandler: addIsExternalProcessorsEnabledEventHandler } = makePHEventFunctions("isExternalProcessorsEnabled");
+const { useValue: useIsExternalPackagesEnabled, setValue: setIsExternalPackagesEnabled, addEventHandler: addIsExternalPackagesEnabledEventHandler } = makePHEventFunctions("isExternalPackagesEnabled");
+const enabledEditorsEventFunctions = makePHEventFunctions("enabledEditors");
+/** Sets the enabled editors for Connect. */
+const setEnabledEditors = enabledEditorsEventFunctions.setValue;
+/** Gets the enabled editors for Connect. */
+const useEnabledEditors = enabledEditorsEventFunctions.useValue;
+/** Adds an event handler for when the enabled editors for Connect changes. */
+const addEnabledEditorsEventHandler = enabledEditorsEventFunctions.addEventHandler;
+const disabledEditorsEventFunctions = makePHEventFunctions("disabledEditors");
+/** Sets the disabled editors for Connect. */
+const setDisabledEditors = disabledEditorsEventFunctions.setValue;
+/** Gets the disabled editors for Connect. */
+const useDisabledEditors = disabledEditorsEventFunctions.useValue;
+/** Adds an event handler for when the disabled editors for Connect changes. */
+const addDisabledEditorsEventHandler = disabledEditorsEventFunctions.addEventHandler;
+const isRelationalProcessorsEnabled = makePHEventFunctions("isRelationalProcessorsEnabled");
+/** Sets the isRelationalProcessorsEnabled for Connect. */
+const setIsRelationalProcessorsEnabled = isRelationalProcessorsEnabled.setValue;
+/** Gets the isRelationalProcessorsEnabled for Connect. */
+const useIsRelationalProcessorsEnabled = isRelationalProcessorsEnabled.useValue;
+/** Adds an event handler for when the isRelationalProcessorsEnabled for Connect changes. */
+const addIsRelationalProcessorsEnabledEventHandler = isRelationalProcessorsEnabled.addEventHandler;
+const isExternalRelationalProcessorsEnabled = makePHEventFunctions("isExternalRelationalProcessorsEnabled");
+/** Sets the isExternalRelationalProcessorsEnabled for Connect. */
+const setIsExternalRelationalProcessorsEnabled = isExternalRelationalProcessorsEnabled.setValue;
+/** Gets the isExternalRelationalProcessorsEnabled for Connect. */
+const useIsExternalRelationalProcessorsEnabled = isExternalRelationalProcessorsEnabled.useValue;
+/** Adds an event handler for when the isExternalRelationalProcessorsEnabled for Connect changes. */
+const addIsExternalRelationalProcessorsEnabledEventHandler = isExternalRelationalProcessorsEnabled.addEventHandler;
+const isAnalyticsEnabledEventFunctions = makePHEventFunctions("isAnalyticsEnabled");
+/** Sets the isAnalyticsEnabled for Connect. */
+const setIsAnalyticsEnabled = isAnalyticsEnabledEventFunctions.setValue;
+/** Gets the isAnalyticsEnabled for Connect. */
+const useIsAnalyticsEnabled = isAnalyticsEnabledEventFunctions.useValue;
+/** Adds an event handler for when the isAnalyticsEnabled for Connect changes. */
+const addIsAnalyticsEnabledEventHandler = isAnalyticsEnabledEventFunctions.addEventHandler;
+const isAnalyticsExternalProcessorsEnabled = makePHEventFunctions("isAnalyticsExternalProcessorsEnabled");
+/** Sets the isAnalyticsExternalProcessorsEnabled for Connect. */
+const setIsAnalyticsExternalProcessorsEnabled = isAnalyticsExternalProcessorsEnabled.setValue;
+/** Gets the isAnalyticsExternalProcessorsEnabled for Connect. */
+const useIsAnalyticsExternalProcessorsEnabled = isAnalyticsExternalProcessorsEnabled.useValue;
+/** Adds an event handler for when the isAnalyticsExternalProcessorsEnabled for Connect changes. */
+const addIsAnalyticsExternalProcessorsEnabledEventHandler = isAnalyticsExternalProcessorsEnabled.addEventHandler;
+const analyticsDatabaseNameEventFunctions = makePHEventFunctions("analyticsDatabaseName");
+/** Sets the analytics database name for Connect. */
+const setAnalyticsDatabaseName = analyticsDatabaseNameEventFunctions.setValue;
+/** Gets the analytics database name for Connect. */
+const useAnalyticsDatabaseName = analyticsDatabaseNameEventFunctions.useValue;
+/** Adds an event handler for when the analytics database name for Connect changes. */
+const addAnalyticsDatabaseNameEventHandler = analyticsDatabaseNameEventFunctions.addEventHandler;
+const logLevelEventFunctions = makePHEventFunctions("logLevel");
+/** Sets the log level for Connect. */
+const setLogLevel = logLevelEventFunctions.setValue;
+/** Gets the log level for Connect. */
+const useLogLevel = logLevelEventFunctions.useValue;
+/** Adds an event handler for when the log level for Connect changes. */
+const addLogLevelEventHandler = logLevelEventFunctions.addEventHandler;
+const allowListEventFunctions = makePHEventFunctions("allowList");
+/** Sets the allow list for Connect. */
+const setAllowList = allowListEventFunctions.setValue;
+/** Gets the allow list for Connect. */
+const useAllowList = allowListEventFunctions.useValue;
+/** Adds an event handler for when the allow list for Connect changes. */
+const addAllowListEventHandler = allowListEventFunctions.addEventHandler;
+const nonUserConfigSetters = {
+	routerBasename: setRouterBasename,
+	version: setVersion,
+	requiresHardRefresh: setRequiresHardRefresh,
+	warnOutdatedApp: setWarnOutdatedApp,
+	studioMode: setStudioMode,
+	basePath: setBasePath,
+	versionCheckInterval: setVersionCheckInterval,
+	cliVersion: setCliVersion,
+	fileUploadOperationsChunkSize: setFileUploadOperationsChunkSize,
+	isDocumentModelSelectionSettingsEnabled: setIsDocumentModelSelectionSettingsEnabled,
+	gaTrackingId: setGaTrackingId,
+	defaultDrivesUrl: setDefaultDrivesUrl,
+	drivesPreserveStrategy: setDrivesPreserveStrategy,
+	isLocalDrivesEnabled: setIsLocalDrivesEnabled,
+	isAddDriveEnabled: setIsAddDriveEnabled,
+	isPublicDrivesEnabled: setIsPublicDrivesEnabled,
+	isAddPublicDrivesEnabled: setIsAddPublicDrivesEnabled,
+	isDeletePublicDrivesEnabled: setIsDeletePublicDrivesEnabled,
+	isCloudDrivesEnabled: setIsCloudDrivesEnabled,
+	isAddCloudDrivesEnabled: setIsAddCloudDrivesEnabled,
+	isDeleteCloudDrivesEnabled: setIsDeleteCloudDrivesEnabled,
+	isAddLocalDrivesEnabled: setIsAddLocalDrivesEnabled,
+	isDeleteLocalDrivesEnabled: setIsDeleteLocalDrivesEnabled,
+	isEditorDebugModeEnabled: setIsEditorDebugModeEnabled,
+	isEditorReadModeEnabled: setIsEditorReadModeEnabled,
+	isRelationalProcessorsEnabled: setIsRelationalProcessorsEnabled,
+	isExternalRelationalProcessorsEnabled: setIsExternalRelationalProcessorsEnabled,
+	isAnalyticsEnabled: setIsAnalyticsEnabled,
+	analyticsDatabaseName: setAnalyticsDatabaseName,
+	isAnalyticsExternalProcessorsEnabled: setIsAnalyticsExternalProcessorsEnabled,
+	isAnalyticsDatabaseWorkerEnabled: setIsAnalyticsDatabaseWorkerEnabled,
+	isDiffAnalyticsEnabled: setIsDiffAnalyticsEnabled,
+	isDriveAnalyticsEnabled: setIsDriveAnalyticsEnabled,
+	renownUrl: setRenownUrl,
+	renownNetworkId: setRenownNetworkId,
+	renownChainId: setRenownChainId,
+	sentryRelease: setSentryRelease,
+	sentryDsn: setSentryDsn,
+	sentryEnv: setSentryEnv,
+	isSentryTracingEnabled: setIsSentryTracingEnabled,
+	isExternalProcessorsEnabled: setIsExternalProcessorsEnabled,
+	isExternalPackagesEnabled: setIsExternalPackagesEnabled,
+	allowList: setAllowList,
+	logLevel: setLogLevel,
+	disabledEditors: setDisabledEditors,
+	enabledEditors: setEnabledEditors
+};
+const phGlobalConfigSetters = {
+	...phAppConfigSetters,
+	...phDocumentEditorConfigSetters,
+	...nonUserConfigSetters
+};
+const nonUserConfigHooks = {
+	routerBasename: useRouterBasename,
+	version: useVersion,
+	requiresHardRefresh: useRequiresHardRefresh,
+	warnOutdatedApp: useWarnOutdatedApp,
+	studioMode: useStudioMode,
+	basePath: useBasePath,
+	versionCheckInterval: useVersionCheckInterval,
+	cliVersion: useCliVersion,
+	fileUploadOperationsChunkSize: useFileUploadOperationsChunkSize,
+	isDocumentModelSelectionSettingsEnabled: useIsDocumentModelSelectionSettingsEnabled,
+	gaTrackingId: useGaTrackingId,
+	defaultDrivesUrl: useDefaultDrivesUrl,
+	drivesPreserveStrategy: useDrivesPreserveStrategy,
+	isAddDriveEnabled: useIsAddDriveEnabled,
+	isPublicDrivesEnabled: useIsPublicDrivesEnabled,
+	isAddPublicDrivesEnabled: useIsAddPublicDrivesEnabled,
+	isDeletePublicDrivesEnabled: useIsDeletePublicDrivesEnabled,
+	isCloudDrivesEnabled: useIsCloudDrivesEnabled,
+	isAddCloudDrivesEnabled: useIsAddCloudDrivesEnabled,
+	isDeleteCloudDrivesEnabled: useIsDeleteCloudDrivesEnabled,
+	isLocalDrivesEnabled: useIsLocalDrivesEnabled,
+	isAddLocalDrivesEnabled: useIsAddLocalDrivesEnabled,
+	isDeleteLocalDrivesEnabled: useIsDeleteLocalDrivesEnabled,
+	isEditorDebugModeEnabled: useIsEditorDebugModeEnabled,
+	isEditorReadModeEnabled: useIsEditorReadModeEnabled,
+	isAnalyticsDatabaseWorkerEnabled: useIsAnalyticsDatabaseWorkerEnabled,
+	isDiffAnalyticsEnabled: useIsDiffAnalyticsEnabled,
+	isDriveAnalyticsEnabled: useIsDriveAnalyticsEnabled,
+	renownUrl: useRenownUrl,
+	renownNetworkId: useRenownNetworkId,
+	renownChainId: useRenownChainId,
+	sentryRelease: useSentryRelease,
+	sentryDsn: useSentryDsn,
+	sentryEnv: useSentryEnv,
+	isSentryTracingEnabled: useIsSentryTracingEnabled,
+	isExternalProcessorsEnabled: useIsExternalProcessorsEnabled,
+	isExternalPackagesEnabled: useIsExternalPackagesEnabled,
+	allowList: useAllowList,
+	isAnalyticsEnabled: useIsAnalyticsEnabled,
+	isAnalyticsExternalProcessorsEnabled: useIsAnalyticsExternalProcessorsEnabled,
+	isRelationalProcessorsEnabled: useIsRelationalProcessorsEnabled,
+	isExternalRelationalProcessorsEnabled: useIsExternalRelationalProcessorsEnabled,
+	analyticsDatabaseName: useAnalyticsDatabaseName,
+	logLevel: useLogLevel,
+	disabledEditors: useDisabledEditors,
+	enabledEditors: useEnabledEditors
+};
+const phGlobalConfigHooks = {
+	...phAppConfigHooks,
+	...phDocumentEditorConfigHooks,
+	...nonUserConfigHooks
+};
+//#endregion
+//#region src/hooks/features.ts
+const featuresEventFunctions = makePHEventFunctions("features");
+const useFeatures = featuresEventFunctions.useValue;
+const setFeatures = featuresEventFunctions.setValue;
+const addFeaturesEventHandler = featuresEventFunctions.addEventHandler;
+//#endregion
+//#region src/hooks/drives.ts
+const drivesEventFunctions = makePHEventFunctions("drives");
+/** Returns all of the drives in the reactor */
+const useDrives = drivesEventFunctions.useValue;
+/** Sets the drives in the reactor */
+const setDrives = drivesEventFunctions.setValue;
+/** Adds an event handler for the drives */
+const addDrivesEventHandler = drivesEventFunctions.addEventHandler;
+//#endregion
+//#region src/hooks/graphql-reactor-client.ts
+const graphQLReactorClientEventFunctions = makePHEventFunctions("reactorGraphQLClient");
+const useGraphQLReactorClient = graphQLReactorClientEventFunctions.useValue;
+const setGraphQLReactorClient = graphQLReactorClientEventFunctions.setValue;
+const addGraphQLReactorClientEventHandler = graphQLReactorClientEventFunctions.addEventHandler;
+//#endregion
+//#region src/hooks/modals.ts
+const modalEventFunctions = makePHEventFunctions("modal");
+/** Returns the current modal */
+const usePHModal = modalEventFunctions.useValue;
+/** Sets the current modal */
+const setPHModal = modalEventFunctions.setValue;
+/** Adds an event handler for the modal */
+const addModalEventHandler = modalEventFunctions.addEventHandler;
+/** Shows a modal */
+function showPHModal(modal) {
+	setPHModal(modal);
+}
+/** Closes the current modal */
+function closePHModal() {
+	setPHModal(void 0);
+}
+/** Shows the create document modal */
+function showCreateDocumentModal(documentType) {
+	setPHModal({
+		type: "createDocument",
+		documentType
+	});
+}
+/** Shows the delete node modal */
+function showDeleteNodeModal(nodeOrId) {
+	setPHModal({
+		type: "deleteItem",
+		id: typeof nodeOrId === "string" ? nodeOrId : nodeOrId.id
+	});
+}
+//#endregion
+//#region src/hooks/package-discovery.ts
+const packageDiscoveryFunctions = makePHEventFunctions("packageDiscoveryService");
+const usePackageDiscoveryService = packageDiscoveryFunctions.useValue;
+const setPackageDiscoveryService = packageDiscoveryFunctions.setValue;
+const addPackageDiscoveryServiceEventHandler = packageDiscoveryFunctions.addEventHandler;
+//#endregion
+//#region src/hooks/reactor.ts
+const reactorClientModuleEventFunctions = makePHEventFunctions("reactorClientModule");
+const reactorClientEventFunctions = makePHEventFunctions("reactorClient");
+/** Returns the reactor client module */
+const useReactorClientModule = reactorClientModuleEventFunctions.useValue;
+/** Sets the reactor client module */
+const setReactorClientModule = reactorClientModuleEventFunctions.setValue;
+/** Adds an event handler for the reactor client module */
+const addReactorClientModuleEventHandler = reactorClientModuleEventFunctions.addEventHandler;
+/** Returns the reactor client */
+const useReactorClient = reactorClientEventFunctions.useValue;
+/** Sets the reactor client */
+const setReactorClient = reactorClientEventFunctions.setValue;
+/** Adds an event handler for the reactor client */
+const addReactorClientEventHandler = reactorClientEventFunctions.addEventHandler;
+const useSync = () => useReactorClientModule()?.reactorModule?.syncModule?.syncManager;
+const useSyncList = () => {
+	return useSync()?.list() ?? [];
+};
+const useModelRegistry = () => useReactorClientModule()?.reactorModule?.documentModelRegistry;
+const useDatabase = () => useReactorClientModule()?.reactorModule?.database;
+const usePGlite = () => useReactorClientModule()?.pg;
+//#endregion
+//#region src/hooks/revision-history.ts
+const revisionHistoryEventFunctions = makePHEventFunctions("revisionHistoryVisible");
+/** Returns whether revision history is visible */
+const useRevisionHistoryVisible = revisionHistoryEventFunctions.useValue;
+/** Sets revision history visibility */
+const setRevisionHistoryVisible = revisionHistoryEventFunctions.setValue;
+/** Adds event handler for revision history visibility */
+const addRevisionHistoryVisibleEventHandler = revisionHistoryEventFunctions.addEventHandler;
+/** Shows the revision history */
+function showRevisionHistory() {
+	setRevisionHistoryVisible(true);
+}
+/** Hides the revision history */
+function hideRevisionHistory() {
+	setRevisionHistoryVisible(false);
+}
+//#endregion
+//#region src/utils/url.ts
+function resolveUrlPathname(path) {
+	return new URL(path.replace(/^\/+/, ""), window.location.origin + (window.ph?.basePath ?? "/")).pathname;
+}
+/** Returns the current path without the base path */
+function getPathWithoutBase(path) {
+	const basePath = window.ph?.basePath ?? "/";
+	return path.replace(basePath, basePath.endsWith("/") ? "/" : "");
+}
+/** Makes a URL component for a drive. */
+function makeDriveUrlComponent(drive) {
+	if (!drive) return "";
+	return `/d/${slug(drive.header.slug)}`;
+}
+/** Makes a URL component for a node. */
+function makeNodeSlug(node) {
+	if (!node) return "";
+	const nodeName = node.name;
+	if (!nodeName) return slug(node.id);
+	return slug(`${nodeName}-${node.id}`);
+}
+/** Extracts the node slug from a path.
+*
+* The path is expected to be in the format `/d/<drive-slug>/<node-slug>`.
+*/
+function extractNodeSlugFromPath(path) {
+	const currentPath = getPathWithoutBase(path);
+	return /^\/d\/[^/]+\/([^/]+)$/.exec(currentPath)?.[1];
+}
+/** Finds a UUID in a string, used for extracting node ids from node slugs in the URL. */
+function findUuid(input) {
+	if (!input) return void 0;
+	return /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/.exec(input)?.[0];
+}
+function extractNodeIdFromSlug(nodeSlug) {
+	return findUuid(nodeSlug);
+}
+function extractNodeIdFromPath(path) {
+	return extractNodeIdFromSlug(extractNodeSlugFromPath(path));
+}
+/** Extracts the drive slug from a path.
+* Used for extracting drive ids from drive slugs in the URL.
+* Expects the path to be in the format `/d/<drive-slug>`.
+*/
+function extractDriveSlugFromPath(path) {
+	const currentPath = getPathWithoutBase(path);
+	return /^\/d\/([^/]+)/.exec(currentPath)?.[1] ?? "";
+}
+function extractDriveIdFromSlug(driveSlug) {
+	return findUuid(driveSlug);
+}
+function extractDriveIdFromPath(path) {
+	return extractDriveIdFromSlug(extractDriveSlugFromPath(path));
+}
+/**
+* Creates a URL string with the given pathname while preserving existing query parameters.
+*/
+function createUrlWithPreservedParams(pathname) {
+	const search = window.location.search;
+	return search ? `${pathname}${search}` : pathname;
+}
+//#endregion
+//#region src/hooks/selected-drive.ts
+const selectedDriveIdEventFunctions = makePHEventFunctions("selectedDriveId");
+/** Returns the selected drive id */
+const useSelectedDriveId = selectedDriveIdEventFunctions.useValue;
+/** Sets the selected drive id */
+const setSelectedDriveId = selectedDriveIdEventFunctions.setValue;
+/** Adds an event handler for the selected drive id */
+const addSelectedDriveIdEventHandler = selectedDriveIdEventFunctions.addEventHandler;
+/** Returns the selected drive */
+function useSelectedDrive() {
+	const drive = useSelectedDriveSafe();
+	if (!drive[0]) throw new Error("There is no drive selected. Did you mean to call 'useSelectedDriveSafe'?");
+	return drive;
+}
+/** Returns the selected drive, or undefined if no drive is selected */
+function useSelectedDriveSafe() {
+	const selectedDriveId = useSelectedDriveId();
+	const selectedDrive = useDrives()?.find((drive) => drive.header.id === selectedDriveId);
+	const [drive, dispatch] = useDispatch(selectedDrive);
+	if (!selectedDrive) return [void 0, void 0];
+	return [drive, dispatch];
+}
+function setSelectedDrive(driveOrDriveSlug) {
+	const driveSlug = typeof driveOrDriveSlug === "string" ? driveOrDriveSlug : driveOrDriveSlug?.header.slug;
+	const driveId = (window.ph?.drives?.find((d) => d.header.slug === driveSlug))?.header.id;
+	setSelectedDriveId(driveId);
+	if (!driveId) {
+		const pathname = resolveUrlPathname("/");
+		if (pathname === window.location.pathname) return;
+		window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+		return;
+	}
+	const pathname = resolveUrlPathname(`/d/${driveSlug}`);
+	if (pathname === window.location.pathname) return;
+	window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+}
+function addSetSelectedDriveOnPopStateEventHandler() {
+	window.addEventListener("popstate", () => {
+		const pathname = window.location.pathname;
+		const driveId = extractDriveIdFromPath(pathname);
+		if (driveId !== window.ph?.selectedDriveId) setSelectedDrive(driveId);
+	});
+}
+//#endregion
+//#region src/utils/nodes.ts
+/** Sorts nodes by name. */
+function sortNodesByName(nodes) {
+	return nodes.toSorted((a, b) => a.name.localeCompare(b.name));
+}
+/** Returns whether a node is a file. */
+function isFileNodeKind(node) {
+	if (!node) return false;
+	return node.kind.toUpperCase() === "FILE";
+}
+/** Returns whether a node is a folder. */
+function isFolderNodeKind(node) {
+	if (!node) return false;
+	return node.kind.toUpperCase() === "FOLDER";
+}
+//#endregion
+//#region src/hooks/items-in-selected-drive.ts
+/** Returns the nodes in the selected drive. */
+function useNodesInSelectedDrive() {
+	const [selectedDrive] = useSelectedDriveSafe();
+	return selectedDrive?.state.global.nodes;
+}
+/** Returns the file nodes in the selected drive. */
+function useFileNodesInSelectedDrive() {
+	return useNodesInSelectedDrive()?.filter((n) => isFileNodeKind(n));
+}
+/** Returns the folder nodes in the selected drive. */
+function useFolderNodesInSelectedDrive() {
+	return useNodesInSelectedDrive()?.filter((n) => isFolderNodeKind(n));
+}
+/** Returns the documents in the selected drive. */
+function useDocumentsInSelectedDrive() {
+	const fileNodeIds = useFileNodesInSelectedDrive()?.map((node) => node.id);
+	return useDocumentsByIds(fileNodeIds);
+}
+/** Returns the document types supported by the selected drive, as defined by the document model documents present in the drive */
+function useDocumentTypesInSelectedDrive() {
+	return (useDocumentsInSelectedDrive()?.filter(isDocumentModelDocument))?.map((doc) => doc.state.global.id);
+}
+function isDocumentModelDocument(document) {
+	return document.header.documentType === "powerhouse/document-model";
+}
+//#endregion
+//#region src/hooks/selected-node.ts
+const selectedNodeIdEventFunctions = makePHEventFunctions("selectedNodeId");
+const useSelectedNodeId = selectedNodeIdEventFunctions.useValue;
+const setSelectedNodeId = selectedNodeIdEventFunctions.setValue;
+const addSelectedNodeIdEventHandler = selectedNodeIdEventFunctions.addEventHandler;
+/** Returns the selected node. */
+function useSelectedNode() {
+	const selectedNodeId = useSelectedNodeId();
+	return useNodesInSelectedDrive()?.find((n) => n.id === selectedNodeId);
+}
+/** Sets the selected node (file or folder). */
+function setSelectedNode(nodeOrNodeSlug) {
+	const nodeSlug = typeof nodeOrNodeSlug === "string" ? nodeOrNodeSlug : makeNodeSlug(nodeOrNodeSlug);
+	setSelectedNodeId(extractNodeIdFromSlug(nodeSlug));
+	const driveSlugFromPath = extractDriveSlugFromPath(window.location.pathname);
+	if (!driveSlugFromPath) return;
+	if (!nodeSlug) {
+		const pathname = resolveUrlPathname(`/d/${driveSlugFromPath}`);
+		if (pathname === window.location.pathname) return;
+		window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+		return;
+	}
+	const pathname = resolveUrlPathname(`/d/${driveSlugFromPath}/${nodeSlug}`);
+	if (pathname === window.location.pathname) return;
+	window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+}
+function addResetSelectedNodeEventHandler() {
+	window.addEventListener("ph:selectedDriveIdUpdated", () => {
+		setSelectedNodeId(void 0);
+	});
+}
+function addSetSelectedNodeOnPopStateEventHandler() {
+	window.addEventListener("popstate", () => {
+		const pathname = window.location.pathname;
+		const nodeSlug = extractNodeSlugFromPath(pathname);
+		if (nodeSlug !== window.ph?.selectedNodeId) setSelectedNode(nodeSlug);
+	});
+}
+//#endregion
+//#region src/hooks/selected-timeline-item.ts
+const selectedTimelineItemEventFunctions = makePHEventFunctions("selectedTimelineItem");
+/** Returns the selected timeline item */
+const useSelectedTimelineItem = selectedTimelineItemEventFunctions.useValue;
+/** Sets the selected timeline item */
+const setSelectedTimelineItem = selectedTimelineItemEventFunctions.setValue;
+/** Adds event handler for selected timeline item */
+const addSelectedTimelineItemEventHandler = selectedTimelineItemEventFunctions.addEventHandler;
+//#endregion
+//#region src/hooks/timeline-revision.ts
+const selectedTimelineRevisionEventFunctions = makePHEventFunctions("selectedTimelineRevision");
+/** Returns the selected timeline revision. */
+const useSelectedTimelineRevision = selectedTimelineRevisionEventFunctions.useValue;
+/** Sets the selected timeline revision. */
+const setSelectedTimelineRevision = selectedTimelineRevisionEventFunctions.setValue;
+/** Adds an event handler for the selected timeline revision. */
+const addSelectedTimelineRevisionEventHandler = selectedTimelineRevisionEventFunctions.addEventHandler;
+//#endregion
+//#region src/hooks/toast.ts
+const toastEventFunctions = makePHEventFunctions("toast");
+/** Returns the toast function */
+const usePHToast = toastEventFunctions.useValue;
+/** Sets the toast function */
+const setPHToast = toastEventFunctions.setValue;
+/** Adds an event handler for the toast */
+const addToastEventHandler = toastEventFunctions.addEventHandler;
+//#endregion
+//#region src/hooks/vetra-packages.ts
+const vetraPackageManagerFunctions = makePHEventFunctions("vetraPackageManager");
+const useVetraPackageManager = vetraPackageManagerFunctions.useValue;
+/** Returns all of the Vetra packages loaded by the Connect instance */
+const useVetraPackages = () => {
+	const packageManager = useVetraPackageManager();
+	return useSyncExternalStore((cb) => packageManager ? packageManager.subscribe(cb) : () => {}, () => packageManager?.packages ?? []);
+};
+/** Adds the Vetra package manager event handler */
+const addVetraPackageManagerEventHandler = vetraPackageManagerFunctions.addEventHandler;
+/** Sets the Vetra package manager and registers its packages */
+function setVetraPackageManager(packageManager) {
+	vetraPackageManagerFunctions.setValue(packageManager);
+	updateReactorClientDocumentModels(packageManager.packages);
+	updateReactorClientUpgradeManifests(packageManager.packages);
+	packageManager.subscribe(({ packages }) => {
+		updateReactorClientDocumentModels(packages);
+		updateReactorClientUpgradeManifests(packages);
+	});
+}
+function updateReactorClientDocumentModels(packages) {
+	const documentModelModules = packages.flatMap((pkg) => pkg.documentModels);
+	const registry = window.ph?.reactorClientModule?.reactorModule?.documentModelRegistry;
+	if (!registry || documentModelModules.length === 0) return;
+	const results = registry.registerModules(...documentModelModules);
+	const duplicates = [];
+	for (const result of results) if (result.status === "error") if (DuplicateModuleError.isError(result.error)) duplicates.push(result);
+	else console.error("Failed to register document model module:", result.error);
+	if (duplicates.length > 0) {
+		const duplicateTypes = duplicates.map((r) => r.item.documentModel.global.id);
+		registry.unregisterModules(...duplicateTypes);
+		registry.registerModules(...duplicates.map((r) => r.item));
+	}
+}
+function updateReactorClientUpgradeManifests(packages) {
+	const upgradeManifests = packages.flatMap((pkg) => pkg.upgradeManifests).filter((u) => u !== void 0);
+	const registry = window.ph?.reactorClientModule?.reactorModule?.documentModelRegistry;
+	if (!registry || upgradeManifests.length === 0) return;
+	const results = registry.registerUpgradeManifests(...upgradeManifests);
+	const duplicates = [];
+	for (const result of results) if (result.status === "error") if (DuplicateManifestError.isError(result.error)) duplicates.push(result);
+	else console.error("Failed to register upgrade manifest:", result.error);
+	if (duplicates.length > 0) {
+		const duplicateTypes = duplicates.map((r) => r.item.documentType).filter((t) => !!t);
+		registry.unregisterUpgradeManifests(...duplicateTypes);
+		registry.registerUpgradeManifests(...duplicates.map((r) => r.item));
+	}
+}
+//#endregion
+//#region src/hooks/add-ph-event-handlers.ts
+const commonGlobalEventHandlerFunctions = {
+	loading: addLoadingEventHandler,
+	drives: addDrivesEventHandler,
+	selectedDriveId: () => {
+		addSelectedDriveIdEventHandler();
+		addSetSelectedDriveOnPopStateEventHandler();
+		addResetSelectedNodeEventHandler();
+	},
+	selectedNodeId: () => {
+		addSelectedNodeIdEventHandler();
+		addSetSelectedNodeOnPopStateEventHandler();
+	},
+	documentCache: addDocumentCacheEventHandler,
+	reactorGraphQLClient: addGraphQLReactorClientEventHandler
+};
+const phGlobalEventHandlerRegisterFunctions = {
+	...commonGlobalEventHandlerFunctions,
+	reactorClientModule: addReactorClientModuleEventHandler,
+	reactorClient: addReactorClientEventHandler,
+	features: addFeaturesEventHandler,
+	modal: addModalEventHandler,
+	renown: addRenownEventHandler,
+	vetraPackageManager: addVetraPackageManagerEventHandler,
+	packageDiscoveryService: addPackageDiscoveryServiceEventHandler,
+	selectedTimelineRevision: addSelectedTimelineRevisionEventHandler,
+	revisionHistoryVisible: addRevisionHistoryVisibleEventHandler,
+	selectedTimelineItem: addSelectedTimelineItemEventHandler,
+	routerBasename: addRouterBasenameEventHandler,
+	version: addVersionEventHandler,
+	logLevel: addLogLevelEventHandler,
+	requiresHardRefresh: addRequiresHardRefreshEventHandler,
+	warnOutdatedApp: addWarnOutdatedAppEventHandler,
+	studioMode: addStudioModeEventHandler,
+	basePath: addBasePathEventHandler,
+	versionCheckInterval: addVersionCheckIntervalEventHandler,
+	cliVersion: addCliVersionEventHandler,
+	fileUploadOperationsChunkSize: addFileUploadOperationsChunkSizeEventHandler,
+	isDocumentModelSelectionSettingsEnabled: addIsDocumentModelSelectionSettingsEnabledEventHandler,
+	gaTrackingId: addGaTrackingIdEventHandler,
+	allowList: addAllowListEventHandler,
+	defaultDrivesUrl: addDefaultDrivesUrlEventHandler,
+	drivesPreserveStrategy: addDrivesPreserveStrategyEventHandler,
+	allowedDocumentTypes: addAllowedDocumentTypesEventHandler,
+	enabledEditors: addEnabledEditorsEventHandler,
+	disabledEditors: addDisabledEditorsEventHandler,
+	isAddDriveEnabled: addIsAddDriveEnabledEventHandler,
+	isLocalDrivesEnabled: addIsLocalDrivesEnabledEventHandler,
+	isPublicDrivesEnabled: addIsPublicDrivesEnabledEventHandler,
+	isAddPublicDrivesEnabled: addIsAddPublicDrivesEnabledEventHandler,
+	isDeletePublicDrivesEnabled: addIsDeletePublicDrivesEnabledEventHandler,
+	isCloudDrivesEnabled: addIsCloudDrivesEnabledEventHandler,
+	isAddCloudDrivesEnabled: addIsAddCloudDrivesEnabledEventHandler,
+	isDeleteCloudDrivesEnabled: addIsDeleteCloudDrivesEnabledEventHandler,
+	isAddLocalDrivesEnabled: addIsAddLocalDrivesEnabledEventHandler,
+	isDeleteLocalDrivesEnabled: addIsDeleteLocalDrivesEnabledEventHandler,
+	isDragAndDropEnabled: addIsDragAndDropEnabledEventHandler,
+	isExternalControlsEnabled: addIsExternalControlsEnabledEventHandler,
+	isEditorDebugModeEnabled: addIsEditorDebugModeEnabledEventHandler,
+	isEditorReadModeEnabled: addIsEditorReadModeEnabledEventHandler,
+	isRelationalProcessorsEnabled: addIsRelationalProcessorsEnabledEventHandler,
+	isExternalRelationalProcessorsEnabled: addIsExternalRelationalProcessorsEnabledEventHandler,
+	isAnalyticsEnabled: addIsAnalyticsEnabledEventHandler,
+	isAnalyticsExternalProcessorsEnabled: addIsAnalyticsExternalProcessorsEnabledEventHandler,
+	analyticsDatabaseName: addAnalyticsDatabaseNameEventHandler,
+	isAnalyticsDatabaseWorkerEnabled: addIsAnalyticsDatabaseWorkerEnabledEventHandler,
+	isDiffAnalyticsEnabled: addIsDiffAnalyticsEnabledEventHandler,
+	isDriveAnalyticsEnabled: addIsDriveAnalyticsEnabledEventHandler,
+	renownUrl: addRenownUrlEventHandler,
+	renownNetworkId: addRenownNetworkIdEventHandler,
+	renownChainId: addRenownChainIdEventHandler,
+	sentryRelease: addSentryReleaseEventHandler,
+	sentryDsn: addSentryDsnEventHandler,
+	sentryEnv: addSentryEnvEventHandler,
+	isSentryTracingEnabled: addIsSentryTracingEnabledEventHandler,
+	isExternalProcessorsEnabled: addIsExternalProcessorsEnabledEventHandler,
+	isExternalPackagesEnabled: addIsExternalPackagesEnabledEventHandler,
+	toast: addToastEventHandler
+};
+function addPHEventHandlers() {
+	callEventHandlerRegisterFunctions(phGlobalEventHandlerRegisterFunctions);
+}
+function callEventHandlerRegisterFunctions(registerFunctions) {
+	forEachObj(registerFunctions, (fn) => fn());
+}
+//#endregion
+//#region src/hooks/document-model-modules.ts
+function useDocumentModelModules() {
+	return useVetraPackages().flatMap((pkg) => pkg.documentModels).filter((module, index, modules) => modules.findIndex((m) => m.documentModel.global.id === module.documentModel.global.id && m.version === module.version) === index);
+}
+function useDocumentModelModuleById(id) {
+	return useDocumentModelModules()?.find((module) => module.documentModel.global.id === id);
+}
+//#endregion
+//#region src/hooks/allowed-document-model-modules.ts
+function useAllowedDocumentModelModules() {
+	const documentModelModules = useDocumentModelModules();
+	const allowedDocumentTypes = useAllowedDocumentTypes();
+	if (!allowedDocumentTypes?.length) return documentModelModules;
+	return documentModelModules?.filter((module) => allowedDocumentTypes.includes(module.documentModel.global.id));
+}
+//#endregion
+//#region src/hooks/selected-folder.ts
+/** Returns the selected folder. */
+function useSelectedFolder() {
+	const selectedNode = useSelectedNode();
+	if (isFolderNodeKind(selectedNode)) return selectedNode;
+}
+//#endregion
+//#region src/hooks/child-nodes.ts
+/** Returns the child nodes for the selected drive or folder. */
+function useNodesInSelectedDriveOrFolder() {
+	const nodes = useNodesInSelectedDrive();
+	const selectedFolderId = useSelectedFolder()?.id;
+	if (!nodes) return [];
+	if (!selectedFolderId) return sortNodesByName(nodes.filter((n) => !n.parentFolder));
+	return sortNodesByName(nodes.filter((n) => n.parentFolder === selectedFolderId));
+}
+//#endregion
+//#region src/hooks/config/set-config-by-key.ts
+function setPHGlobalConfigByKey(key, value) {
+	const setter = phGlobalConfigSetters[key];
+	setter(value);
+}
+function setPHAppConfigByKey(key, value) {
+	const setter = phAppConfigSetters[key];
+	setter(value);
+}
+function setPHDocumentEditorConfigByKey(key, value) {
+	const setter = phDocumentEditorConfigSetters[key];
+	setter(value);
+}
+//#endregion
+//#region src/hooks/config/utils.ts
+function callGlobalSetterForKey(key, value) {
+	const setter = phGlobalConfigSetters[key];
+	setter(value);
+}
+//#endregion
+//#region src/hooks/config/set-config-by-object.ts
+function setDefaultPHGlobalConfig(config) {
+	for (const key of Object.keys(config)) callGlobalSetterForKey(key, config[key]);
+}
+function useSetDefaultPHGlobalConfig(config) {
+	const [isInitialized, setIsInitialized] = useState(false);
+	useEffect(() => {
+		if (isInitialized) return;
+		setDefaultPHGlobalConfig(config);
+		setIsInitialized(true);
+	}, [config, isInitialized]);
+}
+function useResetPHGlobalConfig(defaultConfigForReset) {
+	return function reset() {
+		setPHGlobalConfig(defaultConfigForReset);
+	};
+}
+function setPHGlobalConfig(config) {
+	for (const key of Object.keys(config)) callGlobalSetterForKey(key, config[key]);
+}
+function useSetPHGlobalConfig(config) {
+	const [isInitialized, setIsInitialized] = useState(false);
+	useEffect(() => {
+		if (isInitialized) return;
+		setPHGlobalConfig(config);
+		setIsInitialized(true);
+	}, [config, isInitialized]);
+}
+/** Sets the global drive config.
+*
+* Pass in a partial object of the global drive config to set.
+*/
+function setPHAppConfig(config) {
+	for (const key of Object.keys(config)) callGlobalSetterForKey(key, config[key]);
+}
+/** Sets the global document config.
+*
+* Pass in a partial object of the global document config to set.
+*/
+function setPHDocumentEditorConfig(config) {
+	for (const key of Object.keys(config)) callGlobalSetterForKey(key, config[key]);
+}
+/** Wrapper hook for setting the global app config.
+*
+* Automatically sets the global app config when the component mounts.
+*
+* Pass in a partial object of the global app config to set.
+*/
+function useSetPHAppConfig(config) {
+	const [isInitialized, setIsInitialized] = useState(false);
+	useEffect(() => {
+		if (isInitialized) return;
+		setPHAppConfig(config);
+		setIsInitialized(true);
+	}, [config, isInitialized]);
+}
+/** Wrapper hook for setting the global document editor config.
+*
+* Automatically sets the global document editor config when the component mounts.
+*
+* Pass in a partial object of the global document editor config to set.
+*/
+function useSetPHDocumentEditorConfig(config) {
+	const [isInitialized, setIsInitialized] = useState(false);
+	useEffect(() => {
+		if (isInitialized) return;
+		setPHDocumentEditorConfig(config);
+		setIsInitialized(true);
+	}, [config, isInitialized]);
+}
+//#endregion
+//#region src/hooks/config/use-value-by-key.ts
+function usePHGlobalConfigByKey(key) {
+	const useValueHook = phGlobalConfigHooks[key];
+	return useValueHook();
+}
+/** Gets the value of an item in the global drive config for a given key.
+*
+* Strongly typed, inferred from type definition for the key.
+*/
+function usePHAppConfigByKey(key) {
+	const useValueHook = phAppConfigHooks[key];
+	return useValueHook();
+}
+/** Gets the value of an item in the global document config for a given key.
+*
+* Strongly typed, inferred from type definition for the key.
+*/
+function usePHDocumentEditorConfigByKey(key) {
+	const useValueHook = phDocumentEditorConfigHooks[key];
+	return useValueHook();
+}
+//#endregion
+//#region src/hooks/connection-state.ts
+/**
+* Returns a map of remote name to connection state snapshot for all remotes.
+* Re-renders when any remote's connection state changes.
+*/
+function useConnectionStates() {
+	const syncManager = useSync();
+	const [states, setStates] = useState(() => buildSnapshot(syncManager));
+	const unsubscribesRef = useRef([]);
+	useEffect(() => {
+		if (!syncManager) return;
+		function subscribe() {
+			for (const unsub of unsubscribesRef.current) unsub();
+			unsubscribesRef.current = [];
+			const remotes = syncManager.list();
+			for (const remote of remotes) {
+				const unsub = remote.channel.onConnectionStateChange(() => {
+					setStates(buildSnapshot(syncManager));
+				});
+				unsubscribesRef.current.push(unsub);
+			}
+			setStates(buildSnapshot(syncManager));
+		}
+		subscribe();
+		const interval = setInterval(subscribe, 5e3);
+		return () => {
+			clearInterval(interval);
+			for (const unsub of unsubscribesRef.current) unsub();
+			unsubscribesRef.current = [];
+		};
+	}, [syncManager]);
+	return states;
+}
+/**
+* Returns the connection state snapshot for a specific remote by name.
+*/
+function useConnectionState(remoteName) {
+	return useConnectionStates().get(remoteName);
+}
+function buildSnapshot(syncManager) {
+	const map = /* @__PURE__ */ new Map();
+	if (!syncManager) return map;
+	for (const remote of syncManager.list()) map.set(remote.name, remote.channel.getConnectionState());
+	return map;
+}
+//#endregion
+//#region src/hooks/document-of-type.ts
+/** Returns a document of a specific type, throws an error if the found document has a different type */
+function useDocumentOfType(documentId, documentType) {
+	const [document, dispatch] = useDocumentById(documentId);
+	const documentModelModule = useDocumentModelModuleById(documentType);
+	if (!documentId || !documentType) return [];
+	if (!document) throw new Error(`Document not found: ${documentId}`);
+	if (!documentModelModule) throw new ModuleNotFoundError(documentType);
+	if (document.header.documentType !== documentType) throw new DocumentTypeMismatchError(documentId, documentType, document.header.documentType);
+	return [document, dispatch];
+}
+//#endregion
+//#region src/hooks/document-operations.ts
+/**
+* Hook to fetch document operations via the reactor client.
+* Operations are no longer auto-populated on documents and must be fetched explicitly.
+*
+* @param documentId - The document ID to fetch operations for
+* @returns Object containing globalOperations, localOperations, isLoading, and error
+*/
+function useDocumentOperations(documentId) {
+	const reactorClient = useReactorClient();
+	const hasFetchedRef = useRef(false);
+	const [state, setState] = useState(() => ({
+		globalOperations: [],
+		localOperations: [],
+		isLoading: !!documentId,
+		error: void 0
+	}));
+	const fetchOperations = useCallback(async (retryCount = 0) => {
+		const MAX_RETRIES = 5;
+		const RETRY_DELAY_MS = 500;
+		if (!documentId || !reactorClient) {
+			setState({
+				globalOperations: [],
+				localOperations: [],
+				isLoading: false,
+				error: void 0
+			});
+			return;
+		}
+		setState((prev) => ({
+			...prev,
+			isLoading: true,
+			error: void 0
+		}));
+		let globalOps = [];
+		let localOps = [];
+		let fetchError;
+		try {
+			globalOps = (await reactorClient.getOperations(documentId, { scopes: ["global"] })).results;
+		} catch (err) {
+			fetchError = err instanceof Error ? err : new Error(String(err));
+		}
+		if (!fetchError) try {
+			localOps = (await reactorClient.getOperations(documentId, { scopes: ["local"] })).results;
+		} catch (err) {
+			fetchError = err instanceof Error ? err : new Error(String(err));
+		}
+		if (!fetchError && globalOps.length === 0 && localOps.length === 0 && retryCount < MAX_RETRIES) {
+			await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+			return fetchOperations(retryCount + 1);
+		}
+		setState({
+			globalOperations: globalOps,
+			localOperations: localOps,
+			isLoading: false,
+			error: fetchError
+		});
+		hasFetchedRef.current = true;
+	}, [documentId, reactorClient]);
+	useEffect(() => {
+		if (documentId && reactorClient) fetchOperations();
+		else if (!documentId) {
+			setState({
+				globalOperations: [],
+				localOperations: [],
+				isLoading: false,
+				error: void 0
+			});
+			hasFetchedRef.current = false;
+		}
+	}, [
+		documentId,
+		reactorClient,
+		fetchOperations
+	]);
+	const refetch = useCallback(() => {
+		fetchOperations(0);
+	}, [fetchOperations]);
+	return {
+		...state,
+		refetch
+	};
+}
+//#endregion
+//#region src/hooks/supported-document-types.ts
+/** Returns the supported document types for the reactor (derived from the document model modules) */
+function useSupportedDocumentTypesInReactor() {
+	return useDocumentModelModules()?.map((module) => module.documentModel.global.id);
+}
+//#endregion
+//#region src/hooks/document-types.ts
+/** Returns the document types a app supports.
+*
+* If present, uses the `allowedDocumentTypes` config value.
+* Otherwise, uses the supported document types from the reactor.
+*/
+function useDocumentTypes() {
+	const allowedDocumentTypes = useAllowedDocumentTypes();
+	const supportedDocumentTypes = useSupportedDocumentTypesInReactor();
+	return allowedDocumentTypes ?? supportedDocumentTypes;
+}
+//#endregion
+//#region src/hooks/drive-by-id.ts
+function useDriveById(driveId) {
+	const foundDrive = useDrives()?.find((drive) => drive.header.id === driveId);
+	const [drive, dispatch] = useDispatch(foundDrive);
+	if (!foundDrive) throw new Error(`Drive with id ${driveId} not found`);
+	return [drive, dispatch];
+}
+//#endregion
+//#region src/hooks/editor-modules.ts
+function useEditorModules() {
+	return useVetraPackages().flatMap((pkg) => pkg.editors).filter((module) => !module.documentTypes.includes("powerhouse/document-drive"));
+}
+function useAppModules() {
+	return useVetraPackages().flatMap((pkg) => pkg.editors).filter((module) => module.documentTypes.includes("powerhouse/document-drive"));
+}
+function useFallbackEditorModule(documentType) {
+	const editorModules = useEditorModules();
+	if (!documentType) return void 0;
+	if (editorModules?.length === 0) return void 0;
+	return (editorModules?.filter((module) => module.documentTypes.includes(documentType)))?.[0];
+}
+function useAppModuleById(id) {
+	return useAppModules()?.find((module) => module.config.id === id);
+}
+function useDefaultAppModule() {
+	return useAppModuleById(DEFAULT_DRIVE_EDITOR_ID);
+}
+function useEditorModuleById(id) {
+	return useEditorModules()?.find((module) => module.config.id === id);
+}
+function useEditorModulesForDocumentType(documentType) {
+	const editorModules = useEditorModules();
+	if (!documentType) return void 0;
+	return editorModules?.filter((module) => module.documentTypes.includes(documentType));
+}
+//#endregion
+//#region src/hooks/folder-by-id.ts
+function useFolderById(id) {
+	return useFolderNodesInSelectedDrive()?.find((n) => n.id === id);
+}
+//#endregion
+//#region src/graphql/events.ts
+function dispatchGraphQLClientDocumentEvent(operationName, identifier) {
+	const event = new CustomEvent(operationName, { detail: { identifier } });
+	window.dispatchEvent(event);
+}
+//#endregion
+//#region src/graphql/document-cache-client-middleware.ts
+const documentCacheClientMiddleware = async (action, operationName, operationType, variables) => {
+	console.log({
+		operationName,
+		operationType,
+		variables
+	});
+	const result = await action();
+	if (isIncludedIn(operationName, graphqlEventsToSyncDrive)) window.dispatchEvent(new CustomEvent(operationName));
+	if (isStrictEqual(operationName, "MutateDocument")) dispatchGraphQLClientDocumentEvent(operationName, identifierFromMutateDocumentOperationVariables(variables));
+	return result;
+};
+//#endregion
+//#region src/hooks/init-graphql-reactor-client.ts
+function useInitReactorGraphqlClient(switchboardUrl = DEFAULT_SWITCHBOARD_URL, driveId = DEFAULT_DRIVE_ID) {
+	const [hasInit, setHasInit] = useState(false);
+	useEffect(() => {
+		if (hasInit) return;
+		initGraphQLReactorClientWithDocumentCache(switchboardUrl, driveId).then(() => setHasInit(true)).catch(console.error);
+	}, [hasInit]);
+	return hasInit;
+}
+async function reactorGraphqlFetchDrive(identifier) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	const result = await client.GetDocument({ identifier });
+	if (!result.document?.document) throw new Error("Could not fetch drive with id: " + identifier);
+	return phDocumentFromQuery(result.document.document, DriveDocumentSchema);
+}
+async function reactorGraphqlSyncDrive(driveId) {
+	if (!window.ph?.reactorGraphQLClient) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	const drive = await reactorGraphqlFetchDrive(driveId);
+	setDrives([drive]);
+	setSelectedDrive(drive);
+}
+async function initGraphQLReactorClientWithDocumentCache(switchboardUrl, driveId) {
+	if (!window.ph) window.ph = {};
+	callEventHandlerRegisterFunctions(commonGlobalEventHandlerFunctions);
+	setGraphQLReactorClient(createClient(switchboardUrl, documentCacheClientMiddleware));
+	await reactorGraphqlSyncDrive(driveId);
+	setSelectedNode(void 0);
+	setDocumentCache(new GraphQLClientDocumentCache());
+	forEach(graphqlEventsToSyncDrive, (name) => {
+		window.addEventListener(name, () => {
+			reactorGraphqlSyncDrive(driveId).catch(console.error);
+		});
+	});
+}
+//#endregion
+//#region src/hooks/items-in-selected-folder.ts
+/** Returns the nodes in the selected folder. */
+function useNodesInSelectedFolder() {
+	const selectedFolder = useSelectedFolder();
+	const nodes = useNodesInSelectedDrive();
+	if (!selectedFolder || !nodes) return void 0;
+	return nodes.filter((n) => n.parentFolder === selectedFolder.id);
+}
+/** Returns the file nodes in the selected folder. */
+function useFileNodesInSelectedFolder() {
+	const nodes = useNodesInSelectedFolder();
+	if (!nodes) return void 0;
+	return nodes.filter((n) => isFileNodeKind(n));
+}
+/** Returns the folder nodes in the selected folder. */
+function useFolderNodesInSelectedFolder() {
+	const nodes = useNodesInSelectedFolder();
+	if (!nodes) return void 0;
+	return nodes.filter((n) => isFolderNodeKind(n));
+}
+/** Returns the documents in the selected folder. */
+function useDocumentsInSelectedFolder() {
+	const documents = useDocumentsInSelectedDrive();
+	const fileNodeIds = useFileNodesInSelectedFolder()?.map((node) => node.id);
+	return documents?.filter((d) => fileNodeIds?.includes(d.header.id));
+}
+//#endregion
+//#region src/hooks/node-actions.ts
+function resolveNode(driveId, node) {
+	return node?.id !== driveId ? node : void 0;
+}
+function useNodeActions() {
+	const [selectedDrive] = useSelectedDriveSafe();
+	const selectedFolder = useSelectedFolder();
+	const selectedParentFolder = useFolderById(useSelectedNode()?.parentFolder);
+	const selectedDriveId = selectedDrive?.header.id;
+	const drives = useDrives();
+	async function onAddFile(file, parent) {
+		if (!selectedDriveId) return;
+		return addFile(file, selectedDriveId, file.name.replace(/\..+/gim, ""), resolveNode(selectedDriveId, parent)?.id);
+	}
+	async function onAddFolder(name, parent) {
+		if (!selectedDriveId) return;
+		return addFolder(selectedDriveId, name, resolveNode(selectedDriveId, parent)?.id);
+	}
+	async function onRenameNode(newName, node) {
+		if (!selectedDriveId) return;
+		if (!resolveNode(selectedDriveId, node)) {
+			console.error(`Node ${node.id} not found`);
+			return;
+		}
+		return await renameNode(selectedDriveId, node.id, newName);
+	}
+	async function onCopyNode(src, target) {
+		if (!selectedDriveId) return;
+		const resolvedSrc = resolveNode(selectedDriveId, src);
+		if (!resolvedSrc) {
+			console.error(`Node ${src.id} not found`);
+			return;
+		}
+		await copyNode$1(selectedDriveId, resolvedSrc, resolveNode(selectedDriveId, target));
+	}
+	async function onMoveNode(src, target) {
+		if (!selectedDriveId) return;
+		const resolvedSrc = resolveNode(selectedDriveId, src);
+		if (!resolvedSrc) {
+			console.error(`Node ${src.id} not found`);
+			return;
+		}
+		const resolvedTarget = resolveNode(selectedDriveId, target);
+		if (!resolvedTarget?.id && !src.parentFolder || resolvedTarget?.id === src.parentFolder) return;
+		await moveNode$1(selectedDriveId, resolvedSrc, resolvedTarget);
+	}
+	async function onDuplicateNode(src) {
+		if (!selectedDriveId) return;
+		const resolvedSrc = resolveNode(selectedDriveId, src);
+		if (!resolvedSrc) {
+			console.error(`Node ${src.id} not found`);
+			return;
+		}
+		await copyNode$1(selectedDriveId, resolvedSrc, resolveNode(selectedDriveId, selectedFolder ?? selectedParentFolder));
+	}
+	async function onAddAndSelectNewFolder(name) {
+		if (!name) return;
+		if (!selectedDriveId) return;
+		const resolvedTarget = resolveNode(selectedDriveId, selectedFolder ?? selectedParentFolder);
+		if (!resolvedTarget) return;
+		const newFolder = await onAddFolder(name, resolvedTarget);
+		if (newFolder) setSelectedNode(newFolder);
+	}
+	async function onRenameDriveNodes(newName, nodeId) {
+		if (!drives) return;
+		const drivesWithNode = drives.filter((drive) => drive.state.global.nodes.some((n) => n.id === nodeId));
+		await Promise.all(drivesWithNode.map((drive) => renameDriveNode(drive.header.id, nodeId, newName)));
+	}
+	return {
+		onAddFile,
+		onAddFolder,
+		onRenameNode,
+		onCopyNode,
+		onMoveNode,
+		onDuplicateNode,
+		onAddAndSelectNewFolder,
+		onRenameDriveNodes
+	};
+}
+//#endregion
+//#region src/hooks/node-by-id.ts
+/** Returns a node in the selected drive by id. */
+function useNodeById(id) {
+	return useNodesInSelectedDrive()?.find((n) => n.id === id);
+}
+//#endregion
+//#region src/hooks/node-path.ts
+/** Returns the path to a node in the selected drive */
+function useNodePathById(id) {
+	const nodes = useNodesInSelectedDrive();
+	if (!nodes) return [];
+	const path = [];
+	let current = nodes.find((n) => n.id === id);
+	while (current) {
+		path.push(current);
+		if (!current.parentFolder) break;
+		current = nodes.find((n) => n.id === current?.parentFolder);
+	}
+	return path.reverse();
+}
+/** Returns the path to the currently selected node in the selected drive. */
+function useSelectedNodePath() {
+	return useNodePathById(useSelectedNode()?.id);
+}
+//#endregion
+//#region src/hooks/parent-folder.ts
+function useNodeParentFolderById(id) {
+	return useFolderById(useNodeById(id)?.parentFolder);
+}
+function useParentFolderForSelectedNode() {
+	return useNodeParentFolderById(useSelectedNode()?.id);
+}
+//#endregion
+//#region src/hooks/selected-document.ts
+/** Returns the selected document id */
+function useSelectedDocumentId() {
+	const selectedNode = useSelectedNode();
+	return selectedNode && isFileNode(selectedNode) ? selectedNode.id : void 0;
+}
+/** Returns the selected document. */
+function useSelectedDocument() {
+	const [document, dispatch] = useDocumentById(useSelectedDocumentId());
+	if (!document) throw new NoSelectedDocumentError();
+	return [document, dispatch];
+}
+/** Returns the selected document. */
+function useSelectedDocumentSafe() {
+	return useDocumentById(useSelectedDocumentId());
+}
+function useSelectedDocumentOfType(documentType) {
+	const documentId = useSelectedDocumentId();
+	if (!documentType) return [];
+	if (!documentId) throw new NoSelectedDocumentError();
+	return useDocumentOfType(documentId, documentType);
+}
+//#endregion
+//#region src/hooks/subgraph-modules.ts
+function useSubgraphModules() {
+	return useVetraPackages().flatMap((pkg) => pkg.subgraphs || []);
+}
+//#endregion
+//#region src/hooks/use-drive-system-info.ts
+function deriveSystemUrl(channelUrl) {
+	try {
+		const url = new URL(channelUrl);
+		url.search = "";
+		url.hash = "";
+		if (url.pathname.endsWith("/graphql/r")) url.pathname = url.pathname.slice(0, -10) + "/graphql/system";
+		else url.pathname = "/graphql/system";
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+const cache = /* @__PURE__ */ new Map();
+function useDriveSystemInfo(drive) {
+	const remotes = useSyncList();
+	const driveId = drive?.header.id;
+	const systemUrl = useMemo(() => {
+		if (!driveId) return null;
+		const channelUrl = (remotes.find((r) => r.collectionId === driveCollectionId$1("main", driveId))?.channel)?.config.url;
+		if (typeof channelUrl !== "string") return null;
+		return deriveSystemUrl(channelUrl);
+	}, [remotes, driveId]);
+	const [state, setState] = useState(() => systemUrl ? cache.get(systemUrl) ?? { status: "loading" } : { status: "local" });
+	useEffect(() => {
+		if (!systemUrl) {
+			setState({ status: "local" });
+			return;
+		}
+		const cached = cache.get(systemUrl);
+		if (cached && cached.status !== "loading") {
+			setState(cached);
+			return;
+		}
+		setState({ status: "loading" });
+		cache.set(systemUrl, { status: "loading" });
+		const controller = new AbortController();
+		fetch(systemUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ query: "{ system { version gitHash gitUrl } }" }),
+			signal: controller.signal
+		}).then(async (res) => {
+			const json = await res.json();
+			if (json.errors?.length) throw new Error(json.errors.map((e) => e.message).join("; "));
+			const sys = json.data?.system;
+			if (!sys) throw new Error("Missing system in response");
+			const next = {
+				status: "ready",
+				version: sys.version,
+				gitHash: sys.gitHash,
+				gitUrl: sys.gitUrl ?? null,
+				host: new URL(systemUrl).host
+			};
+			cache.set(systemUrl, next);
+			setState(next);
+		}).catch((err) => {
+			if (controller.signal.aborted) return;
+			const message = err instanceof Error ? err.message : String(err);
+			console.error(message);
+			const next = {
+				status: "error",
+				message
+			};
+			cache.set(systemUrl, next);
+			setState(next);
+		});
+		return () => controller.abort();
+	}, [systemUrl]);
+	return state;
+}
+//#endregion
+//#region src/utils/drives.ts
+const syncStatusToUI = {
+	[SyncStatus.Synced]: "SUCCESS",
+	[SyncStatus.Outgoing]: "SYNCING",
+	[SyncStatus.Incoming]: "SYNCING",
+	[SyncStatus.OutgoingAndIncoming]: "SYNCING",
+	[SyncStatus.Error]: "ERROR"
+};
+async function getDrives(reactor) {
+	return (await reactor.find({ type: "powerhouse/document-drive" })).results;
+}
+function getSyncStatus(documentId, sharingType) {
+	return Promise.resolve(getSyncStatusSync(documentId, sharingType));
+}
+function getSyncStatusSync(documentId, sharingType) {
+	if (sharingType === "LOCAL") return;
+	const syncManager = window.ph?.reactorClientModule?.reactorModule?.syncModule?.syncManager;
+	if (!syncManager) return;
+	const status = syncManager.getSyncStatus(documentId);
+	if (status === void 0) return;
+	return syncStatusToUI[status];
+}
+//#endregion
+//#region src/utils/validate-document.ts
+const validateDocument = (document) => {
+	const errors = [];
+	if (document.header.documentType !== "powerhouse/document-model") return errors;
+	const doc = document;
+	const specs = doc.state.global.specifications[0];
+	const initialStateErrors = Object.keys(specs.state).reduce((acc, scopeKey) => {
+		const scope = scopeKey;
+		return [...acc, ...validateInitialState(specs.state[scope].initialValue, scope !== "global").map((err) => ({
+			...err,
+			message: `${err.message}. Scope: ${scope}`,
+			details: {
+				...err.details,
+				scope
+			}
+		}))];
+	}, []);
+	const schemaStateErrors = Object.keys(specs.state).reduce((acc, scopeKey) => {
+		const scope = scopeKey;
+		const isGlobalScope = scope === "global";
+		return [...acc, ...validateStateSchemaName(specs.state[scope].schema, doc.state.global?.name || doc.header.name || "", !isGlobalScope ? scope : "", !isGlobalScope).map((err) => ({
+			...err,
+			message: `${err.message}. Scope: ${scope}`,
+			details: {
+				...err.details,
+				scope
+			}
+		}))];
+	}, []);
+	const modulesErrors = validateModules(specs.modules);
+	return [
+		...initialStateErrors,
+		...schemaStateErrors,
+		...modulesErrors
+	];
+};
+//#endregion
+//#region src/utils/export-document.ts
+const exportDocument = (document) => {
+	if (!document) return;
+	if (validateDocument(document).length) showPHModal({
+		type: "exportDocumentWithErrors",
+		documentId: document.header.id
+	});
+	else return exportFile(document);
+};
+//#endregion
+//#region src/utils/get-revision-from-date.ts
+const getRevisionFromDate = (startDate, endDate, operations = []) => {
+	if (!startDate || !endDate) return 0;
+	const operation = operations.find((operation) => {
+		const operationDate = new Date(operation.timestampUtcMs);
+		return operationDate >= startDate && operationDate <= endDate;
+	});
+	return operation ? operation.index : 0;
+};
+//#endregion
+//#region src/utils/switchboard.ts
+async function getDriveIdBySlug(driveUrl, slug) {
+	if (!driveUrl) return;
+	const urlParts = driveUrl.split("/");
+	urlParts.pop();
+	urlParts.pop();
+	urlParts.push("drives");
+	const drivesUrl = urlParts.join("/");
+	return (await (await fetch(drivesUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			query: `
+                        query getDriveIdBySlug($slug: String!) {
+                            driveIdBySlug(slug: $slug)
+                        }
+                    `,
+			variables: { slug }
+		})
+	})).json()).data.driveIdBySlug;
+}
+function getSlugFromDriveUrl(driveUrl) {
+	return driveUrl.split("/").pop();
+}
+function getSwitchboardGatewayUrlFromDriveUrl(driveUrl) {
+	const urlParts = driveUrl.split("/");
+	urlParts.pop();
+	urlParts.pop();
+	urlParts.push("graphql");
+	return urlParts.join("/");
+}
+function getDocumentGraphqlQuery() {
+	const loc = GetDocumentWithOperationsDocument.loc;
+	if (!loc) throw new Error("GetDocumentWithOperationsDocument is misconfigured, loc is missing.");
+	return loc.source.body;
+}
+function buildDocumentSubgraphQuery(identifier, authToken) {
+	const query = getDocumentGraphqlQuery();
+	const variables = { identifier };
+	const headers = authToken ? { Authorization: `Bearer ${authToken}` } : void 0;
+	const payload = {
+		document: query.trim(),
+		variables: JSON.stringify(variables, null, 2)
+	};
+	if (headers) payload.headers = JSON.stringify(headers);
+	return lzString.compressToEncodedURIComponent(JSON.stringify(payload));
+}
+function buildDocumentSubgraphUrl(driveUrl, identifier, authToken) {
+	return `${driveUrl}?explorerURLState=${buildDocumentSubgraphQuery(identifier, authToken)}`;
+}
+//#endregion
+//#region src/hooks/use-get-switchboard-link.ts
+/**
+* Hook that returns a function to generate a document's switchboard URL.
+* Only returns a function for documents in remote drives.
+* Returns null for local drives or when the document/drive cannot be determined.
+*
+* The returned function generates a fresh bearer token and builds the switchboard URL
+* with authentication when called.
+*
+* @param document - The document to create a switchboard URL generator for
+* @returns An async function that returns the switchboard URL, or null if not applicable
+*/
+function useGetSwitchboardLink(document) {
+	const [drive] = useSelectedDrive();
+	const remotes = useSyncList();
+	const isRemoteDrive = useMemo(() => {
+		return remotes.some((remote) => remote.collectionId === driveCollectionId$1("main", drive.header.id));
+	}, [remotes, drive]);
+	const remoteUrl = useMemo(() => {
+		try {
+			const channelUrl = (remotes.find((remote) => remote.collectionId === driveCollectionId$1("main", drive.header.id))?.channel)?.config.url;
+			if (typeof channelUrl === "string") return channelUrl;
+			return null;
+		} catch (error) {
+			console.error("Error determining remote URL:", error);
+			return null;
+		}
+	}, [remotes, drive]);
+	const renown = useRenown();
+	const user = useUser();
+	return useMemo(() => {
+		if (!isRemoteDrive || !document?.header.id || !remoteUrl) return null;
+		return async () => {
+			const token = user?.address ? await renown?.getBearerToken({
+				expiresIn: 600,
+				aud: remoteUrl
+			}) : void 0;
+			return buildDocumentSubgraphUrl(remoteUrl, document.header.id, token);
+		};
+	}, [
+		isRemoteDrive,
+		remoteUrl,
+		document,
+		user,
+		renown
+	]);
+}
+//#endregion
+//#region src/hooks/use-on-drop-file.ts
+const useOnDropFile = (documentTypesOverride) => {
+	const selectedDriveId = useSelectedDriveId();
+	const selectedFolder = useSelectedFolder();
+	const documentTypes = useDocumentTypes();
+	const onDropFile = async (file, onProgress, resolveConflict) => {
+		if (!selectedDriveId) {
+			console.warn("No selected drive - upload skipped");
+			return;
+		}
+		const fileName = file.name.replace(/\..+/gim, "");
+		const targetNodeId = selectedFolder?.id;
+		return await addFileWithProgress(file, selectedDriveId, fileName, targetNodeId, onProgress, documentTypesOverride ?? documentTypes, resolveConflict);
+	};
+	return onDropFile;
+};
+//#endregion
+//#region src/hooks/user-permissions.ts
+function useUserPermissions() {
+	const user = useUser();
+	const allowList = useAllowList();
+	if (!allowList) return {
+		isAllowedToCreateDocuments: true,
+		isAllowedToEditDocuments: true
+	};
+	return {
+		isAllowedToCreateDocuments: allowList.includes(user?.address ?? ""),
+		isAllowedToEditDocuments: allowList.includes(user?.address ?? "")
+	};
+}
+//#endregion
+//#region src/pglite/drop.ts
+async function dropTablesInSchema(pg, schema) {
+	await pg.exec(`
+DO $$
+DECLARE
+    _schemaname text := '${schema}';
+    _tablename text;
+BEGIN
+    FOR _tablename IN SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = _schemaname LOOP
+        RAISE INFO 'Dropping table %.%', _schemaname, _tablename;
+        EXECUTE format('DROP TABLE %I.%I CASCADE;', _schemaname, _tablename);
+    END LOOP;
+    IF NOT FOUND THEN
+        RAISE WARNING 'Schema % does not exist', _schemaname;
+    END IF;
+END $$;
+`);
+}
+async function truncateAllTables(pg, schema = REACTOR_SCHEMA$1) {
+	await dropTablesInSchema(pg, schema);
+}
+async function dropAllReactorStorage(pg) {
+	await dropTablesInSchema(pg, REACTOR_SCHEMA$1);
+	await dropTablesInSchema(pg, "public");
+}
+//#endregion
+//#region src/reactor.ts
+const DEFAULT_DEBOUNCE_DELAY_MS = 200;
+const DEFAULT_IMMEDIATE_THRESHOLD_MS = 1e3;
+async function _refreshReactorData(reactor) {
+	setDrives(await getDrives(reactor));
+}
+async function _refreshReactorDataClient(reactor) {
+	if (!reactor) return;
+	setDrives((await reactor.find({ type: "powerhouse/document-drive" })).results);
+}
+function createDebouncedRefreshReactorData(debounceDelayMs = DEFAULT_DEBOUNCE_DELAY_MS, immediateThresholdMs = DEFAULT_IMMEDIATE_THRESHOLD_MS) {
+	let timeout = null;
+	let lastRefreshTime = 0;
+	return (reactor, immediate = false) => {
+		const now = Date.now();
+		const timeSinceLastRefresh = now - lastRefreshTime;
+		if (timeout !== null) clearTimeout(timeout);
+		if (immediate || timeSinceLastRefresh >= immediateThresholdMs) {
+			lastRefreshTime = now;
+			return _refreshReactorData(reactor);
+		}
+		return new Promise((resolve) => {
+			timeout = setTimeout(() => {
+				lastRefreshTime = Date.now();
+				_refreshReactorData(reactor).then(resolve);
+			}, debounceDelayMs);
+		});
+	};
+}
+function createDebouncedRefreshReactorDataClient(debounceDelayMs = DEFAULT_DEBOUNCE_DELAY_MS, immediateThresholdMs = DEFAULT_IMMEDIATE_THRESHOLD_MS) {
+	let timeout = null;
+	let lastRefreshTime = 0;
+	return (reactor, immediate = false) => {
+		const now = Date.now();
+		const timeSinceLastRefresh = now - lastRefreshTime;
+		if (timeout !== null) clearTimeout(timeout);
+		if (immediate || timeSinceLastRefresh >= immediateThresholdMs) {
+			lastRefreshTime = now;
+			return _refreshReactorDataClient(reactor);
+		}
+		return new Promise((resolve) => {
+			timeout = setTimeout(() => {
+				lastRefreshTime = Date.now();
+				_refreshReactorDataClient(reactor).then(resolve);
+			}, debounceDelayMs);
+		});
+	};
+}
+const refreshReactorData = createDebouncedRefreshReactorData();
+const refreshReactorDataClient = createDebouncedRefreshReactorDataClient();
+//#endregion
+//#region src/registry/fetchers.ts
+function trimTrailingSlash(url) {
+	return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+async function getPackages(registryUrl) {
+	const res = await fetch(`${trimTrailingSlash(registryUrl)}/packages`);
+	if (!res.ok) throw new Error(`Registry error: HTTP ${res.status}`);
+	return await res.json();
+}
+async function getPackagesByDocumentType(registryUrl, documentType) {
+	const encodedType = encodeURIComponent(documentType);
+	const res = await fetch(`${trimTrailingSlash(registryUrl)}/packages/by-document-type?type=${encodedType}`);
+	if (!res.ok) throw new Error(`Registry error: HTTP ${res.status}`);
+	return await res.json();
+}
+//#endregion
+//#region src/registry/client.ts
+function cdnUrlToApiUrl(cdnUrl) {
+	return cdnUrl.replace(/\/-\/cdn\/?$/, "");
+}
+var RegistryClient = class {
+	apiUrl;
+	constructor(cdnUrl) {
+		this.apiUrl = cdnUrlToApiUrl(cdnUrl);
+	}
+	async getPackages() {
+		return await getPackages(this.apiUrl);
+	}
+	async getPackagesByDocumentType(documentType) {
+		return await getPackagesByDocumentType(this.apiUrl, documentType);
+	}
+	async searchPackages(query) {
+		const packages = await this.getPackages();
+		if (!query) return packages;
+		const lowerQuery = query.toLowerCase();
+		return packages.filter((pkg) => pkg.name.toLowerCase().includes(lowerQuery) || pkg.manifest?.description?.toLowerCase().includes(lowerQuery));
+	}
+	onPublish(callback) {
+		const eventSource = new EventSource(`${this.apiUrl}/-/events`);
+		eventSource.addEventListener("publish", (e) => {
+			callback(JSON.parse(e.data));
+		});
+		return () => {
+			eventSource.close();
+		};
+	}
+};
+//#endregion
+//#region src/remote-controller/action-tracker.ts
+/**
+* Tracks pending actions with their operation context (prevOpHash, prevOpIndex).
+* Actions are accumulated until flushed (on push).
+*/
+var ActionTracker = class {
+	pending = [];
+	/** Track a new action with its operation context. */
+	track(action, prevOpHash, prevOpIndex) {
+		this.pending.push({
+			action,
+			prevOpHash,
+			prevOpIndex
+		});
+	}
+	/** Flush all pending actions and return them. Clears the internal queue. */
+	flush() {
+		const actions = this.pending;
+		this.pending = [];
+		return actions;
+	}
+	/** Number of pending actions. */
+	get count() {
+		return this.pending.length;
+	}
+	/** Prepend previously flushed actions back to the queue (for retry on failure). */
+	restore(actions) {
+		this.pending = [...actions, ...this.pending];
+	}
+	/** Clear all pending actions without returning them. */
+	clear() {
+		this.pending = [];
+	}
+};
+//#endregion
+//#region src/remote-controller/remote-client.ts
+/**
+* Thin facade over the GraphQL SDK for remote document operations.
+*/
+const DEFAULT_PAGE_SIZE = 100;
+var RemoteClient = class {
+	pageSize;
+	constructor(client, pageSize) {
+		this.client = client;
+		this.pageSize = pageSize ?? DEFAULT_PAGE_SIZE;
+	}
+	/** Fetch a document by identifier. Returns null if not found. */
+	async getDocument(identifier, branch) {
+		return (await this.client.GetDocument({
+			identifier,
+			view: branch ? { branch } : void 0
+		})).document ?? null;
+	}
+	/**
+	* Fetch a document and its operations.
+	*
+	* When scopes are provided and BatchGetDocumentWithOperations is available,
+	* fetches the document and per-scope operations in a single HTTP request.
+	* Otherwise falls back to GetDocumentWithOperations for the first page,
+	* then paginates remaining operations per scope.
+	*/
+	async getDocumentWithOperations(identifier, branch, sinceRevision, scopes) {
+		if (this.client.BatchGetDocumentWithOperations && scopes && scopes.length > 0) return this.batchGetDocumentWithOperations(identifier, branch, sinceRevision, scopes);
+		const result = await this.client.GetDocumentWithOperations({
+			identifier,
+			view: branch ? { branch } : void 0,
+			operationsPaging: {
+				limit: this.pageSize,
+				cursor: null
+			}
+		});
+		if (!result.document) return null;
+		const doc = result.document.document;
+		const opsPage = doc.operations;
+		const operationsByScope = {};
+		if (opsPage) for (const op of opsPage.items) (operationsByScope[op.action.scope] ??= []).push(op);
+		const expectedTotal = doc.revisionsList.reduce((sum, r) => sum + r.revision, 0);
+		if ((opsPage?.items.length ?? 0) >= expectedTotal) return {
+			document: doc,
+			childIds: result.document.childIds,
+			operations: { operationsByScope }
+		};
+		const allScopes = doc.revisionsList.map((r) => r.scope);
+		const allOps = await this.getAllOperations(doc.id, branch, sinceRevision, allScopes);
+		return {
+			document: doc,
+			childIds: result.document.childIds,
+			operations: allOps
+		};
+	}
+	/**
+	* Fetch document + per-scope operations in a single HTTP request
+	* via BatchGetDocumentWithOperations, then paginate any remaining pages.
+	*/
+	async batchGetDocumentWithOperations(identifier, branch, sinceRevision, scopes) {
+		const view = branch ? { branch } : void 0;
+		const filters = scopes.map((scope) => ({
+			documentId: identifier,
+			branch: branch ?? null,
+			sinceRevision: sinceRevision?.[scope] ?? 0,
+			scopes: [scope]
+		}));
+		const pagings = scopes.map(() => ({
+			limit: this.pageSize,
+			cursor: null
+		}));
+		const result = await this.client.BatchGetDocumentWithOperations(identifier, view, filters, pagings);
+		if (!result.document) return null;
+		const operationsByScope = {};
+		let pending = [];
+		for (let i = 0; i < scopes.length; i++) {
+			const page = result.operations[i];
+			for (const op of page.items) (operationsByScope[op.action.scope] ??= []).push(op);
+			if (page.hasNextPage && page.cursor) pending.push({
+				scope: scopes[i],
+				filter: filters[i],
+				cursor: page.cursor
+			});
+		}
+		while (pending.length > 0) {
+			const pages = await this.fetchOperationPages(pending.map((p) => p.filter), pending.map((p) => ({
+				limit: this.pageSize,
+				cursor: p.cursor
+			})));
+			const nextPending = [];
+			for (let i = 0; i < pending.length; i++) {
+				const page = pages[i];
+				for (const op of page.items) (operationsByScope[op.action.scope] ??= []).push(op);
+				if (page.hasNextPage && page.cursor) nextPending.push({
+					...pending[i],
+					cursor: page.cursor
+				});
+			}
+			pending = nextPending;
+		}
+		return {
+			document: result.document.document,
+			childIds: result.document.childIds,
+			operations: { operationsByScope }
+		};
+	}
+	/**
+	* Fetch all operations for a document, paginating through all pages.
+	* Each scope is queried individually because the API only returns
+	* pagination cursors for single-scope queries.
+	*/
+	async getAllOperations(documentId, branch, sinceRevision, scopes) {
+		if (scopes && scopes.length > 0) {
+			const operationsByScope = {};
+			let pending = scopes.map((scope) => ({
+				scope,
+				filter: {
+					documentId,
+					branch: branch ?? null,
+					sinceRevision: sinceRevision?.[scope] ?? 0,
+					scopes: [scope]
+				},
+				cursor: null
+			}));
+			while (pending.length > 0) {
+				const pages = await this.fetchOperationPages(pending.map((p) => p.filter), pending.map((p) => ({
+					limit: this.pageSize,
+					cursor: p.cursor
+				})));
+				const nextPending = [];
+				for (let i = 0; i < pending.length; i++) {
+					const page = pages[i];
+					for (const op of page.items) (operationsByScope[op.action.scope] ??= []).push(op);
+					if (page.hasNextPage && page.cursor) nextPending.push({
+						...pending[i],
+						cursor: page.cursor
+					});
+				}
+				pending = nextPending;
+			}
+			return { operationsByScope };
+		}
+		return this.fetchOperationsForScope(documentId, branch);
+	}
+	/**
+	* Fetch one page of operations per filter.
+	* Uses the composed query (single HTTP request) when available,
+	* otherwise falls back to parallel individual requests.
+	*/
+	async fetchOperationPages(filters, pagings) {
+		if (this.client.BatchGetDocumentOperations) return this.client.BatchGetDocumentOperations(filters, pagings);
+		return Promise.all(filters.map((filter, i) => this.client.GetDocumentOperations({
+			filter,
+			paging: pagings[i]
+		}).then((r) => r.documentOperations)));
+	}
+	/** Fetch all pages of operations for a single scope (or all scopes if none specified). */
+	async fetchOperationsForScope(documentId, branch, sinceRevision, scope) {
+		const operationsByScope = {};
+		let cursor;
+		let hasNextPage = true;
+		while (hasNextPage) {
+			const page = (await this.client.GetDocumentOperations({
+				filter: {
+					documentId,
+					branch: branch ?? null,
+					sinceRevision: sinceRevision ?? 0,
+					scopes: scope ? [scope] : null
+				},
+				paging: {
+					limit: this.pageSize,
+					cursor: cursor ?? null
+				}
+			})).documentOperations;
+			for (const op of page.items) {
+				const s = op.action.scope;
+				(operationsByScope[s] ??= []).push(op);
+			}
+			hasNextPage = page.hasNextPage;
+			cursor = page.cursor;
+		}
+		return { operationsByScope };
+	}
+	/** Push actions to an existing document via MutateDocument. */
+	async pushActions(documentIdentifier, actions, branch) {
+		return (await this.client.MutateDocument({
+			documentIdentifier,
+			actions,
+			view: branch ? { branch } : void 0
+		})).mutateDocument;
+	}
+	/** Create a new document on the remote. */
+	async createDocument(document, parentIdentifier) {
+		return (await this.client.CreateDocument({
+			document,
+			parentIdentifier: parentIdentifier ?? null
+		})).createDocument;
+	}
+	/** Create an empty document of a given type on the remote. */
+	async createEmptyDocument(documentType, parentIdentifier) {
+		return (await this.client.CreateEmptyDocument({
+			documentType,
+			parentIdentifier: parentIdentifier ?? null
+		})).createEmptyDocument;
+	}
+	/** Delete a document on the remote. Returns true if successful. */
+	async deleteDocument(identifier, propagate) {
+		return (await this.client.DeleteDocument({
+			identifier,
+			propagate
+		})).deleteDocument;
+	}
+};
+//#endregion
+//#region src/remote-controller/utils.ts
+/** Convert SCREAMING_SNAKE_CASE to camelCase (e.g. "SET_MODEL_NAME" → "setModelName"). */
+function screamingSnakeToCamel(s) {
+	return s.toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+/** Error thrown when a push conflict is detected with the "reject" strategy. */
+var ConflictError = class extends Error {
+	constructor(conflict) {
+		super("Push conflict: remote has new operations since last pull");
+		this.conflict = conflict;
+		this.name = "ConflictError";
+	}
+};
+/** Convert a remote operation to the local Operation type. */
+function remoteOperationToLocal(remote) {
+	return {
+		id: remote.id ?? "",
+		index: remote.index,
+		skip: remote.skip,
+		timestampUtcMs: remote.timestampUtcMs,
+		hash: remote.hash,
+		error: remote.error ?? void 0,
+		action: {
+			id: remote.action.id,
+			type: remote.action.type,
+			timestampUtcMs: remote.action.timestampUtcMs,
+			input: remote.action.input,
+			scope: remote.action.scope,
+			attachments: remote.action.attachments?.map((a) => ({
+				data: a.data,
+				mimeType: a.mimeType,
+				hash: a.hash,
+				extension: a.extension ?? void 0,
+				fileName: a.fileName ?? void 0
+			})),
+			context: remote.action.context?.signer ? { signer: {
+				user: remote.action.context.signer.user ?? {
+					address: "",
+					networkId: "",
+					chainId: 0
+				},
+				app: remote.action.context.signer.app ?? {
+					name: "",
+					key: ""
+				},
+				signatures: remote.action.context.signer.signatures.map((s) => deserializeSignature(s))
+			} } : void 0
+		}
+	};
+}
+/**
+* Deserialize a signature string back to a 5-element tuple.
+* The server serializes tuples via `tuple.join(", ")`.
+*/
+function deserializeSignature(s) {
+	const parts = s.split(", ");
+	return [
+		parts[0] ?? "",
+		parts[1] ?? "",
+		parts[2] ?? "",
+		parts[3] ?? "",
+		parts[4] ?? ""
+	];
+}
+/** Convert remote operations to local DocumentOperations format. */
+function convertRemoteOperations(operationsByScope) {
+	const operations = {};
+	for (const [scope, remoteOps] of Object.entries(operationsByScope)) operations[scope] = remoteOps.map((op) => remoteOperationToLocal(op));
+	return operations;
+}
+/** Reconstruct a PHDocument from remote document data and operations. */
+function buildPulledDocument(remoteDoc, operations, initialDoc, branch) {
+	return {
+		header: {
+			...initialDoc.header,
+			id: remoteDoc.id,
+			name: remoteDoc.name,
+			slug: remoteDoc.slug ?? "",
+			documentType: remoteDoc.documentType,
+			createdAtUtcIso: typeof remoteDoc.createdAtUtcIso === "string" ? remoteDoc.createdAtUtcIso : remoteDoc.createdAtUtcIso.toISOString(),
+			lastModifiedAtUtcIso: typeof remoteDoc.lastModifiedAtUtcIso === "string" ? remoteDoc.lastModifiedAtUtcIso : remoteDoc.lastModifiedAtUtcIso.toISOString(),
+			revision: Object.fromEntries(remoteDoc.revisionsList.map((r) => [r.scope, r.revision])),
+			branch
+		},
+		state: remoteDoc.state,
+		initialState: initialDoc.initialState,
+		operations,
+		clipboard: []
+	};
+}
+/** Extract revision map from a remote document's revisionsList. */
+function extractRevisionMap(revisionsList) {
+	return Object.fromEntries(revisionsList.map((r) => [r.scope, r.revision]));
+}
+/**
+* Check if any scope in currentRevision is ahead of knownRevision.
+* When `scopes` is provided, only those scopes are checked.
+*/
+function hasRevisionConflict(currentRevision, knownRevision, scopes) {
+	for (const scope in currentRevision) {
+		if (scopes && !scopes.has(scope)) continue;
+		if ((currentRevision[scope] ?? 0) > (knownRevision[scope] ?? 0)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/remote-controller/remote-controller.ts
+/**
+* A controller that wraps a PHDocumentController with remote push/pull capabilities.
+* Composes a local controller and adds GraphQL-based sync with a reactor server.
+*/
+var RemoteDocumentController = class RemoteDocumentController {
+	inner;
+	remoteClient;
+	tracker = new ActionTracker();
+	options;
+	documentId;
+	remoteRevision = {};
+	hasPulled = false;
+	pushScheduled = false;
+	pushQueue = Promise.resolve();
+	listeners = [];
+	constructor(inner, options) {
+		this.inner = inner;
+		this.options = options;
+		this.documentId = options.documentId ?? "";
+		this.remoteClient = new RemoteClient(options.client, options.operationsPageSize);
+		this.setupActionInterceptors();
+	}
+	get header() {
+		return this.inner.header;
+	}
+	get state() {
+		return this.inner.state;
+	}
+	get operations() {
+		return this.inner.operations;
+	}
+	get document() {
+		return this.inner.document;
+	}
+	get status() {
+		return {
+			pendingActionCount: this.tracker.count,
+			connected: this.documentId !== "",
+			documentId: this.documentId,
+			remoteRevision: { ...this.remoteRevision }
+		};
+	}
+	/** Register a listener for document changes. Returns an unsubscribe function. */
+	onChange(listener) {
+		this.listeners.push(listener);
+		return () => {
+			this.listeners = this.listeners.filter((l) => l !== listener);
+		};
+	}
+	notifyListeners(source) {
+		if (this.listeners.length === 0) return;
+		const event = {
+			source,
+			document: this.document
+		};
+		for (const listener of this.listeners) listener(event);
+	}
+	/** Push all pending actions to remote, then pull latest state. */
+	async push() {
+		let tracked = this.tracker.flush();
+		if (tracked.length === 0 && this.documentId !== "") return {
+			remoteDocument: await this.pull(),
+			actionCount: 0,
+			operations: []
+		};
+		try {
+			await this.ensureRemoteDocument();
+			if (this.options.onConflict && tracked.length > 0) tracked = await this.handleConflicts(tracked, this.options.onConflict);
+		} catch (error) {
+			this.tracker.restore(tracked);
+			throw error;
+		}
+		let pushedActions = [];
+		try {
+			if (tracked.length > 0) {
+				const actions = await this.prepareActionsForPush(tracked);
+				pushedActions = actions;
+				await this.remoteClient.pushActions(this.documentId, actions, this.options.branch);
+			}
+		} catch (error) {
+			this.tracker.restore(tracked);
+			throw error;
+		}
+		return {
+			remoteDocument: await this.pull(),
+			actionCount: tracked.length,
+			operations: pushedActions
+		};
+	}
+	/** Delete the document on the remote. */
+	async delete(propagate) {
+		if (this.documentId === "") throw new Error("Cannot delete: no document ID set");
+		return await this.remoteClient.deleteDocument(this.documentId, propagate);
+	}
+	/** Pull latest state from remote, replacing local document. Returns the remote document data. */
+	async pull() {
+		if (this.documentId === "") throw new Error("Cannot pull: no document ID set");
+		const { remoteDoc, operations } = await this.fetchDocumentAndOperations();
+		const pulledDocument = buildPulledDocument(remoteDoc, operations, this.inner.module.utils.createDocument(), this.options.branch ?? "main");
+		const ControllerClass = this.inner.constructor;
+		this.inner = new ControllerClass(pulledDocument);
+		this.setupActionInterceptors();
+		this.tracker.clear();
+		this.remoteRevision = extractRevisionMap(remoteDoc.revisionsList);
+		this.notifyListeners("pull");
+		return remoteDoc;
+	}
+	/**
+	* Pull an existing document from remote and create a controller for it.
+	*/
+	static async pull(ControllerClass, options) {
+		const remote = new RemoteDocumentController(new ControllerClass(), options);
+		if (options.documentId) await remote.pull();
+		return remote;
+	}
+	/**
+	* Wrap an existing controller instance with remote capabilities.
+	* Pending local actions on the inner controller are NOT tracked
+	* (only new actions through the remote controller are tracked).
+	*/
+	static from(controller, options) {
+		return new RemoteDocumentController(controller, options);
+	}
+	/** Create the document on the remote if it doesn't exist yet. */
+	async ensureRemoteDocument() {
+		if (this.documentId !== "") return;
+		this.documentId = (await this.remoteClient.createEmptyDocument(this.inner.header.documentType, this.options.parentIdentifier)).id;
+	}
+	/** Set up interceptors for all action methods on the inner controller. */
+	setupActionInterceptors() {
+		const module = this.inner["module"];
+		for (const actionType in module.actions) {
+			if (actionType in RemoteDocumentController.prototype) continue;
+			Object.defineProperty(this, actionType, {
+				value: (input) => {
+					const opCountsBefore = {};
+					for (const scope in this.inner.operations) opCountsBefore[scope] = this.inner.operations[scope].length;
+					this.inner[actionType](input);
+					const newOp = this.findNewOperation(opCountsBefore);
+					const prevOp = newOp ? this.getLastOperationInScope(newOp.action.scope, newOp) : void 0;
+					const prevOpHash = prevOp?.hash ?? "";
+					const prevOpIndex = prevOp?.index ?? -1;
+					if (!newOp) return this;
+					this.tracker.track(newOp.action, prevOpHash, prevOpIndex);
+					this.notifyListeners("action");
+					if (this.options.mode === "streaming") this.schedulePush();
+					return this;
+				},
+				enumerable: true,
+				configurable: true
+			});
+		}
+	}
+	/**
+	* Find the new operation added after applying an action,
+	* by comparing current operation counts against a previous snapshot.
+	*/
+	findNewOperation(opCountsBefore) {
+		const ops = this.inner.operations;
+		for (const scope in ops) {
+			const scopeOps = ops[scope];
+			const prevCount = opCountsBefore[scope] ?? 0;
+			if (scopeOps.length > prevCount) return scopeOps[scopeOps.length - 1];
+		}
+	}
+	/**
+	* Get the last operation in a specific scope, optionally excluding
+	* a given operation (e.g. the one just added).
+	*/
+	getLastOperationInScope(scope, excludeOp) {
+		const scopeOps = this.inner.operations[scope];
+		if (scopeOps.length === 0) return void 0;
+		for (let i = scopeOps.length - 1; i >= 0; i--) if (scopeOps[i] !== excludeOp) return scopeOps[i];
+	}
+	/**
+	* Detect and handle conflicts between local pending actions and remote state.
+	* Returns the (possibly rebased) tracked actions to push.
+	*/
+	async handleConflicts(localTracked, strategy) {
+		const remoteResult = await this.remoteClient.getDocument(this.documentId, this.options.branch);
+		if (!remoteResult) throw new Error(`Document "${this.documentId}" not found on remote`);
+		const currentRevision = extractRevisionMap(remoteResult.document.revisionsList);
+		const localScopes = new Set(localTracked.map((t) => t.action.scope));
+		if (!hasRevisionConflict(currentRevision, this.remoteRevision, localScopes)) return localTracked;
+		const conflictingScopes = [...localScopes].filter((scope) => (currentRevision[scope] ?? 0) > (this.remoteRevision[scope] ?? 0));
+		const { operationsByScope } = await this.remoteClient.getAllOperations(this.documentId, this.options.branch, this.remoteRevision, conflictingScopes);
+		const remoteOperations = {};
+		for (const [scope, ops] of Object.entries(operationsByScope)) remoteOperations[scope] = ops;
+		const conflictInfo = {
+			remoteOperations,
+			localActions: localTracked,
+			knownRevision: { ...this.remoteRevision },
+			currentRevision: { ...currentRevision }
+		};
+		if (strategy === "reject") throw new ConflictError(conflictInfo);
+		if (strategy === "rebase") return this.pullAndReplay(localTracked.map((t) => t.action));
+		const mergedActions = await strategy(conflictInfo);
+		return this.pullAndReplay(mergedActions);
+	}
+	/**
+	* Pull latest remote state and replay actions through interceptors.
+	* Returns newly tracked actions with correct prevOpHash values.
+	*/
+	async pullAndReplay(actions) {
+		await this.pull();
+		for (const action of actions) {
+			const methodName = screamingSnakeToCamel(action.type);
+			const method = this[methodName];
+			if (typeof method === "function") method.call(this, action.input);
+		}
+		return this.tracker.flush();
+	}
+	/** Prepare actions for push, optionally signing them. */
+	async prepareActionsForPush(tracked) {
+		const actions = [];
+		for (const { action, prevOpHash, prevOpIndex } of tracked) {
+			let prepared = {
+				...action,
+				context: {
+					...action.context,
+					prevOpHash,
+					prevOpIndex
+				}
+			};
+			if (this.options.signer) prepared = await this.signAction(prepared);
+			actions.push(prepared);
+		}
+		return actions;
+	}
+	/** Sign an action using the configured signer, preserving existing signatures. */
+	async signAction(action) {
+		const signer = this.options.signer;
+		const signature = await signer.signAction(action);
+		const existingSignatures = action.context?.signer?.signatures ?? [];
+		return {
+			...action,
+			context: {
+				...action.context,
+				signer: {
+					user: signer.user,
+					app: signer.app,
+					signatures: [...existingSignatures, signature]
+				}
+			}
+		};
+	}
+	/**
+	* Fetch document and operations from the remote.
+	*
+	* On the first pull, uses the combined document+operations query.
+	* On subsequent pulls, fetches only new operations per scope using
+	* sinceRevision, then merges with existing local operations.
+	* Falls back to a full fetch if the merge produces a count mismatch.
+	*/
+	async fetchDocumentAndOperations() {
+		if (this.hasPulled) return this.incrementalFetch();
+		const result = await this.remoteClient.getDocumentWithOperations(this.documentId, this.options.branch);
+		if (!result) throw new Error(`Document "${this.documentId}" not found on remote`);
+		this.hasPulled = true;
+		return {
+			remoteDoc: result.document,
+			operations: convertRemoteOperations(result.operations.operationsByScope)
+		};
+	}
+	/**
+	* Incremental fetch: fetches the document and only new operations per scope
+	* using sinceRevision in a single request when possible.
+	* Falls back to a full fetch on count mismatch.
+	*/
+	async incrementalFetch() {
+		const scopes = Object.keys(this.remoteRevision);
+		const result = await this.remoteClient.getDocumentWithOperations(this.documentId, this.options.branch, this.remoteRevision, scopes.length > 0 ? scopes : void 0);
+		if (!result) throw new Error(`Document "${this.documentId}" not found on remote`);
+		const remoteDoc = result.document;
+		const expectedRevision = extractRevisionMap(remoteDoc.revisionsList);
+		const newOps = convertRemoteOperations(result.operations.operationsByScope);
+		const merged = this.mergeOperations(this.inner.operations, newOps);
+		if (this.hasExpectedOperationCounts(merged, expectedRevision)) return {
+			remoteDoc,
+			operations: merged
+		};
+		return this.fullFetch(remoteDoc);
+	}
+	/**
+	* Full fetch fallback: fetches all operations from the beginning.
+	* Used when an incremental fetch produces a count mismatch.
+	*/
+	async fullFetch(remoteDoc) {
+		const { operationsByScope } = await this.remoteClient.getAllOperations(this.documentId, this.options.branch);
+		return {
+			remoteDoc,
+			operations: convertRemoteOperations(operationsByScope)
+		};
+	}
+	/**
+	* Validate that the merged operations match the expected revision per scope.
+	* Each scope's operation count should equal its revision number.
+	*/
+	hasExpectedOperationCounts(operations, expectedRevision) {
+		for (const [scope, revision] of Object.entries(expectedRevision)) if ((scope in operations ? operations[scope].length : 0) !== revision) return false;
+		return true;
+	}
+	/**
+	* Merge existing local operations with newly fetched operations.
+	* Appends new operations to existing ones per scope.
+	*/
+	mergeOperations(existingOps, newOps) {
+		const merged = {};
+		for (const [scope, ops] of Object.entries(existingOps)) if (ops.length > 0) merged[scope] = [...ops];
+		for (const [scope, ops] of Object.entries(newOps)) if (ops.length > 0) (merged[scope] ??= []).push(...ops);
+		return merged;
+	}
+	/** Schedule a push via microtask (for streaming mode coalescing). */
+	schedulePush() {
+		if (this.pushScheduled) return;
+		this.pushScheduled = true;
+		queueMicrotask(() => {
+			this.pushScheduled = false;
+			this.pushQueue = this.pushQueue.then(async () => {
+				try {
+					await this.push();
+				} catch (error) {
+					this.options.onPushError?.(error);
+				}
+			});
+		});
+	}
+};
+//#endregion
+//#region src/storage/base-storage.ts
+var BaseStorage = class {
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	forEach(callback) {
+		for (const [key, value] of this) callback(value, key, this);
+	}
+};
+//#endregion
+//#region src/storage/local-storage.ts
+var BrowserLocalStorage = class extends BaseStorage {
+	#namespace;
+	#storage = window.localStorage;
+	constructor(namespace) {
+		super();
+		this.#namespace = namespace;
+	}
+	#readMap() {
+		const raw = this.#storage.getItem(this.#namespace);
+		if (!raw) return /* @__PURE__ */ new Map();
+		return new Map(JSON.parse(raw));
+	}
+	#writeMap(map) {
+		this.#storage.setItem(this.#namespace, JSON.stringify(Array.from(map.entries())));
+	}
+	get(key) {
+		return this.#readMap().get(key);
+	}
+	set(key, value) {
+		const map = this.#readMap();
+		map.set(key, value);
+		this.#writeMap(map);
+	}
+	delete(key) {
+		const map = this.#readMap();
+		const deleted = map.delete(key);
+		if (deleted) this.#writeMap(map);
+		return deleted;
+	}
+	has(key) {
+		return this.#readMap().has(key);
+	}
+	clear() {
+		this.#storage.removeItem(this.#namespace);
+	}
+	entries() {
+		return this.#readMap().entries();
+	}
+	keys() {
+		return this.#readMap().keys();
+	}
+	values() {
+		return this.#readMap().values();
+	}
+	[Symbol.iterator]() {
+		return this.#readMap().entries();
+	}
+};
+//#endregion
+export { ActionTracker, BaseStorage, BrowserLocalStorage, COMMON_PACKAGE_ID, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ChannelScheme, ChevronDownIcon, ConflictError, CopyIcon, DEFAULT_DRIVE_EDITOR_ID, DEFAULT_DRIVE_ID, DEFAULT_SWITCHBOARD_URL, DOMAIN_TYPE, DisconnectIcon, DocumentCache, DocumentChangeType, DocumentIntegrityService, GqlRequestChannel, GraphQLClientDocumentCache, ISSUER_TYPE, InMemoryQueue, IntervalPollTimer, PollBehavior, PropagationMode, REACTOR_SCHEMA, RENOWN_CHAIN_ID, RENOWN_NETWORK_ID, RENOWN_URL, ReactorBuilder, ReactorClientBuilder, RegistryClient, RelationalDbProcessor, RemoteClient, RemoteDocumentController, Renown, RenownAuthButton, RenownLoginButton, RenownLogo, RenownUserButton, SpinnerIcon, SyncOperationStatus, UserIcon, VERIFIABLE_CREDENTIAL_EIP712_TYPE, addAllowListEventHandler, addAllowedDocumentTypesEventHandler, addAnalyticsDatabaseNameEventHandler, addBasePathEventHandler, addCliVersionEventHandler, addDefaultDrivesUrlEventHandler, addDisabledEditorsEventHandler, addDocument, addDocumentCacheEventHandler, addDrive, addDrivesEventHandler, addDrivesPreserveStrategyEventHandler, addEnabledEditorsEventHandler, addFeaturesEventHandler, addFileUploadOperationsChunkSizeEventHandler, addFolder, addGaTrackingIdEventHandler, addGraphQLReactorClientEventHandler, addIsAddCloudDrivesEnabledEventHandler, addIsAddDriveEnabledEventHandler, addIsAddLocalDrivesEnabledEventHandler, addIsAddPublicDrivesEnabledEventHandler, addIsAnalyticsDatabaseWorkerEnabledEventHandler, addIsAnalyticsEnabledEventHandler, addIsAnalyticsExternalProcessorsEnabledEventHandler, addIsCloudDrivesEnabledEventHandler, addIsDeleteCloudDrivesEnabledEventHandler, addIsDeleteLocalDrivesEnabledEventHandler, addIsDeletePublicDrivesEnabledEventHandler, addIsDiffAnalyticsEnabledEventHandler, addIsDocumentModelSelectionSettingsEnabledEventHandler, addIsDragAndDropEnabledEventHandler, addIsDriveAnalyticsEnabledEventHandler, addIsEditorDebugModeEnabledEventHandler, addIsEditorReadModeEnabledEventHandler, addIsExternalControlsEnabledEventHandler, addIsExternalPackagesEnabledEventHandler, addIsExternalProcessorsEnabledEventHandler, addIsExternalRelationalProcessorsEnabledEventHandler, addIsLocalDrivesEnabledEventHandler, addIsPublicDrivesEnabledEventHandler, addIsRelationalProcessorsEnabledEventHandler, addIsSentryTracingEnabledEventHandler, addLoadingEventHandler, addLocalDrivesEnabledEventHandler, addLogLevelEventHandler, addModalEventHandler, addPHEventHandlers, addPackageDiscoveryServiceEventHandler, addPromiseState, addReactorClientEventHandler, addReactorClientModuleEventHandler, addRemoteDrive, addRenownChainIdEventHandler, addRenownEventHandler, addRenownNetworkIdEventHandler, addRenownUrlEventHandler, addRequiresHardRefreshEventHandler, addResetSelectedNodeEventHandler, addRevisionHistoryVisibleEventHandler, addRouterBasenameEventHandler, addSelectedDriveIdEventHandler, addSelectedNodeIdEventHandler, addSelectedTimelineItemEventHandler, addSelectedTimelineRevisionEventHandler, addSentryDsnEventHandler, addSentryEnvEventHandler, addSentryReleaseEventHandler, addSetSelectedDriveOnPopStateEventHandler, addSetSelectedNodeOnPopStateEventHandler, addStudioModeEventHandler, addToastEventHandler, addVersionCheckIntervalEventHandler, addVersionEventHandler, addVetraPackageManagerEventHandler, addWarnOutdatedAppEventHandler, baseDocumentModels, baseDocumentModelsMap, buildDocumentSubgraphQuery, buildDocumentSubgraphUrl, callEventHandlerRegisterFunctions, callGlobalSetterForKey, clearGlobal, closePHModal, commonGlobalEventHandlerFunctions, convertRemoteOperations, createAnalyticsStore, createClient, createProcessorQuery, createUrlWithPreservedParams, deleteDrive, deleteNode, deriveSystemUrl, dispatchActions, driveCollectionId, driveIdFromUrl, dropAllReactorStorage, exportDocument, exportFile, extractDriveIdFromPath, extractDriveIdFromSlug, extractDriveSlugFromPath, extractNodeIdFromPath, extractNodeIdFromSlug, extractNodeSlugFromPath, findUuid, getAnalyticsStore, getDocumentGraphqlQuery, getDriveIdBySlug, getDrives, getGlobal, getPackages, getPackagesByDocumentType, getPathWithoutBase, getRevisionFromDate, getSlugFromDriveUrl, getSwitchboardGatewayUrlFromDriveUrl, getSyncStatus, getSyncStatusSync, getUserPermissions, graphqlDocumentEvents, graphqlDocumentsEvents, graphqlEventsToSyncDrive, hideRevisionHistory, identifierFromMutateDocumentOperationVariables, initConnectCrypto, initRenownCrypto, isDocumentTypeSupported, isExternalControlsEnabledEventFunctions, isFileNodeKind, isFolderNodeKind, loading, login, logout, makeDriveUrlComponent, makeNodeSlug, makePHEventFunctions, openRenown, parseDriveUrl, phAppConfigHooks, phAppConfigSetters, phDocumentEditorConfigHooks, phDocumentEditorConfigSetters, phDocumentFromQuery, phDocumentsFromQuery, phGlobalConfigHooks, phGlobalConfigSetters, reactorGraphqlBatchFetchDocuments, reactorGraphqlCreateDocument, reactorGraphqlDeleteDocument, reactorGraphqlDeleteDocuments, reactorGraphqlFetchDocument, reactorGraphqlMutateDocument, readPromiseState, refreshReactorData, refreshReactorDataClient, renameDrive, renameDriveNode, resolveUrlPathname, setAllowList, setAllowedDocumentTypes, setAnalyticsDatabaseName, setBasePath, setCliVersion, setDefaultDrivesUrl, setDefaultPHGlobalConfig, setDisabledEditors, setDocumentCache, setDriveAvailableOffline, setDriveSharingType, setDrives, setDrivesPreserveStrategy, setEnabledEditors, setFeatures, setFileUploadOperationsChunkSize, setGaTrackingId, setGlobal, setGraphQLReactorClient, setIsAddCloudDrivesEnabled, setIsAddDriveEnabled, setIsAddLocalDrivesEnabled, setIsAddPublicDrivesEnabled, setIsAnalyticsDatabaseWorkerEnabled, setIsAnalyticsEnabled, setIsAnalyticsExternalProcessorsEnabled, setIsCloudDrivesEnabled, setIsDeleteCloudDrivesEnabled, setIsDeleteLocalDrivesEnabled, setIsDeletePublicDrivesEnabled, setIsDiffAnalyticsEnabled, setIsDocumentModelSelectionSettingsEnabled, setIsDragAndDropEnabled, setIsDriveAnalyticsEnabled, setIsEditorDebugModeEnabled, setIsEditorReadModeEnabled, setIsExternalControlsEnabled, setIsExternalPackagesEnabled, setIsExternalProcessorsEnabled, setIsExternalRelationalProcessorsEnabled, setIsLocalDrivesEnabled, setIsPublicDrivesEnabled, setIsRelationalProcessorsEnabled, setIsSentryTracingEnabled, setLoading, setLocalDrivesEnabled, setLogLevel, setPHAppConfig, setPHAppConfigByKey, setPHDocumentEditorConfig, setPHDocumentEditorConfigByKey, setPHGlobalConfig, setPHGlobalConfigByKey, setPHModal, setPHToast, setPackageDiscoveryService, setReactorClient, setReactorClientModule, setRenown, setRenownChainId, setRenownNetworkId, setRenownUrl, setRequiresHardRefresh, setRevisionHistoryVisible, setRouterBasename, setSelectedDrive, setSelectedDriveId, setSelectedNode, setSelectedTimelineItem, setSelectedTimelineRevision, setSentryDsn, setSentryEnv, setSentryRelease, setStudioMode, setVersion, setVersionCheckInterval, setVetraPackageManager, setWarnOutdatedApp, showCreateDocumentModal, showDeleteNodeModal, showPHModal, showRevisionHistory, sortNodesByName, truncateAllTables, useAllowList, useAllowedDocumentModelModules, useAllowedDocumentTypes, useAnalyticsDatabaseName, useAppModuleById, useAppModules, useBasePath, useCliVersion, useConnectionState, useConnectionStates, useDatabase, useDefaultAppModule, useDefaultDrivesUrl, useDid, useDisabledEditors, useDispatch, useDocument, useDocumentById, useDocumentCache, useDocumentModelModuleById, useDocumentModelModules, useDocumentOfType, useDocumentOperations, useDocumentTypes, useDocumentTypesInSelectedDrive, useDocuments, useDocumentsByIds, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useDriveById, useDriveSystemInfo, useDrives, useDrivesPreserveStrategy, useEditorModuleById, useEditorModules, useEditorModulesForDocumentType, useEnabledEditors, useFallbackEditorModule, useFeatures, useFileNodesInSelectedDrive, useFileNodesInSelectedFolder, useFileUploadOperationsChunkSize, useFolderById, useFolderNodesInSelectedDrive, useFolderNodesInSelectedFolder, useGaTrackingId, useGetDocument, useGetDocumentAsync, useGetDocuments, useGetSwitchboardLink, useGraphQLReactorClient, useInitReactorGraphqlClient, useIsAddCloudDrivesEnabled, useIsAddDriveEnabled, useIsAddLocalDrivesEnabled, useIsAddPublicDrivesEnabled, useIsAnalyticsDatabaseWorkerEnabled, useIsAnalyticsEnabled, useIsAnalyticsExternalProcessorsEnabled, useIsCloudDrivesEnabled, useIsDeleteCloudDrivesEnabled, useIsDeleteLocalDrivesEnabled, useIsDeletePublicDrivesEnabled, useIsDiffAnalyticsEnabled, useIsDocumentModelSelectionSettingsEnabled, useIsDragAndDropEnabled, useIsDriveAnalyticsEnabled, useIsEditorDebugModeEnabled, useIsEditorReadModeEnabled, useIsExternalControlsEnabled, useIsExternalPackagesEnabled, useIsExternalProcessorsEnabled, useIsExternalRelationalProcessorsEnabled, useIsLocalDrivesEnabled, useIsPublicDrivesEnabled, useIsRelationalProcessorsEnabled, useIsSentryTracingEnabled, useLoading, useLocalDrivesEnabled, useLogLevel, useLoginStatus, useModelRegistry, useNodeActions, useNodeById, useNodeParentFolderById, useNodePathById, useNodesInSelectedDrive, useNodesInSelectedDriveOrFolder, useNodesInSelectedFolder, useOnDropFile, usePGlite, usePHAppConfigByKey, usePHDocumentEditorConfigByKey, usePHGlobalConfigByKey, usePHModal, usePHToast, usePackageDiscoveryService, useParentFolderForSelectedNode, useReactorClient, useReactorClientModule, useRelationalDb, useRelationalQuery, useRenown, useRenownAuth, useRenownChainId, useRenownInit, useRenownNetworkId, useRenownUrl, useRequiresHardRefresh, useResetPHGlobalConfig, useRevisionHistoryVisible, useRouterBasename, useSelectedDocument, useSelectedDocumentId, useSelectedDocumentOfType, useSelectedDocumentSafe, useSelectedDrive, useSelectedDriveId, useSelectedDriveSafe, useSelectedFolder, useSelectedNode, useSelectedNodePath, useSelectedTimelineItem, useSelectedTimelineRevision, useSentryDsn, useSentryEnv, useSentryRelease, useSetDefaultPHGlobalConfig, useSetPHAppConfig, useSetPHDocumentEditorConfig, useSetPHGlobalConfig, useStudioMode, useSubgraphModules, useSupportedDocumentTypesInReactor, useSync, useSyncList, useUser, useUserPermissions, useVersion, useVersionCheckInterval, useVetraPackageManager, useVetraPackages, useWarnOutdatedApp, validateDocument };
+
+//# sourceMappingURL=index.js.map