@powerhousedao/reactor-browser 6.0.0-dev.213 → 6.0.0-dev.215

package/dist/index.js

@@ -1,12 +1,14 @@
 import { C as uploadOperations, S as queueOperations, _ as clearGlobal, a as setDocumentCache, b as dispatchActions, c as useDocuments, d as useGetDocuments, f as DocumentCache, g as getAnalyticsStore, h as createAnalyticsStore, i as addDocumentCacheEventHandler, l as useGetDocument, m as readPromiseState, n as useDocumentsByIds, o as useDocument, p as addPromiseState, r as useDispatch, s as useDocumentCache, t as useDocumentById, u as useGetDocumentAsync, v as getGlobal, x as queueActions, y as setGlobal } from "./document-by-id-CDLUqru5.js";
-import { n as PropagationMode, t as createClient } from "./client-_Vpu9aN7.js";
+import { n as GetDocumentWithOperationsDocument, r as PropagationMode, t as createClient } from "./client-DfoxBz8A.js";
 import { t as makePHEventFunctions } from "./make-ph-event-functions-Cr4GqOTT.js";
 import { A as useLoginStatus, C as RENOWN_CHAIN_ID, D as addRenownEventHandler, E as VERIFIABLE_CREDENTIAL_EIP712_TYPE, F as setLoading, I as useLoading, M as useUser, N as addLoadingEventHandler, O as setRenown, P as loading, S as ISSUER_TYPE, T as RENOWN_URL, _ as openRenown, a as RenownAuthButton, b as CREDENTIAL_TYPES, c as ChevronDownIcon, d as RenownLogo, f as SpinnerIcon, g as logout, h as login, i as initRenownCrypto, j as useRenown, k as useDid, l as CopyIcon, m as useRenownAuth, n as useRenownInit, o as RenownUserButton, p as UserIcon, r as initConnectCrypto, s as RenownLoginButton, t as Renown, u as DisconnectIcon, v as CREDENTIAL_SCHEMA_EIP712_TYPE, w as RENOWN_NETWORK_ID, x as DOMAIN_TYPE, y as CREDENTIAL_SUBJECT_TYPE } from "./renown-CV_45Xc1.js";
 import { n as useRelationalQuery, r as useRelationalDb, t as createProcessorQuery } from "./relational-jwreqDwz.js";
 import { documentModelDocumentModelModule, logger } from "document-model";
 import { baseLoadFromInput, baseSaveToFileHandle, createPresignedHeader, createZip, documentModelDocumentType, generateId, replayDocument, setName, validateInitialState, validateModules, validateStateSchemaName } from "@powerhousedao/shared/document-model";
-import { addFolder as addFolder$1, copyNode, driveCreateDocument, generateNodesCopy, handleTargetNameCollisions, isFileNode, isFolderNode, moveNode, setAvailableOffline, setSharingType, updateNode } from "@powerhousedao/shared/document-drive";
+import { DriveDocumentSchema, addFolder as addFolder$1, copyNode, driveCreateDocument, generateNodesCopy, handleTargetNameCollisions, isFileNode, isFolderNode, moveNode, setAvailableOffline, setSharingType, updateNode } from "@powerhousedao/shared/document-drive";
 import { ChannelScheme, DocumentChangeType, DocumentIntegrityService, DuplicateManifestError, DuplicateModuleError, GqlRequestChannel, InMemoryQueue, IntervalPollTimer, ModuleNotFoundError, REACTOR_SCHEMA, REACTOR_SCHEMA as REACTOR_SCHEMA$1, ReactorBuilder, ReactorClientBuilder, RelationalDbProcessor, SyncOperationStatus, SyncStatus, driveCollectionId, driveCollectionId as driveCollectionId$1, driveIdFromUrl, parseDriveUrl } from "@powerhousedao/reactor";
+import { filter, forEach, forEachObj, funnel, isIncludedIn, isStrictEqual, isTruthy, map, mapToObj, pipe, prop, unique } from "remeda";
+import { z } from "zod";
 import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import slug from "slug";
 import * as lzString from "lz-string";
@@ -554,6 +556,277 @@ const COMMON_PACKAGE_ID = "powerhouse/common";
 const baseDocumentModelsMap = { DocumentModel: documentModelDocumentModelModule };
 const baseDocumentModels = Object.values(baseDocumentModelsMap);
 //#endregion
