@powerhousedao/reactor-browser 6.2.2-dev.9 → 6.2.2

package/dist/index.js

@@ -1,578 +1,185 @@
-import { C as queueOperations, S as queueActions, _ as getAnalyticsStore, a as setDocumentCache, b as setGlobal, c as useDocumentSafe, d as useGetDocumentAsync, f as useGetDocuments, g as createAnalyticsStore, h as readPromiseState, i as addDocumentCacheEventHandler, l as useDocuments, m as addPromiseState, n as useDocumentsByIds, o as useDocument, p as DocumentCache, r as useDispatch, s as useDocumentCache, t as useDocumentById, u as useGetDocument, v as clearGlobal, w as uploadOperations, x as dispatchActions, y as getGlobal } from "./document-by-id-dLYFX-xz.js";
-import { t as makePHEventFunctions } from "./make-ph-event-functions-BHoLPif5.js";
+import { a as setDocumentCache, c as useDocumentSafe, d as useGetDocumentAsync, f as useGetDocuments, h as readPromiseState, i as addDocumentCacheEventHandler, l as useDocuments, m as addPromiseState, n as useDocumentsByIds, o as useDocument, p as DocumentCache, r as useDispatch, s as useDocumentCache, t as useDocumentById, u as useGetDocument, y as dispatchActions } from "./document-by-id-BSZqTN66.js";
+import { A as createUrlWithPreservedParams, B as makeNodeSlug, C as addResetSelectedNodeEventHandler, D as addDrivesEventHandler, E as setSelectedNode, F as extractNodeIdFromSlug, G as DocumentTypeMismatchError, H as ambientRenownTokenProvider, I as extractNodeSlugFromPath, K as NoSelectedDocumentError, L as findUuid, M as extractDriveIdFromSlug, N as extractDriveSlugFromPath, O as setDrives, P as extractNodeIdFromPath, R as getPathWithoutBase, S as useSelectedDriveSafe, T as addSetSelectedNodeOnPopStateEventHandler, U as makeAuthMiddleware, V as resolveUrlPathname, W as DocumentModelNotFoundError, _ as addSetSelectedDriveOnPopStateEventHandler, a as useVetraPackageManager, b as useSelectedDrive, c as useDocumentTypesInSelectedDrive, d as useFolderNodesInSelectedDrive, f as useNodesInSelectedDrive, g as addSelectedDriveIdEventHandler, h as sortNodesByName, i as setVetraPackageManager, j as extractDriveIdFromPath, k as useDrives, l as useDocumentsInSelectedDrive, m as isFolderNodeKind, n as useDocumentModelModules, o as useVetraPackages, p as isFileNodeKind, q as UnsupportedDocumentTypeError, r as addVetraPackageManagerEventHandler, s as useSelectedNode, t as useDocumentModelModuleById, u as useFileNodesInSelectedDrive, v as setSelectedDrive, w as addSelectedNodeIdEventHandler, x as useSelectedDriveId, y as setSelectedDriveId, z as makeDriveUrlComponent } from "./document-model-modules-DfQBNGc-.js";
+import { t as makePHEventFunctions } from "./make-ph-event-functions-DBq3iWYn.js";
+import { $ as addDefaultDrivesUrlEventHandler, $n as useIsAddLocalDrivesEnabled, $r as makeAuthConnectionParams, $t as setEnabledEditors, A as useReactorClientModule, Ai as getDocumentExtension, An as setRenownUrl, Ar as useSentryRelease, At as addRenownAdaptersEventHandler, B as useDragNode, Bi as closePHModal, Bn as setWarnOutdatedApp, Br as phAppConfigHooks, Bt as addSwitchboardUrlEventHandler, C as addReactorClientModuleEventHandler, Ci as addFileWithProgress, Cn as setIsRelationalProcessorsEnabled, Cr as useRenownChainId, Ct as addIsExternalRelationalProcessorsEnabledEventHandler, D as useModelRegistry, Di as exportFile, Dn as setRenownAdapters, Dr as useRouterBasename, Dt as addIsSentryTracingEnabledEventHandler, E as useDatabase, Ei as deleteNode, En as setLogLevel, Er as useRequiresHardRefresh, Et as addIsRelationalProcessorsEnabledEventHandler, F as usePackageDiscoveryService, Fi as setPreferredEditorOnNode, Fn as setSentryRelease, Fr as useWarnOutdatedApp, Ft as addRouterBasenameEventHandler, G as useFeatures, Gi as usePHModal, Gn as useDefaultDrivesUrl, Gr as setIsDragAndDropEnabled, Gt as phGlobalConfigSetters, H as useDropTarget, Hi as showCreateDocumentModal, Hn as useAnalyticsDatabaseName, Hr as phDocumentEditorConfigHooks, Ht as addVersionEventHandler, I as addGraphQLReactorClientEventHandler, Ii as upgradeDocument, In as setStudioMode, Ir as addAllowedDocumentTypesEventHandler, It as addSentryDsnEventHandler, J as useAttachmentService, Jn as useEnabledEditors, Jr as useIsDragAndDropEnabled, Jt as setBasePath, K as addAttachmentServiceEventHandler, Kn as useDisabledEditors, Kr as setIsExternalControlsEnabled, Kt as setAllowList, L as setGraphQLReactorClient, Li as getUserPermissions, Ln as setSwitchboardUrl, Lr as addIsDragAndDropEnabledEventHandler, Lt as addSentryEnvEventHandler, M as useSyncList, Mi as moveNode$1, Mn as setRouterBasename, Mr as useSwitchboardUrl, Mt as addRenownNetworkIdEventHandler, N as addPackageDiscoveryServiceEventHandler, Ni as renameDriveNode, Nn as setSentryDsn, Nr as useVersion, Nt as addRenownUrlEventHandler, O as usePGlite, Oi as extractInitialState, On as setRenownChainId, Or as useSentryDsn, Ot as addLocalDrivesEnabledEventHandler, P as setPackageDiscoveryService, Pi as renameNode, Pn as setSentryEnv, Pr as useVersionCheckInterval, Pt as addRequiresHardRefreshEventHandler, Q as addCliVersionEventHandler, Qn as useIsAddDriveEnabled, Qr as viewFilterInputFromViewFilter, Qt as setDrivesPreserveStrategy, R as useGraphQLReactorClient, Ri as isDocumentTypeSupported, Rn as setVersion, Rr as addIsExternalControlsEnabledEventHandler, Rt as addSentryReleaseEventHandler, S as addReactorClientEventHandler, Si as addDocument, Sn as setIsPublicDrivesEnabled, Sr as useRenownAdapters, St as addIsExternalProcessorsEnabledEventHandler, T as setReactorClientModule, Ti as copyNode$1, Tn as setLocalDrivesEnabled, Tr as useRenownUrl, Tt as addIsPublicDrivesEnabledEventHandler, U as addFeaturesEventHandler, Ui as showDeleteNodeModal, Un as useBasePath, Ur as phDocumentEditorConfigSetters, Ut as addWarnOutdatedAppEventHandler, V as useDropNode, Vi as setPHModal, Vn as useAllowList, Vr as phAppConfigSetters, Vt as addVersionCheckIntervalEventHandler, W as setFeatures, Wi as showPHModal, Wn as useCliVersion, Wr as setAllowedDocumentTypes, Wt as phGlobalConfigHooks, X as addAnalyticsDatabaseNameEventHandler, Xn as useGaTrackingId, Xr as GraphQLReactorClient, Xt as setDefaultDrivesUrl, Y as addAllowListEventHandler, Yn as useFileUploadOperationsChunkSize, Yr as useIsExternalControlsEnabled, Yt as setCliVersion, Z as addBasePathEventHandler, Zn as useIsAddCloudDrivesEnabled, Zr as isGraphQLReactorClient, Zt as setDisabledEditors, _ as addRevisionHistoryVisibleEventHandler, _i as buildPulledDocument, _n as setIsEditorReadModeEnabled, _r as useIsPublicDrivesEnabled, _t as addIsDocumentModelSelectionSettingsEnabledEventHandler, a as addPHEventHandlers, ai as StaticPackageManager, an as setIsAddPublicDrivesEnabled, ar as useIsDeleteCloudDrivesEnabled, at as addIsAddCloudDrivesEnabledEventHandler, b as showRevisionHistory, bi as hasRevisionConflict, bn as setIsExternalRelationalProcessorsEnabled, br as useLocalDrivesEnabled, bt as addIsEditorReadModeEnabledEventHandler, c as addToastEventHandler, ci as prepareSignedActions, cn as setIsAnalyticsExternalProcessorsEnabled, cr as useIsDiffAnalyticsEnabled, ct as addIsAddPublicDrivesEnabledEventHandler, d as addSelectedTimelineRevisionEventHandler, di as MutateDocumentWithOperationsDocument, dn as setIsDeleteLocalDrivesEnabled, dr as useIsEditorDebugModeEnabled, dt as addIsAnalyticsExternalProcessorsEnabledEventHandler, ei as startDocumentChangesSubscription, en as setFileUploadOperationsChunkSize, er as useIsAddPublicDrivesEnabled, et as addDisabledEditorsEventHandler, f as setSelectedTimelineRevision, fi as ReactorOperationFieldsFragmentDoc, fn as setIsDeletePublicDrivesEnabled, fr as useIsEditorReadModeEnabled, ft as addIsCloudDrivesEnabledEventHandler, g as useSelectedTimelineItem, gi as ConflictError, gn as setIsEditorDebugModeEnabled, gr as useIsLocalDrivesEnabled, gt as addIsDiffAnalyticsEnabledEventHandler, h as setSelectedTimelineItem, hi as revisionMapFromRevisionsList, hn as setIsDriveAnalyticsEnabled, hr as useIsExternalRelationalProcessorsEnabled, ht as addIsDeletePublicDrivesEnabledEventHandler, i as useSwitchboardClient, ii as subgraphUrlFromGraphqlUrl, in as setIsAddLocalDrivesEnabled, ir as useIsCloudDrivesEnabled, it as addGaTrackingIdEventHandler, j as useSync, ji as loadFile, jn as setRequiresHardRefresh, jr as useStudioMode, jt as addRenownChainIdEventHandler, k as useReactorClient, ki as fetchDocumentOperations, kn as setRenownNetworkId, kr as useSentryEnv, kt as addLogLevelEventHandler, l as setPHToast, li as signStampedAction, ln as setIsCloudDrivesEnabled, lr as useIsDocumentModelSelectionSettingsEnabled, lt as addIsAnalyticsDatabaseWorkerEnabledEventHandler, m as addSelectedTimelineItemEventHandler, mi as phDocumentFromMutation, mn as setIsDocumentModelSelectionSettingsEnabled, mr as useIsExternalProcessorsEnabled, mt as addIsDeleteLocalDrivesEnabledEventHandler, n as GraphQLReactorProvider, ni as SubgraphSdkRegistry, nn as setIsAddCloudDrivesEnabled, nr as useIsAnalyticsEnabled, nt as addEnabledEditorsEventHandler, o as callEventHandlerRegisterFunctions, oi as packageFromDocumentModels, on as setIsAnalyticsDatabaseWorkerEnabled, or as useIsDeleteLocalDrivesEnabled, ot as addIsAddDriveEnabledEventHandler, p as useSelectedTimelineRevision, pi as phDocumentFromGetDocument, pn as setIsDiffAnalyticsEnabled, pr as useIsExternalPackagesEnabled, pt as addIsDeleteCloudDrivesEnabledEventHandler, q as setAttachmentService, qn as useDrivesPreserveStrategy, qr as useAllowedDocumentTypes, qt as setAnalyticsDatabaseName, r as ensurePHEventHandlers, ri as describeGraphQLDocument, rn as setIsAddDriveEnabled, rr as useIsAnalyticsExternalProcessorsEnabled, rt as addFileUploadOperationsChunkSizeEventHandler, s as commonGlobalEventHandlerFunctions, si as resolveDocumentModelModule, sn as setIsAnalyticsEnabled, sr as useIsDeletePublicDrivesEnabled, st as addIsAddLocalDrivesEnabledEventHandler, t as useDocumentOperations, ti as subscriptionsUrlFromGraphqlUrl, tn as setGaTrackingId, tr as useIsAnalyticsDatabaseWorkerEnabled, tt as addDrivesPreserveStrategyEventHandler, u as usePHToast, ui as stampAction, un as setIsDeleteCloudDrivesEnabled, ur as useIsDriveAnalyticsEnabled, ut as addIsAnalyticsEnabledEventHandler, v as hideRevisionHistory, vi as convertRemoteOperations, vn as setIsExternalPackagesEnabled, vr as useIsRelationalProcessorsEnabled, vt as addIsDriveAnalyticsEnabledEventHandler, w as setReactorClient, wi as addFolder, wn as setIsSentryTracingEnabled, wr as useRenownNetworkId, wt as addIsLocalDrivesEnabledEventHandler, x as useRevisionHistoryVisible, xi as screamingSnakeToCamel, xn as setIsLocalDrivesEnabled, xr as useLogLevel, xt as addIsExternalPackagesEnabledEventHandler, y as setRevisionHistoryVisible, yi as extractRevisionMap, yn as setIsExternalProcessorsEnabled, yr as useIsSentryTracingEnabled, yt as addIsEditorDebugModeEnabledEventHandler, z as addDraggingNodeEventHandler, zi as addModalEventHandler, zn as setVersionCheckInterval, zr as isExternalControlsEnabledEventFunctions, zt as addStudioModeEventHandler } from "./document-operations-CBExT76y.js";
+import { a as setGlobal, i as getGlobal, n as getAnalyticsStore, r as clearGlobal, t as createAnalyticsStore } from "./store-BJYcr_FL.js";
 import { baseDocumentModels, baseDocumentModelsMap } from "./src/document-model.js";
