@powerhousedao/reactor-browser 6.2.2-dev.6 → 6.2.2-dev.61

package/dist/document-operations-C6nce9dH.js

@@ -0,0 +1,2928 @@
+import { S as uploadOperations, _ as isDuplicateManifestError, a as setDocumentCache, b as queueActions, g as DOCUMENT_CHANGE_TYPE, i as addDocumentCacheEventHandler, n as useDocumentsByIds, p as DocumentCache, r as useDispatch, v as isDuplicateModuleError, x as queueOperations } from "./document-by-id-BSZqTN66.js";
+import { t as makePHEventFunctions } from "./make-ph-event-functions-DBq3iWYn.js";
+import { a as PhDocumentFieldsFragmentDoc, n as DocumentChangeType, o as PropagationMode, r as DocumentChangesDocument, t as createClient$1 } from "./client-DB8gP4hz.js";
+import { f as addLoadingEventHandler, t as addRenownEventHandler } from "./renown-BZabzj4l.js";
+import { logger } from "document-model";
+import { UnsupportedDocumentModelVersionError, assertAuthPreservedOnDuplicate, baseLoadFromInput, baseLoadFromInputVersioned, baseSaveToFileHandle, createPresignedHeader, createZip, deserializeSignature, documentModelDocumentType, generateId, hashDocumentStateForScope, normalizeDocumentModelVersion, replayDocumentVersioned, setName, toTransportAction } from "@powerhousedao/shared/document-model";
+import { addFolder, copyNode, generateNodesCopy, handleTargetNameCollisions, isFileNode, isFolderNode, moveNode, updateNode } from "@powerhousedao/shared/document-drive";
+import { allPass, conditional, constant, forEachObj, funnel, isDefined, isNot, isStrictEqual, isString, isTruthy, once } from "remeda";
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { GraphQLClient } from "graphql-request";
+import { gql } from "graphql-tag";
+import { Kind, print } from "graphql";
+import { createClient } from "graphql-ws/client";
+import slug from "slug";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#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 DocumentNotFoundError = class extends Error {
+	constructor(documentId) {
+		super(`Document with id ${documentId} not found`);
+	}
+};
+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/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, documentModelVersion) {
+	setPHModal({
+		type: "createDocument",
+		documentType,
+		...documentModelVersion !== void 0 && { documentModelVersion }
+	});
+}
+/** Shows the delete node modal */
+function showDeleteNodeModal(nodeOrId) {
+	setPHModal({
+		type: "deleteItem",
+		id: typeof nodeOrId === "string" ? nodeOrId : nodeOrId.id
+	});
+}
+//#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 NON_DOMAIN_SCOPES = new Set(["auth", "document"]);
+async function isDocumentInLocation(document, driveId, parentFolder) {
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) return { isDuplicate: false };
+	let drive;
+	try {
+		drive = await reactorClient.get(driveId);
+	} catch {
+		return { isDuplicate: false };
+	}
+	const nodeById = drive.state.global.nodes.find((node) => node.id === document.header.id);
+	if (nodeById && nodeById.parentFolder === (parentFolder ?? null)) return {
+		isDuplicate: true,
+		duplicateType: "id",
+		nodeId: nodeById.id
+	};
+	const nodeByNameAndType = drive.state.global.nodes.find((node) => isFileNode(node) && node.name === document.header.name && node.documentType === document.header.documentType && node.parentFolder === (parentFolder ?? null));
+	if (nodeByNameAndType) return {
+		isDuplicate: true,
+		duplicateType: "name",
+		nodeId: nodeByNameAndType.id
+	};
+	return { isDuplicate: false };
+}
+function getDocumentTypeIcon(document) {
+	switch (document.header.documentType) {
+		case "powerhouse/document-model": return "document-model";
+		case "powerhouse/app": return "app";
+		case "powerhouse/document-editor": return "editor";
+		case "powerhouse/subgraph": return "subgraph";
+		case "powerhouse/package": return "package";
+		case "powerhouse/processor": {
+			const processorType = document.state.global?.type;
+			if (processorType === "analytics") return "analytics-processor";
+			if (processorType === "relational") return "relational-processor";
+			if (processorType === "codegen") return "codegen-processor";
+			return;
+		}
+		default: return;
+	}
+}
+async function downloadFile(document, fileName) {
+	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?.reactorClientModule?.client;
+		if (reactorClient) {
+			const { results: documentModelModules } = await reactorClient.getDocumentModelModules();
+			rawExtension = documentModelModules.find((m) => m.documentModel.global.id === documentType)?.utils.fileExtension;
+		}
+	}
+	return (rawExtension ?? "").replace(/^\.+|\.+$/g, "");
+}
+/**
+* Fetches all operations for a document using cursor-based pagination.
+* The reactor client handles multi-scope cursors transparently via
+* composite cursors, so all scopes are fetched in a single paginated stream.
+*/
+async function fetchDocumentOperations(reactorClient, document, pageSize = 100) {
+	const scopes = Object.keys(document.state);
+	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)));
+}
+function countOperations(operations) {
+	let total = 0;
+	for (const ops of Object.values(operations)) total += ops?.length ?? 0;
+	return total;
+}
+/**
+* Split an imported document's domain operations at its mid-history upgrade
+* boundaries, so the caller can re-dispatch each upgrade between segments.
+*
+* The seed's CREATE_DOCUMENT and 0 -> N upgrade are replayed by the creation
+* path and must not be repeated. A later upgrade must be: it is where the
+* reducer version changes, and dropping it replays everything after it through
+* the module the document was created with.
+*/
+function splitAtUpgradeBoundaries(operations) {
+	const upgrades = (operations.document ?? []).filter((op) => op.action.type === "UPGRADE_DOCUMENT").filter((op) => op.action.input.fromVersion > 0).sort((a, b) => a.index - b.index);
+	const domain = filterDomainOperations(operations);
+	if (upgrades.length === 0) return [{ operations: domain }];
+	const segments = [];
+	const consumed = /* @__PURE__ */ new Map();
+	const take = (until) => {
+		const slice = {};
+		for (const [scope, ops] of Object.entries(domain)) {
+			if (!ops) continue;
+			const from = consumed.get(scope) ?? 0;
+			const stop = Math.max(from, until(scope, ops));
+			const chunk = ops.slice(from, stop);
+			if (chunk.length > 0) slice[scope] = chunk;
+			consumed.set(scope, stop);
+		}
+		return slice;
+	};
+	for (const upgrade of upgrades) {
+		const input = upgrade.action.input;
+		const slice = take((scope, ops) => boundary(upgrade, scope, ops));
+		segments.push({
+			operations: slice,
+			upgradeTo: input.toVersion
+		});
+	}
+	const tail = take((_scope, ops) => ops.length);
+	if (countOperations(tail) > 0) segments.push({ operations: tail });
+	return segments;
+}
+/**
+* How many of a scope's operations precede an upgrade. Must stay identical to
+* the boundary computation in `replayDocumentVersioned` — snapshots compare
+* against operation indices, not array positions, and the timestamp fallback
+* excludes the upgrade's own instant.
+*/
+function boundary(upgrade, scope, ops) {
+	const snapshot = upgrade.action.input.revision;
+	if (snapshot !== void 0) {
+		const revision = snapshot[scope] ?? 0;
+		let count = 0;
+		for (let i = 0; i < ops.length; i++) if (ops[i].index < revision) count = i + 1;
+		return count;
+	}
+	for (let i = 0; i < ops.length; i++) if (ops[i].timestampUtcMs >= upgrade.timestampUtcMs) return i;
+	return ops.length;
+}
+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;
+	}
+}
+/**
+* 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.
+*/
+async function loadFile(path) {
+	const baseDocument = await baseLoadFromInput(path, (state) => state, { checkHashes: true });
+	const reactorClient = window.ph?.reactorClientModule?.client;
+	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, documentModelVersion) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create documents");
+	const reactorClient = window.ph?.reactorClientModule?.client;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	let documentModelModule;
+	if (documentModelVersion !== void 0) {
+		const { results: documentModelModules } = await reactorClient.getDocumentModelModules();
+		const module = documentModelModules.find((m) => m.documentModel.global.id === documentType && (m.version ?? 1) === documentModelVersion);
+		if (!module) throw new Error(`Document model not found for type: ${documentType} with version: ${documentModelVersion}`);
+		documentModelModule = module;
+	} else documentModelModule = await reactorClient.getDocumentModelModule(documentType);
+	const newDocument = document ?? documentModelModule.utils.createDocument();
+	if (!document) newDocument.state.document.version = documentModelModule.version ?? 1;
+	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 });
+	}
+	return {
+		id: newDoc.header.id,
+		name: newDoc.header.name,
+		documentType,
+		parentFolder: parentFolder ?? null,
+		kind: "file"
+	};
+}
+async function addFile(file, driveId, name, parentFolder) {
+	logger.verbose(`addFile(drive: ${driveId}, name: ${name}, folder: ${parentFolder})`);
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create files");
+	const document = await loadFile(file);
+	let duplicateId = false;
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	try {
+		await reactorClient.get(document.header.id);
+		duplicateId = true;
+	} catch {}
+	const documentId = duplicateId ? generateId() : document.header.id;
+	const header = createPresignedHeader(documentId, document.header.documentType);
+	header.lastModifiedAtUtcIso = document.header.createdAtUtcIso;
+	header.meta = document.header.meta;
+	header.name = name || document.header.name;
+	const initialDocument = {
+		...document,
+		header,
+		state: document.initialState,
+		operations: Object.keys(document.operations).reduce((acc, key) => {
+			acc[key] = [];
+			return acc;
+		}, {})
+	};
+	await addDocument(driveId, name || document.header.name, document.header.documentType, parentFolder, initialDocument, documentId, document.header.meta?.preferredEditor);
+	for (const segment of splitAtUpgradeBoundaries(document.operations)) {
+		await uploadOperations(documentId, segment.operations, queueOperations);
+		if (segment.upgradeTo !== void 0) await upgradeDocument(documentId, segment.upgradeTo);
+	}
+}
+async function addFileWithProgress(file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict) {
+	logger.verbose(`addFileWithProgress(drive: ${driveId}, name: ${name}, folder: ${parentFolder})`);
+	const reactor = window.ph?.reactorClientModule?.client;
+	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) {
+			if (UnsupportedDocumentModelVersionError.isError(loadError)) {
+				showPHModal({
+					type: "documentVersionUnsupported",
+					documentType: loadError.documentType,
+					requiredVersion: loadError.requiredVersion,
+					availableVersions: loadError.availableVersions
+				});
+				onProgress?.({
+					stage: "failed",
+					progress: 100,
+					error: loadError.message
+				});
+				return;
+			}
+			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 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");
+		const segments = splitAtUpgradeBoundaries(document.operations);
+		const totalOperations = segments.reduce((total, segment) => total + countOperations(segment.operations), 0);
+		let uploadedBefore = 0;
+		for (const segment of segments) {
+			await uploadOperations(documentId, segment.operations, queueOperations, { onProgress: (uploadProgress) => {
+				if (uploadProgress.uploadedOperations === void 0) return;
+				const uploaded = uploadedBefore + uploadProgress.uploadedOperations;
+				const uploadPercent = totalOperations > 0 ? uploaded / totalOperations : 0;
+				onProgress?.({
+					stage: "uploading",
+					progress: 20 + Math.round(uploadPercent * 80),
+					totalOperations,
+					uploadedOperations: uploaded
+				});
+			} });
+			uploadedBefore += countOperations(segment.operations);
+			if (segment.upgradeTo !== void 0) await reactor.upgradeDocument(documentId, segment.upgradeTo);
+		}
+		onProgress?.({
+			stage: "complete",
+			progress: 100,
+			fileNode
+		});
+		return fileNode;
+	} catch (error) {
+		if (!UnsupportedDocumentTypeError.isError(error)) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			onProgress?.({
+				stage: "failed",
+				progress: 100,
+				error: errorMessage
+			});
+		}
+		throw error;
+	}
+}
+async function retryAfterDiscovery(discoveryService, documentType, file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict) {
+	if (!discoveryService) return;
+	try {
+		await discoveryService.load(documentType);
+	} catch {
+		onProgress?.({
+			stage: "unsupported-document-type",
+			progress: 100,
+			error: `Document type ${documentType} is not supported`
+		});
+		return;
+	}
+	await addFileWithProgress(file, driveId, name, parentFolder, onProgress, documentTypes, resolveConflict);
+}
+async function addFolder$1(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({
+		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?.reactorClientModule?.client;
+	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);
+	const duplicated = replayDocumentVersioned(document.initialState, document.operations, config, header);
+	assertAuthPreservedOnDuplicate(document.header.id, document.state.auth, duplicated.state.auth);
+	return duplicated;
+}
+async function copyNode$1(driveId, src, target) {
+	const reactor = window.ph?.reactorClientModule?.client;
+	if (!reactor) return;
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to copy documents");
+	const drive = await reactor.get(driveId);
+	const copyNodesInput = generateNodesCopy({
+		srcId: src.id,
+		targetParentFolder: target?.id,
+		targetName: src.name
+	}, () => generateId(), drive.state.global.nodes);
+	const resolvedNamesMap = /* @__PURE__ */ new Map();
+	for (const copyNodeInput of copyNodesInput) {
+		const node = drive.state.global.nodes.find((n) => n.id === copyNodeInput.srcId);
+		if (node) {
+			const resolvedName = handleTargetNameCollisions({
+				nodes: drive.state.global.nodes,
+				srcName: copyNodeInput.targetName || node.name,
+				srcKind: isFileNode(node) ? "file" : "folder",
+				targetParentFolder: copyNodeInput.targetParentFolder || null
+			});
+			resolvedNamesMap.set(copyNodeInput.targetId, resolvedName);
+		}
+	}
+	const fileNodesToCopy = copyNodesInput.filter((copyNodeInput) => {
+		const node = drive.state.global.nodes.find((node) => node.id === copyNodeInput.srcId);
+		return node !== void 0 && isFileNode(node);
+	});
+	for (const fileNodeToCopy of fileNodesToCopy) try {
+		const duplicatedDocument = await _duplicateDocument(reactor, await reactor.get(fileNodeToCopy.srcId), fileNodeToCopy.targetId);
+		const resolvedName = resolvedNamesMap.get(fileNodeToCopy.targetId);
+		if (resolvedName) duplicatedDocument.header.name = resolvedName;
+		await reactor.drives.addFile(driveId, duplicatedDocument, target?.id);
+	} catch (e) {
+		logger.error(`Error copying document ${fileNodeToCopy.srcId}: ${String(e)}`);
+	}
+	return await queueActions(drive, copyNodesInput.map((copyNodeInput) => copyNode(copyNodeInput)));
+}
+/**
+* Upgrades a document to a newer document model version. Defaults to the
+* latest registered version for the document's type.
+*/
+async function upgradeDocument(documentId, toVersion) {
+	const reactorClient = window.ph?.reactorClientModule?.client;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	return reactorClient.upgradeDocument(documentId, toVersion);
+}
+//#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,
+		deniedReason: remote.deniedReason ?? 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
+		}
+	};
+}
+/** 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/graphql-client/adapter.ts
+/**
+* Converts a `GetDocument` result into a `PHDocument`.
+*
+* Unlike the legacy `src/graphql/adapters.ts` this preserves the per-scope
+* revision map, which the write path needs to compute the `prevOpIndex` of a
+* signed action. `sig` is filled with the empty shape used by
+* `createPresignedHeader`: the creation signature is not fetchable over
+* GraphQL and is not part of the operation signing payload.
+*
+* The read path never fetches operation history, so `operations` is a map of
+* the document's known scopes to empty arrays.
+*
+* `branch` is the branch the document was read from. The GraphQL type does not
+* carry it, so it has to be passed back in by the caller; it defaults to the
+* server's own default branch.
+*/
+function phDocumentFromGetDocument(document, branch) {
+	const state = document.state;
+	return {
+		header: phDocumentHeaderFromGetDocument(document, branch),
+		state,
+		initialState: state,
+		operations: emptyOperationsForScopes(document.revisionsList),
+		clipboard: []
+	};
+}
+/**
+* Converts a mutation result into a `PHDocument`, carrying the operations the
+* mutation produced.
+*
+* `dispatchActions` reads per-action failures out of `operations[scope]`, so
+* unlike the read path this one must not return empty operation lists.
+*/
+function phDocumentFromMutation(document, operations, branch) {
+	const phDocument = phDocumentFromGetDocument(document, branch);
+	const operationsByScope = { ...phDocument.operations };
+	for (const remote of operations) {
+		const operation = remoteOperationToLocal(remote);
+		const scope = operation.action.scope;
+		const scopeOperations = operationsByScope[scope] ?? [];
+		scopeOperations.push(operation);
+		operationsByScope[scope] = scopeOperations;
+	}
+	phDocument.operations = operationsByScope;
+	return phDocument;
+}
+/** Turns a `revisionsList` selection into the header's per-scope revision map. */
+function revisionMapFromRevisionsList(revisionsList) {
+	return Object.fromEntries(revisionsList.map((r) => [r.scope, r.revision]));
+}
+/** The branch the server reads and writes when none is asked for. */
+const defaultBranch = "main";
+function phDocumentHeaderFromGetDocument(document, branch) {
+	return {
+		id: document.id,
+		sig: {
+			publicKey: {},
+			nonce: ""
+		},
+		documentType: document.documentType,
+		createdAtUtcIso: isoStringFromDateTime(document.createdAtUtcIso),
+		slug: document.slug ?? "",
+		name: document.name,
+		branch: branch ?? defaultBranch,
+		revision: revisionMapFromRevisionsList(document.revisionsList),
+		lastModifiedAtUtcIso: isoStringFromDateTime(document.lastModifiedAtUtcIso)
+	};
+}
+function emptyOperationsForScopes(revisionsList) {
+	return Object.fromEntries(revisionsList.map((r) => [r.scope, []]));
+}
+/** The `DateTime` scalar deserializes as either an ISO string or a `Date`. */
+function isoStringFromDateTime(value) {
+	return value instanceof Date ? value.toISOString() : value;
+}
+//#endregion
+//#region src/graphql-client/auth.ts
+/** Lifetime requested for an ambient Renown token, in seconds. */
+const ambientTokenExpiresInSeconds = 600;
+/**
+* The default token provider: the token of the currently logged-in Renown user.
+*
+* It is deliberately resolved from `window.ph` on every call rather than
+* captured at construction time, so a client built before login starts sending
+* the token as soon as there is one.
+*
+* The token is requested WITHOUT an `aud` claim - the Switchboard verifier
+* rejects tokens that carry an audience.
+*/
+async function ambientRenownTokenProvider() {
+	if (typeof window === "undefined") return;
+	const renown = window.ph?.renown;
+	if (!renown?.user) return;
+	return renown.getBearerToken({ expiresIn: ambientTokenExpiresInSeconds });
+}
+/**
+* Builds the SDK middleware that authenticates every request.
+*
+* The token is resolved per request and never cached, so a login, a logout or
+* an expiry between two calls is picked up by the next one. When no token is
+* available the request goes out unauthenticated.
+*/
+function makeAuthMiddleware(tokenProvider) {
+	return async (action) => {
+		const token = await tokenProvider();
+		if (!token) return action();
+		return action({ authorization: `Bearer ${token}` });
+	};
+}
+//#endregion
+//#region src/graphql-client/operations.ts
+/**
+* The operation selection of `GetDocumentOperations`, lifted into a fragment so
+* the write path can reuse `remoteOperationToLocal` on the items it selects.
+*/
+const ReactorOperationFieldsFragmentDoc = gql`
+  fragment ReactorOperationFields on ReactorOperation {
+    index
+    timestampUtcMs
+    hash
+    skip
+    error
+    deniedReason
+    id
+    action {
+      id
+      type
+      timestampUtcMs
+      input
+      scope
+      context {
+        signer {
+          user {
+            address
+            networkId
+            chainId
+          }
+          app {
+            name
+            key
+          }
+          signatures
+        }
+      }
+    }
+  }
+`;
+/**
+* `mutateDocument` plus the operations the mutation produced.
+*
+* The generated `MutateDocument` only selects the document fields, but
+* `dispatchActions` reads per-action failures out of `result.operations[scope]`
+* (`src/actions/dispatch.ts`), so the reducer-level errors would be lost.
+*
+* The operations filter keeps the extra selection to the operations this call
+* could have appended rather than the whole history. All three of its fields
+* matter:
+* - `sinceRevision` is the lowest head revision across the targeted scopes, so
+*   it is only a safe window when the selection is scope-limited as well;
+* - `scopes` limits the response to the scopes the pushed actions target,
+*   without it the server walks every scope of the document
+*   (`packages/reactor/src/core/reactor.ts` `getOperations`);
+* - `branch` selects the branch the operations are read from, and is the same
+*   variable the mutation writes to. It used to be two - the write went through
+*   a `view`, the filter took its own `branch` - and they had to be kept equal
+*   by hand or the operations came from `main` while the actions were applied
+*   elsewhere. One variable cannot disagree with itself.
+*/
+const MutateDocumentWithOperationsDocument = gql`
+  mutation MutateDocumentWithOperations(
+    $documentIdentifier: String!
+    $actions: [ActionInput!]!
+    $sinceRevision: Int
+    $scopes: [String!]
+    $branch: String
+  ) {
+    mutateDocument: execute(
+      documentIdentifier: $documentIdentifier
+      actions: $actions
+      branch: $branch
+    ) {
+      ...PHDocumentFields
+      operations(
+        filter: {
+          sinceRevision: $sinceRevision
+          scopes: $scopes
+          branch: $branch
+        }
+      ) {
+        items {
+          ...ReactorOperationFields
+        }
+      }
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+  ${ReactorOperationFieldsFragmentDoc}
+`;
+//#endregion
+//#region src/graphql-client/signing.ts
+/**
+* Stamps an action with the head of the scope it targets.
+*
+* `prevOpHash` is the hash of the scope state the action is meant to apply to;
+* for a document at head that is the hash of the last operation in the scope,
+* which the read path cannot fetch, so it is recomputed from the state.
+* `prevOpIndex` is the index of that last operation: revisions count
+* operations and indices are zero based, so an empty scope stamps `-1`, which
+* matches what the remote controller records.
+*
+* `revision` overrides the scope revision the index is derived from. Only a
+* batch needs it - {@link prepareSignedActions} stamps action N at the revision
+* the N actions before it will have produced, which the document itself does
+* not know yet. `prevOpHash` always comes from the supplied document's state.
+*/
+function stampAction(action, document, revision = document.header.revision[action.scope] ?? 0) {
+	return {
+		...action,
+		context: {
+			...action.context,
+			prevOpHash: hashDocumentStateForScope(document, action.scope),
+			prevOpIndex: revision - 1
+		}
+	};
+}
+/**
+* Signs a stamped action, preserving any signatures it already carries.
+*
+* The signer reads `context.prevOpHash` off the action, so this must run after
+* {@link stampAction}.
+*/
+async function signStampedAction(action, signer, signal) {
+	const actionSigner = action.context?.signer;
+	const user = actionSigner?.user ?? signer.user;
+	const app = actionSigner?.app ?? signer.app;
+	if (!user || !app) throw new Error("cannot sign an action: the signer has no user or app identity");
+	const signature = await signer.signAction(action, signal);
+	return {
+		...action,
+		context: {
+			...action.context,
+			signer: {
+				user,
+				app,
+				signatures: [...actionSigner?.signatures ?? [], signature]
+			}
+		}
+	};
+}
+/**
+* Actions a snapshot batch cannot predict the next state for.
+*
+* `UNDO`, `REDO` and `PRUNE` rewrite history the light read path never fetched
+* (and the reducer appends no operation for them); `NOOP` is only ever produced
+* by an undo chain; the document-scope actions run through the reactor's
+* document-action handler rather than a document-model reducer
+* (`DOCUMENT_SCOPE_ACTIONS` in packages/reactor/src/executor/util.ts) and
+* `UPGRADE_DOCUMENT` changes which reducer applies mid-batch.
+*/
+const unsupportedBatchActions = new Set([
+	"UNDO",
+	"REDO",
+	"PRUNE",
+	"NOOP",
+	"CREATE_DOCUMENT",
+	"DELETE_DOCUMENT",
+	"UPGRADE_DOCUMENT",
+	"ADD_RELATIONSHIP",
+	"REMOVE_RELATIONSHIP",
+	"UPDATE_RELATIONSHIP"
+]);
+/**
+* The base-reducer protocol version to predict with when the snapshot's header
+* carries none.
+*
+* `baseReducer` reads `baseReducerVersion(document.header)` for every action and
+* throws when the header has no `protocolVersions` - and a header built by
+* {@link phDocumentFromGetDocument} never has one, because the GraphQL
+* `PHDocument` type does not expose it. The version only selects between the v1
+* and v2 UNDO/NOOP branches, and every action reaching the prediction loop is an
+* ordinary append-only one, so it cannot change the predicted state here; it is
+* passed purely so the lookup does not throw.
+*/
+const predictionProtocolVersion = 2;
+/**
+* Stamps and signs a batch of actions against one document snapshot, so every
+* action carries the head its predecessor will leave behind.
+*
+* The server executes the array in order, each action against the state the one
+* before it produced. The snapshot the light client reads has correct state and
+* per-scope revisions but NO operation history (see `adapter.ts`), so the chain
+* is predicted here: reduce action N over the working document to get the state
+* action N+1 hashes, and carry a virtual revision alongside it. The revision has
+* to be tracked separately because the reducer derives operation indices from
+* the last stored operation, and with an empty history that counts from zero
+* rather than from the document's real revision.
+*
+* A single action needs no prediction and therefore no `module`, which keeps
+* today's callers working unchanged. Two or more require the document's exact
+* reducer, one shared scope (the reactor rejects mixed-scope jobs) and only
+* append-only actions. Anything else rejects: a batch that cannot be predicted
+* must fail before the mutation, never be downgraded to unsigned.
+*/
+async function prepareSignedActions(actions, snapshot, signer, module, signal) {
+	if (actions.length === 0) return [];
+	if (actions.length === 1) return [await signStampedAction(stampAction(actions[0], snapshot), signer, signal)];
+	const scope = sharedScope(actions);
+	assertSupportedBatch(actions);
+	if (!module) throw new Error(`cannot sign ${actions.length} actions: no document model module for ${snapshot.header.documentType} was supplied, so the batch state cannot be predicted`);
+	let working = {
+		...snapshot,
+		operations: {
+			...snapshot.operations,
+			[scope]: [...snapshot.operations[scope] ?? []]
+		}
+	};
+	let revision = snapshot.header.revision[scope] ?? 0;
+	const signed = [];
+	for (const [index, action] of actions.entries()) {
+		throwIfAborted(signal, index);
+		const signedAction = await signStampedAction(stampAction(action, working, revision), signer, signal);
+		signed.push(signedAction);
+		const before = scopeOperationCount(working, scope);
+		let next;
+		try {
+			next = module.reducer(working, signedAction, void 0, { protocolVersion: working.header.protocolVersions?.["base-reducer"] ?? predictionProtocolVersion });
+		} catch (error) {
+			throw new Error(`cannot sign action ${index} (${action.type}): the ${snapshot.header.documentType} reducer rejected it, so the rest of the batch cannot be predicted`, { cause: error });
+		}
+		const after = scopeOperationCount(next, scope);
+		if (after !== before + 1) throw new Error(`cannot sign action ${index} (${action.type}): the reducer appended ${after - before} operations to ${scope}, expected exactly 1`);
+		working = next;
+		revision += 1;
+	}
+	return signed;
+}
+/**
+* How many operations a scope holds.
+*
+* The index signature types the array as always present, but a module's reducer
+* is arbitrary code: one that hands back a document without the scope should
+* produce the actionable error above, not a `TypeError` on `.length`.
+*/
+function scopeOperationCount(document, scope) {
+	return document.operations[scope]?.length ?? 0;
+}
+/** The one scope a reactor job may span (`getSharedActionScope`). */
+function sharedScope(actions) {
+	const scope = actions[0].scope;
+	const mixed = actions.find((action) => action.scope !== scope);
+	if (mixed) throw new Error(`cannot sign a batch spanning scopes "${scope}" and "${mixed.scope}": every action in one request must share a scope`);
+	return scope;
+}
+function assertSupportedBatch(actions) {
+	const unsupported = actions.find((action) => unsupportedBatchActions.has(action.type));
+	if (unsupported) throw new Error(`cannot sign a batch containing ${unsupported.type}: it needs operation history or an alternate executor path, so send it as a single action`);
+}
+function throwIfAborted(signal, index) {
+	if (signal?.aborted) throw new Error(`signing aborted before action ${index}`, { cause: signal.reason });
+}
+//#endregion
+//#region src/graphql-client/static-package-manager.ts
+/**
+* A fixed set of packages presented through the `IPackageManager` interface,
+* so the package-derived hooks - `useDocumentModelModules`,
+* `useDocumentModelModuleById`, `useEditorModules`, `useVetraPackages` - work
+* below `GraphQLReactorProvider` exactly as they do below Connect.
+*
+* Connect's package manager installs, updates and removes packages at runtime.
+* A light app instead declares its packages once, as code it imports itself
+* (every generated package root exports `manifest`, `documentModels`, `editors`
+* and `upgradeManifests` by name), so every mutating member throws and
+* `subscribe` never emits. For hand-picked modules without package artifacts,
+* {@link packageFromDocumentModels} wraps them in one synthetic package.
+*/
+var StaticPackageManager = class {
+	registryUrl = null;
+	packages;
+	constructor(packages) {
+		this.packages = [...packages];
+	}
+	/**
+	* Resolves a module by document type across all packages. Mirrors the
+	* registry's semantics (`IDocumentModelRegistry.getModule`): the LATEST
+	* version wins, with `version ?? 1` as each module's default.
+	*/
+	load(documentType) {
+		const modules = this.packages.flatMap((pkg) => pkg.documentModels);
+		try {
+			return Promise.resolve(resolveDocumentModelModule(modules, documentType));
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	subscribe(_handler) {
+		return () => {};
+	}
+	getPackageSource(_packageName) {
+		return null;
+	}
+	getPackageVersion(_packageName) {}
+	getRegistryPackages() {
+		return [];
+	}
+	addPackage(_packageName) {
+		throw staticPackageManagerError("addPackage");
+	}
+	addPackages(_packageNames) {
+		throw staticPackageManagerError("addPackages");
+	}
+	removePackage(_name) {
+		throw staticPackageManagerError("removePackage");
+	}
+	updateLocalPackage(_pkg, _version) {
+		throw staticPackageManagerError("updateLocalPackage");
+	}
+	addLocalPackage(_name, _loadedPackage, _version) {
+		throw staticPackageManagerError("addLocalPackage");
+	}
+};
+/**
+* Resolves one document-model module out of a flat module list, with the same
+* rule the reactor registry uses (`IDocumentModelRegistry.getModule`, at
+* packages/reactor/src/registry/implementation.ts): with a `version`, only an
+* EXACT `version ?? 1` match resolves; without one, the LATEST version wins.
+*
+* Signing an existing document needs the exact rule. A document carries the
+* model version it was written with in `state.document.version`, and its
+* reducer is the only one whose operations that document's history can accept -
+* so "latest" is correct only when no version is asked for.
+*
+* Pure and dependency-free on purpose: this is reachable from the browser
+* entry, so it must not pull the reactor registry in as a value.
+*/
+function resolveDocumentModelModule(modules, documentType, version) {
+	let latestModule;
+	let latestVersion = -1;
+	for (const module of modules) {
+		if (module.documentModel.global.id !== documentType) continue;
+		const moduleVersion = module.version ?? 1;
+		if (version !== void 0 && moduleVersion === version) return module;
+		if (moduleVersion > latestVersion) {
+			latestVersion = moduleVersion;
+			latestModule = module;
+		}
+	}
+	if (version === void 0 && latestModule) return latestModule;
+	throw new Error(version === void 0 ? `Unknown document type: ${documentType}` : `Unknown document model version: ${documentType} v${version}` + (latestModule ? ` (available: ${availableVersions(modules, documentType).join(", ")})` : " (no module for this document type)"));
+}
+function availableVersions(modules, documentType) {
+	return modules.filter((module) => module.documentModel.global.id === documentType).map((module) => module.version ?? 1).sort((a, b) => a - b);
+}
+function staticPackageManagerError(member) {
+	return /* @__PURE__ */ new Error(`${member} is not supported: StaticPackageManager holds a fixed set of packages`);
+}
+/**
+* Wraps hand-picked modules in one synthetic `DocumentModelLib`, for apps that
+* assemble their model list from mixed sources instead of passing whole
+* packages. The manifest is fabricated - loose modules carry none - so prefer
+* the `packages` prop with the real package exports when you have them: a real
+* package also carries `editors`, which makes the editor hooks work.
+*/
+function packageFromDocumentModels(documentModels) {
+	return {
+		manifest: {
+			name: "graphql-reactor-provider",
+			description: "Document models passed to GraphQLReactorProvider"
+		},
+		documentModels,
+		editors: []
+	};
+}
+//#endregion
+//#region src/graphql-client/subgraph.ts
+/** What {@link describeGraphQLDocument} could not read off a document. */
+const unnamedOperation = "AnonymousOperation";
+const defaultOperationType = "query";
+/**
+* Derives a subgraph's endpoint from the Switchboard's GraphQL endpoint.
+*
+* Subgraphs are served next to the supergraph, at `<graphql base>/<name>`, so
+* `http://localhost:4001/graphql` plus `statements` is
+* `http://localhost:4001/graphql/statements`.
+*/
+function subgraphUrlFromGraphqlUrl(url, name) {
+	const trimmed = name.trim();
+	if (trimmed === "") throw new Error("a subgraph name is required");
+	return `${url.replace(/\/+$/, "")}/${trimmed}`;
+}
+/**
+* Reads the operation name and type off a document, for the middleware.
+*
+* Nothing depends on getting this right - it is reported to the middleware, not
+* sent to the server - so an unreadable document falls back to an anonymous
+* query rather than throwing.
+*/
+function describeGraphQLDocument(document) {
+	if (typeof document !== "string") {
+		const operation = document.definitions.find((definition) => definition.kind === Kind.OPERATION_DEFINITION);
+		if (!operation || operation.kind !== Kind.OPERATION_DEFINITION) return {
+			operationName: unnamedOperation,
+			operationType: defaultOperationType
+		};
+		return {
+			operationName: operation.name?.value ?? unnamedOperation,
+			operationType: operation.operation
+		};
+	}
+	const match = /\b(query|mutation|subscription)\s+([_A-Za-z][_0-9A-Za-z]*)/.exec(document);
+	if (!match) return {
+		operationName: unnamedOperation,
+		operationType: /\bmutation\b/.test(document) ? "mutation" : defaultOperationType
+	};
+	return {
+		operationName: match[2],
+		operationType: match[1]
+	};
+}
+/**
+* Binds typed subgraph SDKs to one Switchboard's transport and auth.
+*
+* Every capability a Switchboard exposes lives behind the same base URL, so an
+* app should not have to build a second client - with a second copy of the auth
+* configuration - to reach a project's own subgraph. The registry derives the
+* endpoint, reuses one transport per subgraph and hands the code generator's
+* `getSdk` the very middleware the reactor operations already go through.
+*
+* Transport and typing only: subgraph results are not cached and produce no
+* change events.
+*/
+var SubgraphSdkRegistry = class {
+	url;
+	middleware;
+	bindings = /* @__PURE__ */ new Map();
+	constructor(url, middleware) {
+		this.url = url;
+		this.middleware = middleware;
+	}
+	/**
+	* Returns the subgraph's SDK, building it on first use.
+	*
+	* The transport is kept per subgraph name, so repeated calls do not rebuild
+	* it. The SDK itself is only reused when the same factory is passed again -
+	* two different generated SDKs over one subgraph each get their own, rather
+	* than the second call being handed the first one's methods.
+	*/
+	get(name, getSdk) {
+		const binding = this.binding(name);
+		if (binding.factory === getSdk) return binding.sdk;
+		const sdk = getSdk(binding.transport, this.middleware);
+		binding.factory = getSdk;
+		binding.sdk = sdk;
+		return sdk;
+	}
+	/** Returns the subgraph's endpoint, for diagnostics and tests. */
+	urlFor(name) {
+		return subgraphUrlFromGraphqlUrl(this.url, name);
+	}
+	binding(name) {
+		const existing = this.bindings.get(name);
+		if (existing) return existing;
+		const binding = { transport: new GraphQLClient(this.urlFor(name)) };
+		this.bindings.set(name, binding);
+		return binding;
+	}
+};
+//#endregion
+//#region src/graphql-client/subscriptions.ts
+/**
+* Opens one `documentChanges` subscription and feeds every event to `onEvent`.
+*
+* The subscription is a firehose: no `search` argument, so the server sends
+* every change the connection is allowed to see and the caller filters. This is
+* the only module that knows about `graphql-ws`.
+*
+* Returns the stop function, which cancels the subscription and closes the
+* socket. It is safe to call more than once.
+*/
+function startDocumentChangesSubscription(options) {
+	const client = createClient({
+		url: options.wsUrl,
+		connectionParams: options.connectionParams
+	});
+	const unsubscribe = client.subscribe({
+		operationName: "DocumentChanges",
+		query: print(DocumentChangesDocument)
+	}, {
+		next: (result) => {
+			const event = result.data?.documentChanges;
+			if (event) options.onEvent(event);
+		},
+		error: (error) => options.onError(error),
+		complete: () => void 0
+	});
+	let stopped = false;
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		unsubscribe();
+		client.dispose();
+	};
+}
+/**
+* Derives the websocket endpoint from the GraphQL http endpoint.
+*
+* `http://host/graphql` becomes `ws://host/graphql/subscriptions`, which is
+* where the Switchboard mounts its websocket server (`packages/reactor-api`
+* `startServer`). A URL that already speaks `ws`/`wss` only gets the path.
+*/
+function subscriptionsUrlFromGraphqlUrl(url) {
+	const trimmed = url.replace(/\/+$/, "");
+	return `${trimmed.startsWith("https://") ? `wss://${trimmed.slice(8)}` : trimmed.startsWith("http://") ? `ws://${trimmed.slice(7)}` : trimmed}/subscriptions`;
+}
+/**
+* Turns a bearer token provider into `connectionParams`.
+*
+* The header key is the lowercase `authorization` the Switchboard's websocket
+* context factory reads. Without a token the payload is empty: an open
+* Switchboard serves anonymous subscribers.
+*/
+function makeAuthConnectionParams(tokenProvider) {
+	return async () => {
+		const token = await tokenProvider();
+		if (!token) return {};
+		return { authorization: `Bearer ${token}` };
+	};
+}
+//#endregion
+//#region src/graphql-client/graphql-reactor-client.ts
+/** Paging defaults, matching the reactor's own client. */
+const defaultPaging = {
+	cursor: "0",
+	limit: 100
+};
+/**
+* The marker {@link isGraphQLReactorClient} looks for.
+*
+* A page can end up with two copies of this module - an app that bundles a
+* package carrying its own copy, or a dev server that hot-replaced it - and
+* then `instanceof` compares an instance against the other copy's class object
+* and answers `false`. A branded property survives both.
+*/
+const graphQLReactorClientBrand = "__powerhouseGraphQLReactorClient";
+/**
+* A light implementation of {@link IReactorBrowserClient} that talks plain
+* GraphQL to a Switchboard, with no reactor in the bundle.
+*
+* It fills the same `window.ph` slots the full in-browser reactor client fills,
+* so the reactor-browser hooks cannot tell the two apart.
+*/
+var GraphQLReactorClient = class {
+	/** See {@link isGraphQLReactorClient}. */
+	[graphQLReactorClientBrand] = true;
+	sdk;
+	subgraphs;
+	listeners = [];
+	tokenProvider;
+	subscriptionsUrl;
+	documentModels;
+	signer;
+	stopRealtime;
+	realtimeStarted = false;
+	realtimeGeneration = 0;
+	realtimeErrorLogged = false;
+	constructor(options) {
+		this.tokenProvider = options.tokenProvider ?? ambientRenownTokenProvider;
+		this.documentModels = [...options.documentModels ?? []];
+		this.signer = options.signer;
+		this.subscriptionsUrl = options.realtime === false ? void 0 : options.subscriptionsUrl ?? subscriptionsUrlFromGraphqlUrl(options.url);
+		const middleware = makeAuthMiddleware(this.tokenProvider);
+		this.sdk = options.graphqlClient ?? createClient$1(options.url, middleware);
+		this.subgraphs = new SubgraphSdkRegistry(options.url, middleware);
+	}
+	async get(identifier, view, signal) {
+		const viewInput = viewFilterInputFromViewFilter(view);
+		const document = (await this.sdk.GetDocument({
+			identifier,
+			view: viewInput
+		}, void 0, signal)).document;
+		if (!document) throw new Error(`Document not found: ${identifier}`);
+		return phDocumentFromGetDocument(document.document, view?.branch);
+	}
+	async getOperations(documentIdentifier, view, filter, paging, signal) {
+		const viewInput = viewFilterInputFromViewFilter(view);
+		const operationsFilter = {
+			documentId: documentIdentifier,
+			branch: viewInput?.branch,
+			scopes: viewInput?.scopes,
+			actionTypes: filter?.actionTypes,
+			timestampFrom: filter?.timestampFrom,
+			timestampTo: filter?.timestampTo,
+			sinceRevision: filter?.sinceRevision
+		};
+		const page = (await this.sdk.GetDocumentOperations({
+			filter: operationsFilter,
+			paging: pagingInputFromPaging(paging)
+		}, void 0, signal)).documentOperations;
+		const nextCursor = page.hasNextPage ? page.cursor ?? void 0 : void 0;
+		const effectivePaging = paging ?? defaultPaging;
+		return {
+			results: page.items.map((item) => remoteOperationToLocal(item)),
+			options: effectivePaging,
+			nextCursor,
+			totalCount: page.totalCount,
+			next: nextCursor ? () => this.getOperations(documentIdentifier, view, filter, {
+				cursor: nextCursor,
+				limit: effectivePaging.limit
+			}, signal) : void 0
+		};
+	}
+	async create(document, parentIdentifier, signal) {
+		const created = phDocumentFromGetDocument((await this.sdk.CreateDocument({
+			document,
+			parentIdentifier
+		}, void 0, signal)).createDocument);
+		this.emitChange({
+			type: DOCUMENT_CHANGE_TYPE.Created,
+			documents: [created]
+		});
+		return created;
+	}
+	/**
+	* Pushes actions to the Switchboard and returns the updated document.
+	*
+	* The document is fetched first: the response is the baseline for the
+	* `sinceRevision` filter that narrows the returned operations to the ones
+	* this call appended, and it carries the state hash a signed action is
+	* stamped with.
+	*
+	* The emitted `Updated` event carries the document's id, never the
+	* identifier this was called with: subscribers - including `DocumentCache` -
+	* work in id space.
+	*/
+	async execute(documentIdentifier, branch, actions, signal) {
+		const document = await this.get(documentIdentifier, { branch }, signal);
+		const variables = {
+			documentIdentifier,
+			actions: (await prepareActionsForPush(actions, document, this.documentModels, this.signer, signal)).map(toTransportAction),
+			sinceRevision: sinceRevisionForActions(document, actions),
+			scopes: scopesForActions(actions),
+			branch
+		};
+		const mutated = (await this.sdk.RunDocument({
+			operationName: "MutateDocumentWithOperations",
+			operationType: "mutation",
+			document: MutateDocumentWithOperationsDocument,
+			variables,
+			signal
+		})).mutateDocument;
+		const updated = phDocumentFromMutation(mutated, mutated.operations?.items ?? [], branch);
+		this.emitChange({
+			type: DOCUMENT_CHANGE_TYPE.Updated,
+			documents: [updated]
+		});
+		return updated;
+	}
+	/**
+	* Deletes a document and announces it as a `Deleted` event.
+	*
+	* Pass a document id. The server resolves a slug just as happily, but
+	* `deleteDocument` returns a boolean - there is no document left to read an
+	* id off - so the identifier is announced verbatim on `context.childId`. A
+	* subscriber keyed by id, `DocumentCache` included, therefore only reacts to
+	* a delete by id.
+	*/
+	async deleteDocument(identifier, propagate, signal) {
+		await this.sdk.DeleteDocument({
+			identifier,
+			propagate: propagationModeInput(propagate)
+		}, void 0, signal);
+		this.emitChange({
+			type: DOCUMENT_CHANGE_TYPE.Deleted,
+			documents: [],
+			context: { childId: identifier }
+		});
+	}
+	/**
+	* Registers a change subscriber and returns its unsubscribe function.
+	*
+	* Two things produce the events delivered here. Every successful `create`,
+	* `execute` and `deleteDocument` emits one, which is what makes a
+	* `DocumentCache` built on this client invalidate after a dispatch. And,
+	* unless realtime is switched off, the first call to this method opens a
+	* websocket to the Switchboard and every change it reports - from another
+	* user, another tab or a server-side processor - is emitted too. A write of
+	* this client's own is therefore announced twice, once locally and once by
+	* the server; the cache refetches twice, which is harmless.
+	*
+	* A websocket that cannot be opened or is refused is logged once and then
+	* ignored: realtime is an enhancement, never a dependency. The failed socket
+	* is closed, so the next subscriber to arrive tries again.
+	*
+	* `view` is accepted for interface compatibility and ignored: the emitted
+	* documents are whatever the write returned, so there is nothing to re-scope.
+	*
+	* Events live in id space: `search.ids` is matched against the resolved
+	* document id, never against the identifier the write was issued with. The
+	* one exception is `deleteDocument`, which has no document to resolve an id
+	* from - see its own note. A `DocumentCache` on this client must therefore
+	* be read by id: a slug-keyed entry is never invalidated.
+	*/
+	subscribe(search, callback, view) {
+		const listener = {
+			search,
+			callback
+		};
+		this.listeners.push(listener);
+		this.startRealtime();
+		return () => {
+			const index = this.listeners.indexOf(listener);
+			if (index !== -1) this.listeners.splice(index, 1);
+		};
+	}
+	/**
+	* Closes the realtime socket, if one was opened.
+	*
+	* Registered subscribers are left in place: they still receive the events
+	* this client produces itself.
+	*
+	* Disposing is NOT final - a later `subscribe` opens a new socket. React
+	* remounts a tree by running an effect's cleanup and then the effect again,
+	* on the same client, and `StrictMode` does exactly that on every mount; a
+	* terminal flag here would leave those pages without realtime for good, with
+	* nothing logged.
+	*/
+	dispose() {
+		this.teardownRealtime();
+	}
+	/**
+	* Binds a project's generated SDK to this client's transport and auth.
+	*
+	* Subgraphs are served next to the reactor's own supergraph, so the endpoint
+	* is derived from the client's `url` by appending the name, and the SDK is
+	* handed the same auth middleware every reactor call goes through. An app
+	* therefore configures one URL and one token provider, and reaches every
+	* capability of its Switchboard through this one client.
+	*
+	* `getSdk` is the function a GraphQL code generator emits for the subgraph's
+	* schema - see the README in this folder for the codegen recipe.
+	*
+	* Transport and typing only. Subgraph results are not cached, produce no
+	* change events and never reach `useDocument`.
+	*/
+	subgraph(name, getSdk) {
+		return this.subgraphs.get(name, getSdk);
+	}
+	/**
+	* Runs a one-off GraphQL document against the Switchboard's own endpoint,
+	* through the same transport and auth as everything else.
+	*
+	* The escape hatch for an operation not worth generating an SDK for. Pass a
+	* document a code generator typed and the result type follows; pass a plain
+	* `gql` document or a string and name the result type at the call site.
+	*/
+	async request(document, variables, options) {
+		const described = describeGraphQLDocument(document);
+		return this.sdk.RunDocument({
+			operationName: options?.operationName ?? described.operationName,
+			operationType: options?.operationType ?? described.operationType,
+			document,
+			variables,
+			signal: options?.signal
+		});
+	}
+	/**
+	* Opens the realtime socket on the first subscriber.
+	*
+	* The subscription is a firehose - no `search` argument - and this client
+	* applies each subscriber's own filter on the way out, exactly as it does for
+	* its own emissions.
+	*/
+	startRealtime() {
+		if (!this.subscriptionsUrl || this.realtimeStarted) return;
+		this.realtimeStarted = true;
+		const generation = this.realtimeGeneration;
+		const stop = startDocumentChangesSubscription({
+			wsUrl: this.subscriptionsUrl,
+			connectionParams: makeAuthConnectionParams(this.tokenProvider),
+			onEvent: (event) => this.emitServerEvent(event),
+			onError: (error) => this.handleRealtimeFailure(generation, error)
+		});
+		if (this.realtimeGeneration !== generation) {
+			stop();
+			return;
+		}
+		this.stopRealtime = stop;
+	}
+	/**
+	* Gives up on a failed socket so that a later subscriber can try again.
+	*
+	* `graphql-ws` retries on its own and only reports here once it has given up,
+	* or once the server refused the subscription outright - which is what an
+	* auth-enabled Switchboard does to an anonymous subscriber. Keeping the dead
+	* stop function would make every later `subscribe` a no-op, so realtime would
+	* stay off for the life of the page even after the user signs in.
+	*
+	* The generation stamp discards a report from a socket that has already been
+	* replaced or disposed.
+	*/
+	handleRealtimeFailure(generation, error) {
+		if (generation !== this.realtimeGeneration) return;
+		this.teardownRealtime();
+		this.logRealtimeError(error);
+	}
+	/** Closes the socket and lets a later subscriber open a new one. */
+	teardownRealtime() {
+		this.realtimeGeneration += 1;
+		this.realtimeStarted = false;
+		this.stopRealtime?.();
+		this.stopRealtime = void 0;
+	}
+	/** Maps a server event onto the client-side event and emits it. */
+	emitServerEvent(event) {
+		this.emitChange({
+			type: documentChangeTypes[event.type],
+			documents: event.documents.map((document) => phDocumentFromGetDocument(document)),
+			context: event.context ? {
+				parentId: event.context.parentId ?? void 0,
+				childId: event.context.childId ?? void 0
+			} : void 0
+		});
+	}
+	/**
+	* Reports a broken realtime socket once per client, however many sockets it
+	* goes through.
+	*
+	* `graphql-ws` retries on its own, and a Switchboard without a websocket
+	* endpoint would otherwise fill the console for as long as the page is open.
+	*/
+	logRealtimeError(error) {
+		if (this.realtimeErrorLogged) return;
+		this.realtimeErrorLogged = true;
+		logger.warn("GraphQLReactorClient: realtime document changes are unavailable, falling back to local change events", error);
+	}
+	/**
+	* Delivers an event to every matching subscriber.
+	*
+	* A subscriber that throws is logged and skipped so one bad listener cannot
+	* stop the others from being notified.
+	*/
+	emitChange(event) {
+		for (const listener of [...this.listeners]) {
+			if (!eventMatchesSearch(event, listener.search)) continue;
+			try {
+				listener.callback(event);
+			} catch (error) {
+				logger.error("GraphQLReactorClient: a document change subscriber threw", error);
+			}
+		}
+	}
+};
+/**
+* Whether a value is a {@link GraphQLReactorClient}, including one built by
+* another copy of this module.
+*
+* Use this rather than `instanceof`: the brand it tests for is shared by every
+* copy of the class, so a client built by a hot-replaced module or by a package
+* that bundled its own copy is still recognised.
+*/
+function isGraphQLReactorClient(client) {
+	return client?.[graphQLReactorClientBrand] === true;
+}
+/** The schema's change types, mapped onto the reactor's. */
+const documentChangeTypes = {
+	[DocumentChangeType.Created]: DOCUMENT_CHANGE_TYPE.Created,
+	[DocumentChangeType.Deleted]: DOCUMENT_CHANGE_TYPE.Deleted,
+	[DocumentChangeType.Updated]: DOCUMENT_CHANGE_TYPE.Updated,
+	[DocumentChangeType.ParentAdded]: DOCUMENT_CHANGE_TYPE.ParentAdded,
+	[DocumentChangeType.ParentRemoved]: DOCUMENT_CHANGE_TYPE.ParentRemoved,
+	[DocumentChangeType.ChildAdded]: DOCUMENT_CHANGE_TYPE.ChildAdded,
+	[DocumentChangeType.ChildRemoved]: DOCUMENT_CHANGE_TYPE.ChildRemoved
+};
+/**
+* Decides whether an event reaches a subscriber.
+*
+* Every populated field of the search filter is an AND condition, matching the
+* reactor's own subscription manager - which also treats an empty array as a
+* filter that nothing satisfies. `parentId` is a drive concept and is ignored.
+*
+* A `Deleted` event carries no documents, so it is matched on its
+* `context.childId` for identifier filters and delivered unconditionally to
+* type and slug filters: there is no document left to check them against.
+*/
+function eventMatchesSearch(event, search) {
+	const deleted = event.type === DOCUMENT_CHANGE_TYPE.Deleted;
+	const { ids, slugs, type } = search;
+	if (ids) {
+		if (!(deleted ? [event.context?.childId] : event.documents.map((document) => document.header.id)).some((id) => id !== void 0 && ids.includes(id))) return false;
+	}
+	if (slugs && !deleted) {
+		if (!event.documents.map((document) => document.header.slug).some((slug) => slugs.includes(slug))) return false;
+	}
+	if (type && !deleted) {
+		if (!event.documents.map((document) => document.header.documentType).includes(type)) return false;
+	}
+	return true;
+}
+/**
+* Maps a reactor `ViewFilter` onto the GraphQL `ViewFilterInput`.
+*
+* Point-in-time reads are rejected: the Switchboard read API has no revision
+* argument, so silently returning the head state would be wrong.
+*/
+function viewFilterInputFromViewFilter(view) {
+	if (!view) return;
+	if (view.revision !== void 0) throw new Error("point-in-time views are not supported by GraphQLReactorClient");
+	if (view.branch === void 0 && view.scopes === void 0) return;
+	return {
+		branch: view.branch,
+		scopes: view.scopes
+	};
+}
+function pagingInputFromPaging(paging) {
+	if (!paging) return;
+	return {
+		cursor: paging.cursor,
+		limit: paging.limit
+	};
+}
+/**
+* The reactor and the GraphQL schema disagree on the enum: the reactor's
+* `None` is the schema's `ORPHAN`. This is the inverse of the server's
+* `toReactorPropagationMode`.
+*/
+const propagationModeInputs = {
+	cascade: PropagationMode.Cascade,
+	none: PropagationMode.Orphan
+};
+function propagationModeInput(propagate) {
+	return propagate === void 0 ? void 0 : propagationModeInputs[propagate];
+}
+/**
+* Stamps and signs the actions about to be pushed.
+*
+* With no signer the actions go out exactly as given, batch or not - this
+* client does not require signatures. With one, every action is signed:
+* {@link prepareSignedActions} predicts the chain a batch will produce by
+* running the document's own reducer between signatures, which is why a batch
+* needs the module matching the document's type and exact version.
+*
+* A batch that cannot be predicted - no matching module, mixed scopes, an
+* action needing history - throws here, before the mutation. Sending it
+* unsigned instead would silently drop the signatures the caller asked for.
+*/
+async function prepareActionsForPush(actions, document, documentModels, explicitSigner, signal) {
+	const signer = explicitSigner ?? resolveAmbientSigner();
+	if (!signer || actions.length === 0) return actions;
+	return prepareSignedActions(actions, document, signer, actions.length > 1 ? resolveDocumentModelModule(documentModels, document.header.documentType, documentModelVersion(document)) : void 0, signal);
+}
+/**
+* The document-model version the document's actions must be reduced with.
+*
+* `state` arrives as JSON over GraphQL, so its `document` scope is only as
+* reliable as the server that sent it - one written before that scope existed
+* carries no version at all. `normalizeDocumentModelVersion` maps that, and 0,
+* to 1: the same rule `SimpleJobExecutor` applies before asking the registry
+* for a module, so client and server cannot resolve different reducers.
+*/
+function documentModelVersion(document) {
+	const documentScope = document.state.document;
+	return normalizeDocumentModelVersion(documentScope?.version);
+}
+/** Resolves the signer of the logged-in user, if there is one. */
+function resolveAmbientSigner() {
+	if (typeof window === "undefined") return;
+	const renown = window.ph?.renown;
+	return renown?.user ? renown.signer : void 0;
+}
+/**
+* The revision the pushed operations start from: the lowest head revision
+* across the scopes the actions target.
+*
+* The baseline is only meaningful together with {@link scopesForActions}: a
+* batch that touches a scope at revision 1 and one at revision 5000 would
+* otherwise re-download the whole history of every scope of the document.
+*/
+function sinceRevisionForActions(document, actions) {
+	const revisions = actions.map((action) => document.header.revision[action.scope] ?? 0);
+	return revisions.length > 0 ? Math.min(...revisions) : 0;
+}
+/** The distinct scopes the pushed actions target, in first-seen order. */
+function scopesForActions(actions) {
+	if (actions.length === 0) return;
+	return [...new Set(actions.map((action) => action.scope))];
+}
+//#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: useSwitchboardUrl, setValue: setSwitchboardUrl, addEventHandler: addSwitchboardUrlEventHandler } = makePHEventFunctions("switchboardUrl");
+const { useValue: useRenownAdapters, setValue: setRenownAdapters, addEventHandler: addRenownAdaptersEventHandler } = makePHEventFunctions("renownAdapters");
+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,
+	switchboardUrl: setSwitchboardUrl,
+	renownAdapters: setRenownAdapters,
+	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,
+	switchboardUrl: useSwitchboardUrl,
+	renownAdapters: useRenownAdapters,
+	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).filter((module, index, modules) => modules.findIndex((m) => m.documentModel.global.id === module.documentModel.global.id && (m.version ?? 1) === (module.version ?? 1)) === index);
+	const registry = window.ph?.reactorClientModule?.reactorModule?.documentModelRegistry;
+	if (!registry || documentModelModules.length === 0) return;
+	const results = registry.registerModules(...documentModelModules);
+	const duplicateTypes = /* @__PURE__ */ new Set();
+	for (const result of results) if (result.status === "error") if (isDuplicateModuleError(result.error)) duplicateTypes.add(result.item.documentModel.global.id);
+	else console.error("Failed to register document model module:", result.error);
+	if (duplicateTypes.size > 0) {
+		registry.unregisterModules(...duplicateTypes);
+		registry.registerModules(...documentModelModules.filter((module) => duplicateTypes.has(module.documentModel.global.id)));
+	}
+}
+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 (isDuplicateManifestError(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,
+	switchboardUrl: addSwitchboardUrlEventHandler,
+	renownAdapters: addRenownAdaptersEventHandler,
+	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/graphql-client/graphql-reactor-provider.tsx
+/**
+* Registers the `window.ph` event handlers once per page.
+*
+* The `set*` helpers only dispatch CustomEvents - nothing writes `window.ph`
+* until `addPHEventHandlers` has registered the listeners that do. Registration
+* is guarded by a marker on `window` rather than a module-level flag so that a
+* hot module replacement, or two copies of this module, still register once.
+*/
+function ensurePHEventHandlers() {
+	if (typeof window === "undefined" || window.__phEventHandlersRegistered) return;
+	addPHEventHandlers();
+	window.__phEventHandlersRegistered = true;
+}
+/**
+* Mounts a {@link GraphQLReactorClient} into the `window.ph` slots the
+* reactor-browser hooks read, so `useDocument`, `useDispatch` and
+* `useReactorClient` work below it against a Switchboard, with no reactor in
+* the bundle.
+*
+* It fills the document slots, plus `window.ph.vetraPackageManager` when
+* `documentModels` is given (a fixed {@link StaticPackageManager}, which makes
+* the document-model hooks work). The same modules go to the client itself, so
+* a dispatch of two or more actions is signed rather than refused.
+* `window.ph.reactorClientModule` always stays empty, so full-reactor surfaces
+* (drives, jobs, editor auto-discovery) find nothing - an app below this
+* provider renders components it imports itself.
+*
+* The client is built on the client only: on the server the slots stay empty
+* and the hooks report their normal loading states. The props are read once,
+* when the client is built - changing `url` afterwards does not rebuild it.
+*
+* The effect's cleanup disposes the cache and the client's socket, and the
+* effect rebuilds both if it runs again on the same client - which is what a
+* `StrictMode` mount does.
+*/
+function GraphQLReactorProvider({ url, tokenProvider, subscriptionsUrl, realtime, attachmentService, documentModels, children }) {
+	const [client] = useState(() => typeof window === "undefined" ? void 0 : new GraphQLReactorClient({
+		url,
+		tokenProvider,
+		subscriptionsUrl,
+		realtime,
+		documentModels
+	}));
+	useEffect(() => {
+		if (!client) return;
+		ensurePHEventHandlers();
+		setReactorClient(client);
+		const documentCache = new DocumentCache(client);
+		setDocumentCache(documentCache);
+		return () => {
+			documentCache.dispose();
+			client.dispose();
+		};
+	}, [client]);
+	useEffect(() => {
+		if (!attachmentService) return;
+		ensurePHEventHandlers();
+		setAttachmentService(attachmentService);
+	}, [attachmentService]);
+	useEffect(() => {
+		if (!documentModels || documentModels.length === 0) return;
+		ensurePHEventHandlers();
+		setVetraPackageManager(new StaticPackageManager([packageFromDocumentModels(documentModels)]));
+	}, [documentModels]);
+	return /* @__PURE__ */ jsx(Fragment, { children });
+}
+/**
+* Returns the {@link GraphQLReactorClient} mounted by
+* {@link GraphQLReactorProvider}, or `undefined` when the slot holds something
+* else - the full in-browser reactor client, or nothing yet.
+*
+* `useReactorClient` is typed as the narrow `IReactorBrowserClient` subset both
+* implementations share. This is how a component reaches the light client's own
+* surface, i.e. `subgraph` and `request`.
+*
+* The narrowing is by brand, not by `instanceof`: a page can carry two copies
+* of this module - a bundled package with its own copy, or a hot-replaced one -
+* and `instanceof` would then answer `false` for a perfectly good client and
+* leave the component silently without one.
+*/
+function useSwitchboardClient() {
+	const client = useReactorClient();
+	return isGraphQLReactorClient(client) ? client : void 0;
+}
+//#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);
+}
+/**
+* Resolves a document model module by document type, mirroring the registry's
+* semantics (`IDocumentModelRegistry.getModule`): with `version` omitted the
+* LATEST version of the type wins (`version ?? 1` as each module's default),
+* with `version` given only an exact match is returned. The reactor resolves
+* modules the same way when a document is created, so metadata read through
+* this hook and the version a creation actually uses cannot disagree.
+*/
+function useDocumentModelModuleById(id, version) {
+	const documentModelModules = useDocumentModelModules();
+	if (!id || !documentModelModules) return void 0;
+	let latestModule;
+	let latestVersion = -1;
+	for (const module of documentModelModules) {
+		if (module.documentModel.global.id !== id) continue;
+		const moduleVersion = module.version ?? 1;
+		if (version !== void 0) {
+			if (moduleVersion === version) return module;
+			continue;
+		}
+		if (moduleVersion > latestVersion) {
+			latestVersion = moduleVersion;
+			latestModule = module;
+		}
+	}
+	return latestModule;
+}
+//#endregion
+//#region src/hooks/document-operations.ts
+/**
+* Hook to fetch document operations via the reactor client.
+* Operations are no longer auto-populated on documents and must be fetched explicitly.
+*
+* @param documentId - The document ID to fetch operations for
+* @returns Object containing globalOperations, localOperations, isLoading, and error
+*/
+function useDocumentOperations(documentId) {
+	const reactorClient = useReactorClient();
+	const hasFetchedRef = useRef(false);
+	const [state, setState] = useState(() => ({
+		globalOperations: [],
+		localOperations: [],
+		isLoading: !!documentId,
+		error: void 0
+	}));
+	const fetchOperations = useCallback(async (retryCount = 0) => {
+		const MAX_RETRIES = 5;
+		const RETRY_DELAY_MS = 500;
+		if (!documentId || !reactorClient) {
+			setState({
+				globalOperations: [],
+				localOperations: [],
+				isLoading: false,
+				error: void 0
+			});
+			return;
+		}
+		setState((prev) => ({
+			...prev,
+			isLoading: true,
+			error: void 0
+		}));
+		let globalOps = [];
+		let localOps = [];
+		let fetchError;
+		try {
+			globalOps = (await reactorClient.getOperations(documentId, { scopes: ["global"] })).results;
+		} catch (err) {
+			fetchError = err instanceof Error ? err : new Error(String(err));
+		}
+		if (!fetchError) try {
+			localOps = (await reactorClient.getOperations(documentId, { scopes: ["local"] })).results;
+		} catch (err) {
+			fetchError = err instanceof Error ? err : new Error(String(err));
+		}
+		if (!fetchError && globalOps.length === 0 && localOps.length === 0 && retryCount < MAX_RETRIES) {
+			await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+			return fetchOperations(retryCount + 1);
+		}
+		setState({
+			globalOperations: globalOps,
+			localOperations: localOps,
+			isLoading: false,
+			error: fetchError
+		});
+		hasFetchedRef.current = true;
+	}, [documentId, reactorClient]);
+	useEffect(() => {
+		if (documentId && reactorClient) fetchOperations();
+		else if (!documentId) {
+			setState({
+				globalOperations: [],
+				localOperations: [],
+				isLoading: false,
+				error: void 0
+			});
+			hasFetchedRef.current = false;
+		}
+	}, [
+		documentId,
+		reactorClient,
+		fetchOperations
+	]);
+	const refetch = useCallback(() => {
+		fetchOperations(0);
+	}, [fetchOperations]);
+	return {
+		...state,
+		refetch
+	};
+}
+//#endregion
+export { useGraphQLReactorClient as $, ReactorOperationFieldsFragmentDoc as $i, setIsDeletePublicDrivesEnabled as $n, useIsEditorReadModeEnabled as $r, addIsCloudDrivesEnabledEventHandler as $t, isFolderNodeKind as A, showPHModal as Aa, phDocumentEditorConfigSetters as Ai, addWarnOutdatedAppEventHandler as An, useBasePath as Ar, addFeaturesEventHandler as At, setReactorClientModule as B, makeAuthConnectionParams as Bi, setEnabledEditors as Bn, useIsAddLocalDrivesEnabled as Br, addDefaultDrivesUrlEventHandler as Bt, useSelectedNode as C, getUserPermissions as Ca, addAllowedDocumentTypesEventHandler as Ci, addSentryDsnEventHandler as Cn, setStudioMode as Cr, extractNodeIdFromSlug as Ct, useFolderNodesInSelectedDrive as D, setPHModal as Da, phAppConfigHooks as Di, addSwitchboardUrlEventHandler as Dn, setWarnOutdatedApp as Dr, makeDriveUrlComponent as Dt, useFileNodesInSelectedDrive as E, closePHModal as Ea, isExternalControlsEnabledEventFunctions as Ei, addStudioModeEventHandler as En, setVersionCheckInterval as Er, getPathWithoutBase as Et, showRevisionHistory as F, NoSelectedDocumentError as Fa, useIsDragAndDropEnabled as Fi, setBasePath as Fn, useEnabledEditors as Fr, useAttachmentService as Ft, useReactorClientModule as G, subgraphUrlFromGraphqlUrl as Gi, setIsAddLocalDrivesEnabled as Gn, useIsCloudDrivesEnabled as Gr, addGaTrackingIdEventHandler as Gt, useModelRegistry as H, subscriptionsUrlFromGraphqlUrl as Hi, setGaTrackingId as Hn, useIsAnalyticsDatabaseWorkerEnabled as Hr, addDrivesPreserveStrategyEventHandler as Ht, useRevisionHistoryVisible as I, UnsupportedDocumentTypeError as Ia, useIsExternalControlsEnabled as Ii, setCliVersion as In, useFileUploadOperationsChunkSize as Ir, addAllowListEventHandler as It, addPackageDiscoveryServiceEventHandler as J, resolveDocumentModelModule as Ji, setIsAnalyticsEnabled as Jn, useIsDeletePublicDrivesEnabled as Jr, addIsAddLocalDrivesEnabledEventHandler as Jt, useSync as K, StaticPackageManager as Ki, setIsAddPublicDrivesEnabled as Kn, useIsDeleteCloudDrivesEnabled as Kr, addIsAddCloudDrivesEnabledEventHandler as Kt, addReactorClientEventHandler as L, GraphQLReactorClient as Li, setDefaultDrivesUrl as Ln, useGaTrackingId as Lr, addAnalyticsDatabaseNameEventHandler as Lt, addRevisionHistoryVisibleEventHandler as M, DocumentModelNotFoundError as Ma, setIsDragAndDropEnabled as Mi, phGlobalConfigSetters as Mn, useDefaultDrivesUrl as Mr, useFeatures as Mt, hideRevisionHistory as N, DocumentNotFoundError as Na, setIsExternalControlsEnabled as Ni, setAllowList as Nn, useDisabledEditors as Nr, addAttachmentServiceEventHandler as Nt, useNodesInSelectedDrive as O, showCreateDocumentModal as Oa, phAppConfigSetters as Oi, addVersionCheckIntervalEventHandler as On, useAllowList as Or, makeNodeSlug as Ot, setRevisionHistoryVisible as P, DocumentTypeMismatchError as Pa, useAllowedDocumentTypes as Pi, setAnalyticsDatabaseName as Pn, useDrivesPreserveStrategy as Pr, setAttachmentService as Pt, setGraphQLReactorClient as Q, MutateDocumentWithOperationsDocument as Qi, setIsDeleteLocalDrivesEnabled as Qn, useIsEditorDebugModeEnabled as Qr, addIsAnalyticsExternalProcessorsEnabledEventHandler as Qt, addReactorClientModuleEventHandler as R, isGraphQLReactorClient as Ri, setDisabledEditors as Rn, useIsAddCloudDrivesEnabled as Rr, addBasePathEventHandler as Rt, useSelectedTimelineItem as S, upgradeDocument as Sa, useWarnOutdatedApp as Si, addRouterBasenameEventHandler as Sn, setSentryRelease as Sr, extractNodeIdFromPath as St, useDocumentsInSelectedDrive as T, addModalEventHandler as Ta, addIsExternalControlsEnabledEventHandler as Ti, addSentryReleaseEventHandler as Tn, setVersion as Tr, findUuid as Tt, usePGlite as U, SubgraphSdkRegistry as Ui, setIsAddCloudDrivesEnabled as Un, useIsAnalyticsEnabled as Ur, addEnabledEditorsEventHandler as Ut, useDatabase as V, startDocumentChangesSubscription as Vi, setFileUploadOperationsChunkSize as Vn, useIsAddPublicDrivesEnabled as Vr, addDisabledEditorsEventHandler as Vt, useReactorClient as W, describeGraphQLDocument as Wi, setIsAddDriveEnabled as Wn, useIsAnalyticsExternalProcessorsEnabled as Wr, addFileUploadOperationsChunkSizeEventHandler as Wt, usePackageDiscoveryService as X, signStampedAction as Xi, setIsCloudDrivesEnabled as Xn, useIsDocumentModelSelectionSettingsEnabled as Xr, addIsAnalyticsDatabaseWorkerEnabledEventHandler as Xt, setPackageDiscoveryService as Y, prepareSignedActions as Yi, setIsAnalyticsExternalProcessorsEnabled as Yn, useIsDiffAnalyticsEnabled as Yr, addIsAddPublicDrivesEnabledEventHandler as Yt, addGraphQLReactorClientEventHandler as Z, stampAction as Zi, setIsDeleteCloudDrivesEnabled as Zn, useIsDriveAnalyticsEnabled as Zr, addIsAnalyticsEnabledEventHandler as Zt, addSelectedTimelineRevisionEventHandler as _, exportFile as _a, useSentryRelease as _i, addRenownAdaptersEventHandler as _n, setRenownUrl as _r, useDrives as _t, ensurePHEventHandlers as a, ConflictError as aa, useIsRelationalProcessorsEnabled as ai, addIsDriveAnalyticsEnabledEventHandler as an, setIsExternalPackagesEnabled as ar, addSetSelectedDriveOnPopStateEventHandler as at, addSelectedTimelineItemEventHandler as b, renameDriveNode as ba, useVersion as bi, addRenownUrlEventHandler as bn, setSentryDsn as br, extractDriveIdFromSlug as bt, callEventHandlerRegisterFunctions as c, extractRevisionMap as ca, useLogLevel as ci, addIsExternalPackagesEnabledEventHandler as cn, setIsLocalDrivesEnabled as cr, useSelectedDrive as ct, setVetraPackageManager as d, addDocument as da, useRenownNetworkId as di, addIsLocalDrivesEnabledEventHandler as dn, setIsSentryTracingEnabled as dr, addResetSelectedNodeEventHandler as dt, ambientRenownTokenProvider as ea, useIsExternalPackagesEnabled as ei, addIsDeleteCloudDrivesEnabledEventHandler as en, setIsDiffAnalyticsEnabled as er, addDraggingNodeEventHandler as et, useVetraPackageManager as f, addFile as fa, useRenownUrl as fi, addIsPublicDrivesEnabledEventHandler as fn, setLocalDrivesEnabled as fr, addSelectedNodeIdEventHandler as ft, usePHToast as g, deleteNode as ga, useSentryEnv as gi, addLogLevelEventHandler as gn, setRenownNetworkId as gr, setDrives as gt, setPHToast as h, copyNode$1 as ha, useSentryDsn as hi, addLocalDrivesEnabledEventHandler as hn, setRenownChainId as hr, addDrivesEventHandler as ht, GraphQLReactorProvider as i, revisionMapFromRevisionsList as ia, useIsPublicDrivesEnabled as ii, addIsDocumentModelSelectionSettingsEnabledEventHandler as in, setIsEditorReadModeEnabled as ir, addSelectedDriveIdEventHandler as it, sortNodesByName as j, usePHModal as ja, setAllowedDocumentTypes as ji, phGlobalConfigHooks as jn, useCliVersion as jr, setFeatures as jt, isFileNodeKind as k, showDeleteNodeModal as ka, phDocumentEditorConfigHooks as ki, addVersionEventHandler as kn, useAnalyticsDatabaseName as kr, resolveUrlPathname as kt, commonGlobalEventHandlerFunctions as l, hasRevisionConflict as la, useRenownAdapters as li, addIsExternalProcessorsEnabledEventHandler as ln, setIsPublicDrivesEnabled as lr, useSelectedDriveId as lt, addToastEventHandler as m, addFolder$1 as ma, useRouterBasename as mi, addIsSentryTracingEnabledEventHandler as mn, setRenownAdapters as mr, setSelectedNode as mt, useDocumentModelModuleById as n, phDocumentFromGetDocument as na, useIsExternalRelationalProcessorsEnabled as ni, addIsDeletePublicDrivesEnabledEventHandler as nn, setIsDriveAnalyticsEnabled as nr, useDropNode as nt, useSwitchboardClient as o, buildPulledDocument as oa, useIsSentryTracingEnabled as oi, addIsEditorDebugModeEnabledEventHandler as on, setIsExternalProcessorsEnabled as or, setSelectedDrive as ot, useVetraPackages as p, addFileWithProgress as pa, useRequiresHardRefresh as pi, addIsRelationalProcessorsEnabledEventHandler as pn, setLogLevel as pr, addSetSelectedNodeOnPopStateEventHandler as pt, useSyncList as q, packageFromDocumentModels as qi, setIsAnalyticsDatabaseWorkerEnabled as qn, useIsDeleteLocalDrivesEnabled as qr, addIsAddDriveEnabledEventHandler as qt, useDocumentModelModules as r, phDocumentFromMutation as ra, useIsLocalDrivesEnabled as ri, addIsDiffAnalyticsEnabledEventHandler as rn, setIsEditorDebugModeEnabled as rr, useDropTarget as rt, addPHEventHandlers as s, convertRemoteOperations as sa, useLocalDrivesEnabled as si, addIsEditorReadModeEnabledEventHandler as sn, setIsExternalRelationalProcessorsEnabled as sr, setSelectedDriveId as st, useDocumentOperations as t, makeAuthMiddleware as ta, useIsExternalProcessorsEnabled as ti, addIsDeleteLocalDrivesEnabledEventHandler as tn, setIsDocumentModelSelectionSettingsEnabled as tr, useDragNode as tt, addVetraPackageManagerEventHandler as u, screamingSnakeToCamel as ua, useRenownChainId as ui, addIsExternalRelationalProcessorsEnabledEventHandler as un, setIsRelationalProcessorsEnabled as ur, useSelectedDriveSafe as ut, setSelectedTimelineRevision as v, loadFile as va, useStudioMode as vi, addRenownChainIdEventHandler as vn, setRequiresHardRefresh as vr, createUrlWithPreservedParams as vt, useDocumentTypesInSelectedDrive as w, isDocumentTypeSupported as wa, addIsDragAndDropEnabledEventHandler as wi, addSentryEnvEventHandler as wn, setSwitchboardUrl as wr, extractNodeSlugFromPath as wt, setSelectedTimelineItem as x, renameNode as xa, useVersionCheckInterval as xi, addRequiresHardRefreshEventHandler as xn, setSentryEnv as xr, extractDriveSlugFromPath as xt, useSelectedTimelineRevision as y, moveNode$1 as ya, useSwitchboardUrl as yi, addRenownNetworkIdEventHandler as yn, setRouterBasename as yr, extractDriveIdFromPath as yt, setReactorClient as z, viewFilterInputFromViewFilter as zi, setDrivesPreserveStrategy as zn, useIsAddDriveEnabled as zr, addCliVersionEventHandler as zt };
+
+//# sourceMappingURL=document-operations-C6nce9dH.js.map