+//#region src/graphql/adapters.ts
+function phDocumentFromQuery(document, documentSchema) {
+	const phDocument = {
+		header: phDocumentHeaderFromQuery(document),
+		state: phDocumentStateFromQuery(document),
+		initialState: phDocumentStateFromQuery(document),
+		operations: phDocumentOperationsFromGetDocumentWithOperationsQuery(document),
+		clipboard: []
+	};
+	if (documentSchema !== void 0) documentSchema.parse(phDocument);
+	return phDocument;
+}
+function phDocumentsFromQuery(items, documentSchema) {
+	return pipe(items, map((document) => phDocumentFromQuery(document, documentSchema)));
+}
+function phDocumentHeaderFromQuery(queryDocument) {
+	return {
+		branch: "main",
+		id: queryDocument.id,
+		name: queryDocument.name,
+		documentType: queryDocument.documentType,
+		createdAtUtcIso: queryDocument.createdAtUtcIso instanceof Date ? queryDocument.createdAtUtcIso.toUTCString() : queryDocument.createdAtUtcIso,
+		lastModifiedAtUtcIso: queryDocument.lastModifiedAtUtcIso instanceof Date ? queryDocument.lastModifiedAtUtcIso.toUTCString() : queryDocument.lastModifiedAtUtcIso,
+		slug: queryDocument.slug ?? ""
+	};
+}
+function phDocumentStateFromQuery(queryDocument, documentSchema) {
+	if (documentSchema !== void 0) return documentSchema.shape.state.parse(queryDocument.state);
+	return queryDocument.state;
+}
+function phDocumentOperationsFromGetDocumentWithOperationsQuery(queryDocument) {
+	if (queryDocument.operations === null || queryDocument.operations === void 0) return { global: [] };
+	return { global: [...queryDocument.operations.items] };
+}
+function identifierFromMutateDocumentOperationVariables(variables) {
+	return z.object({ documentIdentifier: z.string() }).parse(variables).documentIdentifier;
+}
+//#endregion
+//#region src/graphql/constants.ts
+const DEFAULT_DRIVE_ID = "powerhouse";
+const DEFAULT_SWITCHBOARD_URL = "http://localhost:4001/graphql";
+const graphqlEventsToSyncDrive = [
+	"CreateEmptyDocument",
+	"CreateDocument",
+	"AddChildren",
+	"RemoveChildren",
+	"MoveChildren",
+	"DeleteDocument",
+	"DeleteDocuments"
+];
+const graphqlDocumentEvents = [
+	"MutateDocument",
+	"MutateDocumentAsync",
+	"DeleteDocument"
+];
+const graphqlDocumentsEvents = ["DeleteDocuments"];
+//#endregion
+//#region src/graphql/fetchers.ts
+async function reactorGraphqlFetchDocument(identifier, documentSchema) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	try {
+		const document = (await client.GetDocument({ identifier })).document?.document;
+		if (!document) return void 0;
+		return phDocumentFromQuery(document, documentSchema);
+	} catch (error) {
+		return;
+	}
+}
+async function reactorGraphqlBatchFetchDocuments(identifiers) {
+	if (!window.ph?.reactorGraphQLClient) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	const promises = map(identifiers, (identifier) => reactorGraphqlFetchDocument(identifier));
+	return await Promise.all(promises);
+}
+//#endregion
+//#region src/graphql/batch.ts
+/**
+* A reference implementation for an async batching utility function built on
+* top of the `funnel` general purpose execution utility function. It will
+* accumulate all params passed to an async `call` method within the defined
+* burst duration and then use an async executor to process them in one
+* invocation. It then extracts an individual result for each call which is
+* used to resolve the original call.
+*
+* This allows synchronizing multiple async calls while keeping each call site
+* isolated from the rest (for example, as react components).
+*
+* This reference implementation can be copied into your project as-is, or you
+* can use it as the basis for a more complex implementation with additional
+* features.
+*
+* @param callback - The main function that takes a batch and returns an
+* aggregated response. The typing for the it's parameters will derive the
+* typing for the extractor and the `call` method.
+* @param extractor - A function that takes the aggregated response and extracts
+* from it the result for each individual call. The function is called with both
+* the index in the batch, and the params passed to the `call` method. This
+* allows handling APIs that return batch results as both objects and arrays.
+* @param maxBurstDurationMs - The period of time where the batcher would
+* collect params before triggering the executor. When set to 0 the batcher
+* does not incur any additional delays to the execution and would trigger at
+* the next tick, just like a regular async function would. This is also the
+* default value.
+* @returns A Funnel object with the `call` method augmented to support async
+* response.
+*/
+function batch(callback, extractor, maxBurstDurationMs = 0) {
+	const batchFunnel = funnel((requests) => {
+		callback(requests.map(({ params }) => params)).then((response) => {
+			for (const [index, { params, promiseCallbacks: [resolve, reject] }] of requests.entries()) try {
+				resolve(extractor(response, index, ...params));
+			} catch (error) {
+				reject(error);
+			}
+		}).catch((error) => {
+			for (const { promiseCallbacks: [, reject] } of requests) reject(error);
+		});
+	}, {
+		reducer: (requests, request) => [...requests ?? [], request],
+		maxBurstDurationMs,
+		triggerAt: "end"
+	});
+	return {
+		...batchFunnel,
+		call: (...params) => new Promise((...promiseCallbacks) => {
+			batchFunnel.call({
+				promiseCallbacks,
+				params
+			});
+		})
+	};
+}
+//#endregion
+//#region src/graphql/document-fetcher.ts
+function makeDocumentsById(documents = []) {
+	return pipe(documents, filter(isTruthy), mapToObj((document) => [document.header.id, document]));
+}
+var DocumentFetcher = class {
+	batchGetDocuments;
+	constructor() {
+		this.batchGetDocuments = batch(async (requests) => {
+			return makeDocumentsById(await reactorGraphqlBatchFetchDocuments(unique(map(requests, ([id]) => id))));
+		}, (documentsById, _, id) => {
+			return prop(documentsById, id);
+		});
+	}
+	get(id) {
+		return this.batchGetDocuments.call(id);
+	}
+	getBatch(ids) {
+		return Promise.all(map(ids, (id) => this.get(id)));
+	}
+};
+//#endregion
+//#region src/graphql/graphql-client-document-cache.ts
+var GraphQLClientDocumentCache = class {
+	fetcher;
+	documents = /* @__PURE__ */ new Map();
+	batchPromises = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Map();
+	constructor() {
+		this.fetcher = new DocumentFetcher();
+		window.addEventListener("MutateDocument", (event) => {
+			this.handleDocumentMutated(event.detail.identifier).catch(console.error);
+		});
+		window.addEventListener("MutateDocumentAsync", (event) => {
+			this.handleDocumentMutated(event.detail.identifier).catch(console.error);
+		});
+	}
+	get(id, refetch) {
+		const current = this.documents.get(id);
+		if (current) {
+			if (current.status === "pending") return current;
+			if (!refetch) return current;
+		}
+		const promise = addPromiseState(this.fetcher.get(id).then((document) => {
+			this.invalidateBatchesContaining(id);
+			return document;
+		}));
+		this.documents.set(id, promise);
+		return promise;
+	}
+	getBatch(ids) {
+		const key = ids.join(",");
+		const cached = this.batchPromises.get(key);
+		const currentPromises = ids.map((id) => this.get(id));
+		if (cached) {
+			if (currentPromises.every((promise, index) => promise === cached.promises[index])) return cached.promise;
+		}
+		const states = currentPromises.map((promise) => readPromiseState(promise));
+		if (states.every((state) => state.status === "fulfilled")) {
+			const values = states.map((state) => state.value);
+			const batchPromise = Promise.resolve(values);
+			batchPromise.status = "fulfilled";
+			batchPromise.value = values;
+			this.batchPromises.set(key, {
+				promises: currentPromises,
+				promise: batchPromise
+			});
+			return batchPromise;
+		}
+		const batchPromise = addPromiseState(Promise.all(currentPromises));
+		this.batchPromises.set(key, {
+			promises: currentPromises,
+			promise: batchPromise
+		});
+		return batchPromise;
+	}
+	invalidateBatchesContaining(documentId) {
+		for (const key of this.batchPromises.keys()) if (key.split(",").includes(documentId)) this.batchPromises.delete(key);
+	}
+	subscribe(id, callback) {
+		const ids = Array.isArray(id) ? id : [id];
+		for (const documentId of ids) {
+			const listeners = this.listeners.get(documentId) ?? [];
+			this.listeners.set(documentId, [...listeners, callback]);
+		}
+		return () => {
+			for (const documentId of ids) {
+				const listeners = this.listeners.get(documentId) ?? [];
+				this.listeners.set(documentId, listeners.filter((listener) => listener !== callback));
+			}
+		};
+	}
+	notify(id) {
+		const listeners = this.listeners.get(id) ?? [];
+		for (const listener of listeners) listener();
+	}
+	async handleDocumentMutated(id) {
+		this.invalidateBatchesContaining(id);
+		await this.get(id);
+		this.notify(id);
+	}
+	handleDocumentDeleted(id) {
+		this.documents.delete(id);
+		this.invalidateBatchesContaining(id);
+		this.notify(id);
+	}
+	handleDocumentsDeleted(ids) {
+		forEach(ids, (id) => this.handleDocumentDeleted(id));
+	}
+};
+//#endregion
+//#region src/graphql/mutators.ts
+async function reactorGraphqlCreateDocument(document, parentIdentifier = DEFAULT_DRIVE_ID) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.CreateDocument({
+		document,
+		parentIdentifier
+	});
+}
+async function reactorGraphqlDeleteDocument(identifier) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.DeleteDocument({ identifier });
+}
+async function reactorGraphqlDeleteDocuments(identifiers) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.DeleteDocuments({ identifiers });
+}
+async function reactorGraphqlMutateDocument(documentIdentifier, ...actions) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	return await client.MutateDocument({
+		documentIdentifier,
+		actions
+	});
+}
+//#endregion
 //#region src/hooks/config/editor.ts
 const isExternalControlsEnabledEventFunctions = makePHEventFunctions("isExternalControlsEnabled");
 /** Sets whether external controls are enabled for a given editor. */