-import { n as GetDocumentWithOperationsDocument, r as PropagationMode, t as createClient } from "./client-_Gh2Uf0E.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-D-1c_Bvx.js";
-import { i as setPGliteDB, n as useRelationalQuery, r as useRelationalDb, t as createProcessorQuery } from "./relational-Dj06-YkI.js";
-import { i as trimTrailingSlash, n as getPackages, r as getPackagesByDocumentType, t as RegistryClient } from "./client-u13cr-Vg.js";
-import { logger } from "document-model";
-import { baseLoadFromInput, baseLoadFromInputVersioned, baseSaveToFileHandle, createPresignedHeader, createZip, documentModelDocumentType, generateId, replayDocumentVersioned, setName, validateInitialState, validateModules, validateStateSchemaName } from "@powerhousedao/shared/document-model";
-import { DriveDocumentSchema, addFolder as addFolder$1, copyNode, driveCreateDocument, generateNodesCopy, handleTargetNameCollisions, isFileNode, isFolderNode, moveNode, setAvailableOffline, setDriveIcon, setDriveName, setSharingType, updateNode } from "@powerhousedao/shared/document-drive";
-import { allPass, conditional, constant, filter, find, forEach, forEachObj, funnel, hasAtLeast, isArray, isDefined, isIncludedIn, isNot, isStrictEqual, isString, isTruthy, last, map, mapToObj, once, pipe, prop, split, unique } from "remeda";
-import { ChannelScheme, DocumentChangeType, DocumentChangeType as DocumentChangeType$1, DocumentIntegrityService, DriveCollectionId, DriveCollectionId as DriveCollectionId$1, DuplicateManifestError, DuplicateModuleError, GqlRequestChannel, InMemoryQueue, IntervalPollTimer, ModuleNotFoundError, PollBehavior, PropagationMode as PropagationMode$1, REACTOR_SCHEMA, REACTOR_SCHEMA as REACTOR_SCHEMA$1, ReactorBuilder, ReactorClientBuilder, RelationalDbProcessor, SyncOperationStatus, SyncStatus, driveIdFromUrl, isDriveAuthError, isDriveAuthError as isDriveAuthError$1, parseDriveUrl } from "@powerhousedao/reactor";
+import { i as GetDocumentWithOperationsDocument, o as PropagationMode, t as createClient } from "./client-D66jVnot.js";
+import { a as useRenown, c as RENOWN_INITIAL_UNKNOWN, d as useRenownInitialUser, f as addLoadingEventHandler, h as useLoading, i as useLoginStatus, l as RenownInitialUserProvider, m as setLoading, n as setRenown, o as useUser, p as loading, r as useDid, s as RENOWN_INITIAL_ANONYMOUS, t as addRenownEventHandler, u as useRenownInitialAuth } from "./renown-BHxwP7xU.js";
+import { A as RENOWN_CHAIN_ID, C as logout, D as CREDENTIAL_TYPES, E as CREDENTIAL_SUBJECT_TYPE, M as RENOWN_URL, N as VERIFIABLE_CREDENTIAL_EIP712_TYPE, O as DOMAIN_TYPE, S as login, T as CREDENTIAL_SCHEMA_EIP712_TYPE, _ as RenownLogo, a as Renown, b as useRenownAuth, c as useRenownSessionSynced, d as RenownAuthButton, f as RenownUserButton, g as DisconnectIcon, h as CopyIcon, i as RenownWalletProvider, j as RENOWN_NETWORK_ID, k as ISSUER_TYPE, l as initConnectCrypto, m as ChevronDownIcon, n as useRenownLoginMethods, o as useRenownInit, p as RenownLoginButton, r as RenownProvider, s as useRenownSessionCookie, t as useRenownWalletAdapter, u as initRenownCrypto, v as SpinnerIcon, w as openRenown, x as useRenownAuthAsync, y as UserIcon } from "./renown-BIEv6bSI.js";
+import { c as useSelectedDocument, d as useSelectedDocumentSafe, f as useDocumentOfType, l as useSelectedDocumentId, t as GQL_CHANNEL_SUFFIX, u as useSelectedDocumentOfType } from "./switchboard-D4-_jwk-.js";
+import { i as setPGliteDB, n as useRelationalQuery, r as useRelationalDb, t as createProcessorQuery } from "./relational-D4sxGPz7.js";
+import { a as getPackagesForDocumentType, i as getPackagesByDocumentType, n as getPackagePage, o as trimTrailingSlash, r as getPackages, t as RegistryClient } from "./client-B8ezRmBB.js";
+import { createZip, isDocumentZip, parseBulkArchive, toTransportAction, validateInitialState, validateModules, validateStateSchemaName, zipEntries } from "@powerhousedao/shared/document-model";
+import { DriveDocumentSchema, driveCreateDocument, getDescendants, getNextCopyNumber, isFileNode, isFolderNode, setAvailableOffline, setDriveIcon, setDriveName, setSharingType } from "@powerhousedao/shared/document-drive";
+import { allPass, filter, find, forEach, funnel, hasAtLeast, isArray, isDefined, isIncludedIn, isStrictEqual, isTruthy, last, map, mapToObj, once, pipe, prop, split, unique } from "remeda";
+import { pascalCase } from "change-case";
 import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { AuthEnforcementDisabledError, ChannelScheme, DocumentChangeType, DocumentChangeType as DocumentChangeType$1, DocumentIntegrityService, DriveCollectionId, DriveCollectionId as DriveCollectionId$1, GqlRequestChannel, InMemoryQueue, IntervalPollTimer, PollBehavior, PropagationMode as PropagationMode$1, REACTOR_SCHEMA, REACTOR_SCHEMA as REACTOR_SCHEMA$1, ReactorBuilder, ReactorClientBuilder, RelationalDbProcessor, SyncOperationStatus, SyncStatus, driveIdFromUrl, isDriveAuthError, isDriveAuthError as isDriveAuthError$1, parseDriveUrl } from "@powerhousedao/reactor";
+import { Kind, parse } from "graphql";
 import { z } from "zod";
-import slug from "slug";
 import normalizeException from "normalize-exception";
-import * as lzString from "lz-string";
+import lzString from "lz-string";
 import { createAttachmentClient } from "@powerhousedao/reactor-attachments/client";
-//#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) {
+//#region src/actions/bulk-archive.ts
+/**
+* Expand a dropped file into import jobs. A single-document zip is passed
+* through unchanged. A bulk archive (a zip whose tree of files are
+* single-document zips) has its top-level folder — and subfolders —
+* recreated under `targetParent` (existing same-named folders are reused),
+* and each leaf becomes one job targeting its recreated folder. Throws
+* without touching the drive when no leaf is a document zip.
+*/
+async function expandBulkArchive(file, driveId, targetParent) {
+	const data = new Uint8Array(await file.arrayBuffer());
+	if (await isDocumentZip(data)) return [{
+		file,
+		parent: targetParent
+	}];
+	const entries = await parseBulkArchive(data);
+	if (!(await Promise.all(entries.map((entry) => isDocumentZip(entry.data)))).some(Boolean)) throw new Error("Archive contains no Powerhouse documents");
 	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
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const knownNodes = [...(await reactorClient.get(driveId)).state.global.nodes];
+	const dirToNode = /* @__PURE__ */ new Map();
+	const ensureDir = async (dirPath, parent) => {
+		const cached = dirToNode.get(dirPath);
+		if (cached) return cached;
+		const name = dirPath.split("/").pop() ?? dirPath;
+		const node = knownNodes.find((n) => isFolderNode(n) && n.name === name && (n.parentFolder ?? null) === (parent?.id ?? null)) ?? await addFolder(driveId, name, parent?.id);
+		dirToNode.set(dirPath, node);
+		knownNodes.push(node);
+		return node;
 	};
-	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) {
-	try {
-		const data = await createZip(document);
-		const blob = new Blob([new Uint8Array(data)], { type: "application/zip" });
-		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 (e) {
-		logger.error(e instanceof Error ? e.message : String(e));
-	}
-}
-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;
+	const jobs = [];
+	for (const entry of entries) {
+		const segments = entry.path.split("/");
+		const leaf = segments.pop();
+		let parent = targetParent;
+		let prefix = "";
+		for (const segment of segments) {
+			prefix = prefix ? `${prefix}/${segment}` : segment;
+			parent = await ensureDir(prefix, parent);
 		}
+		jobs.push({
+			file: new File([new Uint8Array(entry.data)], leaf),
+			parent
+		});
 	}
-	return (rawExtension ?? "").replace(/^\.+|\.+$/g, "");
+	return jobs;
 }
+//#endregion
+//#region src/actions/folder-zip.ts
+const sanitize = (segment) => segment.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.
+* Name segments from the exported folder (exclusive) down to `node`
+* (inclusive), in top-down order. `root === undefined` means the drive root:
+* all ancestors. A node that IS the exported folder yields no segments.
 */
-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;
+function segmentsBelow(root, node, allNodes) {
+	const segments = [];
+	let current = node;
+	while (current && current.id !== root?.id) {
+		segments.push(sanitize(current.name));
+		const parentId = current.parentFolder;
+		current = parentId ? allNodes.find((n) => n.id === parentId) : void 0;
 	}
+	return segments.reverse();
 }
 /**
-* Loads a document file and replays it with version-aware reducers from the registry.
-* Falls back to single-version legacy replay when no upgrade manifest is registered for
-* the document type.
+* Assemble the archive zip for a folder (or the whole drive when
+* `folderNode` is undefined). Every folder in the subtree becomes a
+* directory entry (empty folders survive); every file becomes a standard
+* single-document zip named after the node (drive naming convention:
+* `${name}.${extension}.phd`, ` (copy) N` on a same-folder collision).
+*
+* `fetchDocument` must return the document WITH its full operations and
+* initialState (see downloadFolderZip).
 */
-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 documentType = baseDocument.header.documentType;
-	const { results: documentModelModules } = await reactorClient.getDocumentModelModules();
-	const modulesForType = documentModelModules.filter((module) => module.documentModel.global.id === documentType);
-	if (modulesForType.length === 0) throw new DocumentModelNotFoundError(documentType);
-	const reducers = {};
-	for (const module of modulesForType) reducers[module.version ?? 1] = module.reducer;
-	const registry = window.ph?.reactorClientModule?.reactorModule?.documentModelRegistry;
-	let upgradeManifest;
-	if (registry) try {
-		upgradeManifest = registry.getUpgradeManifest(documentType);
-	} catch {}
-	return baseLoadFromInputVersioned(path, {
-		reducers,
-		upgradeManifest
-	});
-}
-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: @error", e);
-		throw new Error("There was an error adding document", { cause: e });
+async function buildFolderZip(drive, folderNode, fetchDocument, onProgress) {
+	const allNodes = drive.state.global.nodes;
+	const topName = sanitize(folderNode?.name ?? (drive.state.global.name || drive.header.name));
+	const subtree = folderNode ? [folderNode, ...getDescendants(folderNode, allNodes)] : allNodes;
+	const entries = { [topName + "/"]: new Uint8Array(0) };
+	for (const node of subtree) {
+		if (!isFolderNode(node)) continue;
+		const dir = [topName, ...segmentsBelow(folderNode, node, allNodes)].join("/");
+		entries[dir + "/"] = new Uint8Array(0);
+	}
+	const files = subtree.filter(isFileNode);
+	const failed = [];
+	const usedNamesByDir = /* @__PURE__ */ new Map();
+	let done = 0;
+	for (const node of files) try {
+		const doc = await fetchDocument(node.id);
+		const extension = await getDocumentExtension(doc);
+		const parent = node.parentFolder ? allNodes.find((n) => n.id === node.parentFolder) : void 0;
+		const dir = [topName, ...parent ? segmentsBelow(folderNode, parent, allNodes) : []].join("/");
+		let usedNames = usedNamesByDir.get(dir);
+		if (!usedNames) {
+			usedNames = /* @__PURE__ */ new Set();
+			usedNamesByDir.set(dir, usedNames);
+		}
+		const base = sanitize(node.name);
+		let candidate = base;
+		let count = getNextCopyNumber([...usedNames], base);
+		while (usedNames.has(candidate)) {
+			candidate = `${base} (copy) ${count}`;
+			count += 1;
+		}
+		usedNames.add(candidate);
+		const leaf = extension ? `${candidate}.${extension}.phd` : `${candidate}.phd`;
+		entries[`${dir}/${leaf}`] = await createZip(doc);
+	} catch {
+		failed.push(node.name);
+	} finally {
+		done += 1;
+		onProgress?.(done, files.length);
 	}
 	return {
-		id: newDoc.header.id,
-		name: newDoc.header.name,
-		documentType,
-		parentFolder: parentFolder ?? null,
-		kind: "file"
+		zip: await zipEntries(entries),
+		archiveName: `${topName}.zip`,
+		entryCount: files.length - failed.length,
+		failed
 	};
 }
-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;
+/**
+* Export a folder (or whole drive) to disk: fetches every document with its
+* full operation history, builds the archive, and saves it via
+* showSaveFilePicker (fallback: blob download), mirroring exportFile.
+*/
+async function downloadFolderZip(drive, folderNode, onProgress) {
 	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;
-		}
-		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 result = await buildFolderZip(drive, folderNode, async (id) => {
+		const doc = await reactorClient.get(id);
+		const operations = await fetchDocumentOperations(reactorClient, doc);
+		const initialState = extractInitialState(operations["document"] ?? []);
+		return {
+			...doc,
+			operations,
+			initialState
 		};
-		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;
+	}, onProgress);
+	if (!window.showSaveFilePicker) {
+		const blob = new Blob([new Uint8Array(result.zip)], { type: "application/zip" });
+		const link = window.document.createElement("a");
+		link.style.display = "none";
+		link.href = URL.createObjectURL(blob);
+		link.download = result.archiveName;
+		window.document.body.appendChild(link);
+		link.click();
+		window.document.body.removeChild(link);
+		return result;
 	}
-}
-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 moveNodeById(args) {
-	const { driveId, srcId, targetId } = args;
-	if (!driveId || !srcId) return;
-	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");
-	const targetParentFolder = conditional(targetId, [isNot(isDefined), constant(void 0)], [isStrictEqual(driveId), constant(void 0)], constant(targetId));
-	if (isStrictEqual(targetParentFolder, srcId)) return;
-	return await reactorClient.execute(driveId, "main", [moveNode({
-		srcFolder: srcId,
-		targetParentFolder
-	})]);
-}
-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
-	})]);
-}
-/**
-* Duplicates a document under a new id using version-aware replay.
-* Falls back gracefully when no upgrade manifest is registered for the document type.
-*/
-async function _duplicateDocument(reactor, document, newId = generateId()) {
-	const documentType = document.header.documentType;
-	const { results: allModules } = await reactor.getDocumentModelModules();
-	const modulesForType = allModules.filter((m) => m.documentModel.global.id === documentType);
-	const reducers = {};
-	for (const m of modulesForType) reducers[m.version ?? 1] = m.reducer;
-	if (Object.keys(reducers).length === 0) throw new Error(`Document model module not found for type: ${documentType}`);
-	const registry = window.ph?.reactorClientModule?.reactorModule?.documentModelRegistry;
-	let upgradeManifest;
-	if (registry) try {
-		upgradeManifest = registry.getUpgradeManifest(documentType);
-	} catch {}
-	const config = {
-		reducers,
-		upgradeManifest
-	};
-	const header = createPresignedHeader(newId, documentType);
-	return replayDocumentVersioned(document.initialState, document.operations, config, header);
-}
-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);
+		const writable = await (await window.showSaveFilePicker({ suggestedName: result.archiveName })).createWritable();
+		await writable.write(new Uint8Array(result.zip));
+		await writable.close();
 	} catch (e) {
-		logger.error(`Error copying document ${fileNodeToCopy.srcId}: ${String(e)}`);
+		if (!(e instanceof DOMException && e.name === "AbortError")) throw e;
 	}
-	return await queueActions(drive, copyNodesInput.map((copyNodeInput) => copyNode(copyNodeInput)));
-}
-//#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
-	});
+	return result;
 }
 //#endregion
 //#region src/actions/drive.ts
@@ -630,11 +237,12 @@ async function addDrive(input, preferredEditor) {
 		icon: input.global.icon ?? null,
 		nodes: []
 	} });