@@ -807,12 +1080,6 @@ const useFeatures = featuresEventFunctions.useValue;
 const setFeatures = featuresEventFunctions.setValue;
 const addFeaturesEventHandler = featuresEventFunctions.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/drives.ts
 const drivesEventFunctions = makePHEventFunctions("drives");
 /** Returns all of the drives in the reactor */
@@ -822,6 +1089,12 @@ const setDrives = drivesEventFunctions.setValue;
 /** Adds an event handler for the drives */
 const addDrivesEventHandler = drivesEventFunctions.addEventHandler;
 //#endregion
+//#region src/hooks/graphql-reactor-client.ts
+const graphQLReactorClientEventFunctions = makePHEventFunctions("reactorGraphQLClient");
+const useGraphQLReactorClient = graphQLReactorClientEventFunctions.useValue;
+const setGraphQLReactorClient = graphQLReactorClientEventFunctions.setValue;
+const addGraphQLReactorClientEventHandler = graphQLReactorClientEventFunctions.addEventHandler;
+//#endregion
 //#region src/hooks/modals.ts
 const modalEventFunctions = makePHEventFunctions("modal");
 /** Returns the current modal */
@@ -853,6 +1126,12 @@ function showDeleteNodeModal(nodeOrId) {
 	});
 }
 //#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");
@@ -1158,15 +1437,9 @@ function updateReactorClientUpgradeManifests(packages) {
 }
 //#endregion
 //#region src/hooks/add-ph-event-handlers.ts
-const phGlobalEventHandlerRegisterFunctions = {
+const commonGlobalEventHandlerFunctions = {
 	loading: addLoadingEventHandler,
-	reactorClientModule: addReactorClientModuleEventHandler,
-	reactorClient: addReactorClientEventHandler,
-	features: addFeaturesEventHandler,
-	modal: addModalEventHandler,
-	renown: addRenownEventHandler,
 	drives: addDrivesEventHandler,
-	documentCache: addDocumentCacheEventHandler,
 	selectedDriveId: () => {
 		addSelectedDriveIdEventHandler();
 		addSetSelectedDriveOnPopStateEventHandler();
@@ -1176,6 +1449,16 @@ const phGlobalEventHandlerRegisterFunctions = {
 		addSelectedNodeIdEventHandler();
 		addSetSelectedNodeOnPopStateEventHandler();
 	},
+	documentCache: addDocumentCacheEventHandler,
+	reactorGraphQLClient: addGraphQLReactorClientEventHandler
+};
+const phGlobalEventHandlerRegisterFunctions = {
+	...commonGlobalEventHandlerFunctions,
+	reactorClientModule: addReactorClientModuleEventHandler,
+	reactorClient: addReactorClientEventHandler,
+	features: addFeaturesEventHandler,
+	modal: addModalEventHandler,
+	renown: addRenownEventHandler,
 	vetraPackageManager: addVetraPackageManagerEventHandler,
 	packageDiscoveryService: addPackageDiscoveryServiceEventHandler,
 	selectedTimelineRevision: addSelectedTimelineRevisionEventHandler,
@@ -1233,7 +1516,10 @@ const phGlobalEventHandlerRegisterFunctions = {
 	toast: addToastEventHandler
 };
 function addPHEventHandlers() {
-	for (const fn of Object.values(phGlobalEventHandlerRegisterFunctions)) fn();
+	callEventHandlerRegisterFunctions(phGlobalEventHandlerRegisterFunctions);
+}
+function callEventHandlerRegisterFunctions(registerFunctions) {
+	forEachObj(registerFunctions, (fn) => fn());
 }
 //#endregion
 //#region src/hooks/document-model-modules.ts
@@ -1583,6 +1869,61 @@ function useFolderById(id) {
 	return useFolderNodesInSelectedDrive()?.find((n) => n.id === id);
 }
 //#endregion
+//#region src/graphql/events.ts
+function dispatchGraphQLClientDocumentEvent(operationName, identifier) {
+	const event = new CustomEvent(operationName, { detail: { identifier } });
+	window.dispatchEvent(event);
+}
+//#endregion
+//#region src/graphql/document-cache-client-middleware.ts
+const documentCacheClientMiddleware = async (action, operationName, operationType, variables) => {
+	console.log({
+		operationName,
+		operationType,
+		variables
+	});
+	const result = await action();
+	if (isIncludedIn(operationName, graphqlEventsToSyncDrive)) window.dispatchEvent(new CustomEvent(operationName));
+	if (isStrictEqual(operationName, "MutateDocument")) dispatchGraphQLClientDocumentEvent(operationName, identifierFromMutateDocumentOperationVariables(variables));
+	return result;
+};
+//#endregion
+//#region src/hooks/init-graphql-reactor-client.ts
+function useInitReactorGraphqlClient(switchboardUrl = DEFAULT_SWITCHBOARD_URL, driveId = DEFAULT_DRIVE_ID) {
+	const [hasInit, setHasInit] = useState(false);
+	useEffect(() => {
+		if (hasInit) return;
+		initGraphQLReactorClientWithDocumentCache(switchboardUrl, driveId).then(() => setHasInit(true)).catch(console.error);
+	}, [hasInit]);
+	return hasInit;
+}
+async function reactorGraphqlFetchDrive(identifier) {
+	const client = window.ph?.reactorGraphQLClient;
+	if (!client) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	const result = await client.GetDocument({ identifier });
+	if (!result.document?.document) throw new Error("Could not fetch drive with id: " + identifier);
+	return phDocumentFromQuery(result.document.document, DriveDocumentSchema);
+}
+async function reactorGraphqlSyncDrive(driveId) {
+	if (!window.ph?.reactorGraphQLClient) throw new Error("Please call `useInitReactorGraphqlClient` to use its functions");
+	const drive = await reactorGraphqlFetchDrive(driveId);
+	setDrives([drive]);
+	setSelectedDrive(drive);
+}
+async function initGraphQLReactorClientWithDocumentCache(switchboardUrl, driveId) {
+	if (!window.ph) window.ph = {};
+	callEventHandlerRegisterFunctions(commonGlobalEventHandlerFunctions);
+	setGraphQLReactorClient(createClient(switchboardUrl, documentCacheClientMiddleware));
+	await reactorGraphqlSyncDrive(driveId);
+	setSelectedNode(void 0);
+	setDocumentCache(new GraphQLClientDocumentCache());
+	forEach(graphqlEventsToSyncDrive, (name) => {
+		window.addEventListener(name, () => {
+			reactorGraphqlSyncDrive(driveId).catch(console.error);
+		});
+	});
+}
+//#endregion
 //#region src/hooks/items-in-selected-folder.ts
 /** Returns the nodes in the selected folder. */
 function useNodesInSelectedFolder() {
@@ -1751,6 +2092,74 @@ function useSubgraphModules() {
 	return useVetraPackages().flatMap((pkg) => pkg.subgraphs || []);
 }
 //#endregion
+//#region src/hooks/use-drive-system-info.ts
+function deriveSystemUrl(channelUrl) {
+	try {
+		const url = new URL(channelUrl);
+		url.pathname = "/graphql/system";
+		url.search = "";
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+const cache = /* @__PURE__ */ new Map();
+function useDriveSystemInfo(drive) {
+	const remotes = useSyncList();
+	const driveId = drive?.header.id;
+	const systemUrl = useMemo(() => {
+		if (!driveId) return null;
+		const channelUrl = (remotes.find((r) => r.collectionId === driveCollectionId$1("main", driveId))?.channel)?.config.url;
+		if (typeof channelUrl !== "string") return null;
+		return deriveSystemUrl(channelUrl);
+	}, [remotes, driveId]);
+	const [state, setState] = useState(() => systemUrl ? cache.get(systemUrl) ?? { status: "loading" } : { status: "local" });
+	useEffect(() => {
+		if (!systemUrl) {
+			setState({ status: "local" });
+			return;
+		}
+		const cached = cache.get(systemUrl);
+		if (cached && cached.status !== "loading") {
+			setState(cached);
+			return;
+		}
+		setState({ status: "loading" });
+		cache.set(systemUrl, { status: "loading" });
+		const controller = new AbortController();
+		fetch(systemUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ query: "{ system { version gitHash } }" }),
+			signal: controller.signal
+		}).then(async (res) => {
+			const json = await res.json();
+			if (json.errors?.length) throw new Error(json.errors.map((e) => e.message).join("; "));
+			const sys = json.data?.system;
+			if (!sys) throw new Error("Missing system in response");
+			const next = {
+				status: "ready",
+				version: sys.version,
+				gitHash: sys.gitHash,
+				host: new URL(systemUrl).host
+			};
+			cache.set(systemUrl, next);
+			setState(next);
+		}).catch((err) => {
+			if (controller.signal.aborted) return;
+			const next = {
+				status: "error",
+				message: err instanceof Error ? err.message : String(err)
+			};
+			cache.set(systemUrl, next);
+			setState(next);
+		});
+		return () => controller.abort();
+	}, [systemUrl]);
+	return state;
+}
+//#endregion
 //#region src/utils/drives.ts
 const syncStatusToUI = {
 	[SyncStatus.Synced]: "SUCCESS",
@@ -1863,25 +2272,13 @@ function getSwitchboardGatewayUrlFromDriveUrl(driveUrl) {
 	return urlParts.join("/");
 }
 function getDocumentGraphqlQuery() {
-	return `query getDocument($documentId: String!) {
-  document(id: $documentId) {
-      id
-      documentType
-      createdAtUtcIso
-      lastModifiedAtUtcIso
-      name
-      revision
-      stateJSON
-    }
-  }`;
-}
-function buildDocumentSubgraphQuery(driveUrl, documentId, authToken) {
-	const driveSlug = getSlugFromDriveUrl(driveUrl);
+	const loc = GetDocumentWithOperationsDocument.loc;
+	if (!loc) throw new Error("GetDocumentWithOperationsDocument is misconfigured, loc is missing.");
+	return loc.source.body;
+}
+function buildDocumentSubgraphQuery(identifier, authToken) {
 	const query = getDocumentGraphqlQuery();
-	const variables = {
-		documentId,
-		driveId: driveSlug
-	};
+	const variables = { identifier };
 	const headers = authToken ? { Authorization: `Bearer ${authToken}` } : void 0;
 	const payload = {
 		document: query.trim(),
@@ -1890,8 +2287,8 @@ function buildDocumentSubgraphQuery(driveUrl, documentId, authToken) {
 	if (headers) payload.headers = JSON.stringify(headers);
 	return lzString.compressToEncodedURIComponent(JSON.stringify(payload));
 }
-function buildDocumentSubgraphUrl(driveUrl, documentId, authToken) {
-	return `${driveUrl}?explorerURLState=${buildDocumentSubgraphQuery(driveUrl, documentId, authToken)}`;
+function buildDocumentSubgraphUrl(driveUrl, identifier, authToken) {
+	return `${driveUrl}?explorerURLState=${buildDocumentSubgraphQuery(identifier, authToken)}`;
 }
 //#endregion
 //#region src/hooks/use-get-switchboard-link.ts
@@ -2843,6 +3240,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, DOMAIN_TYPE, DisconnectIcon, DocumentCache, DocumentChangeType, DocumentIntegrityService, GqlRequestChannel, ISSUER_TYPE, InMemoryQueue, IntervalPollTimer, PropagationMode, REACTOR_SCHEMA, RENOWN_CHAIN_ID, RENOWN_NETWORK_ID, RENOWN_URL, ReactorBuilder, ReactorClientBuilder, RegistryClient, RelationalDbProcessor, RemoteClient, RemoteDocumentController, Renown, RenownAuthButton, RenownLoginButton, RenownLogo, RenownUserButton, SpinnerIcon, SyncOperationStatus, UserIcon, VERIFIABLE_CREDENTIAL_EIP712_TYPE, addAllowListEventHandler, addAllowedDocumentTypesEventHandler, addAnalyticsDatabaseNameEventHandler, addBasePathEventHandler, addCliVersionEventHandler, addDefaultDrivesUrlEventHandler, addDisabledEditorsEventHandler, addDocument, addDocumentCacheEventHandler, addDrive, addDrivesEventHandler, addDrivesPreserveStrategyEventHandler, addEnabledEditorsEventHandler, addFeaturesEventHandler, addFileUploadOperationsChunkSizeEventHandler, addFolder, addGaTrackingIdEventHandler, 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, callGlobalSetterForKey, clearGlobal, closePHModal, convertRemoteOperations, createAnalyticsStore, createClient, createProcessorQuery, createUrlWithPreservedParams, deleteDrive, deleteNode, dispatchActions, driveCollectionId, driveIdFromUrl, dropAllReactorStorage, exportDocument, exportFile, extractDriveIdFromPath, extractDriveIdFromSlug, extractDriveSlugFromPath, extractNodeIdFromPath, extractNodeIdFromSlug, extractNodeSlugFromPath, findUuid, getAnalyticsStore, getDocumentGraphqlQuery, getDriveIdBySlug, getDrives, getGlobal, getPackages, getPackagesByDocumentType, getPathWithoutBase, getRevisionFromDate, getSlugFromDriveUrl, getSwitchboardGatewayUrlFromDriveUrl, getSyncStatus, getSyncStatusSync, getUserPermissions, hideRevisionHistory, initConnectCrypto, initRenownCrypto, isDocumentTypeSupported, isExternalControlsEnabledEventFunctions, isFileNodeKind, isFolderNodeKind, loading, login, logout, makeDriveUrlComponent, makeNodeSlug, makePHEventFunctions, openRenown, parseDriveUrl, phAppConfigHooks, phAppConfigSetters, phDocumentEditorConfigHooks, phDocumentEditorConfigSetters, phGlobalConfigHooks, phGlobalConfigSetters, readPromiseState, refreshReactorData, refreshReactorDataClient, renameDrive, renameDriveNode, resolveUrlPathname, setAllowList, setAllowedDocumentTypes, setAnalyticsDatabaseName, setBasePath, setCliVersion, setDefaultDrivesUrl, setDefaultPHGlobalConfig, setDisabledEditors, setDocumentCache, setDriveAvailableOffline, setDriveSharingType, setDrives, setDrivesPreserveStrategy, setEnabledEditors, setFeatures, setFileUploadOperationsChunkSize, setGaTrackingId, setGlobal, setIsAddCloudDrivesEnabled, setIsAddDriveEnabled, setIsAddLocalDrivesEnabled, setIsAddPublicDrivesEnabled, setIsAnalyticsDatabaseWorkerEnabled, setIsAnalyticsEnabled, setIsAnalyticsExternalProcessorsEnabled, setIsCloudDrivesEnabled, setIsDeleteCloudDrivesEnabled, setIsDeleteLocalDrivesEnabled, setIsDeletePublicDrivesEnabled, setIsDiffAnalyticsEnabled, setIsDocumentModelSelectionSettingsEnabled, setIsDragAndDropEnabled, setIsDriveAnalyticsEnabled, setIsEditorDebugModeEnabled, setIsEditorReadModeEnabled, setIsExternalControlsEnabled, setIsExternalPackagesEnabled, setIsExternalProcessorsEnabled, setIsExternalRelationalProcessorsEnabled, setIsLocalDrivesEnabled, setIsPublicDrivesEnabled, setIsRelationalProcessorsEnabled, setIsSentryTracingEnabled, setLoading, setLocalDrivesEnabled, setLogLevel, setPHAppConfig, setPHAppConfigByKey, setPHDocumentEditorConfig, setPHDocumentEditorConfigByKey, setPHGlobalConfig, setPHGlobalConfigByKey, setPHModal, setPHToast, setPackageDiscoveryService, setReactorClient, setReactorClientModule, setRenown, setRenownChainId, setRenownNetworkId, setRenownUrl, setRequiresHardRefresh, setRevisionHistoryVisible, setRouterBasename, setSelectedDrive, setSelectedNode, setSelectedTimelineItem, setSelectedTimelineRevision, setSentryDsn, setSentryEnv, setSentryRelease, setStudioMode, setVersion, setVersionCheckInterval, setVetraPackageManager, setWarnOutdatedApp, showCreateDocumentModal, showDeleteNodeModal, showPHModal, showRevisionHistory, sortNodesByName, truncateAllTables, useAllowList, useAllowedDocumentModelModules, useAllowedDocumentTypes, useAnalyticsDatabaseName, useAppModuleById, useAppModules, useBasePath, useCliVersion, useConnectionState, useConnectionStates, useDatabase, useDefaultAppModule, useDefaultDrivesUrl, useDid, useDisabledEditors, useDispatch, useDocument, useDocumentById, useDocumentCache, useDocumentModelModuleById, useDocumentModelModules, useDocumentOfType, useDocumentOperations, useDocumentTypes, useDocumentTypesInSelectedDrive, useDocuments, useDocumentsByIds, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useDriveById, useDrives, useDrivesPreserveStrategy, useEditorModuleById, useEditorModules, useEditorModulesForDocumentType, useEnabledEditors, useFallbackEditorModule, useFeatures, useFileNodesInSelectedDrive, useFileNodesInSelectedFolder, useFileUploadOperationsChunkSize, useFolderById, useFolderNodesInSelectedDrive, useFolderNodesInSelectedFolder, useGaTrackingId, useGetDocument, useGetDocumentAsync, useGetDocuments, useGetSwitchboardLink, useIsAddCloudDrivesEnabled, useIsAddDriveEnabled, useIsAddLocalDrivesEnabled, useIsAddPublicDrivesEnabled, useIsAnalyticsDatabaseWorkerEnabled, useIsAnalyticsEnabled, useIsAnalyticsExternalProcessorsEnabled, useIsCloudDrivesEnabled, useIsDeleteCloudDrivesEnabled, useIsDeleteLocalDrivesEnabled, useIsDeletePublicDrivesEnabled, useIsDiffAnalyticsEnabled, useIsDocumentModelSelectionSettingsEnabled, useIsDragAndDropEnabled, useIsDriveAnalyticsEnabled, useIsEditorDebugModeEnabled, useIsEditorReadModeEnabled, useIsExternalControlsEnabled, useIsExternalPackagesEnabled, useIsExternalProcessorsEnabled, useIsExternalRelationalProcessorsEnabled, useIsLocalDrivesEnabled, useIsPublicDrivesEnabled, useIsRelationalProcessorsEnabled, useIsSentryTracingEnabled, useLoading, useLocalDrivesEnabled, useLogLevel, useLoginStatus, useModelRegistry, useNodeActions, useNodeById, useNodeParentFolderById, useNodePathById, useNodesInSelectedDrive, useNodesInSelectedDriveOrFolder, useNodesInSelectedFolder, useOnDropFile, usePGlite, usePHAppConfigByKey, usePHDocumentEditorConfigByKey, usePHGlobalConfigByKey, usePHModal, usePHToast, usePackageDiscoveryService, useParentFolderForSelectedNode, useReactorClient, useReactorClientModule, useRelationalDb, useRelationalQuery, useRenown, useRenownAuth, useRenownChainId, useRenownInit, useRenownNetworkId, useRenownUrl, useRequiresHardRefresh, useResetPHGlobalConfig, useRevisionHistoryVisible, useRouterBasename, useSelectedDocument, useSelectedDocumentId, useSelectedDocumentOfType, useSelectedDocumentSafe, useSelectedDrive, useSelectedDriveId, useSelectedDriveSafe, useSelectedFolder, useSelectedNode, useSelectedNodePath, useSelectedTimelineItem, useSelectedTimelineRevision, useSentryDsn, useSentryEnv, useSentryRelease, useSetDefaultPHGlobalConfig, useSetPHAppConfig, useSetPHDocumentEditorConfig, useSetPHGlobalConfig, useStudioMode, useSubgraphModules, useSupportedDocumentTypesInReactor, useSync, useSyncList, useUser, useUserPermissions, useVersion, useVersionCheckInterval, useVetraPackageManager, useVetraPackages, useWarnOutdatedApp, validateDocument };
+export { ActionTracker, BaseStorage, BrowserLocalStorage, COMMON_PACKAGE_ID, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, ChannelScheme, ChevronDownIcon, ConflictError, CopyIcon, DEFAULT_DRIVE_EDITOR_ID, DEFAULT_DRIVE_ID, DEFAULT_SWITCHBOARD_URL, DOMAIN_TYPE, DisconnectIcon, DocumentCache, DocumentChangeType, DocumentIntegrityService, GqlRequestChannel, GraphQLClientDocumentCache, ISSUER_TYPE, InMemoryQueue, IntervalPollTimer, PropagationMode, REACTOR_SCHEMA, RENOWN_CHAIN_ID, RENOWN_NETWORK_ID, RENOWN_URL, ReactorBuilder, ReactorClientBuilder, RegistryClient, RelationalDbProcessor, RemoteClient, RemoteDocumentController, Renown, RenownAuthButton, RenownLoginButton, RenownLogo, RenownUserButton, SpinnerIcon, SyncOperationStatus, UserIcon, VERIFIABLE_CREDENTIAL_EIP712_TYPE, addAllowListEventHandler, addAllowedDocumentTypesEventHandler, addAnalyticsDatabaseNameEventHandler, addBasePathEventHandler, addCliVersionEventHandler, addDefaultDrivesUrlEventHandler, addDisabledEditorsEventHandler, addDocument, addDocumentCacheEventHandler, addDrive, addDrivesEventHandler, addDrivesPreserveStrategyEventHandler, addEnabledEditorsEventHandler, addFeaturesEventHandler, addFileUploadOperationsChunkSizeEventHandler, addFolder, addGaTrackingIdEventHandler, addGraphQLReactorClientEventHandler, addIsAddCloudDrivesEnabledEventHandler, addIsAddDriveEnabledEventHandler, addIsAddLocalDrivesEnabledEventHandler, addIsAddPublicDrivesEnabledEventHandler, addIsAnalyticsDatabaseWorkerEnabledEventHandler, addIsAnalyticsEnabledEventHandler, addIsAnalyticsExternalProcessorsEnabledEventHandler, addIsCloudDrivesEnabledEventHandler, addIsDeleteCloudDrivesEnabledEventHandler, addIsDeleteLocalDrivesEnabledEventHandler, addIsDeletePublicDrivesEnabledEventHandler, addIsDiffAnalyticsEnabledEventHandler, addIsDocumentModelSelectionSettingsEnabledEventHandler, addIsDragAndDropEnabledEventHandler, addIsDriveAnalyticsEnabledEventHandler, addIsEditorDebugModeEnabledEventHandler, addIsEditorReadModeEnabledEventHandler, addIsExternalControlsEnabledEventHandler, addIsExternalPackagesEnabledEventHandler, addIsExternalProcessorsEnabledEventHandler, addIsExternalRelationalProcessorsEnabledEventHandler, addIsLocalDrivesEnabledEventHandler, addIsPublicDrivesEnabledEventHandler, addIsRelationalProcessorsEnabledEventHandler, addIsSentryTracingEnabledEventHandler, addLoadingEventHandler, addLocalDrivesEnabledEventHandler, addLogLevelEventHandler, addModalEventHandler, addPHEventHandlers, addPackageDiscoveryServiceEventHandler, addPromiseState, addReactorClientEventHandler, addReactorClientModuleEventHandler, addRemoteDrive, addRenownChainIdEventHandler, addRenownEventHandler, addRenownNetworkIdEventHandler, addRenownUrlEventHandler, addRequiresHardRefreshEventHandler, addResetSelectedNodeEventHandler, addRevisionHistoryVisibleEventHandler, addRouterBasenameEventHandler, addSelectedDriveIdEventHandler, addSelectedNodeIdEventHandler, addSelectedTimelineItemEventHandler, addSelectedTimelineRevisionEventHandler, addSentryDsnEventHandler, addSentryEnvEventHandler, addSentryReleaseEventHandler, addSetSelectedDriveOnPopStateEventHandler, addSetSelectedNodeOnPopStateEventHandler, addStudioModeEventHandler, addToastEventHandler, addVersionCheckIntervalEventHandler, addVersionEventHandler, addVetraPackageManagerEventHandler, addWarnOutdatedAppEventHandler, baseDocumentModels, baseDocumentModelsMap, buildDocumentSubgraphQuery, buildDocumentSubgraphUrl, callEventHandlerRegisterFunctions, callGlobalSetterForKey, clearGlobal, closePHModal, commonGlobalEventHandlerFunctions, convertRemoteOperations, createAnalyticsStore, createClient, createProcessorQuery, createUrlWithPreservedParams, deleteDrive, deleteNode, deriveSystemUrl, dispatchActions, driveCollectionId, driveIdFromUrl, dropAllReactorStorage, exportDocument, exportFile, extractDriveIdFromPath, extractDriveIdFromSlug, extractDriveSlugFromPath, extractNodeIdFromPath, extractNodeIdFromSlug, extractNodeSlugFromPath, findUuid, getAnalyticsStore, getDocumentGraphqlQuery, getDriveIdBySlug, getDrives, getGlobal, getPackages, getPackagesByDocumentType, getPathWithoutBase, getRevisionFromDate, getSlugFromDriveUrl, getSwitchboardGatewayUrlFromDriveUrl, getSyncStatus, getSyncStatusSync, getUserPermissions, graphqlDocumentEvents, graphqlDocumentsEvents, graphqlEventsToSyncDrive, hideRevisionHistory, identifierFromMutateDocumentOperationVariables, initConnectCrypto, initRenownCrypto, isDocumentTypeSupported, isExternalControlsEnabledEventFunctions, isFileNodeKind, isFolderNodeKind, loading, login, logout, makeDriveUrlComponent, makeNodeSlug, makePHEventFunctions, openRenown, parseDriveUrl, phAppConfigHooks, phAppConfigSetters, phDocumentEditorConfigHooks, phDocumentEditorConfigSetters, phDocumentFromQuery, phDocumentsFromQuery, phGlobalConfigHooks, phGlobalConfigSetters, reactorGraphqlBatchFetchDocuments, reactorGraphqlCreateDocument, reactorGraphqlDeleteDocument, reactorGraphqlDeleteDocuments, reactorGraphqlFetchDocument, reactorGraphqlMutateDocument, readPromiseState, refreshReactorData, refreshReactorDataClient, renameDrive, renameDriveNode, resolveUrlPathname, setAllowList, setAllowedDocumentTypes, setAnalyticsDatabaseName, setBasePath, setCliVersion, setDefaultDrivesUrl, setDefaultPHGlobalConfig, setDisabledEditors, setDocumentCache, setDriveAvailableOffline, setDriveSharingType, setDrives, setDrivesPreserveStrategy, setEnabledEditors, setFeatures, setFileUploadOperationsChunkSize, setGaTrackingId, setGlobal, setGraphQLReactorClient, setIsAddCloudDrivesEnabled, setIsAddDriveEnabled, setIsAddLocalDrivesEnabled, setIsAddPublicDrivesEnabled, setIsAnalyticsDatabaseWorkerEnabled, setIsAnalyticsEnabled, setIsAnalyticsExternalProcessorsEnabled, setIsCloudDrivesEnabled, setIsDeleteCloudDrivesEnabled, setIsDeleteLocalDrivesEnabled, setIsDeletePublicDrivesEnabled, setIsDiffAnalyticsEnabled, setIsDocumentModelSelectionSettingsEnabled, setIsDragAndDropEnabled, setIsDriveAnalyticsEnabled, setIsEditorDebugModeEnabled, setIsEditorReadModeEnabled, setIsExternalControlsEnabled, setIsExternalPackagesEnabled, setIsExternalProcessorsEnabled, setIsExternalRelationalProcessorsEnabled, setIsLocalDrivesEnabled, setIsPublicDrivesEnabled, setIsRelationalProcessorsEnabled, setIsSentryTracingEnabled, setLoading, setLocalDrivesEnabled, setLogLevel, setPHAppConfig, setPHAppConfigByKey, setPHDocumentEditorConfig, setPHDocumentEditorConfigByKey, setPHGlobalConfig, setPHGlobalConfigByKey, setPHModal, setPHToast, setPackageDiscoveryService, setReactorClient, setReactorClientModule, setRenown, setRenownChainId, setRenownNetworkId, setRenownUrl, setRequiresHardRefresh, setRevisionHistoryVisible, setRouterBasename, setSelectedDrive, setSelectedDriveId, setSelectedNode, setSelectedTimelineItem, setSelectedTimelineRevision, setSentryDsn, setSentryEnv, setSentryRelease, setStudioMode, setVersion, setVersionCheckInterval, setVetraPackageManager, setWarnOutdatedApp, showCreateDocumentModal, showDeleteNodeModal, showPHModal, showRevisionHistory, sortNodesByName, truncateAllTables, useAllowList, useAllowedDocumentModelModules, useAllowedDocumentTypes, useAnalyticsDatabaseName, useAppModuleById, useAppModules, useBasePath, useCliVersion, useConnectionState, useConnectionStates, useDatabase, useDefaultAppModule, useDefaultDrivesUrl, useDid, useDisabledEditors, useDispatch, useDocument, useDocumentById, useDocumentCache, useDocumentModelModuleById, useDocumentModelModules, useDocumentOfType, useDocumentOperations, useDocumentTypes, useDocumentTypesInSelectedDrive, useDocuments, useDocumentsByIds, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useDriveById, useDriveSystemInfo, useDrives, useDrivesPreserveStrategy, useEditorModuleById, useEditorModules, useEditorModulesForDocumentType, useEnabledEditors, useFallbackEditorModule, useFeatures, useFileNodesInSelectedDrive, useFileNodesInSelectedFolder, useFileUploadOperationsChunkSize, useFolderById, useFolderNodesInSelectedDrive, useFolderNodesInSelectedFolder, useGaTrackingId, useGetDocument, useGetDocumentAsync, useGetDocuments, useGetSwitchboardLink, useGraphQLReactorClient, useInitReactorGraphqlClient, useIsAddCloudDrivesEnabled, useIsAddDriveEnabled, useIsAddLocalDrivesEnabled, useIsAddPublicDrivesEnabled, useIsAnalyticsDatabaseWorkerEnabled, useIsAnalyticsEnabled, useIsAnalyticsExternalProcessorsEnabled, useIsCloudDrivesEnabled, useIsDeleteCloudDrivesEnabled, useIsDeleteLocalDrivesEnabled, useIsDeletePublicDrivesEnabled, useIsDiffAnalyticsEnabled, useIsDocumentModelSelectionSettingsEnabled, useIsDragAndDropEnabled, useIsDriveAnalyticsEnabled, useIsEditorDebugModeEnabled, useIsEditorReadModeEnabled, useIsExternalControlsEnabled, useIsExternalPackagesEnabled, useIsExternalProcessorsEnabled, useIsExternalRelationalProcessorsEnabled, useIsLocalDrivesEnabled, useIsPublicDrivesEnabled, useIsRelationalProcessorsEnabled, useIsSentryTracingEnabled, useLoading, useLocalDrivesEnabled, useLogLevel, useLoginStatus, useModelRegistry, useNodeActions, useNodeById, useNodeParentFolderById, useNodePathById, useNodesInSelectedDrive, useNodesInSelectedDriveOrFolder, useNodesInSelectedFolder, useOnDropFile, usePGlite, usePHAppConfigByKey, usePHDocumentEditorConfigByKey, usePHGlobalConfigByKey, usePHModal, usePHToast, usePackageDiscoveryService, useParentFolderForSelectedNode, useReactorClient, useReactorClientModule, useRelationalDb, useRelationalQuery, useRenown, useRenownAuth, useRenownChainId, useRenownInit, useRenownNetworkId, useRenownUrl, useRequiresHardRefresh, useResetPHGlobalConfig, useRevisionHistoryVisible, useRouterBasename, useSelectedDocument, useSelectedDocumentId, useSelectedDocumentOfType, useSelectedDocumentSafe, useSelectedDrive, useSelectedDriveId, useSelectedDriveSafe, useSelectedFolder, useSelectedNode, useSelectedNodePath, useSelectedTimelineItem, useSelectedTimelineRevision, useSentryDsn, useSentryEnv, useSentryRelease, useSetDefaultPHGlobalConfig, useSetPHAppConfig, useSetPHDocumentEditorConfig, useSetPHGlobalConfig, useStudioMode, useSubgraphModules, useSupportedDocumentTypesInReactor, useSync, useSyncList, useUser, useUserPermissions, useVersion, useVersionCheckInterval, useVetraPackageManager, useVetraPackages, useWarnOutdatedApp, validateDocument };
 
 //# sourceMappingURL=index.js.map