+	if (input.id) driveDoc.header.id = input.id;
 	if (preferredEditor) driveDoc.header.meta = { preferredEditor };
 	return await reactorClient.create(driveDoc);
 }
 async function addRemoteDrive(url, driveId, options) {
-	const reactorClient = window.ph?.reactorClient;
+	const reactorClient = window.ph?.reactorClientModule?.client;
 	if (!reactorClient) throw new Error("ReactorClient not initialized");
 	const sync = window.ph?.reactorClientModule?.reactorModule?.syncModule?.syncManager;
 	if (!sync) throw new Error("Sync not initialized");
@@ -681,7 +289,7 @@ async function deleteDrive(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;
+	const reactorClient = window.ph?.reactorClientModule?.client;
 	if (!reactorClient) throw new Error("ReactorClient not initialized");
 	return await reactorClient.rename(driveId, name);
 }
@@ -706,7 +314,7 @@ async function setDriveMetadata(driveId, metadata) {
 	if (!reactorClient) throw new Error("ReactorClient not initialized");
 	const actions = [];
 	if (metadata.name) actions.push(setDriveName({ name: metadata.name }));
-	if (metadata.icon !== void 0 && metadata.icon !== null) actions.push(setDriveIcon({ icon: metadata.icon }));
+	if (metadata.icon !== void 0) actions.push(setDriveIcon({ icon: metadata.icon }));
 	if (actions.length === 0) return;
 	return await reactorClient.execute(driveId, "main", actions);
 }
@@ -993,876 +601,6 @@ async function reactorGraphqlMutateDocument(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/attachment-service.ts
-const attachmentServiceEventFunctions = makePHEventFunctions("attachmentService");
-/** Returns the attachment service from window.ph */
-const useAttachmentService = attachmentServiceEventFunctions.useValue;
-/** Sets the attachment service on window.ph */
-const setAttachmentService = attachmentServiceEventFunctions.setValue;
-/** Registers the attachmentService window event handler */
-const addAttachmentServiceEventHandler = attachmentServiceEventFunctions.addEventHandler;
-//#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/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/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/set-selected-node.ts
-const selectedNodeIdEventFunctions = makePHEventFunctions("selectedNodeId");
-const useSelectedNodeId = selectedNodeIdEventFunctions.useValue;
-const setSelectedNodeId = selectedNodeIdEventFunctions.setValue;
-const addSelectedNodeIdEventHandler = selectedNodeIdEventFunctions.addEventHandler;
-/** 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 (extractNodeIdFromSlug(nodeSlug) !== window.ph?.selectedNodeId) setSelectedNode(nodeSlug);
-	});
-}
-//#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 drives = window.ph?.drives;
-	const driveId = (typeof driveOrDriveSlug === "object" && driveOrDriveSlug !== null ? driveOrDriveSlug : drives?.find((d) => d.header.slug === driveSlug))?.header.id;
-	if (!driveId && driveSlug && extractDriveSlugFromPath(window.location.pathname) === driveSlug) {
-		if (window.ph?.selectedDriveId) setSelectedDriveId(void 0);
-		deferDriveSelection(driveSlug);
-		return;
-	}
-	cancelPendingDriveSelection();
-	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));
-}
-const DEFERRED_DRIVE_TICK_MS = 2e3;
-const DEFERRED_DRIVE_MAX_WAIT_MS = 15e3;
-function isInitialSyncInFlight() {
-	const remotes = window.ph?.reactorClientModule?.reactorModule?.syncModule?.syncManager?.list();
-	if (!remotes?.length) return false;
-	return remotes.some((remote) => {
-		try {
-			const snapshot = remote.channel.getConnectionState();
-			return snapshot.receivingPages || !snapshot.lastSuccessUtcMs && snapshot.state !== "error";
-		} catch {
-			return false;
-		}
-	});
-}
-let pendingHandler;
-let pendingTimeout;
-function cancelPendingDriveSelection() {
-	if (pendingHandler) {
-		window.removeEventListener("ph:drivesUpdated", pendingHandler);
-		pendingHandler = void 0;
-	}
-	if (pendingTimeout) {
-		clearTimeout(pendingTimeout);
-		pendingTimeout = void 0;
-	}
-}
-function deferDriveSelection(driveSlug) {
-	cancelPendingDriveSelection();
-	const nodeSlug = extractNodeSlugFromPath(window.location.pathname);
-	const handler = () => {
-		if (!window.ph?.drives?.find((d) => d.header.slug === driveSlug)) return;
-		cancelPendingDriveSelection();
-		setSelectedDrive(driveSlug);
-		setSelectedNode(nodeSlug);
-	};
-	pendingHandler = handler;
-	window.addEventListener("ph:drivesUpdated", handler);
-	const deadline = Date.now() + DEFERRED_DRIVE_MAX_WAIT_MS;
-	const scheduleTick = () => {
-		pendingTimeout = setTimeout(() => {
-			if (Date.now() < deadline && isInitialSyncInFlight()) {
-				scheduleTick();
-				return;
-			}
-			cancelPendingDriveSelection();
-			const pathname = resolveUrlPathname("/");
-			if (pathname === window.location.pathname) return;
-			window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
-		}, DEFERRED_DRIVE_TICK_MS);
-	};
-	scheduleTick();
-}
-function addSetSelectedDriveOnPopStateEventHandler() {
-	window.addEventListener("popstate", () => {
-		const pathname = window.location.pathname;
-		const driveId = extractDriveIdFromPath(pathname);
-		if (driveId !== window.ph?.selectedDriveId) setSelectedDrive(driveId);
-	});
-}
-//#endregion
-//#region src/hooks/use-drop-target.ts
-function useDropTarget() {
-	const [isDropTarget, setIsDropTarget] = useState(false);
-	const isDragAndDropEnabled = useIsDragAndDropEnabled();
-	const targetSetter = funnel(() => setIsDropTarget(true), {
-		triggerAt: "start",
-		minQuietPeriodMs: 100
-	});
-	const targetUnsetter = funnel(() => setIsDropTarget(false), {
-		triggerAt: "start",
-		minQuietPeriodMs: 100
-	});
-	function setTarget() {
-		if (!isDragAndDropEnabled) return;
-		targetUnsetter.cancel();
-		targetSetter.call();
-	}
-	function unsetTarget() {
-		if (!isDragAndDropEnabled) return;
-		targetSetter.cancel();
-		targetUnsetter.call();
-	}
-	return {
-		isDropTarget,
-		setTarget,
-		unsetTarget
-	};
-}
-//#endregion
-//#region src/hooks/node-drag-and-drop.ts
-const draggingNodeEventFunctions = makePHEventFunctions("draggingNode");
-const useDraggingNode = draggingNodeEventFunctions.useValue;
-const setDraggingNode = draggingNodeEventFunctions.setValue;
-const addDraggingNodeEventHandler = draggingNodeEventFunctions.addEventHandler;
-const draggingNodeSetter = funnel((node) => setDraggingNode(node), {
-	reducer: (_, newNode) => newNode,
-	triggerAt: "start",
-	minQuietPeriodMs: 100
-});
-const draggingNodeUnsetter = funnel(() => setDraggingNode(void 0), {
-	triggerAt: "start",
-	minQuietPeriodMs: 100
-});
-function setDragging(node) {
-	draggingNodeUnsetter.cancel();
-	draggingNodeSetter.call(node);
-}
-function unsetDragging() {
-	draggingNodeSetter.cancel();
-	draggingNodeUnsetter.call();
-}
-const isNodeDrag = (params) => conditional(params, [({ srcId }) => isNot(isTruthy)(srcId), constant(false)], [({ driveId }) => isNot(isTruthy)(driveId), constant(false)], [({ driveId, srcId }) => isStrictEqual(driveId, srcId), constant(false)], constant(true));
-function useDragNode(args) {
-	const { srcId, parentId } = args;
-	const driveId = useSelectedDriveId();
-	const draggingNodeId = useDraggingNode()?.srcId;
-	const params = {
-		driveId,
-		srcId,
-		parentId
-	};
-	const draggable = isNodeDrag(params);
-	const isDragging = allPass({
-		srcId,
-		draggingNodeId
-	}, [
-		() => draggable,
-		({ srcId }) => isString(srcId),
-		({ draggingNodeId }) => isString(draggingNodeId),
-		({ srcId, draggingNodeId }) => isStrictEqual(srcId, draggingNodeId)
-	]);
-	const onDragStart = () => {
-		if (!draggable) return;
-		setDragging(params);
-	};
-	const onDragEnd = () => {
-		if (!draggable) return;
-		unsetDragging();
-	};
-	return {
-		isDragging,
-		draggable,
-		onDragStart,
-		onDragEnd
-	};
-}
-const isNodeDrop = (params) => conditional(params, [({ srcId }) => isNot(isTruthy)(srcId), constant(false)], [({ driveId }) => isNot(isDefined)(driveId), constant(false)], [({ srcId, targetId }) => isStrictEqual(srcId, targetId), constant(false)], [({ driveId, parentId, targetId }) => isNot(isTruthy)(parentId) && isStrictEqual(targetId, driveId), constant(false)], [({ targetId, parentId }) => isStrictEqual(targetId, parentId), constant(false)], constant(true));
-function useDropNode(targetId) {
-	const driveId = useSelectedDriveId();
-	const { srcId, parentId } = useDraggingNode() ?? {};
-	const { isDropTarget, setTarget, unsetTarget } = useDropTarget();
-	const params = {
-		driveId,
-		parentId,
-		targetId,
-		srcId
-	};
-	function handleNodeDrop(event, cb) {
-		if (!isNodeDrop(params)) return;
-		event.preventDefault();
-		event.stopPropagation();
-		cb?.();
-	}
-	const onDragEnter = (event) => handleNodeDrop(event);
-	const onDragOver = (event) => handleNodeDrop(event, once(setTarget));
-	const onDragLeave = (event) => handleNodeDrop(event, once(unsetTarget));
-	const onDrop = (event) => handleNodeDrop(event, once(() => {
-		unsetDragging();
-		unsetTarget();
-		moveNodeById(params).catch(console.error);
-	}));
-	return {
-		isDropTarget,
-		onDragEnter,
-		onDragOver,
-		onDragLeave,
-		onDrop
-	};
-}
-//#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/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 (in-process or worker-backed) */
-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 = () => {
-	const module = useReactorClientModule();
-	return module?.kind === "browser" ? module.reactorModule?.database : void 0;
-};
-const usePGlite = () => {
-	const module = useReactorClientModule();
-	return module?.kind === "browser" ? module.reactorModule?.pg : void 0;
-};
-//#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/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
-/** Returns the selected node. */
-function useSelectedNode() {
-	const selectedNodeId = useSelectedNodeId();
-	return useNodesInSelectedDrive()?.find((n) => n.id === selectedNodeId);
-}
-//#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,
-	draggingNode: addDraggingNodeEventHandler
-};
-const phGlobalEventHandlerRegisterFunctions = {
-	...commonGlobalEventHandlerFunctions,
-	reactorClientModule: addReactorClientModuleEventHandler,
-	reactorClient: addReactorClientEventHandler,
-	attachmentService: addAttachmentServiceEventHandler,
-	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();
@@ -2017,130 +755,34 @@ function useConnectionStates() {
 			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.meta.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
-	};
+				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.meta.name, remote.channel.getConnectionState());
+	return map;
 }
 //#endregion
 //#region src/hooks/supported-document-types.ts
@@ -2161,6 +803,52 @@ function useDocumentTypes() {
 	return allowedDocumentTypes ?? supportedDocumentTypes;
 }
 //#endregion
+//#region src/hooks/document-version-status.ts
+/**
+* Classifies a document's model version against the installed module
+* versions. Pure logic, extracted for testing.
+*/
+function getDocumentVersionStatus(documentVersion, availableVersions, hasUpgradePath) {
+	if (availableVersions.length === 0) return;
+	const sorted = [...availableVersions].sort((a, b) => a - b);
+	const latestVersion = sorted[sorted.length - 1];
+	if (documentVersion > latestVersion) return {
+		kind: "unsupported",
+		documentVersion,
+		availableVersions: sorted
+	};
+	if (documentVersion === latestVersion) return {
+		kind: "current",
+		documentVersion
+	};
+	return {
+		kind: "upgrade-available",
+		documentVersion,
+		latestVersion,
+		canUpgrade: hasUpgradePath(documentVersion, latestVersion)
+	};
+}
+/**
+* Compares the given document's model version against the versions available
+* from installed Vetra packages. Returns undefined while packages load or
+* when the document type has no installed modules.
+*/
+function useDocumentVersionStatus(document) {
+	const modules = useDocumentModelModules();
+	const registry = useModelRegistry();
+	if (!document || !modules) return;
+	const documentType = document.header.documentType;
+	return getDocumentVersionStatus(document.state.document.version || 1, modules.filter((m) => m.documentModel.global.id === documentType).map((m) => m.version ?? 1), (fromVersion, toVersion) => {
+		if (!registry) return false;
+		try {
+			registry.computeUpgradePath(documentType, fromVersion, toVersion);
+			return true;
+		} catch {
+			return false;
+		}
+	});
+}
+//#endregion
 //#region src/utils/validate-document.ts
 const validateDocument = (document) => {
 	const errors = [];
@@ -2233,6 +921,27 @@ function useDownloadDocument(id) {
 	};
 }
 //#endregion
+//#region src/hooks/download-folder.ts
+/**
+* Downloads the selected drive's folder (or the whole drive when no folder
+* is given) as a single zip archive mirroring the folder tree.
+*/
+function useDownloadFolder(folderNode) {
+	const [selectedDrive] = useSelectedDriveSafe();
+	const toast = usePHToast();
+	return async () => {
+		if (!selectedDrive) return;
+		const name = folderNode?.name ?? selectedDrive.header.name;
+		toast?.(`Downloading "${name}"…`);
+		try {
+			const { entryCount, failed } = await downloadFolderZip(selectedDrive, folderNode);
+			toast?.(failed.length ? `Downloaded ${entryCount} files (${failed.length} failed)` : `Downloaded ${entryCount} files`);
+		} catch (error) {
+			toast?.(`Failed to download "${name}": ${error.message}`);
+		}
+	};
+}
+//#endregion
 //#region src/hooks/drive-by-id.ts
 function useDriveById(driveId) {
 	const foundDrive = useDrives()?.find((drive) => drive.header.id === driveId);
@@ -2354,6 +1063,7 @@ function useDropFile(handleAddFile) {
 	const { isDropTarget, setTarget, unsetTarget } = useDropTarget();
 	const isDragAndDropEnabled = useIsDragAndDropEnabled();
 	const selectedFolder = useSelectedFolder();
+	const selectedDriveId = useSelectedDriveId();
 	function handleDragEvent(event, cb) {
 		if (!isDragAndDropEnabled) return;
 		if (!isFileDrop(event)) return;
@@ -2365,7 +1075,24 @@ function useDropFile(handleAddFile) {
 		event.stopPropagation();
 		cb?.();
 	}
-	const handleAddFiles = (event) => Promise.all(pipe(event, getFileItems, filter(hasAllowedExtension), map((file) => handleAddFile(file, selectedFolder))));
+	const handleAddFiles = async (event) => {
+		const dropped = pipe(event, getFileItems, filter(hasAllowedExtension));
+		const jobs = [];
+		for (const file of dropped) {
+			if (selectedDriveId) try {
+				const expanded = await expandBulkArchive(file, selectedDriveId, selectedFolder);
+				jobs.push(...expanded);
+				continue;
+			} catch (error) {
+				console.error("Bulk archive expansion failed", error);
+			}
+			jobs.push({
+				file,
+				parent: selectedFolder
+			});
+		}
+		await Promise.all(jobs.map((job) => handleAddFile(job.file, job.parent)));
+	};
 	const onDragEnter = (event) => handleDragEvent(event);
 	const onDragOver = (event) => handleDragEvent(event, setTarget);
 	const onDragLeave = (event) => handleDragEvent(event, unsetTarget);
@@ -2481,7 +1208,7 @@ function useNodeActions() {
 	const drives = useDrives();
 	async function onAddFile(file, parent) {
 		if (!selectedDriveId) return;
-		return addFile(file, selectedDriveId, file.name.replace(/\..+/gim, ""), resolveNode(selectedDriveId, parent)?.id);
+		return addFileWithProgress(file, selectedDriveId, file.name.replace(/\..+/gim, ""), resolveNode(selectedDriveId, parent)?.id, void 0, void 0, "duplicate");
 	}
 	async function onAddFolder(name, parent) {
 		if (!selectedDriveId) return;
@@ -2582,29 +1309,6 @@ 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 || []);
@@ -2706,6 +1410,138 @@ function useTheme() {
 	};
 }
 //#endregion
+//#region src/hooks/use-can-execute.ts
+const IDLE = { status: "idle" };
+const LOADING = { status: "loading" };
+const UNSUPPORTED = { status: "unsupported" };
+function readyState(answer) {
+	return {
+		status: "ready",
+		evaluations: answer.evaluations,
+		allAllowed: answer.allAllowed,
+		anyAllowed: answer.anyAllowed,
+		allDenied: answer.allDenied,
+		anyDenied: answer.anyDenied
+	};
+}
+/**
+* Whether the subject the reactor client would decide for now is the one it is
+* going to keep.
+*
+* Renown's login status is the signal. Only `checking` is transient --
+* mid-login, about to resolve -- and `authorized` without a user yet is still
+* mid-resolution. Everything else is a steady state: `initial` is the anonymous
+* subject for a user who never logged in or just logged out (a restored session
+* is `authorized` from construction, so `initial` is not a pre-login window),
+* and `not-authorized` is a failed login, anonymous too.
+*
+* An absent status counts as unsettled, which is one render in a host that wires
+* renown -- and forever in a host that does not. Such a host names its subject
+* through the `subject` parameter instead, which needs nothing to settle.
+*/
+function subjectSettled(loginStatus, user) {
+	if (loginStatus === "authorized") return user !== void 0;
+	return loginStatus === "initial" || loginStatus === "not-authorized";
+}
+/**
+* Predicts whether the current subject may execute each of a set of candidate
+* operations on one document, so a UI can disable a control rather than offer an
+* action that fails on submit.
+*
+* The answer is a prediction and not a promise: the submit path is the only
+* authority, and this cannot reproduce the append condition real admission
+* compiles. Treat an allow as "worth offering", never as "will succeed", and
+* keep handling the submit's refusal.
+*
+* A candidate whose verdict depends on its input has to carry that input, since
+* a conditional grant reads it. A candidate standing for a form the user has not
+* filled in yet predicts the verdict an empty form earns.
+*
+* Deliberately reads the client off the reactor client module rather than
+* through `useReactorClient`: the latter hands back the minimal browser client
+* contract, which does not carry the preflight, and the plain-GraphQL setup that
+* implements it sets no module at all. No module therefore reports
+* `unsupported`.
+*
+* Re-evaluated when the document's revision moves, which covers a policy change
+* written to the document being asked about. Two gaps are known and accepted:
+*
+* - A group membership change is a write to the *group* document, so it fires no
+*   change event for this one. A group-gated grant can therefore be stale here
+*   until something else re-evaluates.
+* - A change event carries no scope, so any write to the document re-evaluates,
+*   including one that cannot affect a verdict.
+*
+* @param documentId - The document the candidates target, or null/undefined to stay idle
+* @param candidates - Operations to predict a verdict for. Read by content, so an inline array is fine
+* @param branch - Branch to evaluate against, defaulting to main
+* @param subject - Optional subject to decide for instead of the client's signer
+*/
+function useCanExecute(documentId, candidates, branch = "main", subject) {
+	const client = useReactorClientModule()?.client;
+	const loginStatus = useLoginStatus();
+	const user = useUser();
+	const revision = useDocumentSafe(documentId).data?.header.revision;
+	const [nonce, setNonce] = useState(0);
+	const [state, setState] = useState(IDLE);
+	const candidateKey = JSON.stringify(candidates);
+	const subjectKey = JSON.stringify(subject);
+	const stableCandidates = useMemo(() => candidates, [candidateKey]);
+	const stableSubject = useMemo(() => subject, [subjectKey]);
+	const settled = subject !== void 0 || subjectSettled(loginStatus, user);
+	const subjectIdentity = subject !== void 0 ? subjectKey : `${loginStatus ?? ""}:${user?.address ?? ""}`;
+	const revisionKey = JSON.stringify(revision);
+	const refetch = useCallback(() => {
+		setNonce((count) => count + 1);
+	}, []);
+	useEffect(() => {
+		if (client === void 0) {
+			setState(UNSUPPORTED);
+			return;
+		}
+		if (!documentId) {
+			setState(IDLE);
+			return;
+		}
+		if (!settled) {
+			setState(LOADING);
+			return;
+		}
+		let active = true;
+		setState(LOADING);
+		const evaluate = async () => {
+			let next;
+			try {
+				next = readyState(await client.evaluateActions(documentId, branch, stableCandidates, stableSubject));
+			} catch (error) {
+				next = AuthEnforcementDisabledError.isError(error) ? UNSUPPORTED : {
+					status: "error",
+					error: Error.isError(error) ? error : new Error(String(error))
+				};
+			}
+			if (active) setState(next);
+		};
+		evaluate();
+		return () => {
+			active = false;
+		};
+	}, [
+		client,
+		documentId,
+		branch,
+		stableCandidates,
+		stableSubject,
+		settled,
+		subjectIdentity,
+		revisionKey,
+		nonce
+	]);
+	return {
+		...state,
+		refetch
+	};
+}
+//#endregion
 //#region src/hooks/use-drive-system-info.ts
 function deriveSystemUrl(channelUrl) {
 	try {
@@ -2894,8 +1730,134 @@ function getDocumentGraphqlQuery() {
 	if (!loc) throw new Error("GetDocumentWithOperationsDocument is misconfigured, loc is missing.");
 	return loc.source.body;
 }
-function buildDocumentSubgraphQuery(identifier, authToken) {
-	const query = getDocumentGraphqlQuery();
+/**
+* The base URL of the switchboard that serves a drive's GraphQL channel.
+*
+* The channel URL is `<origin>[<proxy-prefix>]/graphql/r`, so stripping the
+* suffix preserves any proxy prefix (e.g. `/api/reactor`). A URL that does
+* not end with the suffix is unexpected — fall back to its origin.
+*/
+function getSwitchboardBaseFromChannelUrl(channelUrl) {
+	if (channelUrl.endsWith("/graphql/r")) return channelUrl.slice(0, -GQL_CHANNEL_SUFFIX.length);
+	return new URL(channelUrl).origin;
+}
+/**
+* The GraphQL name the switchboard exposes a document model under. Mirrors
+* `getDocumentModelSchemaName` on the server (`create-schema.ts`): the root
+* query field and the state type names are all derived from the model's
+* `global.name`.
+*/
+function getDocumentModelSchemaName(model) {
+	return pascalCase(model.documentModel.global.name.replaceAll("/", " "));
+}
+function buildStateTypeMap(definitions) {
+	const typeMap = /* @__PURE__ */ new Map();
+	for (const def of definitions) if (def.kind === Kind.OBJECT_TYPE_DEFINITION) typeMap.set(def.name.value, def);
+	return typeMap;
+}
+/**
+* Recursively expands the fields of a state object type into a GraphQL
+* selection. Objects expand their sub-selection (lists expand their item
+* type); enums, scalars, and built-ins are leaves.
+*/
+function expandStateFields(typeDef, typeMap) {
+	return (typeDef.fields ?? []).map((field) => {
+		const fieldName = field.name.value;
+		let typeNode = field.type;
+		if (typeNode.kind === Kind.NON_NULL_TYPE) typeNode = typeNode.type;
+		if (typeNode.kind === Kind.LIST_TYPE) {
+			let itemType = typeNode.type;
+			if (itemType.kind === Kind.NON_NULL_TYPE) itemType = itemType.type;
+			if (itemType.kind === Kind.LIST_TYPE) throw new Error(`Nested lists are not supported in state selections: ${fieldName}`);
+			if (itemType.kind !== Kind.NAMED_TYPE) return fieldName;
+			const itemTypeDef = typeMap.get(itemType.name.value);
+			if (!itemTypeDef) return fieldName;
+			return `${fieldName} { ${expandStateFields(itemTypeDef, typeMap)} }`;
+		}
+		if (typeNode.kind !== Kind.NAMED_TYPE) return fieldName;
+		const typeDef = typeMap.get(typeNode.name.value);
+		if (!typeDef) return fieldName;
+		return `${fieldName} { ${expandStateFields(typeDef, typeMap)} }`;
+	}).join(" ");
+}
+/**
+* Finds the root state object type in a state SDL. Root state types follow
+* the `<Name>State` / `<Name>GlobalState` conventions, and are defined last
+* by convention — the same resolution order the server uses
+* (`extractRootTypeName` in `create-schema.ts`).
+*/
+function findRootStateType(definitions, candidates) {
+	let lastObjectType = null;
+	for (const def of definitions) {
+		if (def.kind !== Kind.OBJECT_TYPE_DEFINITION) continue;
+		if (candidates.includes(def.name.value)) return def;
+		lastObjectType = def;
+	}
+	if (!lastObjectType) throw new Error("No root state type found in the document model schema");
+	return lastObjectType;
+}
+/**
+* Derives the subselection for the document's `global` state scope from the
+* model's state SDL (e.g. `name total`), expanding object fields
+* recursively. Throws when the schema is missing, unparseable, or has no
+* root object type — the caller falls back to the generic document query.
+*/
+function getDocumentStateSelection(model) {
+	const schema = model.documentModel.global.specifications.at(-1)?.state.global.schema;
+	if (!schema || !schema.trim()) throw new Error("Document model has no global state schema");
+	const ast = parse(schema);
+	const typeMap = buildStateTypeMap(ast.definitions);
+	const documentName = getDocumentModelSchemaName(model);
+	return expandStateFields(findRootStateType(ast.definitions, [`${documentName}State`, `${documentName}GlobalState`]), typeMap);
+}
+function getLocalStateSelection(localSchema, documentName) {
+	const ast = parse(localSchema);
+	const typeMap = buildStateTypeMap(ast.definitions);
+	return expandStateFields(findRootStateType(ast.definitions, [`${documentName}LocalState`]), typeMap);
+}
+/**
+* Builds a query scoped to a document type's own subgraph root field,
+* selecting the document and its full typed state. The shape mirrors what
+* the switchboard generates per model (`generateNewApiSchema` in
+* `create-schema.ts`): `<Name> { document(identifier:) { document { ...
+* state { auth document global local } } } childIds }`.
+*/
+function buildModelScopedQuery(model) {
+	const globalState = model.documentModel.global;
+	const documentName = getDocumentModelSchemaName(model);
+	const globalSelection = getDocumentStateSelection(model);
+	const localSchema = globalState.specifications.at(-1)?.state.local.schema ?? "";
+	const localSelection = localSchema.includes(`type ${documentName}LocalState`) ? getLocalStateSelection(localSchema, documentName) : null;
+	return [
+		"query GetDocument($identifier: String!) {",
+		`  ${documentName} {`,
+		"    document(identifier: $identifier) {",
+		"      document {",
+		"        id",
+		"        name",
+		"        documentType",
+		"        state {",
+		"          auth",
+		"          document { version hash { algorithm encoding } isDeleted deletedAtUtcIso deletedBy deletionReason }",
+		`          global { ${globalSelection} }`,
+		`          ${localSelection ? `local { ${localSelection} }` : "local"}`,
+		"        }",
+		"      }",
+		"      childIds",
+		"    }",
+		"  }",
+		"}"
+	].join("\n");
+}
+function buildDocumentSubgraphQuery(documentType, identifier, model, authToken) {
+	let query;
+	if (model && model.documentModel.global.id === documentType) try {
+		query = buildModelScopedQuery(model);
+	} catch (error) {
+		console.warn("Could not derive a document-scoped query from the document model, falling back to the generic document query:", error);
+		query = getDocumentGraphqlQuery();
+	}
+	else query = getDocumentGraphqlQuery();
 	const variables = { identifier };
 	const headers = authToken ? { Authorization: `Bearer ${authToken}` } : void 0;
 	const payload = {
@@ -2905,8 +1867,119 @@ function buildDocumentSubgraphQuery(identifier, authToken) {
 	if (headers) payload.headers = JSON.stringify(headers);
 	return lzString.compressToEncodedURIComponent(JSON.stringify(payload));
 }
-function buildDocumentSubgraphUrl(driveUrl, identifier, authToken) {
-	return `${driveUrl}?explorerURLState=${buildDocumentSubgraphQuery(identifier, authToken)}`;
+function buildDocumentSubgraphUrl(channelUrl, documentType, identifier, model, authToken) {
+	const encodedQuery = buildDocumentSubgraphQuery(documentType, identifier, model, authToken);
+	return `${getSwitchboardBaseFromChannelUrl(channelUrl)}/explorer?explorerURLState=${encodedQuery}`;
+}
+//#endregion
+//#region src/utils/upgrade-preview.ts
+const NON_DOMAIN_SCOPES = new Set(["auth", "document"]);
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function walkShapes(before, after, path, added, removed) {
+	if (isPlainObject(before) && isPlainObject(after)) {
+		const beforeKeys = Object.keys(before);
+		const afterKeys = Object.keys(after);
+		for (const key of afterKeys) {
+			const childPath = path ? `${path}.${key}` : key;
+			if (!beforeKeys.includes(key)) {
+				added.push(childPath);
+				continue;
+			}
+			walkShapes(before[key], after[key], childPath, added, removed);
+		}
+		for (const key of beforeKeys) if (!afterKeys.includes(key)) removed.push(path ? `${path}.${key}` : key);
+		return;
+	}
+	if (Array.isArray(before) && Array.isArray(after)) {
+		if (before.length > 0 && after.length > 0) walkShapes(before[0], after[0], `${path}[]`, added, removed);
+	}
+}
+/**
+* Recursively diffs the structural shape of two values, returning dot-paths
+* of keys present in `after` but not `before` (added) and vice versa
+* (removed). Array fields are compared by the shape of a representative
+* element (the first element on each side, when both sides have one) using
+* the `path[]` notation, e.g. `todos[].status`. Only key presence is
+* compared — array length and primitive values are ignored.
+*/
+function diffStateShapes(before, after) {
+	const added = [];
+	const removed = [];
+	walkShapes(before, after, "", added, removed);
+	return {
+		added,
+		removed
+	};
+}
+/**
+* Computes a dry-run preview of upgrading `document` to the latest
+* registered version of its document model: the version jump, the upgrade
+* steps that will run, and which state fields will be added or removed.
+* Applies the upgrade reducers against a deep clone of the document, so the
+* original is left untouched.
+*
+* Returns undefined when the registry is unavailable, the document is
+* already at (or above) the latest registered version, or the upgrade path
+* cannot be computed.
+*/
+function getDocumentUpgradePreview(document, registry) {
+	if (!registry) return;
+	const documentType = document.header.documentType;
+	const fromVersion = document.state.document.version || 1;
+	let latestVersion;
+	try {
+		latestVersion = registry.getLatestVersion(documentType);
+	} catch {
+		return;
+	}
+	if (fromVersion >= latestVersion) return;
+	let transitions;
+	try {
+		transitions = registry.computeUpgradePath(documentType, fromVersion, latestVersion);
+	} catch {
+		return;
+	}
+	const stubAction = {
+		id: "",
+		type: "UPGRADE_DOCUMENT",
+		scope: "document",
+		timestampUtcMs: "",
+		input: {
+			documentId: document.header.id,
+			model: documentType,
+			fromVersion,
+			toVersion: latestVersion
+		}
+	};
+	let upgraded = structuredClone(document);
+	try {
+		for (const transition of transitions) upgraded = transition.upgradeReducer(upgraded, stubAction);
+	} catch {
+		return;
+	}
+	const addedFields = [];
+	const removedFields = [];
+	const scopes = new Set([...Object.keys(document.state), ...Object.keys(upgraded.state)]);
+	for (const scope of scopes) {
+		if (NON_DOMAIN_SCOPES.has(scope)) continue;
+		const beforeScope = document.state[scope];
+		const afterScope = upgraded.state[scope];
+		const { added, removed } = diffStateShapes(beforeScope, afterScope);
+		for (const path of added) addedFields.push(`${scope}.${path}`);
+		for (const path of removed) removedFields.push(`${scope}.${path}`);
+	}
+	return {
+		fromVersion,
+		toVersion: latestVersion,
+		steps: transitions.map((transition) => ({
+			toVersion: transition.toVersion,
+			description: transition.description ?? ""
+		})),
+		addedFields,
+		removedFields
+	};
 }
 //#endregion
 //#region src/hooks/use-get-switchboard-link.ts
@@ -2924,6 +1997,7 @@ function buildDocumentSubgraphUrl(driveUrl, identifier, authToken) {
 function useGetSwitchboardLink(document) {
 	const [drive] = useSelectedDriveSafe();
 	const remotes = useSyncList();
+	const documentModelModule = useDocumentModelModuleById(document?.header.documentType);
 	const isRemoteDrive = useMemo(() => {
 		if (!isDefined(drive)) return false;
 		return remotes.some((remote) => remote.meta.collectionId.equals(DriveCollectionId$1.forDrive(drive.header.id)));
@@ -2948,12 +2022,13 @@ function useGetSwitchboardLink(document) {
 				expiresIn: 600,
 				aud: remoteUrl
 			}) : void 0;
-			return buildDocumentSubgraphUrl(remoteUrl, document.header.id, token);
+			return buildDocumentSubgraphUrl(remoteUrl, document.header.documentType, document.header.id, documentModelModule, token);
 		};
 	}, [
 		isRemoteDrive,
 		remoteUrl,
 		document,
+		documentModelModule,
 		user,
 		renown
 	]);
@@ -2964,14 +2039,12 @@ const useOnDropFile = (documentTypesOverride) => {
 	const selectedDriveId = useSelectedDriveId();
 	const selectedFolder = useSelectedFolder();
 	const documentTypes = useDocumentTypes();
-	const onDropFile = async (file, onProgress, resolveConflict) => {
+	const onDropFile = async (file, targetFolder, 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 await addFileWithProgress(file, selectedDriveId, file.name.replace(/\..+/gim, ""), targetFolder?.id ?? selectedFolder?.id, onProgress, documentTypesOverride ?? documentTypes, resolveConflict);
 	};
 	return onDropFile;
 };
@@ -2990,58 +2063,323 @@ function useUserPermissions() {
 	};
 }
 //#endregion
+//#region src/hooks/attachment-progress.ts
+const IDLE_PROGRESS = {
+	percent: 0,
+	loaded: 0,
+	total: void 0,
+	indeterminate: false
+};
+function toProgressState(progress) {
+	return {
+		percent: toPercent(progress),
+		loaded: progress.loaded,
+		total: progress.total,
+		indeterminate: progress.indeterminate
+	};
+}
+function toPercent(progress) {
+	if (progress.indeterminate) return 0;
+	if (progress.total === void 0) return 0;
+	if (progress.total === 0) return 100;
+	const percent = progress.loaded / progress.total * 100;
+	if (percent < 0) return 0;
+	return percent > 100 ? 100 : percent;
+}
+/** Terminal frame for a transfer of `total` bytes, written on resolution. */
+function doneProgress(total) {
+	return {
+		percent: 100,
+		loaded: total,
+		total,
+		indeterminate: false
+	};
+}
+/**
+* Second coalescer, on top of the client's time throttle, keyed on what
+* actually changed for a UI rather than on elapsed time:
+*
+* - a determinate tick commits only when the whole percent changes, capping
+*   commits at ~101 per transfer no matter how many byte events arrive;
+* - a tick with no position — indeterminate, or determinate with no
+*   denominator — has no percent to change, so it falls back to a time
+*   budget; otherwise a byte counter with no denominator would never update;
+* - gaining or losing a position always commits, since the UI switches between
+*   a spinner and a bar. Stage entry is indeterminate at 0%, so without this
+*   the first byte event of a stage reads as "still 0%" and is dropped, and a
+*   50 MB upload sits on the spinner until it crosses 1%;
+* - a stage change always commits, because the label changed.
+*
+* Uses `Date.now()` so tests can drive it with fake timers.
+*/
+function createProgressGate(options) {
+	const budget = options?.indeterminateCommitMs ?? 150;
+	const now = options?.now ?? (() => Date.now());
+	let lastStage;
+	let lastPercent = -1;
+	let lastIndeterminate;
+	let lastTotalKnown;
+	let lastCommitAt = Number.NEGATIVE_INFINITY;
+	return (progress) => {
+		const commit = () => {
+			lastStage = progress.stage;
+			lastPercent = Math.floor(toPercent(progress));
+			lastIndeterminate = progress.indeterminate;
+			lastTotalKnown = progress.total !== void 0;
+			lastCommitAt = now();
+			return true;
+		};
+		if (progress.stage !== lastStage) return commit();
+		if (progress.indeterminate !== lastIndeterminate) return commit();
+		if (progress.total !== void 0 !== lastTotalKnown) return commit();
+		if (progress.indeterminate || progress.total === void 0) return now() - lastCommitAt >= budget ? commit() : false;
+		return Math.floor(toPercent(progress)) !== lastPercent ? commit() : false;
+	};
+}
+//#endregion
 //#region src/hooks/use-attachments.ts
+/**
+* One client per service, shared across every component.
+*
+* A per-component `useMemo` handed each caller its own wrapper, so nothing
+* client-scoped could ever be shared or cached. Keyed weakly so a replaced
+* service is collectable.
+*/
+const clientsByService = /* @__PURE__ */ new WeakMap();
+function clientFor(service) {
+	const existing = clientsByService.get(service);
+	if (existing) return existing;
+	const created = createAttachmentClient(service);
+	clientsByService.set(service, created);
+	return created;
+}
 /** Returns an IAttachmentClient wrapping the current IAttachmentService, or undefined if none is set. */
 function useAttachments() {
 	const service = useAttachmentService();
-	return useMemo(() => service ? createAttachmentClient(service) : void 0, [service]);
-}
-/** Upload lifecycle status. progress is coarse (0 before/during, 1 on Done) because RemoteAttachmentUpload buffers the full body before issuing a single PUT. */
-let UploadStatus = /* @__PURE__ */ function(UploadStatus) {
-	UploadStatus["None"] = "None";
-	UploadStatus["Hashing"] = "Hashing";
-	UploadStatus["Uploading"] = "Uploading";
-	UploadStatus["Done"] = "Done";
-	UploadStatus["Error"] = "Error";
-	return UploadStatus;
-}({});
-/** Hook for managing the full attachment preprocess + upload lifecycle. preprocess and upload callbacks are stable (useCallback) and depend only on the current IAttachmentClient reference. */
+	return service ? clientFor(service) : void 0;
+}
+const DEFAULT_PREVIEW_RETRIES = 3;
+const DEFAULT_PREVIEW_RETRY_DELAY_MS = 3e3;
+const IDLE_PREVIEW = {
+	url: void 0,
+	header: void 0,
+	loading: false,
+	error: void 0,
+	stage: "idle",
+	progress: IDLE_PROGRESS,
+	attempt: 0,
+	maxAttempts: 1,
+	lastError: void 0
+};
+/**
+* Document-authorized inline preview of an attachment. Downloads the bytes
+* through the normal authorized flow, exposes them as an object URL, and
+* revokes it automatically on unmount and whenever documentId/ref change —
+* editors never touch blobs or URL lifecycles. Failed attempts are retried
+* (`retries` × `retryDelayMs`) so a preview requested right after attaching
+* appears as soon as the server's reference index catches up. Progress resets
+* per attempt; nothing resumes.
+*/
+function useAttachmentPreview({ documentId, ref, retries = DEFAULT_PREVIEW_RETRIES, retryDelayMs = DEFAULT_PREVIEW_RETRY_DELAY_MS }) {
+	const client = useAttachments();
+	const [state, setState] = useState(IDLE_PREVIEW);
+	useEffect(() => {
+		if (!client || !ref) {
+			setState(IDLE_PREVIEW);
+			return;
+		}
+		const maxAttempts = retries + 1;
+		let live = true;
+		const controller = new AbortController();
+		let revoke;
+		let timer;
+		let attempt = 0;
+		setState({
+			...IDLE_PREVIEW,
+			loading: true,
+			attempt: 1,
+			maxAttempts
+		});
+		const load = () => {
+			attempt += 1;
+			const gate = createProgressGate();
+			const attemptNumber = attempt;
+			client.downloadObjectUrl({
+				documentId,
+				ref,
+				signal: controller.signal
+			}, { onProgress: (progress) => {
+				if (!live) return;
+				if (progress.stage === "done" || progress.stage === "error") return;
+				if (!gate(progress)) return;
+				setState((prev) => ({
+					...prev,
+					stage: progress.stage,
+					progress: toProgressState(progress)
+				}));
+			} }).then((result) => {
+				if (!live) {
+					result.revoke();
+					return;
+				}
+				revoke = result.revoke;
+				setState((prev) => ({
+					...prev,
+					url: result.url,
+					header: result.header,
+					loading: false,
+					error: void 0,
+					stage: "done",
+					progress: doneProgress(result.header.sizeBytes),
+					attempt: attemptNumber,
+					maxAttempts
+				}));
+			}).catch((err) => {
+				if (!live) return;
+				const error = err instanceof Error ? err : new Error(String(err));
+				if (attempt < maxAttempts) {
+					setState((prev) => ({
+						...prev,
+						lastError: error,
+						attempt: attempt + 1,
+						progress: IDLE_PROGRESS,
+						stage: "idle"
+					}));
+					timer = setTimeout(load, retryDelayMs);
+					return;
+				}
+				setState((prev) => ({
+					...prev,
+					url: void 0,
+					header: void 0,
+					loading: false,
+					error,
+					lastError: error,
+					stage: "error",
+					attempt: attemptNumber,
+					maxAttempts
+				}));
+			});
+		};
+		load();
+		return () => {
+			live = false;
+			if (timer !== void 0) clearTimeout(timer);
+			controller.abort();
+			revoke?.();
+		};
+	}, [
+		client,
+		documentId,
+		ref,
+		retries,
+		retryDelayMs
+	]);
+	return state;
+}
+const IDLE_UPLOAD = {
+	stage: "idle",
+	progress: IDLE_PROGRESS,
+	result: void 0,
+	error: void 0
+};
+/**
+* Full attachment preprocess + upload lifecycle with byte-level progress.
+*
+* The two-call split is kept on purpose: the ref must reach the document
+* before the bytes are committed, so callers preprocess, dispatch the
+* operation, then upload. The second call routes through `client.upload`
+* rather than reimplementing the flow, which is what makes progress, dedup
+* reporting and cancellation identical to the non-React path.
+*/
 function useAttachmentUpload() {
-	const [status, setStatus] = useState(UploadStatus.None);
-	const [progress, setProgress] = useState(0);
-	const [error, setError] = useState(void 0);
+	const [state, setState] = useState(IDLE_UPLOAD);
 	const client = useAttachments();
+	const abortRef = useRef(void 0);
+	const mountedRef = useRef(true);
+	const runIdRef = useRef(0);
+	useEffect(() => {
+		mountedRef.current = true;
+		return () => {
+			mountedRef.current = false;
+		};
+	}, []);
 	return {
 		preprocess: useCallback(async (file) => {
 			if (!client) throw new Error("AttachmentClient not available");
-			setError(void 0);
-			setStatus(UploadStatus.Hashing);
+			const runId = ++runIdRef.current;
+			setState({
+				...IDLE_UPLOAD,
+				stage: "hashing"
+			});
 			try {
 				return await client.preprocess(file);
 			} catch (err) {
-				setError(err instanceof Error ? err : new Error(String(err)));
-				setStatus(UploadStatus.Error);
+				const error = err instanceof Error ? err : new Error(String(err));
+				if (mountedRef.current && runId === runIdRef.current) setState((prev) => ({
+					...prev,
+					stage: "error",
+					error
+				}));
 				throw err;
 			}
 		}, [client]),
 		upload: useCallback(async (results) => {
 			if (!client) throw new Error("AttachmentClient not available");
-			setError(void 0);
-			setStatus(UploadStatus.Uploading);
-			setProgress(0);
+			const runId = ++runIdRef.current;
+			const controller = new AbortController();
+			abortRef.current = controller;
+			const gate = createProgressGate();
+			const isCurrent = () => mountedRef.current && runId === runIdRef.current;
+			setState({
+				...IDLE_UPLOAD,
+				stage: "reserving"
+			});
+			let uploadResult;
 			try {
-				await client.reserve(results.options, (handle) => handle.send(results.stream()));
+				uploadResult = await client.upload({
+					preprocessed: results,
+					signal: controller.signal
+				}, { onProgress: (progress) => {
+					if (!isCurrent()) return;
+					if (progress.stage === "done" || progress.stage === "error") return;
+					if (!gate(progress)) return;
+					setState((prev) => ({
+						...prev,
+						stage: progress.stage,
+						progress: toProgressState(progress)
+					}));
+				} });
 			} catch (err) {
-				setError(err instanceof Error ? err : new Error(String(err)));
-				setStatus(UploadStatus.Error);
+				const error = err instanceof Error ? err : new Error(String(err));
+				if (isCurrent()) setState((prev) => ({
+					...prev,
+					stage: "error",
+					error
+				}));
 				throw err;
 			}
-			setProgress(1);
-			setStatus(UploadStatus.Done);
+			if (isCurrent()) setState((prev) => ({
+				...prev,
+				stage: "done",
+				progress: doneProgress(results.sizeBytes),
+				result: uploadResult,
+				error: void 0
+			}));
 		}, [client]),
-		status,
-		progress,
-		error
+		cancel: useCallback(() => {
+			abortRef.current?.abort();
+		}, []),
+		reset: useCallback(() => {
+			runIdRef.current += 1;
+			abortRef.current?.abort();
+			abortRef.current = void 0;
+			setState(IDLE_UPLOAD);
+		}, []),
+		stage: state.stage,
+		progress: state.progress,
+		result: state.result,
+		error: state.error
 	};
 }
 //#endregion
@@ -3340,12 +2678,18 @@ var RemoteClient = class {
 		}
 		return { operationsByScope };
 	}
-	/** Push actions to an existing document via MutateDocument. */
+	/**
+	* Push actions to an existing document via MutateDocument.
+	*
+	* Takes the wire shape rather than an in-process `Action`: a signature is a
+	* tuple in one and a string in the other, so the caller projects before it
+	* gets here.
+	*/
 	async pushActions(documentIdentifier, actions, branch) {
 		return (await this.client.MutateDocument({
 			documentIdentifier,
 			actions,
-			view: branch ? { branch } : void 0
+			branch
 		})).mutateDocument;
 	}
 	/** Create a new document on the remote. */
@@ -3371,105 +2715,6 @@ var RemoteClient = class {
 	}
 };
 //#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,
-			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.
@@ -3548,7 +2793,7 @@ var RemoteDocumentController = class RemoteDocumentController {
 			if (tracked.length > 0) {
 				const actions = await this.prepareActionsForPush(tracked);
 				pushedActions = actions;
-				await this.remoteClient.pushActions(this.documentId, actions, this.options.branch);
+				await this.remoteClient.pushActions(this.documentId, actions.map(toTransportAction), this.options.branch);
 			}
 		} catch (error) {
 			this.tracker.restore(tracked);
@@ -3860,6 +3105,6 @@ var BrowserLocalStorage = class extends BaseStorage {
 	}
 };
 //#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, DRIVE_DOCUMENT_TYPES, DisconnectIcon, DocumentCache, DocumentChangeType, DocumentIntegrityService, DriveCollectionId, EDITOR_FILE_DROP_OPT_OUT_ATTR, 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, UploadStatus, UserIcon, VERIFIABLE_CREDENTIAL_EIP712_TYPE, addAllowListEventHandler, addAllowedDocumentTypesEventHandler, addAnalyticsDatabaseNameEventHandler, addAttachmentServiceEventHandler, addBasePathEventHandler, addCliVersionEventHandler, addDefaultDrivesUrlEventHandler, addDisabledEditorsEventHandler, addDocument, addDocumentCacheEventHandler, addDraggingNodeEventHandler, 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, downloadDocument, driveIdFromUrl, dropAllReactorStorage, 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, hasPreloadBandwidth, hideRevisionHistory, identifierFromMutateDocumentOperationVariables, initConnectCrypto, initRenownCrypto, initTheme, isDocumentTypeSupported, isDriveAuthError, isExternalControlsEnabledEventFunctions, isFileNodeKind, isFolderNodeKind, loading, login, logout, makeDriveUrlComponent, makeNodeSlug, makePHEventFunctions, openRenown, parseDriveUrl, phAppConfigHooks, phAppConfigSetters, phDocumentEditorConfigHooks, phDocumentEditorConfigSetters, phDocumentFromQuery, phDocumentsFromQuery, phGlobalConfigHooks, phGlobalConfigSetters, preloadEditorModule, reactorGraphqlBatchFetchDocuments, reactorGraphqlCreateDocument, reactorGraphqlDeleteDocument, reactorGraphqlDeleteDocuments, reactorGraphqlFetchDocument, reactorGraphqlMutateDocument, readPromiseState, refreshReactorData, refreshReactorDataClient, renameDrive, renameDriveNode, resolveUrlPathname, setAllowList, setAllowedDocumentTypes, setAnalyticsDatabaseName, setAttachmentService, setBasePath, setCliVersion, setDefaultDrivesUrl, setDefaultPHGlobalConfig, setDisabledEditors, setDocumentCache, setDriveAvailableOffline, setDriveMetadata, 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, setPGliteDB, 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, trimTrailingSlash, truncateAllTables, useAllowList, useAllowedDocumentModelModules, useAllowedDocumentTypes, useAnalyticsDatabaseName, useAppModuleById, useAppModules, useAttachmentService, useAttachmentUpload, useAttachments, useBasePath, useCliVersion, useConnectionState, useConnectionStates, useDatabase, useDefaultAppModule, useDefaultDrivesUrl, useDid, useDisabledEditors, useDispatch, useDocument, useDocumentById, useDocumentCache, useDocumentModelModuleById, useDocumentModelModules, useDocumentOfType, useDocumentOperations, useDocumentSafe, useDocumentTypes, useDocumentTypesInSelectedDrive, useDocuments, useDocumentsByIds, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useDownloadDocument, useDragNode, useDriveById, useDriveSystemInfo, useDrives, useDrivesPreserveStrategy, useDropFile, useDropNode, useEditorFileDrop, useEditorModuleById, useEditorModules, useEditorModulesForDocumentType, useEditorPreloader, 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, useTheme, useUser, useUserPermissions, useVersion, useVersionCheckInterval, useVetraPackageManager, useVetraPackages, useWarnOutdatedApp, validateDocument, waitForDocumentReady };
+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, DRIVE_DOCUMENT_TYPES, DisconnectIcon, DocumentCache, DocumentChangeType, DocumentIntegrityService, DocumentModelNotFoundError, DocumentTypeMismatchError, DriveCollectionId, EDITOR_FILE_DROP_OPT_OUT_ATTR, GqlRequestChannel, GraphQLClientDocumentCache, GraphQLReactorClient, GraphQLReactorProvider, ISSUER_TYPE, InMemoryQueue, IntervalPollTimer, MutateDocumentWithOperationsDocument, NoSelectedDocumentError, PollBehavior, PropagationMode, REACTOR_SCHEMA, RENOWN_CHAIN_ID, RENOWN_INITIAL_ANONYMOUS, RENOWN_INITIAL_UNKNOWN, RENOWN_NETWORK_ID, RENOWN_URL, ReactorBuilder, ReactorClientBuilder, ReactorOperationFieldsFragmentDoc, RegistryClient, RelationalDbProcessor, RemoteClient, RemoteDocumentController, Renown, RenownAuthButton, RenownInitialUserProvider, RenownLoginButton, RenownLogo, RenownProvider, RenownUserButton, RenownWalletProvider, SpinnerIcon, StaticPackageManager, SubgraphSdkRegistry, SyncOperationStatus, UnsupportedDocumentTypeError, UserIcon, VERIFIABLE_CREDENTIAL_EIP712_TYPE, addAllowListEventHandler, addAllowedDocumentTypesEventHandler, addAnalyticsDatabaseNameEventHandler, addAttachmentServiceEventHandler, addBasePathEventHandler, addCliVersionEventHandler, addDefaultDrivesUrlEventHandler, addDisabledEditorsEventHandler, addDocument, addDocumentCacheEventHandler, addDraggingNodeEventHandler, addDrive, addDrivesEventHandler, addDrivesPreserveStrategyEventHandler, addEnabledEditorsEventHandler, addFeaturesEventHandler, addFileUploadOperationsChunkSizeEventHandler, addFileWithProgress, 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, addRenownAdaptersEventHandler, addRenownChainIdEventHandler, addRenownEventHandler, addRenownNetworkIdEventHandler, addRenownUrlEventHandler, addRequiresHardRefreshEventHandler, addResetSelectedNodeEventHandler, addRevisionHistoryVisibleEventHandler, addRouterBasenameEventHandler, addSelectedDriveIdEventHandler, addSelectedNodeIdEventHandler, addSelectedTimelineItemEventHandler, addSelectedTimelineRevisionEventHandler, addSentryDsnEventHandler, addSentryEnvEventHandler, addSentryReleaseEventHandler, addSetSelectedDriveOnPopStateEventHandler, addSetSelectedNodeOnPopStateEventHandler, addStudioModeEventHandler, addSwitchboardUrlEventHandler, addToastEventHandler, addVersionCheckIntervalEventHandler, addVersionEventHandler, addVetraPackageManagerEventHandler, addWarnOutdatedAppEventHandler, ambientRenownTokenProvider, baseDocumentModels, baseDocumentModelsMap, buildDocumentSubgraphQuery, buildDocumentSubgraphUrl, buildFolderZip, callEventHandlerRegisterFunctions, callGlobalSetterForKey, clearGlobal, closePHModal, commonGlobalEventHandlerFunctions, convertRemoteOperations, createAnalyticsStore, createClient, createProcessorQuery, createUrlWithPreservedParams, deleteDrive, deleteNode, deriveSystemUrl, describeGraphQLDocument, diffStateShapes, dispatchActions, downloadDocument, downloadFolderZip, driveIdFromUrl, dropAllReactorStorage, ensurePHEventHandlers, expandBulkArchive, exportFile, extractDriveIdFromPath, extractDriveIdFromSlug, extractDriveSlugFromPath, extractNodeIdFromPath, extractNodeIdFromSlug, extractNodeSlugFromPath, findUuid, getAnalyticsStore, getDocumentExtension, getDocumentGraphqlQuery, getDocumentStateSelection, getDocumentUpgradePreview, getDocumentVersionStatus, getDriveIdBySlug, getDrives, getGlobal, getPackagePage, getPackages, getPackagesByDocumentType, getPackagesForDocumentType, getPathWithoutBase, getRevisionFromDate, getSlugFromDriveUrl, getSwitchboardBaseFromChannelUrl, getSwitchboardGatewayUrlFromDriveUrl, getSyncStatus, getSyncStatusSync, getUserPermissions, graphqlDocumentEvents, graphqlDocumentsEvents, graphqlEventsToSyncDrive, hasPreloadBandwidth, hideRevisionHistory, identifierFromMutateDocumentOperationVariables, initConnectCrypto, initRenownCrypto, initTheme, isDocumentTypeSupported, isDriveAuthError, isExternalControlsEnabledEventFunctions, isFileNodeKind, isFolderNodeKind, isGraphQLReactorClient, loadFile, loading, login, logout, makeAuthConnectionParams, makeAuthMiddleware, makeDriveUrlComponent, makeNodeSlug, makePHEventFunctions, openRenown, packageFromDocumentModels, parseDriveUrl, phAppConfigHooks, phAppConfigSetters, phDocumentEditorConfigHooks, phDocumentEditorConfigSetters, phDocumentFromGetDocument, phDocumentFromMutation, phDocumentFromQuery, phDocumentsFromQuery, phGlobalConfigHooks, phGlobalConfigSetters, preloadEditorModule, prepareSignedActions, reactorGraphqlBatchFetchDocuments, reactorGraphqlCreateDocument, reactorGraphqlDeleteDocument, reactorGraphqlDeleteDocuments, reactorGraphqlFetchDocument, reactorGraphqlMutateDocument, readPromiseState, refreshReactorData, refreshReactorDataClient, renameDrive, renameDriveNode, resolveDocumentModelModule, resolveUrlPathname, revisionMapFromRevisionsList, setAllowList, setAllowedDocumentTypes, setAnalyticsDatabaseName, setAttachmentService, setBasePath, setCliVersion, setDefaultDrivesUrl, setDefaultPHGlobalConfig, setDisabledEditors, setDocumentCache, setDriveAvailableOffline, setDriveMetadata, 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, setPGliteDB, setPHAppConfig, setPHAppConfigByKey, setPHDocumentEditorConfig, setPHDocumentEditorConfigByKey, setPHGlobalConfig, setPHGlobalConfigByKey, setPHModal, setPHToast, setPackageDiscoveryService, setPreferredEditorOnNode, setReactorClient, setReactorClientModule, setRenown, setRenownAdapters, setRenownChainId, setRenownNetworkId, setRenownUrl, setRequiresHardRefresh, setRevisionHistoryVisible, setRouterBasename, setSelectedDrive, setSelectedDriveId, setSelectedNode, setSelectedTimelineItem, setSelectedTimelineRevision, setSentryDsn, setSentryEnv, setSentryRelease, setStudioMode, setSwitchboardUrl, setVersion, setVersionCheckInterval, setVetraPackageManager, setWarnOutdatedApp, showCreateDocumentModal, showDeleteNodeModal, showPHModal, showRevisionHistory, signStampedAction, sortNodesByName, stampAction, startDocumentChangesSubscription, subgraphUrlFromGraphqlUrl, subscriptionsUrlFromGraphqlUrl, trimTrailingSlash, truncateAllTables, upgradeDocument, useAllowList, useAllowedDocumentModelModules, useAllowedDocumentTypes, useAnalyticsDatabaseName, useAppModuleById, useAppModules, useAttachmentPreview, useAttachmentService, useAttachmentUpload, useAttachments, useBasePath, useCanExecute, useCliVersion, useConnectionState, useConnectionStates, useDatabase, useDefaultAppModule, useDefaultDrivesUrl, useDid, useDisabledEditors, useDispatch, useDocument, useDocumentById, useDocumentCache, useDocumentModelModuleById, useDocumentModelModules, useDocumentOfType, useDocumentOperations, useDocumentSafe, useDocumentTypes, useDocumentTypesInSelectedDrive, useDocumentVersionStatus, useDocuments, useDocumentsByIds, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useDownloadDocument, useDownloadFolder, useDragNode, useDriveById, useDriveSystemInfo, useDrives, useDrivesPreserveStrategy, useDropFile, useDropNode, useEditorFileDrop, useEditorModuleById, useEditorModules, useEditorModulesForDocumentType, useEditorPreloader, 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, useRenownAdapters, useRenownAuth, useRenownAuthAsync, useRenownChainId, useRenownInit, useRenownInitialAuth, useRenownInitialUser, useRenownLoginMethods, useRenownNetworkId, useRenownSessionCookie, useRenownSessionSynced, useRenownUrl, useRenownWalletAdapter, 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, useSwitchboardClient, useSwitchboardUrl, useSync, useSyncList, useTheme, useUser, useUserPermissions, useVersion, useVersionCheckInterval, useVetraPackageManager, useVetraPackages, useWarnOutdatedApp, validateDocument, viewFilterInputFromViewFilter, waitForDocumentReady };
 
 //# sourceMappingURL=index.js.map