@yurikilian/lex4 0.1.0

package/dist/lex4-editor.cjs

@@ -0,0 +1,3774 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+const lexical = require("lexical");
+const LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const list = require("@lexical/list");
+const LexicalComposer = require("@lexical/react/LexicalComposer");
+const LexicalRichTextPlugin = require("@lexical/react/LexicalRichTextPlugin");
+const LexicalContentEditable = require("@lexical/react/LexicalContentEditable");
+const LexicalListPlugin = require("@lexical/react/LexicalListPlugin");
+const LexicalErrorBoundary = require("@lexical/react/LexicalErrorBoundary");
+const LexicalOnChangePlugin = require("@lexical/react/LexicalOnChangePlugin");
+const richText = require("@lexical/rich-text");
+function createEmptyPage(id) {
+  return {
+    id: id ?? crypto.randomUUID(),
+    bodyState: null,
+    headerState: null,
+    footerState: null,
+    headerHeight: 0,
+    footerHeight: 0,
+    bodySyncVersion: 0,
+    headerSyncVersion: 0,
+    footerSyncVersion: 0
+  };
+}
+function createPageFromTemplate(template) {
+  return {
+    ...createEmptyPage(),
+    headerState: (template == null ? void 0 : template.headerState) ?? null,
+    footerState: (template == null ? void 0 : template.footerState) ?? null,
+    headerHeight: (template == null ? void 0 : template.headerHeight) ?? 0,
+    footerHeight: (template == null ? void 0 : template.footerHeight) ?? 0
+  };
+}
+function createEmptyDocument() {
+  return {
+    pages: [createEmptyPage()],
+    headerFooterEnabled: false,
+    pageCounterMode: "none",
+    defaultHeaderState: null,
+    defaultFooterState: null,
+    defaultHeaderHeight: 0,
+    defaultFooterHeight: 0
+  };
+}
+const DocumentContext = React.createContext(null);
+function useDocument() {
+  const ctx = React.useContext(DocumentContext);
+  if (!ctx) {
+    throw new Error("useDocument must be used within a DocumentProvider");
+  }
+  return ctx;
+}
+const A4_WIDTH_MM = 210;
+const A4_HEIGHT_MM = 297;
+const PX_PER_MM = 96 / 25.4;
+const A4_WIDTH_PX = Math.round(A4_WIDTH_MM * PX_PER_MM);
+const A4_HEIGHT_PX = Math.round(A4_HEIGHT_MM * PX_PER_MM);
+const PAGE_MARGIN_PX = 40;
+const MAX_HEADER_RATIO = 0.2;
+const MAX_FOOTER_RATIO = 0.2;
+const MAX_HEADER_HEIGHT_PX = Math.round(A4_HEIGHT_PX * MAX_HEADER_RATIO);
+const MAX_FOOTER_HEIGHT_PX = Math.round(A4_HEIGHT_PX * MAX_FOOTER_RATIO);
+const CHANNEL_COLORS = {
+  reducer: "#e91e63",
+  overflow: "#ff5722",
+  registry: "#9c27b0",
+  page: "#2196f3",
+  toolbar: "#4caf50",
+  header: "#ff9800",
+  footer: "#795548",
+  focus: "#607d8b"
+};
+function getFlag() {
+  if (typeof window === "undefined") return null;
+  const win = window.__LEX4_DEBUG__;
+  if (win !== void 0 && win !== null) return win;
+  if (typeof localStorage !== "undefined") {
+    return localStorage.getItem("lex4:debug");
+  }
+  return null;
+}
+function isEnabled(channel) {
+  const flag = getFlag();
+  if (!flag) return false;
+  if (flag === true || flag === "*" || flag === "true") return true;
+  if (typeof flag === "string") {
+    return flag.split(",").some((s) => s.trim() === channel);
+  }
+  return false;
+}
+function debug(channel, message, ...data) {
+  if (!isEnabled(channel)) return;
+  const color = CHANNEL_COLORS[channel];
+  const prefix = `%c[lex4:${channel}]`;
+  const style = `color: ${color}; font-weight: bold;`;
+  if (data.length > 0) {
+    console.log(prefix, style, message, ...data);
+  } else {
+    console.log(prefix, style, message);
+  }
+}
+function debugWarn(channel, message, ...data) {
+  if (!isEnabled(channel)) return;
+  const color = CHANNEL_COLORS[channel];
+  const prefix = `%c[lex4:${channel}]`;
+  const style = `color: ${color}; font-weight: bold;`;
+  if (data.length > 0) {
+    console.warn(prefix, style, message, ...data);
+  } else {
+    console.warn(prefix, style, message);
+  }
+}
+function shortId(id) {
+  return id.substring(0, 8);
+}
+function serializedStateChanged(current, next) {
+  return JSON.stringify(current) !== JSON.stringify(next);
+}
+function withExternalSyncVersions(currentDocument, nextDocument) {
+  const currentPages = new Map(currentDocument.pages.map((page) => [page.id, page]));
+  return {
+    ...nextDocument,
+    pages: nextDocument.pages.map((nextPage) => {
+      const currentPage = currentPages.get(nextPage.id);
+      if (!currentPage) {
+        return nextPage;
+      }
+      const bodyChanged = serializedStateChanged(currentPage.bodyState, nextPage.bodyState);
+      const headerChanged = currentPage.headerHeight !== nextPage.headerHeight || serializedStateChanged(currentPage.headerState, nextPage.headerState);
+      const footerChanged = currentPage.footerHeight !== nextPage.footerHeight || serializedStateChanged(currentPage.footerState, nextPage.footerState);
+      return {
+        ...nextPage,
+        bodySyncVersion: bodyChanged ? currentPage.bodySyncVersion + 1 : currentPage.bodySyncVersion,
+        headerSyncVersion: headerChanged ? currentPage.headerSyncVersion + 1 : currentPage.headerSyncVersion,
+        footerSyncVersion: footerChanged ? currentPage.footerSyncVersion + 1 : currentPage.footerSyncVersion
+      };
+    })
+  };
+}
+function documentReducer(state, action) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  switch (action.type) {
+    case "ADD_PAGE": {
+      const newPage = action.page ?? createEmptyPage();
+      const pages = [...state.pages];
+      const insertAt = action.afterIndex !== void 0 ? action.afterIndex + 1 : pages.length;
+      pages.splice(insertAt, 0, newPage);
+      const hasBody = !!((_d = (_c = (_b = (_a = action.page) == null ? void 0 : _a.bodyState) == null ? void 0 : _b.root) == null ? void 0 : _c.children) == null ? void 0 : _d.length);
+      debug("reducer", `ADD_PAGE id=${shortId(newPage.id)} at=${insertAt} withBody=${hasBody} totalPages=${pages.length}`);
+      return { ...state, pages };
+    }
+    case "REMOVE_PAGE": {
+      if (state.pages.length <= 1) {
+        debug("reducer", `REMOVE_PAGE id=${shortId(action.pageId)} — skipped (last page)`);
+        return state;
+      }
+      debug("reducer", `REMOVE_PAGE id=${shortId(action.pageId)} remaining=${state.pages.length - 1}`);
+      return {
+        ...state,
+        pages: state.pages.filter((p) => p.id !== action.pageId)
+      };
+    }
+    case "UPDATE_PAGE_BODY": {
+      const childCount = ((_g = (_f = (_e = action.bodyState) == null ? void 0 : _e.root) == null ? void 0 : _f.children) == null ? void 0 : _g.length) ?? 0;
+      debug("reducer", `UPDATE_PAGE_BODY id=${shortId(action.pageId)} children=${childCount}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, bodyState: action.bodyState } : p
+        )
+      };
+    }
+    case "UPDATE_PAGE_HEADER": {
+      debug("reducer", `UPDATE_PAGE_HEADER id=${shortId(action.pageId)}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, headerState: action.headerState } : p
+        )
+      };
+    }
+    case "UPDATE_PAGE_HEADER_CONTENT": {
+      const clamped = Math.min(action.height, MAX_HEADER_HEIGHT_PX);
+      debug("reducer", `UPDATE_PAGE_HEADER_CONTENT id=${shortId(action.pageId)} height=${clamped}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, headerState: action.headerState, headerHeight: clamped } : p
+        )
+      };
+    }
+    case "UPDATE_PAGE_FOOTER": {
+      debug("reducer", `UPDATE_PAGE_FOOTER id=${shortId(action.pageId)}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, footerState: action.footerState } : p
+        )
+      };
+    }
+    case "UPDATE_PAGE_FOOTER_CONTENT": {
+      const clamped = Math.min(action.height, MAX_FOOTER_HEIGHT_PX);
+      debug("reducer", `UPDATE_PAGE_FOOTER_CONTENT id=${shortId(action.pageId)} height=${clamped}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, footerState: action.footerState, footerHeight: clamped } : p
+        )
+      };
+    }
+    case "SET_HEADER_FOOTER_ENABLED": {
+      debug("reducer", `SET_HEADER_FOOTER_ENABLED enabled=${action.enabled}`);
+      return { ...state, headerFooterEnabled: action.enabled };
+    }
+    case "SET_PAGE_COUNTER_MODE": {
+      debug("reducer", `SET_PAGE_COUNTER_MODE mode=${action.mode}`);
+      return { ...state, pageCounterMode: action.mode };
+    }
+    case "COPY_HEADER_TO_ALL": {
+      debug("reducer", `COPY_HEADER_TO_ALL from=${shortId(action.sourcePageId)}`);
+      const source = state.pages.find((p) => p.id === action.sourcePageId);
+      if (!source) return state;
+      return {
+        ...state,
+        defaultHeaderState: source.headerState,
+        defaultHeaderHeight: source.headerHeight,
+        pages: state.pages.map((p) => ({
+          ...p,
+          headerState: source.headerState,
+          headerHeight: source.headerHeight,
+          headerSyncVersion: p.headerSyncVersion + 1
+        }))
+      };
+    }
+    case "COPY_FOOTER_TO_ALL": {
+      debug("reducer", `COPY_FOOTER_TO_ALL from=${shortId(action.sourcePageId)}`);
+      const source = state.pages.find((p) => p.id === action.sourcePageId);
+      if (!source) return state;
+      return {
+        ...state,
+        defaultFooterState: source.footerState,
+        defaultFooterHeight: source.footerHeight,
+        pages: state.pages.map((p) => ({
+          ...p,
+          footerState: source.footerState,
+          footerHeight: source.footerHeight,
+          footerSyncVersion: p.footerSyncVersion + 1
+        }))
+      };
+    }
+    case "CLEAR_HEADER": {
+      debug("reducer", `CLEAR_HEADER id=${shortId(action.pageId)}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, headerState: null, headerHeight: 0, headerSyncVersion: p.headerSyncVersion + 1 } : p
+        )
+      };
+    }
+    case "CLEAR_FOOTER": {
+      debug("reducer", `CLEAR_FOOTER id=${shortId(action.pageId)}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, footerState: null, footerHeight: 0, footerSyncVersion: p.footerSyncVersion + 1 } : p
+        )
+      };
+    }
+    case "CLEAR_ALL_HEADERS": {
+      debug("reducer", "CLEAR_ALL_HEADERS");
+      return {
+        ...state,
+        defaultHeaderState: null,
+        defaultHeaderHeight: 0,
+        pages: state.pages.map((p) => ({
+          ...p,
+          headerState: null,
+          headerHeight: 0,
+          headerSyncVersion: p.headerSyncVersion + 1
+        }))
+      };
+    }
+    case "CLEAR_ALL_FOOTERS": {
+      debug("reducer", "CLEAR_ALL_FOOTERS");
+      return {
+        ...state,
+        defaultFooterState: null,
+        defaultFooterHeight: 0,
+        pages: state.pages.map((p) => ({
+          ...p,
+          footerState: null,
+          footerHeight: 0,
+          footerSyncVersion: p.footerSyncVersion + 1
+        }))
+      };
+    }
+    case "CLEAR_DOCUMENT_CONTENT": {
+      debug("reducer", "CLEAR_DOCUMENT_CONTENT");
+      const firstPage = state.pages[0];
+      return {
+        ...state,
+        pages: [{
+          ...createEmptyPage(firstPage == null ? void 0 : firstPage.id),
+          headerState: (firstPage == null ? void 0 : firstPage.headerState) ?? null,
+          footerState: (firstPage == null ? void 0 : firstPage.footerState) ?? null,
+          headerHeight: (firstPage == null ? void 0 : firstPage.headerHeight) ?? 0,
+          footerHeight: (firstPage == null ? void 0 : firstPage.footerHeight) ?? 0,
+          bodySyncVersion: ((firstPage == null ? void 0 : firstPage.bodySyncVersion) ?? 0) + 1,
+          headerSyncVersion: (firstPage == null ? void 0 : firstPage.headerSyncVersion) ?? 0,
+          footerSyncVersion: (firstPage == null ? void 0 : firstPage.footerSyncVersion) ?? 0
+        }]
+      };
+    }
+    case "SET_HEADER_HEIGHT": {
+      const clamped = Math.min(action.height, MAX_HEADER_HEIGHT_PX);
+      debug("header", `SET_HEADER_HEIGHT id=${shortId(action.pageId)} raw=${action.height} clamped=${clamped}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, headerHeight: clamped } : p
+        )
+      };
+    }
+    case "SET_FOOTER_HEIGHT": {
+      const clamped = Math.min(action.height, MAX_FOOTER_HEIGHT_PX);
+      debug("footer", `SET_FOOTER_HEIGHT id=${shortId(action.pageId)} raw=${action.height} clamped=${clamped}`);
+      return {
+        ...state,
+        pages: state.pages.map(
+          (p) => p.id === action.pageId ? { ...p, footerHeight: clamped } : p
+        )
+      };
+    }
+    case "SET_DOCUMENT": {
+      debug("reducer", `SET_DOCUMENT pages=${action.document.pages.length}`);
+      return withExternalSyncVersions(state, action.document);
+    }
+    default:
+      return state;
+  }
+}
+const MAX_HISTORY_ACTIONS = 100;
+function cloneSnapshot(document2) {
+  return structuredClone(document2);
+}
+function createHistoryEntry(document2, descriptor, undoSnapshot, caretPosition, caretSelection, undoCaretPosition, undoCaretSelection) {
+  return {
+    ...descriptor,
+    id: crypto.randomUUID(),
+    snapshot: cloneSnapshot(document2),
+    undoSnapshot: cloneSnapshot(undoSnapshot),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    caretPosition,
+    caretSelection,
+    undoCaretPosition,
+    undoCaretSelection
+  };
+}
+function createHistoryState(document2, baseCaretPosition = null) {
+  return {
+    baseSnapshot: cloneSnapshot(document2),
+    baseCaretPosition,
+    entries: [],
+    cursor: 0
+  };
+}
+function getHistorySnapshot(history, cursor = history.cursor) {
+  if (cursor <= 0) {
+    return cloneSnapshot(history.baseSnapshot);
+  }
+  return cloneSnapshot(history.entries[cursor - 1].snapshot);
+}
+function clearHistoryState(document2, baseCaretPosition = null) {
+  return createHistoryState(document2, baseCaretPosition);
+}
+function recordHistoryEntry(history, nextDocument, descriptor, undoSnapshot, caretPosition, caretSelection, undoCaretPosition, undoCaretSelection) {
+  const entries = history.entries.slice(0, history.cursor);
+  entries.push(createHistoryEntry(
+    nextDocument,
+    descriptor,
+    undoSnapshot,
+    caretPosition,
+    caretSelection,
+    undoCaretPosition,
+    undoCaretSelection
+  ));
+  let baseSnapshot = cloneSnapshot(history.baseSnapshot);
+  let baseCaretPosition = history.baseCaretPosition;
+  let trimmedEntries = entries;
+  if (trimmedEntries.length > MAX_HISTORY_ACTIONS) {
+    baseSnapshot = cloneSnapshot(trimmedEntries[1].undoSnapshot);
+    baseCaretPosition = trimmedEntries[1].undoCaretPosition;
+    trimmedEntries = trimmedEntries.slice(1);
+  }
+  return {
+    baseSnapshot,
+    baseCaretPosition,
+    entries: trimmedEntries,
+    cursor: trimmedEntries.length
+  };
+}
+function undoHistory(history) {
+  if (history.cursor === 0) {
+    return null;
+  }
+  const cursor = history.cursor - 1;
+  const nextHistory = {
+    ...history,
+    cursor
+  };
+  return {
+    history: nextHistory,
+    document: cloneSnapshot(history.entries[history.cursor - 1].undoSnapshot),
+    caretPosition: history.entries[history.cursor - 1].undoCaretPosition,
+    caretSelection: history.entries[history.cursor - 1].undoCaretSelection
+  };
+}
+function redoHistory(history) {
+  var _a, _b;
+  if (history.cursor >= history.entries.length) {
+    return null;
+  }
+  const cursor = history.cursor + 1;
+  const nextHistory = {
+    ...history,
+    cursor
+  };
+  return {
+    history: nextHistory,
+    document: getHistorySnapshot(nextHistory),
+    caretPosition: ((_a = nextHistory.entries[cursor - 1]) == null ? void 0 : _a.caretPosition) ?? nextHistory.baseCaretPosition,
+    caretSelection: ((_b = nextHistory.entries[cursor - 1]) == null ? void 0 : _b.caretSelection) ?? null
+  };
+}
+function jumpToHistoryEntry(history, entryIndex) {
+  var _a, _b;
+  if (entryIndex < 0 || entryIndex >= history.entries.length) {
+    return null;
+  }
+  const nextHistory = {
+    ...history,
+    cursor: entryIndex + 1
+  };
+  return {
+    history: nextHistory,
+    document: getHistorySnapshot(nextHistory),
+    caretPosition: ((_a = nextHistory.entries[nextHistory.cursor - 1]) == null ? void 0 : _a.caretPosition) ?? nextHistory.baseCaretPosition,
+    caretSelection: ((_b = nextHistory.entries[nextHistory.cursor - 1]) == null ? void 0 : _b.caretSelection) ?? null
+  };
+}
+const HISTORY_RESTORE_SUPPRESSION_MS = 100;
+const HISTORY_BATCH_FLUSH_MS = 16;
+function cloneDocumentSnapshot(document2) {
+  return structuredClone(document2);
+}
+function captureUndoSnapshot(document2, activeEditor, caretPosition) {
+  const snapshot = cloneDocumentSnapshot(document2);
+  if (!activeEditor || !caretPosition) {
+    return snapshot;
+  }
+  const page = snapshot.pages.find((candidate) => candidate.id === caretPosition.pageId);
+  if (!page) {
+    return snapshot;
+  }
+  const editorState = activeEditor.getEditorState().toJSON();
+  if (caretPosition.region === "body") {
+    page.bodyState = editorState;
+  } else if (caretPosition.region === "header") {
+    page.headerState = editorState;
+  } else {
+    page.footerState = editorState;
+  }
+  return snapshot;
+}
+function captureCaretSelection(editor) {
+  if (!editor) {
+    return null;
+  }
+  const rootElement = editor.getRootElement();
+  const domSelection = window.getSelection();
+  const selectionInRoot = (node) => !!node && !!rootElement && (node === rootElement || rootElement.contains(node));
+  const getTextOffset = (node, offset) => {
+    if (!rootElement) {
+      return 0;
+    }
+    const range = document.createRange();
+    range.setStart(rootElement, 0);
+    range.setEnd(node, offset);
+    return range.toString().length;
+  };
+  let caretSelection = null;
+  editor.getEditorState().read(() => {
+    const selection = lexical.$createRangeSelectionFromDom(window.getSelection(), editor) ?? lexical.$getSelection();
+    if (!lexical.$isRangeSelection(selection)) {
+      return;
+    }
+    caretSelection = {
+      anchor: {
+        key: selection.anchor.key,
+        offset: selection.anchor.offset,
+        type: selection.anchor.type
+      },
+      focus: {
+        key: selection.focus.key,
+        offset: selection.focus.offset,
+        type: selection.focus.type
+      },
+      anchorTextOffset: domSelection && selectionInRoot(domSelection.anchorNode) ? getTextOffset(domSelection.anchorNode, domSelection.anchorOffset) : 0,
+      focusTextOffset: domSelection && selectionInRoot(domSelection.focusNode) ? getTextOffset(domSelection.focusNode, domSelection.focusOffset) : 0,
+      format: selection.format,
+      style: selection.style
+    };
+  });
+  return caretSelection;
+}
+function getPageNumber(document2, pageId) {
+  if (!pageId) {
+    return null;
+  }
+  const index = document2.pages.findIndex((page) => page.id === pageId);
+  return index >= 0 ? index + 1 : null;
+}
+function describeAction(action, document2) {
+  switch (action.type) {
+    case "UPDATE_PAGE_BODY": {
+      const pageNumber = getPageNumber(document2, action.pageId);
+      return {
+        label: pageNumber ? `Edited body - Page ${pageNumber}` : "Edited body",
+        source: "body",
+        pageId: action.pageId,
+        region: "body"
+      };
+    }
+    case "UPDATE_PAGE_HEADER":
+    case "UPDATE_PAGE_HEADER_CONTENT": {
+      const pageNumber = getPageNumber(document2, action.pageId);
+      return {
+        label: pageNumber ? `Edited header - Page ${pageNumber}` : "Edited header",
+        source: "header",
+        pageId: action.pageId,
+        region: "header"
+      };
+    }
+    case "UPDATE_PAGE_FOOTER":
+    case "UPDATE_PAGE_FOOTER_CONTENT": {
+      const pageNumber = getPageNumber(document2, action.pageId);
+      return {
+        label: pageNumber ? `Edited footer - Page ${pageNumber}` : "Edited footer",
+        source: "footer",
+        pageId: action.pageId,
+        region: "footer"
+      };
+    }
+    case "SET_HEADER_FOOTER_ENABLED":
+      return {
+        label: action.enabled ? "Enabled headers and footers" : "Disabled headers and footers",
+        source: "document",
+        region: "document"
+      };
+    case "SET_PAGE_COUNTER_MODE":
+      return {
+        label: `Page counter set to ${action.mode}`,
+        source: "document",
+        region: "document"
+      };
+    case "COPY_HEADER_TO_ALL":
+      return {
+        label: "Copied header to all pages",
+        source: "toolbar",
+        pageId: action.sourcePageId,
+        region: "header"
+      };
+    case "COPY_FOOTER_TO_ALL":
+      return {
+        label: "Copied footer to all pages",
+        source: "toolbar",
+        pageId: action.sourcePageId,
+        region: "footer"
+      };
+    case "CLEAR_HEADER": {
+      const pageNumber = getPageNumber(document2, action.pageId);
+      return {
+        label: pageNumber ? `Cleared header - Page ${pageNumber}` : "Cleared header",
+        source: "toolbar",
+        pageId: action.pageId,
+        region: "header"
+      };
+    }
+    case "CLEAR_FOOTER": {
+      const pageNumber = getPageNumber(document2, action.pageId);
+      return {
+        label: pageNumber ? `Cleared footer - Page ${pageNumber}` : "Cleared footer",
+        source: "toolbar",
+        pageId: action.pageId,
+        region: "footer"
+      };
+    }
+    case "CLEAR_ALL_HEADERS":
+      return {
+        label: "Cleared all headers",
+        source: "toolbar",
+        region: "header"
+      };
+    case "CLEAR_ALL_FOOTERS":
+      return {
+        label: "Cleared all footers",
+        source: "toolbar",
+        region: "footer"
+      };
+    case "CLEAR_DOCUMENT_CONTENT":
+      return {
+        label: "Cleared document body",
+        source: "document",
+        region: "document"
+      };
+    case "SET_HEADER_HEIGHT": {
+      const pageNumber = getPageNumber(document2, action.pageId);
+      return {
+        label: pageNumber ? `Resized header - Page ${pageNumber}` : "Resized header",
+        source: "header",
+        pageId: action.pageId,
+        region: "header"
+      };
+    }
+    case "SET_FOOTER_HEIGHT": {
+      const pageNumber = getPageNumber(document2, action.pageId);
+      return {
+        label: pageNumber ? `Resized footer - Page ${pageNumber}` : "Resized footer",
+        source: "footer",
+        pageId: action.pageId,
+        region: "footer"
+      };
+    }
+    case "ADD_PAGE":
+      return {
+        label: "Added page",
+        source: "overflow",
+        region: "document"
+      };
+    case "REMOVE_PAGE":
+      return {
+        label: "Removed page",
+        source: "overflow",
+        region: "document"
+      };
+    case "SET_DOCUMENT":
+      return {
+        label: "Document reflow",
+        source: "overflow",
+        region: "document"
+      };
+    default:
+      return {
+        label: "Updated document",
+        source: "document",
+        region: "document"
+      };
+  }
+}
+function documentsAreEqual(current, next) {
+  return JSON.stringify(current) === JSON.stringify(next);
+}
+const DocumentProvider = ({
+  initialDocument,
+  onDocumentChange,
+  children
+}) => {
+  var _a, _b;
+  const initialSnapshot = initialDocument ?? createEmptyDocument();
+  const [document2, baseDispatch] = React.useReducer(documentReducer, initialSnapshot);
+  const [historyState, setHistoryState] = React.useState(() => createHistoryState(initialSnapshot));
+  const documentRef = React.useRef(document2);
+  const historyStateRef = React.useRef(historyState);
+  const [activePageId, setActivePageIdRaw] = React.useState(
+    ((_a = initialSnapshot.pages[0]) == null ? void 0 : _a.id) ?? null
+  );
+  const activePageIdRef = React.useRef(((_b = initialSnapshot.pages[0]) == null ? void 0 : _b.id) ?? null);
+  const [globalSelectionActive, setGlobalSelectionActive] = React.useState(false);
+  const [historySidebarOpen, setHistorySidebarOpen] = React.useState(true);
+  const [focusAtEndVersion, setFocusAtEndVersion] = React.useState(0);
+  const activeEditorRef = React.useRef(null);
+  const activeCaretPositionRef = React.useRef(null);
+  const pendingCaretPositionRef = React.useRef(null);
+  const pendingCaretSelectionRef = React.useRef(null);
+  const pendingFocusAtEndRef = React.useRef(null);
+  const [, forceUpdate] = React.useState(0);
+  const historySuppressedRef = React.useRef(false);
+  const historyReleaseTimerRef = React.useRef(null);
+  const historyFlushTimerRef = React.useRef(null);
+  const pendingHistoryActionRef = React.useRef(null);
+  const pendingUndoSnapshotRef = React.useRef(null);
+  const pendingUndoCaretPositionRef = React.useRef(null);
+  const pendingUndoCaretSelectionRef = React.useRef(null);
+  const historyBatchRef = React.useRef(null);
+  const editorMapRef = React.useRef(/* @__PURE__ */ new Map());
+  const editorRegistry = React.useMemo(() => ({
+    register: (pageId, editor) => {
+      editorMapRef.current.set(pageId, editor);
+    },
+    unregister: (pageId) => {
+      editorMapRef.current.delete(pageId);
+    },
+    get: (pageId) => editorMapRef.current.get(pageId),
+    all: () => Array.from(editorMapRef.current.values())
+  }), []);
+  const setActivePageId = React.useCallback((id) => {
+    activePageIdRef.current = id;
+    setActivePageIdRaw(id);
+  }, []);
+  const setActiveEditor = React.useCallback((editor, caretPosition = null) => {
+    activeEditorRef.current = editor;
+    activeCaretPositionRef.current = caretPosition;
+    forceUpdate((n) => n + 1);
+  }, []);
+  const focusEditorAtEnd = React.useCallback((editor, caretPosition) => {
+    requestAnimationFrame(() => {
+      setActivePageId(caretPosition.pageId);
+      setActiveEditor(editor, caretPosition);
+      editor.focus(() => {
+        editor.update(() => {
+          lexical.$getRoot().selectEnd();
+        });
+      });
+    });
+  }, [setActiveEditor, setActivePageId]);
+  const consumePendingCaretPosition = React.useCallback((caretPosition) => {
+    const pendingCaretPosition = pendingCaretPositionRef.current;
+    if (!pendingCaretPosition || pendingCaretPosition.pageId !== caretPosition.pageId || pendingCaretPosition.region !== caretPosition.region) {
+      return void 0;
+    }
+    pendingCaretPositionRef.current = null;
+    const pendingCaretSelection = pendingCaretSelectionRef.current;
+    pendingCaretSelectionRef.current = null;
+    return pendingCaretSelection;
+  }, []);
+  const consumePendingFocusAtEnd = React.useCallback((caretPosition) => {
+    const pendingFocusAtEnd = pendingFocusAtEndRef.current;
+    if (!pendingFocusAtEnd || pendingFocusAtEnd.pageId !== caretPosition.pageId || pendingFocusAtEnd.region !== caretPosition.region) {
+      return false;
+    }
+    pendingFocusAtEndRef.current = null;
+    return true;
+  }, []);
+  const requestFocusAtEnd = React.useCallback((caretPosition) => {
+    pendingCaretPositionRef.current = null;
+    pendingCaretSelectionRef.current = null;
+    if (caretPosition.region === "body") {
+      const editor = editorRegistry.get(caretPosition.pageId);
+      if (editor) {
+        pendingFocusAtEndRef.current = null;
+        focusEditorAtEnd(editor, caretPosition);
+        return;
+      }
+    }
+    pendingFocusAtEndRef.current = caretPosition;
+    setFocusAtEndVersion((version) => version + 1);
+  }, [editorRegistry, focusEditorAtEnd]);
+  const flushHistoryBatch = React.useCallback(() => {
+    if (historyFlushTimerRef.current) {
+      clearTimeout(historyFlushTimerRef.current);
+      historyFlushTimerRef.current = null;
+    }
+    const batch = historyBatchRef.current;
+    historyBatchRef.current = null;
+    pendingHistoryActionRef.current = null;
+    pendingUndoSnapshotRef.current = null;
+    pendingUndoCaretPositionRef.current = null;
+    pendingUndoCaretSelectionRef.current = null;
+    if (!batch || historySuppressedRef.current || !batch.hasMutation || !batch.nextDocument) {
+      return;
+    }
+    const undoSnapshot = batch.undoSnapshot ?? batch.nextDocument;
+    setHistoryState((previousHistory) => {
+      const nextHistory = recordHistoryEntry(
+        previousHistory,
+        batch.nextDocument,
+        batch.descriptor,
+        undoSnapshot,
+        activeCaretPositionRef.current,
+        captureCaretSelection(activeEditorRef.current),
+        batch.undoCaretPosition,
+        batch.undoCaretSelection
+      );
+      historyStateRef.current = nextHistory;
+      return nextHistory;
+    });
+  }, []);
+  const scheduleHistoryBatchFlush = React.useCallback(() => {
+    if (historyFlushTimerRef.current) {
+      clearTimeout(historyFlushTimerRef.current);
+    }
+    historyFlushTimerRef.current = setTimeout(() => {
+      flushHistoryBatch();
+    }, HISTORY_BATCH_FLUSH_MS);
+  }, [flushHistoryBatch]);
+  const queueHistoryAction = React.useCallback((action) => {
+    pendingHistoryActionRef.current = action;
+    pendingUndoSnapshotRef.current = action ? captureUndoSnapshot(
+      documentRef.current,
+      activeEditorRef.current,
+      activeCaretPositionRef.current
+    ) : null;
+    pendingUndoCaretPositionRef.current = action ? activeCaretPositionRef.current : null;
+    pendingUndoCaretSelectionRef.current = action ? captureCaretSelection(activeEditorRef.current) : null;
+  }, []);
+  const runHistoryAction = React.useCallback((action, callback) => {
+    if (historyBatchRef.current) {
+      callback();
+      return;
+    }
+    historyBatchRef.current = {
+      descriptor: action,
+      nextDocument: null,
+      undoSnapshot: captureUndoSnapshot(
+        documentRef.current,
+        activeEditorRef.current,
+        activeCaretPositionRef.current
+      ),
+      undoCaretPosition: activeCaretPositionRef.current,
+      undoCaretSelection: captureCaretSelection(activeEditorRef.current),
+      hasMutation: false
+    };
+    pendingHistoryActionRef.current = action;
+    pendingUndoSnapshotRef.current = null;
+    pendingUndoCaretPositionRef.current = null;
+    pendingUndoCaretSelectionRef.current = null;
+    try {
+      callback();
+    } finally {
+      scheduleHistoryBatchFlush();
+    }
+  }, [scheduleHistoryBatchFlush]);
+  const suppressHistoryTemporarily = React.useCallback(() => {
+    historySuppressedRef.current = true;
+    pendingHistoryActionRef.current = null;
+    pendingUndoSnapshotRef.current = null;
+    pendingUndoCaretPositionRef.current = null;
+    pendingUndoCaretSelectionRef.current = null;
+    historyBatchRef.current = null;
+    if (historyFlushTimerRef.current) {
+      clearTimeout(historyFlushTimerRef.current);
+      historyFlushTimerRef.current = null;
+    }
+    if (historyReleaseTimerRef.current) {
+      clearTimeout(historyReleaseTimerRef.current);
+    }
+    historyReleaseTimerRef.current = setTimeout(() => {
+      historySuppressedRef.current = false;
+      historyReleaseTimerRef.current = null;
+    }, HISTORY_RESTORE_SUPPRESSION_MS);
+  }, []);
+  const dispatch = React.useCallback((action) => {
+    const currentDocument = documentRef.current;
+    const nextDocument = documentReducer(currentDocument, action);
+    const changed = !documentsAreEqual(currentDocument, nextDocument);
+    const suppressPassiveBodyHistory = action.type === "UPDATE_PAGE_BODY" && action.pageId !== activePageIdRef.current && !historyBatchRef.current && !pendingHistoryActionRef.current;
+    documentRef.current = nextDocument;
+    if (changed && !historySuppressedRef.current && !suppressPassiveBodyHistory) {
+      if (historyBatchRef.current) {
+        historyBatchRef.current.nextDocument = cloneDocumentSnapshot(nextDocument);
+        historyBatchRef.current.hasMutation = true;
+        scheduleHistoryBatchFlush();
+      } else if (pendingHistoryActionRef.current) {
+        historyBatchRef.current = {
+          descriptor: pendingHistoryActionRef.current,
+          nextDocument: cloneDocumentSnapshot(nextDocument),
+          undoSnapshot: pendingUndoSnapshotRef.current,
+          undoCaretPosition: pendingUndoCaretPositionRef.current,
+          undoCaretSelection: pendingUndoCaretSelectionRef.current,
+          hasMutation: true
+        };
+        scheduleHistoryBatchFlush();
+      } else {
+        const descriptor = describeAction(action, currentDocument);
+        setHistoryState((previousHistory) => {
+          const nextHistory = recordHistoryEntry(
+            previousHistory,
+            nextDocument,
+            descriptor,
+            captureUndoSnapshot(
+              currentDocument,
+              activeEditorRef.current,
+              activeCaretPositionRef.current
+            ),
+            activeCaretPositionRef.current,
+            captureCaretSelection(activeEditorRef.current),
+            activeCaretPositionRef.current,
+            captureCaretSelection(activeEditorRef.current)
+          );
+          historyStateRef.current = nextHistory;
+          return nextHistory;
+        });
+      }
+    } else {
+      pendingHistoryActionRef.current = null;
+      pendingUndoSnapshotRef.current = null;
+      pendingUndoCaretPositionRef.current = null;
+      pendingUndoCaretSelectionRef.current = null;
+    }
+    baseDispatch(action);
+  }, [scheduleHistoryBatchFlush]);
+  const restoreDocument = React.useCallback((snapshot, caretPosition, caretSelection) => {
+    suppressHistoryTemporarily();
+    pendingCaretPositionRef.current = caretPosition;
+    pendingCaretSelectionRef.current = caretSelection;
+    activeEditorRef.current = null;
+    activeCaretPositionRef.current = caretPosition;
+    forceUpdate((n) => n + 1);
+    documentRef.current = cloneDocumentSnapshot(snapshot);
+    baseDispatch({ type: "SET_DOCUMENT", document: cloneDocumentSnapshot(snapshot) });
+  }, [suppressHistoryTemporarily]);
+  const undo = React.useCallback(() => {
+    flushHistoryBatch();
+    const result = undoHistory(historyStateRef.current);
+    if (!result) {
+      return;
+    }
+    historyStateRef.current = result.history;
+    setHistoryState(result.history);
+    restoreDocument(result.document, result.caretPosition, result.caretSelection);
+  }, [flushHistoryBatch, restoreDocument]);
+  const redo = React.useCallback(() => {
+    flushHistoryBatch();
+    const result = redoHistory(historyStateRef.current);
+    if (!result) {
+      return;
+    }
+    historyStateRef.current = result.history;
+    setHistoryState(result.history);
+    restoreDocument(result.document, result.caretPosition, result.caretSelection);
+  }, [flushHistoryBatch, restoreDocument]);
+  const clearHistory = React.useCallback(() => {
+    flushHistoryBatch();
+    const nextHistory = clearHistoryState(documentRef.current, activeCaretPositionRef.current);
+    historyStateRef.current = nextHistory;
+    setHistoryState(nextHistory);
+  }, [flushHistoryBatch]);
+  const handleJumpToHistoryEntry = React.useCallback((entryIndex) => {
+    flushHistoryBatch();
+    const result = jumpToHistoryEntry(historyStateRef.current, entryIndex);
+    if (!result) {
+      return;
+    }
+    historyStateRef.current = result.history;
+    setHistoryState(result.history);
+    restoreDocument(result.document, result.caretPosition, result.caretSelection);
+  }, [flushHistoryBatch, restoreDocument]);
+  React.useEffect(() => {
+    documentRef.current = document2;
+    onDocumentChange == null ? void 0 : onDocumentChange(document2);
+  }, [document2, onDocumentChange]);
+  React.useEffect(() => {
+    historyStateRef.current = historyState;
+  }, [historyState]);
+  React.useEffect(() => {
+    var _a2;
+    const firstPageId = ((_a2 = document2.pages[0]) == null ? void 0 : _a2.id) ?? null;
+    const activePageStillExists = activePageId !== null && document2.pages.some((page) => page.id === activePageId);
+    if (!activePageStillExists) {
+      activePageIdRef.current = firstPageId;
+      setActivePageIdRaw(firstPageId);
+      activeEditorRef.current = null;
+      activeCaretPositionRef.current = null;
+      forceUpdate((n) => n + 1);
+    }
+  }, [activePageId, document2.pages]);
+  React.useEffect(
+    () => () => {
+      if (historyFlushTimerRef.current) {
+        clearTimeout(historyFlushTimerRef.current);
+      }
+      if (historyReleaseTimerRef.current) {
+        clearTimeout(historyReleaseTimerRef.current);
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(DocumentContext.Provider, { value: {
+    document: document2,
+    dispatch,
+    activePageId,
+    setActivePageId,
+    activeEditor: activeEditorRef.current,
+    consumePendingCaretPosition,
+    consumePendingFocusAtEnd,
+    requestFocusAtEnd,
+    focusAtEndVersion,
+    setActiveEditor,
+    globalSelectionActive,
+    setGlobalSelectionActive,
+    historyEntries: historyState.entries,
+    historyCursor: historyState.cursor,
+    canUndo: historyState.cursor > 0,
+    canRedo: historyState.cursor < historyState.entries.length,
+    queueHistoryAction,
+    runHistoryAction,
+    jumpToHistoryEntry: handleJumpToHistoryEntry,
+    clearHistory,
+    historySidebarOpen,
+    setHistorySidebarOpen,
+    undo,
+    redo,
+    editorRegistry
+  }, children });
+};
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+  return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+}).join(" ").trim();
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const toCamelCase = (string) => string.replace(
+  /^([A-Z])|[\s-_]+(\w)/g,
+  (match, p1, p2) => p2 ? p2.toUpperCase() : p1.toLowerCase()
+);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const toPascalCase = (string) => {
+  const camelCase = toCamelCase(string);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+};
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const hasA11yProp = (props) => {
+  for (const prop in props) {
+    if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+      return true;
+    }
+  }
+  return false;
+};
+const LucideContext = React.createContext({});
+const useLucideContext = () => React.useContext(LucideContext);
+const Icon = React.forwardRef(
+  ({ color, size, strokeWidth, absoluteStrokeWidth, className = "", children, iconNode, ...rest }, ref) => {
+    const {
+      size: contextSize = 24,
+      strokeWidth: contextStrokeWidth = 2,
+      absoluteStrokeWidth: contextAbsoluteStrokeWidth = false,
+      color: contextColor = "currentColor",
+      className: contextClass = ""
+    } = useLucideContext() ?? {};
+    const calculatedStrokeWidth = absoluteStrokeWidth ?? contextAbsoluteStrokeWidth ? Number(strokeWidth ?? contextStrokeWidth) * 24 / Number(size ?? contextSize) : strokeWidth ?? contextStrokeWidth;
+    return React.createElement(
+      "svg",
+      {
+        ref,
+        ...defaultAttributes,
+        width: size ?? contextSize ?? defaultAttributes.width,
+        height: size ?? contextSize ?? defaultAttributes.height,
+        stroke: color ?? contextColor,
+        strokeWidth: calculatedStrokeWidth,
+        className: mergeClasses("lucide", contextClass, className),
+        ...!children && !hasA11yProp(rest) && { "aria-hidden": "true" },
+        ...rest
+      },
+      [
+        ...iconNode.map(([tag, attrs]) => React.createElement(tag, attrs)),
+        ...Array.isArray(children) ? children : [children]
+      ]
+    );
+  }
+);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const createLucideIcon = (iconName, iconNode) => {
+  const Component = React.forwardRef(
+    ({ className, ...props }, ref) => React.createElement(Icon, {
+      ref,
+      iconNode,
+      className: mergeClasses(
+        `lucide-${toKebabCase(toPascalCase(iconName))}`,
+        `lucide-${iconName}`,
+        className
+      ),
+      ...props
+    })
+  );
+  Component.displayName = toPascalCase(iconName);
+  return Component;
+};
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$j = [
+  [
+    "path",
+    { d: "M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8", key: "mg9rjx" }
+  ]
+];
+const Bold = createLucideIcon("bold", __iconNode$j);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$i = [
+  ["line", { x1: "15", x2: "15", y1: "12", y2: "18", key: "1p7wdc" }],
+  ["line", { x1: "12", x2: "18", y1: "15", y2: "15", key: "1nscbv" }],
+  ["rect", { width: "14", height: "14", x: "8", y: "8", rx: "2", ry: "2", key: "17jyea" }],
+  ["path", { d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2", key: "zix9uf" }]
+];
+const CopyPlus = createLucideIcon("copy-plus", __iconNode$i);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$h = [
+  [
+    "path",
+    {
+      d: "M21 21H8a2 2 0 0 1-1.42-.587l-3.994-3.999a2 2 0 0 1 0-2.828l10-10a2 2 0 0 1 2.829 0l5.999 6a2 2 0 0 1 0 2.828L12.834 21",
+      key: "g5wo59"
+    }
+  ],
+  ["path", { d: "m5.082 11.09 8.828 8.828", key: "1wx5vj" }]
+];
+const Eraser = createLucideIcon("eraser", __iconNode$h);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$g = [
+  ["line", { x1: "4", x2: "20", y1: "9", y2: "9", key: "4lhtct" }],
+  ["line", { x1: "4", x2: "20", y1: "15", y2: "15", key: "vyu0kd" }],
+  ["line", { x1: "10", x2: "8", y1: "3", y2: "21", key: "1ggp8o" }],
+  ["line", { x1: "16", x2: "14", y1: "3", y2: "21", key: "weycgp" }]
+];
+const Hash = createLucideIcon("hash", __iconNode$g);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$f = [
+  ["line", { x1: "19", x2: "10", y1: "4", y2: "4", key: "15jd3p" }],
+  ["line", { x1: "14", x2: "5", y1: "20", y2: "20", key: "bu0au3" }],
+  ["line", { x1: "15", x2: "9", y1: "4", y2: "20", key: "uljnxc" }]
+];
+const Italic = createLucideIcon("italic", __iconNode$f);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$e = [
+  ["path", { d: "M21 5H11", key: "us1j55" }],
+  ["path", { d: "M21 12H11", key: "wd7e0v" }],
+  ["path", { d: "M21 19H11", key: "saa85w" }],
+  ["path", { d: "m7 8-4 4 4 4", key: "o5hrat" }]
+];
+const ListIndentDecrease = createLucideIcon("list-indent-decrease", __iconNode$e);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$d = [
+  ["path", { d: "M21 5H11", key: "us1j55" }],
+  ["path", { d: "M21 12H11", key: "wd7e0v" }],
+  ["path", { d: "M21 19H11", key: "saa85w" }],
+  ["path", { d: "m3 8 4 4-4 4", key: "1a3j6y" }]
+];
+const ListIndentIncrease = createLucideIcon("list-indent-increase", __iconNode$d);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$c = [
+  ["path", { d: "M11 5h10", key: "1cz7ny" }],
+  ["path", { d: "M11 12h10", key: "1438ji" }],
+  ["path", { d: "M11 19h10", key: "11t30w" }],
+  ["path", { d: "M4 4h1v5", key: "10yrso" }],
+  ["path", { d: "M4 9h2", key: "r1h2o0" }],
+  ["path", { d: "M6.5 20H3.4c0-1 2.6-1.925 2.6-3.5a1.5 1.5 0 0 0-2.6-1.02", key: "xtkcd5" }]
+];
+const ListOrdered = createLucideIcon("list-ordered", __iconNode$c);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$b = [
+  ["path", { d: "M3 5h.01", key: "18ugdj" }],
+  ["path", { d: "M3 12h.01", key: "nlz23k" }],
+  ["path", { d: "M3 19h.01", key: "noohij" }],
+  ["path", { d: "M8 5h13", key: "1pao27" }],
+  ["path", { d: "M8 12h13", key: "1za7za" }],
+  ["path", { d: "M8 19h13", key: "m83p4d" }]
+];
+const List = createLucideIcon("list", __iconNode$b);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$a = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M15 3v18", key: "14nvp0" }]
+];
+const PanelRight = createLucideIcon("panel-right", __iconNode$a);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$9 = [
+  ["path", { d: "m15 14 5-5-5-5", key: "12vg1m" }],
+  ["path", { d: "M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13", key: "6uklza" }]
+];
+const Redo2 = createLucideIcon("redo-2", __iconNode$9);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$8 = [
+  ["path", { d: "M16 4H9a3 3 0 0 0-2.83 4", key: "43sutm" }],
+  ["path", { d: "M14 12a4 4 0 0 1 0 8H6", key: "nlfj13" }],
+  ["line", { x1: "4", x2: "20", y1: "12", y2: "12", key: "1e0a9i" }]
+];
+const Strikethrough = createLucideIcon("strikethrough", __iconNode$8);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$7 = [
+  ["path", { d: "M21 5H3", key: "1fi0y6" }],
+  ["path", { d: "M17 12H7", key: "16if0g" }],
+  ["path", { d: "M19 19H5", key: "vjpgq2" }]
+];
+const TextAlignCenter = createLucideIcon("text-align-center", __iconNode$7);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$6 = [
+  ["path", { d: "M21 5H3", key: "1fi0y6" }],
+  ["path", { d: "M21 12H9", key: "dn1m92" }],
+  ["path", { d: "M21 19H7", key: "4cu937" }]
+];
+const TextAlignEnd = createLucideIcon("text-align-end", __iconNode$6);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$5 = [
+  ["path", { d: "M3 5h18", key: "1u36vt" }],
+  ["path", { d: "M3 12h18", key: "1i2n21" }],
+  ["path", { d: "M3 19h18", key: "awlh7x" }]
+];
+const TextAlignJustify = createLucideIcon("text-align-justify", __iconNode$5);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$4 = [
+  ["path", { d: "M21 5H3", key: "1fi0y6" }],
+  ["path", { d: "M15 12H3", key: "6jk70r" }],
+  ["path", { d: "M17 19H3", key: "z6ezky" }]
+];
+const TextAlignStart = createLucideIcon("text-align-start", __iconNode$4);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$3 = [
+  ["path", { d: "M10 11v6", key: "nco0om" }],
+  ["path", { d: "M14 11v6", key: "outv1u" }],
+  ["path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6", key: "miytrc" }],
+  ["path", { d: "M3 6h18", key: "d0wm0j" }],
+  ["path", { d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2", key: "e791ji" }]
+];
+const Trash2 = createLucideIcon("trash-2", __iconNode$3);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$2 = [
+  ["path", { d: "M6 4v6a6 6 0 0 0 12 0V4", key: "9kb039" }],
+  ["line", { x1: "4", x2: "20", y1: "20", y2: "20", key: "nun2al" }]
+];
+const Underline = createLucideIcon("underline", __iconNode$2);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$1 = [
+  ["path", { d: "M9 14 4 9l5-5", key: "102s5s" }],
+  ["path", { d: "M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11", key: "f3b9sd" }]
+];
+const Undo2 = createLucideIcon("undo-2", __iconNode$1);
+/**
+ * @license lucide-react v1.8.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode = [
+  ["path", { d: "M18 6 6 18", key: "1bl5f8" }],
+  ["path", { d: "m6 6 12 12", key: "d8bk6v" }]
+];
+const X = createLucideIcon("x", __iconNode);
+const EditorSidebar = ({
+  title,
+  subtitle,
+  open,
+  onClose,
+  headerActions,
+  children
+}) => {
+  if (!open) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "aside",
+    {
+      className: "flex h-full w-[320px] shrink-0 flex-col border-l border-gray-200 bg-white",
+      "data-testid": "editor-sidebar",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start justify-between border-b border-gray-200 px-3 py-2.5", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+            /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "text-xs font-semibold text-gray-900", children: title }),
+            subtitle && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-0.5 text-xs text-gray-500", children: subtitle })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [
+            headerActions,
+            onClose && /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: "flex h-6 w-6 items-center justify-center rounded text-gray-400\n                         transition-colors hover:bg-gray-100 hover:text-gray-600",
+                "data-testid": "close-editor-sidebar",
+                onClick: onClose,
+                "aria-label": "Close sidebar",
+                children: /* @__PURE__ */ jsxRuntime.jsx(X, { size: 14 })
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "min-h-0 flex-1 overflow-auto", children })
+      ]
+    }
+  );
+};
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+}
+const HistorySidebar = () => {
+  const {
+    clearHistory,
+    historyEntries,
+    historyCursor,
+    historySidebarOpen,
+    jumpToHistoryEntry: jumpToHistoryEntry2,
+    setHistorySidebarOpen
+  } = useDocument();
+  const visibleEntries = historyEntries.slice().reverse();
+  const headerActions = /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      title: "Clear History",
+      "aria-label": "Clear History",
+      onMouseDown: (e) => e.preventDefault(),
+      onClick: () => clearHistory("manual"),
+      className: "flex h-6 w-6 items-center justify-center rounded text-gray-400\n                 transition-colors hover:bg-gray-100 hover:text-gray-600",
+      "data-testid": "clear-history",
+      children: /* @__PURE__ */ jsxRuntime.jsx(Trash2, { size: 13 })
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    EditorSidebar,
+    {
+      title: "History",
+      subtitle: "Word-style session history (last 100 actions)",
+      open: historySidebarOpen,
+      onClose: () => setHistorySidebarOpen(false),
+      headerActions,
+      children: visibleEntries.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "px-3 py-4 text-xs text-gray-500",
+          "data-testid": "history-empty",
+          children: "No history yet."
+        }
+      ) : /* @__PURE__ */ jsxRuntime.jsx("ol", { className: "divide-y divide-gray-100", "data-testid": "history-entry-list", children: visibleEntries.map((entry, reversedIndex) => {
+        const actualIndex = historyEntries.length - reversedIndex - 1;
+        const isCurrent = actualIndex === historyCursor - 1;
+        return /* @__PURE__ */ jsxRuntime.jsx("li", { children: /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: `w-full px-3 py-2 text-left transition-colors ${isCurrent ? "bg-blue-50" : "bg-white hover:bg-gray-50"}`,
+            "data-testid": `history-entry-${actualIndex}`,
+            "data-history-current": isCurrent ? "true" : "false",
+            onClick: () => jumpToHistoryEntry2(actualIndex),
+            children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start justify-between gap-2", children: [
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "min-w-0", children: [
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: `text-xs ${isCurrent ? "font-semibold text-blue-700" : "text-gray-900"}`, children: entry.label }),
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-0.5 text-xs text-gray-400", children: entry.source })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "shrink-0 text-xs text-gray-400", children: formatTimestamp(entry.timestamp) })
+            ] })
+          }
+        ) }, entry.id);
+      }) })
+    }
+  );
+};
+const HeaderFooterToggle = ({
+  enabled,
+  onToggle
+}) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "label",
+    {
+      className: "flex items-center gap-1.5 cursor-pointer select-none",
+      "data-testid": "header-footer-toggle",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium text-gray-600", children: "Headers & Footers" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            role: "switch",
+            "aria-checked": enabled,
+            onMouseDown: (e) => e.preventDefault(),
+            onClick: () => onToggle(!enabled),
+            className: `
+          relative inline-flex h-4 w-7 items-center rounded-full
+          transition-colors duration-200
+          ${enabled ? "bg-blue-500" : "bg-gray-300"}
+        `,
+            "data-testid": "header-footer-switch",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: `
+            inline-block h-3 w-3 rounded-full bg-white shadow-sm
+            transition-transform duration-200
+            ${enabled ? "translate-x-3.5" : "translate-x-0.5"}
+          `
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+};
+const HeaderFooterActions = ({
+  activePageId,
+  pageCounterMode,
+  onPageCounterModeChange,
+  onCopyHeaderToAll,
+  onCopyFooterToAll,
+  onClearHeader,
+  onClearFooter,
+  onClearAllHeaders,
+  onClearAllFooters
+}) => {
+  const hasActivePage = activePageId !== null;
+  const handlePageCounterModeChange = (event) => {
+    const nextMode = event.target.value;
+    if (nextMode === "none" || nextMode === "header" || nextMode === "footer" || nextMode === "both") {
+      onPageCounterModeChange(nextMode);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: "flex flex-wrap items-center gap-2 text-xs",
+      "data-testid": "header-footer-actions",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex items-center gap-1 text-gray-500", htmlFor: "page-counter-mode", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(Hash, { size: 13, className: "text-gray-400" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "select",
+            {
+              id: "page-counter-mode",
+              className: "h-6 rounded border border-gray-200 bg-white px-1.5 text-xs text-gray-600\n                     focus:border-blue-400 focus:outline-none focus:ring-1 focus:ring-blue-400",
+              "data-testid": "page-counter-mode",
+              value: pageCounterMode,
+              onChange: handlePageCounterModeChange,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "none", children: "None" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "header", children: "Header" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "footer", children: "Footer" }),
+                /* @__PURE__ */ jsxRuntime.jsx("option", { value: "both", children: "Both" })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(ActionDivider, {}),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-400 font-medium", children: "Header" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ActionIconButton,
+          {
+            title: "Copy header to all pages",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(CopyPlus, { size: 13 }),
+            onClick: onCopyHeaderToAll,
+            disabled: !hasActivePage,
+            testId: "copy-header-all"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ActionIconButton,
+          {
+            title: "Clear header on this page",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Eraser, { size: 13 }),
+            onClick: onClearHeader,
+            disabled: !hasActivePage,
+            testId: "clear-header"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ActionIconButton,
+          {
+            title: "Clear all headers",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Trash2, { size: 13 }),
+            onClick: onClearAllHeaders,
+            testId: "clear-all-headers"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(ActionDivider, {}),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-400 font-medium", children: "Footer" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ActionIconButton,
+          {
+            title: "Copy footer to all pages",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(CopyPlus, { size: 13 }),
+            onClick: onCopyFooterToAll,
+            disabled: !hasActivePage,
+            testId: "copy-footer-all"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ActionIconButton,
+          {
+            title: "Clear footer on this page",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Eraser, { size: 13 }),
+            onClick: onClearFooter,
+            disabled: !hasActivePage,
+            testId: "clear-footer"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ActionIconButton,
+          {
+            title: "Clear all footers",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Trash2, { size: 13 }),
+            onClick: onClearAllFooters,
+            testId: "clear-all-footers"
+          }
+        )
+      ]
+    }
+  );
+};
+const ActionIconButton = ({ title, icon, onClick, disabled, testId }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "button",
+  {
+    type: "button",
+    title,
+    "aria-label": title,
+    onMouseDown: (e) => e.preventDefault(),
+    onClick,
+    disabled,
+    className: "flex h-6 w-6 items-center justify-center rounded text-gray-500 transition-colors\n               hover:bg-gray-200/60 hover:text-gray-700\n               disabled:cursor-not-allowed disabled:text-gray-300",
+    "data-testid": testId,
+    children: icon
+  }
+);
+const ActionDivider = () => /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mx-0.5 h-4 w-px bg-gray-300/60" });
+const SUPPORTED_FONTS = [
+  "Times New Roman",
+  "Arial",
+  "Calibri",
+  "Georgia",
+  "Courier New"
+];
+function applyFontFamily(editor, fontFamily) {
+  editor.update(() => {
+    const selection = lexical.$getSelection();
+    if (!lexical.$isRangeSelection(selection)) return;
+    const nodes = selection.getNodes();
+    for (const node of nodes) {
+      if (lexical.$isTextNode(node)) {
+        node.setStyle(`font-family: ${fontFamily}`);
+      }
+    }
+  });
+}
+function toggleFormat(editor, format) {
+  editor.dispatchCommand(lexical.FORMAT_TEXT_COMMAND, format);
+}
+function toggleBold(editor) {
+  toggleFormat(editor, "bold");
+}
+function toggleItalic(editor) {
+  toggleFormat(editor, "italic");
+}
+function toggleUnderline(editor) {
+  toggleFormat(editor, "underline");
+}
+function toggleStrikethrough(editor) {
+  toggleFormat(editor, "strikethrough");
+}
+function setAlignment(editor, alignment) {
+  editor.dispatchCommand(lexical.FORMAT_ELEMENT_COMMAND, alignment);
+}
+function insertList(editor, type) {
+  if (type === "number") {
+    editor.dispatchCommand(list.INSERT_ORDERED_LIST_COMMAND, void 0);
+  } else {
+    editor.dispatchCommand(list.INSERT_UNORDERED_LIST_COMMAND, void 0);
+  }
+}
+function indentContent(editor) {
+  editor.dispatchCommand(lexical.INDENT_CONTENT_COMMAND, void 0);
+}
+function outdentContent(editor) {
+  editor.dispatchCommand(lexical.OUTDENT_CONTENT_COMMAND, void 0);
+}
+const Toolbar = () => {
+  const {
+    document: document2,
+    dispatch,
+    activePageId,
+    activeEditor,
+    canRedo,
+    canUndo,
+    editorRegistry,
+    globalSelectionActive,
+    historySidebarOpen,
+    redo,
+    runHistoryAction,
+    setHistorySidebarOpen,
+    undo
+  } = useDocument();
+  const withBodySelection = React.useCallback(
+    (editor, action) => {
+      editor.update(() => {
+        lexical.$selectAll();
+      });
+      action(editor);
+    },
+    []
+  );
+  const applyToBodyEditors = React.useCallback(
+    (action) => {
+      const targetEditors = globalSelectionActive ? editorRegistry.all() : activeEditor ? [activeEditor] : [];
+      targetEditors.forEach((editor) => {
+        if (globalSelectionActive) {
+          withBodySelection(editor, action);
+        } else {
+          action(editor);
+        }
+      });
+    },
+    [activeEditor, editorRegistry, globalSelectionActive, withBodySelection]
+  );
+  const runToolbarAction = React.useCallback(
+    (label, callback) => {
+      runHistoryAction(
+        {
+          label,
+          source: "toolbar",
+          region: "document"
+        },
+        callback
+      );
+    },
+    [runHistoryAction]
+  );
+  const handleToggle = (enabled) => {
+    runToolbarAction(
+      enabled ? "Enabled headers and footers" : "Disabled headers and footers",
+      () => {
+        dispatch({ type: "SET_HEADER_FOOTER_ENABLED", enabled });
+      }
+    );
+  };
+  const handleCopyHeaderToAll = () => {
+    if (activePageId) {
+      runToolbarAction("Copied header to all pages", () => {
+        dispatch({ type: "COPY_HEADER_TO_ALL", sourcePageId: activePageId });
+      });
+    }
+  };
+  const handleCopyFooterToAll = () => {
+    if (activePageId) {
+      runToolbarAction("Copied footer to all pages", () => {
+        dispatch({ type: "COPY_FOOTER_TO_ALL", sourcePageId: activePageId });
+      });
+    }
+  };
+  const handleClearHeader = () => {
+    if (activePageId) {
+      runToolbarAction("Cleared header", () => {
+        dispatch({ type: "CLEAR_HEADER", pageId: activePageId });
+      });
+    }
+  };
+  const handleClearFooter = () => {
+    if (activePageId) {
+      runToolbarAction("Cleared footer", () => {
+        dispatch({ type: "CLEAR_FOOTER", pageId: activePageId });
+      });
+    }
+  };
+  const handleClearAllHeaders = () => runToolbarAction("Cleared all headers", () => {
+    dispatch({ type: "CLEAR_ALL_HEADERS" });
+  });
+  const handleClearAllFooters = () => runToolbarAction("Cleared all footers", () => {
+    dispatch({ type: "CLEAR_ALL_FOOTERS" });
+  });
+  const handlePageCounterModeChange = React.useCallback((mode) => {
+    runToolbarAction(`Page counter set to ${mode}`, () => {
+      dispatch({ type: "SET_PAGE_COUNTER_MODE", mode });
+    });
+  }, [dispatch, runToolbarAction]);
+  const handleBold = React.useCallback(() => {
+    debug("toolbar", `bold (globalSelection=${globalSelectionActive}, editors=${editorRegistry.all().length}, hasEditor=${!!activeEditor})`);
+    runToolbarAction("Bold applied", () => {
+      applyToBodyEditors(toggleBold);
+    });
+  }, [activeEditor, applyToBodyEditors, editorRegistry, globalSelectionActive, runToolbarAction]);
+  const handleItalic = React.useCallback(() => {
+    debug("toolbar", `italic (globalSelection=${globalSelectionActive}, hasEditor=${!!activeEditor})`);
+    runToolbarAction("Italic applied", () => {
+      applyToBodyEditors(toggleItalic);
+    });
+  }, [activeEditor, applyToBodyEditors, globalSelectionActive, runToolbarAction]);
+  const handleUnderline = React.useCallback(() => {
+    debug("toolbar", `underline (globalSelection=${globalSelectionActive}, hasEditor=${!!activeEditor})`);
+    runToolbarAction("Underline applied", () => {
+      applyToBodyEditors(toggleUnderline);
+    });
+  }, [activeEditor, applyToBodyEditors, globalSelectionActive, runToolbarAction]);
+  const handleStrikethrough = React.useCallback(() => {
+    debug("toolbar", `strikethrough (globalSelection=${globalSelectionActive}, hasEditor=${!!activeEditor})`);
+    runToolbarAction("Strikethrough applied", () => {
+      applyToBodyEditors(toggleStrikethrough);
+    });
+  }, [activeEditor, applyToBodyEditors, globalSelectionActive, runToolbarAction]);
+  const handleAlignLeft = React.useCallback(() => {
+    runToolbarAction("Aligned left", () => {
+      applyToBodyEditors((editor) => setAlignment(editor, "left"));
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleAlignCenter = React.useCallback(() => {
+    runToolbarAction("Aligned center", () => {
+      applyToBodyEditors((editor) => setAlignment(editor, "center"));
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleAlignRight = React.useCallback(() => {
+    runToolbarAction("Aligned right", () => {
+      applyToBodyEditors((editor) => setAlignment(editor, "right"));
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleAlignJustify = React.useCallback(() => {
+    runToolbarAction("Justified text", () => {
+      applyToBodyEditors((editor) => setAlignment(editor, "justify"));
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleListNumber = React.useCallback(() => {
+    runToolbarAction("Inserted numbered list", () => {
+      applyToBodyEditors((editor) => insertList(editor, "number"));
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleListBullet = React.useCallback(() => {
+    runToolbarAction("Inserted bullet list", () => {
+      applyToBodyEditors((editor) => insertList(editor, "bullet"));
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleIndent = React.useCallback(() => {
+    runToolbarAction("Indented content", () => {
+      applyToBodyEditors(indentContent);
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleOutdent = React.useCallback(() => {
+    runToolbarAction("Outdented content", () => {
+      applyToBodyEditors(outdentContent);
+    });
+  }, [applyToBodyEditors, runToolbarAction]);
+  const handleFontChange = React.useCallback(
+    (e) => {
+      runToolbarAction(`Font changed to ${e.target.value}`, () => {
+        applyToBodyEditors((editor) => applyFontFamily(editor, e.target.value));
+      });
+    },
+    [applyToBodyEditors, runToolbarAction]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: "lex4-toolbar sticky top-0 z-10 bg-white border-b border-gray-200",
+      "data-testid": "toolbar",
+      children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1 px-2 py-1.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5", "data-testid": "history-controls", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ToolbarIconButton,
+            {
+              title: "Undo",
+              testId: "btn-undo",
+              disabled: !canUndo,
+              onClick: undo,
+              children: /* @__PURE__ */ jsxRuntime.jsx(Undo2, { size: 15 })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            ToolbarIconButton,
+            {
+              title: "Redo",
+              testId: "btn-redo",
+              disabled: !canRedo,
+              onClick: redo,
+              children: /* @__PURE__ */ jsxRuntime.jsx(Redo2, { size: 15 })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(Divider, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "select",
+          {
+            className: "h-7 rounded border border-gray-200 bg-white px-2 text-xs text-gray-700\n                     focus:border-blue-400 focus:outline-none focus:ring-1 focus:ring-blue-400",
+            "data-testid": "font-selector",
+            defaultValue: "Arial",
+            onChange: handleFontChange,
+            children: SUPPORTED_FONTS.map((font) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: font, style: { fontFamily: font }, children: font }, font))
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(Divider, {}),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5", "data-testid": "format-group", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Bold (Ctrl+B)", testId: "btn-bold", onClick: handleBold, children: /* @__PURE__ */ jsxRuntime.jsx(Bold, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Italic (Ctrl+I)", testId: "btn-italic", onClick: handleItalic, children: /* @__PURE__ */ jsxRuntime.jsx(Italic, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Underline (Ctrl+U)", testId: "btn-underline", onClick: handleUnderline, children: /* @__PURE__ */ jsxRuntime.jsx(Underline, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Strikethrough", testId: "btn-strike", onClick: handleStrikethrough, children: /* @__PURE__ */ jsxRuntime.jsx(Strikethrough, { size: 15 }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(Divider, {}),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5", "data-testid": "align-group", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Align Left", testId: "btn-align-left", onClick: handleAlignLeft, children: /* @__PURE__ */ jsxRuntime.jsx(TextAlignStart, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Align Center", testId: "btn-align-center", onClick: handleAlignCenter, children: /* @__PURE__ */ jsxRuntime.jsx(TextAlignCenter, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Align Right", testId: "btn-align-right", onClick: handleAlignRight, children: /* @__PURE__ */ jsxRuntime.jsx(TextAlignEnd, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Justify", testId: "btn-align-justify", onClick: handleAlignJustify, children: /* @__PURE__ */ jsxRuntime.jsx(TextAlignJustify, { size: 15 }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(Divider, {}),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5", "data-testid": "list-group", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Numbered List", testId: "btn-list-number", onClick: handleListNumber, children: /* @__PURE__ */ jsxRuntime.jsx(ListOrdered, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Bullet List", testId: "btn-list-bullet", onClick: handleListBullet, children: /* @__PURE__ */ jsxRuntime.jsx(List, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Indent", testId: "btn-indent", onClick: handleIndent, children: /* @__PURE__ */ jsxRuntime.jsx(ListIndentIncrease, { size: 15 }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ToolbarIconButton, { title: "Outdent", testId: "btn-outdent", onClick: handleOutdent, children: /* @__PURE__ */ jsxRuntime.jsx(ListIndentDecrease, { size: 15 }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(Divider, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          HeaderFooterToggle,
+          {
+            enabled: document2.headerFooterEnabled,
+            onToggle: handleToggle
+          }
+        ),
+        document2.headerFooterEnabled && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(Divider, {}),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            HeaderFooterActions,
+            {
+              activePageId,
+              pageCounterMode: document2.pageCounterMode,
+              onPageCounterModeChange: handlePageCounterModeChange,
+              onCopyHeaderToAll: handleCopyHeaderToAll,
+              onCopyFooterToAll: handleCopyFooterToAll,
+              onClearHeader: handleClearHeader,
+              onClearFooter: handleClearFooter,
+              onClearAllHeaders: handleClearAllHeaders,
+              onClearAllFooters: handleClearAllFooters
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ml-auto flex items-center", children: /* @__PURE__ */ jsxRuntime.jsx(
+          ToolbarIconButton,
+          {
+            title: historySidebarOpen ? "Close History" : "Open History",
+            testId: "toggle-history-sidebar",
+            active: historySidebarOpen,
+            onClick: () => setHistorySidebarOpen(!historySidebarOpen),
+            children: /* @__PURE__ */ jsxRuntime.jsx(PanelRight, { size: 15 })
+          }
+        ) })
+      ] })
+    }
+  );
+};
+const ToolbarIconButton = ({
+  title,
+  testId,
+  disabled = false,
+  active = false,
+  onClick,
+  children
+}) => /* @__PURE__ */ jsxRuntime.jsx(
+  "button",
+  {
+    type: "button",
+    title,
+    "aria-label": title,
+    disabled,
+    onMouseDown: (e) => e.preventDefault(),
+    onClick,
+    className: `
+      flex h-7 w-7 items-center justify-center rounded transition-colors
+      ${disabled ? "cursor-not-allowed text-gray-300" : active ? "bg-blue-50 text-blue-600" : "text-gray-600 hover:bg-gray-100 hover:text-gray-900"}
+    `,
+    "data-testid": testId,
+    children
+  }
+);
+const Divider = () => /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mx-0.5 h-5 w-px bg-gray-200" });
+function computeBodyHeight(headerHeight, footerHeight) {
+  const verticalMargins = PAGE_MARGIN_PX * 2;
+  return A4_HEIGHT_PX - headerHeight - footerHeight - verticalMargins;
+}
+function getTopLevelNodes(state) {
+  if (!state) return [];
+  return state.root.children ?? [];
+}
+function createEditorStateFromNodes(nodes) {
+  return {
+    root: {
+      children: nodes,
+      direction: null,
+      format: "",
+      indent: 0,
+      type: "root",
+      version: 1
+    }
+  };
+}
+function splitEditorState(state, splitIndex) {
+  const nodes = getTopLevelNodes(state);
+  if (splitIndex <= 0) {
+    return [null, state];
+  }
+  if (splitIndex >= nodes.length) {
+    return [state, null];
+  }
+  const before = nodes.slice(0, splitIndex);
+  const after = nodes.slice(splitIndex);
+  return [
+    before.length > 0 ? createEditorStateFromNodes(before) : null,
+    after.length > 0 ? createEditorStateFromNodes(after) : null
+  ];
+}
+function mergeEditorStates(stateA, stateB) {
+  const nodesA = getTopLevelNodes(stateA);
+  const nodesB = getTopLevelNodes(stateB);
+  const all = [...nodesA, ...nodesB];
+  if (all.length === 0) return null;
+  return createEditorStateFromNodes(all);
+}
+function usePagination(document2, dispatch) {
+  const reflowingRef = React.useRef(false);
+  const pendingReflowRef = React.useRef(false);
+  const estimateNodesFitting = React.useCallback(
+    (state, bodyHeight) => {
+      const nodes = getTopLevelNodes(state);
+      if (nodes.length === 0) return 0;
+      const estimatedLineHeight = 24;
+      let usedHeight = 0;
+      let fitCount = 0;
+      for (const _node of nodes) {
+        usedHeight += estimatedLineHeight;
+        if (usedHeight > bodyHeight) break;
+        fitCount++;
+      }
+      return Math.max(1, fitCount);
+    },
+    []
+  );
+  const handlePageOverflow = React.useCallback(
+    (pageIndex) => {
+      if (reflowingRef.current) {
+        pendingReflowRef.current = true;
+        return;
+      }
+      reflowingRef.current = true;
+      try {
+        const pages = document2.pages;
+        const page = pages[pageIndex];
+        if (!page) return;
+        const headerH = document2.headerFooterEnabled ? page.headerHeight : 0;
+        const footerH = document2.headerFooterEnabled ? page.footerHeight : 0;
+        const bodyHeight = computeBodyHeight(headerH, footerH);
+        const nodes = getTopLevelNodes(page.bodyState);
+        if (nodes.length <= 1) return;
+        const fitCount = estimateNodesFitting(page.bodyState, bodyHeight);
+        if (fitCount >= nodes.length) return;
+        const [keepState, overflowState] = splitEditorState(page.bodyState, fitCount);
+        if (!overflowState) return;
+        const nextPage = pages[pageIndex + 1];
+        if (nextPage) {
+          const mergedBody = mergeEditorStates(overflowState, nextPage.bodyState);
+          dispatch({
+            type: "SET_DOCUMENT",
+            document: {
+              ...document2,
+              pages: pages.map((p, i) => {
+                if (i === pageIndex) return { ...p, bodyState: keepState };
+                if (i === pageIndex + 1) return { ...p, bodyState: mergedBody };
+                return p;
+              })
+            }
+          });
+        } else {
+          const newPage = {
+            ...createPageFromTemplate({
+              headerState: document2.defaultHeaderState,
+              footerState: document2.defaultFooterState,
+              headerHeight: document2.defaultHeaderHeight,
+              footerHeight: document2.defaultFooterHeight
+            }),
+            bodyState: overflowState
+          };
+          dispatch({
+            type: "SET_DOCUMENT",
+            document: {
+              ...document2,
+              pages: [
+                ...pages.map(
+                  (p, i) => i === pageIndex ? { ...p, bodyState: keepState } : p
+                ),
+                newPage
+              ]
+            }
+          });
+        }
+      } finally {
+        reflowingRef.current = false;
+        if (pendingReflowRef.current) {
+          pendingReflowRef.current = false;
+          setTimeout(() => handlePageOverflow(pageIndex), 0);
+        }
+      }
+    },
+    [document2, dispatch, estimateNodesFitting]
+  );
+  const handlePageUnderflow = React.useCallback(
+    (pageIndex) => {
+      if (reflowingRef.current) return;
+      const pages = document2.pages;
+      const page = pages[pageIndex];
+      const nextPage = pages[pageIndex + 1];
+      if (!page || !nextPage) return;
+      const nextNodes = getTopLevelNodes(nextPage.bodyState);
+      if (nextNodes.length === 0) {
+        if (pages.length > 1) {
+          dispatch({
+            type: "SET_DOCUMENT",
+            document: {
+              ...document2,
+              pages: pages.filter((_, i) => i !== pageIndex + 1)
+            }
+          });
+        }
+        return;
+      }
+      const headerH = document2.headerFooterEnabled ? page.headerHeight : 0;
+      const footerH = document2.headerFooterEnabled ? page.footerHeight : 0;
+      const bodyHeight = computeBodyHeight(headerH, footerH);
+      const currentNodes = getTopLevelNodes(page.bodyState);
+      const estimatedCurrentHeight = currentNodes.length * 24;
+      const remainingSpace = bodyHeight - estimatedCurrentHeight;
+      if (remainingSpace > 24) {
+        const [pulled, remaining] = [nextNodes.slice(0, 1), nextNodes.slice(1)];
+        const updatedCurrent = mergeEditorStates(
+          page.bodyState,
+          createEditorStateFromNodes(pulled)
+        );
+        const updatedNext = remaining.length > 0 ? createEditorStateFromNodes(remaining) : null;
+        const newPages = pages.map((p, i) => {
+          if (i === pageIndex) return { ...p, bodyState: updatedCurrent };
+          if (i === pageIndex + 1) return { ...p, bodyState: updatedNext };
+          return p;
+        });
+        while (newPages.length > 1) {
+          const last = newPages[newPages.length - 1];
+          if (getTopLevelNodes(last.bodyState).length === 0) {
+            newPages.pop();
+          } else {
+            break;
+          }
+        }
+        dispatch({
+          type: "SET_DOCUMENT",
+          document: { ...document2, pages: newPages }
+        });
+      }
+    },
+    [document2, dispatch]
+  );
+  const reflowAll = React.useCallback(() => {
+    if (reflowingRef.current) return;
+    reflowingRef.current = true;
+    try {
+      const pages = document2.pages;
+      const allNodes = pages.flatMap((p) => getTopLevelNodes(p.bodyState));
+      if (allNodes.length === 0) {
+        if (pages.length !== 1) {
+          dispatch({
+            type: "SET_DOCUMENT",
+            document: {
+              ...document2,
+              pages: [pages[0] ?? createEmptyPage()]
+            }
+          });
+        }
+        return;
+      }
+      const newPages = [];
+      let remainingNodes = [...allNodes];
+      let pageIdx = 0;
+      while (remainingNodes.length > 0) {
+        const existingPage = pages[pageIdx];
+        const headerH = document2.headerFooterEnabled ? (existingPage == null ? void 0 : existingPage.headerHeight) ?? 0 : 0;
+        const footerH = document2.headerFooterEnabled ? (existingPage == null ? void 0 : existingPage.footerHeight) ?? 0 : 0;
+        const bodyHeight = computeBodyHeight(headerH, footerH);
+        const estimatedLineHeight = 24;
+        const maxNodes = Math.max(1, Math.floor(bodyHeight / estimatedLineHeight));
+        const pageNodes = remainingNodes.slice(0, maxNodes);
+        remainingNodes = remainingNodes.slice(maxNodes);
+        const basePage = existingPage ?? createPageFromTemplate({
+          headerState: document2.defaultHeaderState,
+          footerState: document2.defaultFooterState,
+          headerHeight: document2.defaultHeaderHeight,
+          footerHeight: document2.defaultFooterHeight
+        });
+        newPages.push({
+          ...basePage,
+          bodyState: createEditorStateFromNodes(pageNodes)
+        });
+        pageIdx++;
+      }
+      dispatch({
+        type: "SET_DOCUMENT",
+        document: { ...document2, pages: newPages }
+      });
+    } finally {
+      reflowingRef.current = false;
+    }
+  }, [document2, dispatch]);
+  return {
+    handlePageOverflow,
+    handlePageUnderflow,
+    reflowAll
+  };
+}
+const lexicalTheme = {
+  root: "lex4-root outline-none",
+  paragraph: "lex4-paragraph mb-1",
+  heading: {
+    h1: "text-3xl font-bold mb-2",
+    h2: "text-2xl font-bold mb-2",
+    h3: "text-xl font-semibold mb-1",
+    h4: "text-lg font-semibold mb-1",
+    h5: "text-base font-medium mb-1"
+  },
+  text: {
+    bold: "font-bold",
+    italic: "italic",
+    underline: "underline",
+    strikethrough: "line-through",
+    underlineStrikethrough: "underline line-through"
+  },
+  list: {
+    nested: {
+      listitem: "list-none"
+    },
+    ol: "list-decimal ml-6",
+    ul: "list-disc ml-6",
+    listitem: "lex4-listitem",
+    listitemChecked: "lex4-listitem-checked",
+    listitemUnchecked: "lex4-listitem-unchecked"
+  },
+  quote: "border-l-4 border-gray-300 pl-4 italic text-gray-600"
+};
+function createEditorConfig(mode, pageId) {
+  const namespace = pageId ? `lex4-${mode}-${pageId}` : `lex4-${mode}`;
+  return {
+    namespace,
+    theme: lexicalTheme,
+    nodes: [richText.HeadingNode, richText.QuoteNode, list.ListNode, list.ListItemNode],
+    onError: (error) => {
+      console.error(`[Lex4 ${mode} editor error]`, error);
+    }
+  };
+}
+const TabIndentPlugin = () => {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const handleTab = React.useCallback(
+    (event) => {
+      event.preventDefault();
+      if (event.shiftKey) {
+        outdentContent(editor);
+      } else {
+        indentContent(editor);
+      }
+      return true;
+    },
+    [editor]
+  );
+  React.useEffect(() => {
+    return editor.registerCommand(lexical.KEY_TAB_COMMAND, handleTab, lexical.COMMAND_PRIORITY_LOW);
+  }, [editor, handleTab]);
+  return null;
+};
+const FIRST_LINE_INDENT_PX = 40;
+function visitElements(node, callback) {
+  callback(node);
+  for (const child of node.getChildren()) {
+    if (lexical.$isElementNode(child)) {
+      visitElements(child, callback);
+    }
+  }
+}
+const ParagraphIndentPlugin = () => {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  React.useEffect(() => {
+    const syncParagraphIndents = () => editor.getEditorState().read(() => {
+      visitElements(lexical.$getRoot(), (node) => {
+        if (!lexical.$isParagraphNode(node)) {
+          return;
+        }
+        const element = editor.getElementByKey(node.getKey());
+        if (!(element instanceof HTMLElement)) {
+          return;
+        }
+        const indent = node.getIndent();
+        element.style.paddingInlineStart = "0px";
+        element.style.textIndent = indent > 0 ? `${indent * FIRST_LINE_INDENT_PX}px` : "";
+      });
+    });
+    syncParagraphIndents();
+    return editor.registerUpdateListener(() => {
+      syncParagraphIndents();
+    });
+  }, [editor]);
+  return null;
+};
+const PastePlugin = () => {
+  return null;
+};
+function resolveTextOffset(root, targetOffset) {
+  var _a, _b;
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let remaining = targetOffset;
+  let currentNode = walker.nextNode();
+  let lastTextNode = null;
+  while (currentNode) {
+    const textLength = ((_a = currentNode.textContent) == null ? void 0 : _a.length) ?? 0;
+    if (remaining <= textLength) {
+      return { node: currentNode, offset: remaining };
+    }
+    remaining -= textLength;
+    lastTextNode = currentNode;
+    currentNode = walker.nextNode();
+  }
+  if (lastTextNode) {
+    return {
+      node: lastTextNode,
+      offset: ((_b = lastTextNode.textContent) == null ? void 0 : _b.length) ?? 0
+    };
+  }
+  return {
+    node: root,
+    offset: root.childNodes.length
+  };
+}
+const ActiveEditorPlugin = ({
+  pageId,
+  region,
+  onFocus
+}) => {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const {
+    consumePendingCaretPosition,
+    consumePendingFocusAtEnd,
+    focusAtEndVersion,
+    setActiveEditor,
+    setActivePageId
+  } = useDocument();
+  React.useEffect(() => {
+    const caretPosition = { pageId, region };
+    const selectionToRestore = consumePendingCaretPosition(caretPosition);
+    if (selectionToRestore === void 0) {
+      return;
+    }
+    requestAnimationFrame(() => {
+      setActivePageId(pageId);
+      setActiveEditor(editor, caretPosition);
+      editor.focus();
+      if (!selectionToRestore) {
+        return;
+      }
+      requestAnimationFrame(() => {
+        const rootElement = editor.getRootElement();
+        const domSelection = window.getSelection();
+        if (!rootElement || !domSelection) {
+          return;
+        }
+        const anchorPoint = resolveTextOffset(rootElement, selectionToRestore.anchorTextOffset);
+        const focusPoint = resolveTextOffset(rootElement, selectionToRestore.focusTextOffset);
+        const range = document.createRange();
+        range.setStart(anchorPoint.node, anchorPoint.offset);
+        range.setEnd(focusPoint.node, focusPoint.offset);
+        domSelection.removeAllRanges();
+        domSelection.addRange(range);
+        editor.update(() => {
+          const nextSelection = lexical.$createRangeSelectionFromDom(window.getSelection(), editor);
+          if (nextSelection) {
+            lexical.$setSelection(nextSelection);
+          }
+        });
+      });
+    });
+  }, [consumePendingCaretPosition, editor, pageId, region, setActiveEditor, setActivePageId]);
+  React.useEffect(() => {
+    const caretPosition = { pageId, region };
+    if (!consumePendingFocusAtEnd(caretPosition)) {
+      return;
+    }
+    requestAnimationFrame(() => {
+      setActivePageId(pageId);
+      setActiveEditor(editor, caretPosition);
+      editor.focus(() => {
+        editor.update(() => {
+          lexical.$getRoot().selectEnd();
+        });
+      });
+    });
+  }, [
+    consumePendingFocusAtEnd,
+    editor,
+    focusAtEndVersion,
+    pageId,
+    region,
+    setActiveEditor,
+    setActivePageId
+  ]);
+  React.useEffect(() => {
+    return editor.registerCommand(
+      lexical.FOCUS_COMMAND,
+      () => {
+        debug("focus", `editor focused (ns=${editor.getKey()})`);
+        setActivePageId(pageId);
+        setActiveEditor(editor, { pageId, region });
+        onFocus == null ? void 0 : onFocus(editor);
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [editor, onFocus, pageId, region, setActiveEditor, setActivePageId]);
+  return null;
+};
+function serializeNodeTree(node) {
+  const json = node.exportJSON();
+  if (lexical.$isElementNode(node)) {
+    json.children = node.getChildren().map(serializeNodeTree);
+  }
+  return json;
+}
+const OVERFLOW_DEBOUNCE_MS = 300;
+const OverflowPlugin = ({
+  onOverflow
+}) => {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const processingRef = React.useRef(false);
+  const onOverflowRef = React.useRef(onOverflow);
+  onOverflowRef.current = onOverflow;
+  React.useEffect(() => {
+    let observer = null;
+    let unregisterUpdateListener = null;
+    let debounceTimer = null;
+    const checkOverflow = (rootElement, container, cause) => {
+      if (processingRef.current) return;
+      const availableHeight = container.clientHeight;
+      if (availableHeight <= 0) return;
+      const contentHeight = rootElement.scrollHeight;
+      if (contentHeight <= availableHeight + 2) return;
+      const children = Array.from(rootElement.children);
+      if (children.length === 0) return;
+      if (children.length <= 1) {
+        debug("overflow", `single block overflows (content=${contentHeight}px > available=${availableHeight}px) — cannot split`);
+        return;
+      }
+      processingRef.current = true;
+      debug("overflow", `OVERFLOW detected: content=${contentHeight}px available=${availableHeight}px children=${children.length}`);
+      let splitIndex = children.length;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const childBottom = child.offsetTop + child.offsetHeight;
+        if (childBottom > availableHeight && i > 0) {
+          splitIndex = i;
+          debug("overflow", `split at index ${i} (childBottom=${childBottom}px > ${availableHeight}px)`);
+          break;
+        }
+      }
+      if (splitIndex >= children.length) {
+        debugWarn("overflow", "no valid split point found — all children fit individually");
+        processingRef.current = false;
+        return;
+      }
+      editor.update(
+        () => {
+          const root = lexical.$getRoot();
+          const allChildren = root.getChildren();
+          if (splitIndex >= allChildren.length) {
+            debugWarn("overflow", `splitIndex=${splitIndex} >= Lexical children=${allChildren.length} — mismatch`);
+            processingRef.current = false;
+            return;
+          }
+          const overflowNodes = [];
+          const toRemove = allChildren.slice(splitIndex);
+          for (const node of toRemove) {
+            overflowNodes.push(serializeNodeTree(node));
+          }
+          for (const node of toRemove) {
+            node.remove();
+          }
+          debug("overflow", `extracted ${overflowNodes.length} overflow nodes, kept ${splitIndex} nodes on current page`);
+          const overflowState = {
+            root: {
+              children: overflowNodes,
+              direction: null,
+              format: "",
+              indent: 0,
+              type: "root",
+              version: 1
+            }
+          };
+          setTimeout(() => {
+            onOverflowRef.current(overflowState, cause);
+            processingRef.current = false;
+          }, 0);
+        },
+        { tag: "overflow-split" }
+      );
+    };
+    const setupObservers = (rootElement) => {
+      if (observer) observer.disconnect();
+      if (unregisterUpdateListener) unregisterUpdateListener();
+      if (debounceTimer) clearTimeout(debounceTimer);
+      const container = rootElement.closest(".lex4-page-body");
+      if (!container) {
+        debugWarn("overflow", "no .lex4-page-body container found");
+        return;
+      }
+      debug("overflow", `observers attached (ns=${editor.getKey()})`);
+      const immediateCheck = () => {
+        requestAnimationFrame(() => checkOverflow(rootElement, container, "content"));
+      };
+      const pasteCheck = () => {
+        requestAnimationFrame(() => checkOverflow(rootElement, container, "paste"));
+      };
+      const debouncedCheck = () => {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(immediateCheck, OVERFLOW_DEBOUNCE_MS);
+      };
+      observer = new ResizeObserver(debouncedCheck);
+      observer.observe(rootElement);
+      observer.observe(container);
+      unregisterUpdateListener = editor.registerUpdateListener(({ tags }) => {
+        if (tags.has("overflow-split")) return;
+        if (tags.has("paste")) {
+          debug("overflow", `paste check (tags=${Array.from(tags).join(",")})`);
+          pasteCheck();
+        } else if (tags.has("collaboration") || tags.has("historic")) {
+          debug("overflow", `immediate check (tags=${Array.from(tags).join(",")})`);
+          immediateCheck();
+        } else {
+          debouncedCheck();
+        }
+      });
+      immediateCheck();
+    };
+    const unregisterRootListener = editor.registerRootListener(
+      (rootElement) => {
+        if (rootElement) {
+          debug("overflow", `rootListener: root available (ns=${editor.getKey()})`);
+          setupObservers(rootElement);
+        } else {
+          debug("overflow", `rootListener: root detached (ns=${editor.getKey()})`);
+          if (observer) observer.disconnect();
+          if (unregisterUpdateListener) unregisterUpdateListener();
+          if (debounceTimer) clearTimeout(debounceTimer);
+          observer = null;
+          unregisterUpdateListener = null;
+          debounceTimer = null;
+        }
+      }
+    );
+    return () => {
+      unregisterRootListener();
+      if (observer) observer.disconnect();
+      if (unregisterUpdateListener) unregisterUpdateListener();
+      if (debounceTimer) clearTimeout(debounceTimer);
+    };
+  }, [editor]);
+  return null;
+};
+function createPageLabel(region, pageNumber) {
+  if (region === "body") {
+    return pageNumber ? `Page ${pageNumber}` : "Body";
+  }
+  const regionLabel = region.charAt(0).toUpperCase() + region.slice(1);
+  return pageNumber ? `${regionLabel} Page ${pageNumber}` : regionLabel;
+}
+const HistoryCapturePlugin = ({ pageId, region }) => {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { document: document2, queueHistoryAction } = useDocument();
+  const context = React.useMemo(() => {
+    const pageNumber = document2.pages.findIndex((page) => page.id === pageId);
+    return {
+      pageNumber: pageNumber >= 0 ? pageNumber + 1 : null,
+      source: region
+    };
+  }, [document2.pages, pageId, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.CONTROLLED_TEXT_INSERTION_COMMAND,
+      () => {
+        queueHistoryAction(buildDescriptor("Typed text"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.KEY_DOWN_COMMAND,
+      (event) => {
+        if (event.metaKey || event.ctrlKey || event.altKey) {
+          return false;
+        }
+        if (event.key.length !== 1) {
+          return false;
+        }
+        queueHistoryAction(buildDescriptor("Typed text"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.PASTE_COMMAND,
+      (event) => {
+        var _a;
+        const text = ((_a = event.clipboardData) == null ? void 0 : _a.getData("text/plain")) ?? "";
+        if (text.trim().length === 0) {
+          return false;
+        }
+        queueHistoryAction(buildDescriptor("Pasted content"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.KEY_ENTER_COMMAND,
+      () => {
+        queueHistoryAction(buildDescriptor("Inserted line break"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.KEY_BACKSPACE_COMMAND,
+      () => {
+        queueHistoryAction(buildDescriptor("Deleted backward"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.KEY_DELETE_COMMAND,
+      () => {
+        queueHistoryAction(buildDescriptor("Deleted forward"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.FORMAT_TEXT_COMMAND,
+      () => {
+        queueHistoryAction(buildDescriptor("Formatted text"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  React.useEffect(() => {
+    const buildDescriptor = (prefix) => ({
+      label: `${prefix} - ${createPageLabel(region, context.pageNumber)}`,
+      source: context.source,
+      pageId,
+      region
+    });
+    return editor.registerCommand(
+      lexical.FORMAT_ELEMENT_COMMAND,
+      () => {
+        queueHistoryAction(buildDescriptor("Formatted paragraph"));
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [context.pageNumber, context.source, editor, pageId, queueHistoryAction, region]);
+  return null;
+};
+function getCollapsedTextPosition(rootElement) {
+  const domSelection = window.getSelection();
+  if (!rootElement || !domSelection || domSelection.rangeCount === 0 || !domSelection.isCollapsed) {
+    return null;
+  }
+  const range = domSelection.getRangeAt(0);
+  if (!rootElement.contains(range.startContainer)) {
+    return null;
+  }
+  const offsetRange = document.createRange();
+  offsetRange.setStart(rootElement, 0);
+  offsetRange.setEnd(range.startContainer, range.startOffset);
+  const contentRange = document.createRange();
+  contentRange.selectNodeContents(rootElement);
+  return {
+    textOffset: offsetRange.toString().length,
+    totalTextLength: contentRange.toString().length
+  };
+}
+const PageBoundaryPlugin = ({
+  onBackspaceAtStart,
+  onDeleteAtEnd,
+  onMoveToPreviousPage,
+  onMoveToNextPage
+}) => {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  React.useEffect(() => editor.registerCommand(
+    lexical.KEY_BACKSPACE_COMMAND,
+    () => {
+      const position = getCollapsedTextPosition(editor.getRootElement());
+      if (!position || position.textOffset !== 0) {
+        return false;
+      }
+      onBackspaceAtStart();
+      return true;
+    },
+    lexical.COMMAND_PRIORITY_HIGH
+  ), [editor, onBackspaceAtStart]);
+  React.useEffect(() => editor.registerCommand(
+    lexical.KEY_DELETE_COMMAND,
+    () => {
+      const position = getCollapsedTextPosition(editor.getRootElement());
+      if (!position || position.textOffset !== position.totalTextLength) {
+        return false;
+      }
+      onDeleteAtEnd();
+      return true;
+    },
+    lexical.COMMAND_PRIORITY_HIGH
+  ), [editor, onDeleteAtEnd]);
+  React.useEffect(() => editor.registerCommand(
+    lexical.KEY_DOWN_COMMAND,
+    (event) => {
+      if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) {
+        return false;
+      }
+      const position = getCollapsedTextPosition(editor.getRootElement());
+      if (!position) {
+        return false;
+      }
+      if ((event.key === "ArrowLeft" || event.key === "ArrowUp") && position.textOffset === 0) {
+        event.preventDefault();
+        onMoveToPreviousPage();
+        return true;
+      }
+      if ((event.key === "ArrowRight" || event.key === "ArrowDown") && position.textOffset === position.totalTextLength) {
+        event.preventDefault();
+        onMoveToNextPage();
+        return true;
+      }
+      return false;
+    },
+    lexical.COMMAND_PRIORITY_HIGH
+  ), [editor, onMoveToNextPage, onMoveToPreviousPage]);
+  return null;
+};
+const EditorRegistryPlugin = ({ pageId }) => {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { editorRegistry } = useDocument();
+  React.useEffect(() => {
+    editorRegistry.register(pageId, editor);
+    debug("registry", `registered editor for page ${shortId(pageId)}`);
+    return () => {
+      editorRegistry.unregister(pageId);
+      debug("registry", `unregistered editor for page ${shortId(pageId)}`);
+    };
+  }, [editor, pageId, editorRegistry]);
+  return null;
+};
+const PageBody = ({
+  pageId,
+  initialBodyState,
+  onBodyChange,
+  onOverflow,
+  onFocus,
+  onBackspaceAtStart,
+  onDeleteAtEnd,
+  onMoveToPreviousPage,
+  onMoveToNextPage,
+  readOnly = false
+}) => {
+  const config = React.useMemo(
+    () => {
+      var _a, _b;
+      const baseConfig = {
+        ...createEditorConfig("body", pageId),
+        editable: !readOnly
+      };
+      if (initialBodyState) {
+        debug("page", `PageBody ${shortId(pageId)}: initializing with ${((_b = (_a = initialBodyState.root) == null ? void 0 : _a.children) == null ? void 0 : _b.length) ?? 0} children`);
+        return {
+          ...baseConfig,
+          editorState: JSON.stringify(initialBodyState)
+        };
+      }
+      debug("page", `PageBody ${shortId(pageId)}: initializing empty`);
+      return baseConfig;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- intentionally only use initialBodyState at mount time
+    [pageId, readOnly]
+  );
+  const handleChange = React.useCallback(
+    (editorState) => {
+      const serialized = editorState.toJSON();
+      onBodyChange == null ? void 0 : onBodyChange(serialized);
+    },
+    [onBodyChange]
+  );
+  const handleOverflow = React.useCallback(
+    (overflowContent, cause) => {
+      var _a, _b;
+      debug("page", `PageBody ${shortId(pageId)}: overflow callback fired with ${((_b = (_a = overflowContent.root) == null ? void 0 : _a.children) == null ? void 0 : _b.length) ?? 0} children`);
+      onOverflow == null ? void 0 : onOverflow(overflowContent, cause);
+    },
+    [onOverflow, pageId]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: "lex4-page-body flex-1 min-h-0 relative",
+      style: { overflow: "hidden" },
+      "data-testid": `page-body-${pageId}`,
+      onFocus,
+      children: /* @__PURE__ */ jsxRuntime.jsxs(LexicalComposer.LexicalComposer, { initialConfig: config, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          LexicalRichTextPlugin.RichTextPlugin,
+          {
+            contentEditable: /* @__PURE__ */ jsxRuntime.jsx(
+              LexicalContentEditable.ContentEditable,
+              {
+                className: "outline-none h-full p-0",
+                style: { overflow: "visible" }
+              }
+            ),
+            placeholder: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute top-0 left-0 text-gray-400 pointer-events-none select-none", children: "Start typing..." }),
+            ErrorBoundary: LexicalErrorBoundary.LexicalErrorBoundary
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(LexicalListPlugin.ListPlugin, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(ParagraphIndentPlugin, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(TabIndentPlugin, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(PastePlugin, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(EditorRegistryPlugin, { pageId }),
+        /* @__PURE__ */ jsxRuntime.jsx(ActiveEditorPlugin, { pageId, region: "body" }),
+        !readOnly && /* @__PURE__ */ jsxRuntime.jsx(HistoryCapturePlugin, { pageId, region: "body" }),
+        !readOnly && onBackspaceAtStart && onDeleteAtEnd && onMoveToPreviousPage && onMoveToNextPage && /* @__PURE__ */ jsxRuntime.jsx(
+          PageBoundaryPlugin,
+          {
+            onBackspaceAtStart,
+            onDeleteAtEnd,
+            onMoveToPreviousPage,
+            onMoveToNextPage
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(OverflowPlugin, { onOverflow: handleOverflow }),
+        /* @__PURE__ */ jsxRuntime.jsx(LexicalOnChangePlugin.OnChangePlugin, { onChange: handleChange, ignoreSelectionChange: true })
+      ] })
+    }
+  );
+};
+function HeightLimitPlugin({ maxHeight, channel }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const lastGoodStateRef = React.useRef(null);
+  const isRevertingRef = React.useRef(false);
+  React.useEffect(() => {
+    lastGoodStateRef.current = JSON.stringify(editor.getEditorState().toJSON());
+    const removeEnterCommand = editor.registerCommand(
+      lexical.KEY_ENTER_COMMAND,
+      () => {
+        const root = editor.getRootElement();
+        if (root && root.scrollHeight >= maxHeight) {
+          debug(channel, `blocked Enter — scrollHeight ${root.scrollHeight}px >= max ${maxHeight}px`);
+          return true;
+        }
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_CRITICAL
+    );
+    const removePasteCommand = editor.registerCommand(
+      lexical.PASTE_COMMAND,
+      () => {
+        const root = editor.getRootElement();
+        if (root && root.scrollHeight >= maxHeight) {
+          debug(channel, `blocked paste — scrollHeight ${root.scrollHeight}px >= max ${maxHeight}px`);
+          return true;
+        }
+        return false;
+      },
+      lexical.COMMAND_PRIORITY_CRITICAL
+    );
+    const removeUpdateListener = editor.registerUpdateListener(({ editorState, prevEditorState }) => {
+      if (isRevertingRef.current) return;
+      const root = editor.getRootElement();
+      if (!root) return;
+      requestAnimationFrame(() => {
+        if (root.scrollHeight > maxHeight) {
+          debug(channel, `reverting — scrollHeight ${root.scrollHeight}px > max ${maxHeight}px`);
+          const restoreState = JSON.stringify(prevEditorState.toJSON()) || lastGoodStateRef.current;
+          if (!restoreState) {
+            return;
+          }
+          isRevertingRef.current = true;
+          editor.setEditorState(editor.parseEditorState(restoreState));
+          isRevertingRef.current = false;
+        } else {
+          lastGoodStateRef.current = JSON.stringify(editorState.toJSON());
+        }
+      });
+    });
+    return () => {
+      removeEnterCommand();
+      removePasteCommand();
+      removeUpdateListener();
+    };
+  }, [editor, maxHeight, channel]);
+  return null;
+}
+const PageHeader = ({
+  pageId,
+  initialHeaderState,
+  pageCounterLabel,
+  onHeaderChange
+}) => {
+  const hasPageCounter = !!pageCounterLabel;
+  const config = React.useMemo(
+    () => {
+      const baseConfig = createEditorConfig("header", pageId);
+      if (initialHeaderState) {
+        return { ...baseConfig, editorState: JSON.stringify(initialHeaderState) };
+      }
+      return baseConfig;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- syncVersion forces remount via key, only used at init
+    [pageId]
+  );
+  const contentRef = React.useRef(null);
+  const handleChange = React.useCallback(
+    (editorState) => {
+      requestAnimationFrame(() => {
+        const el = contentRef.current;
+        if (el) {
+          if (el.scrollHeight > MAX_HEADER_HEIGHT_PX) {
+            debug(
+              "header",
+              `page ${shortId(pageId)}: skipped external sync at ${el.scrollHeight}px > max ${MAX_HEADER_HEIGHT_PX}px`
+            );
+            return;
+          }
+          const height = Math.min(el.scrollHeight, MAX_HEADER_HEIGHT_PX);
+          debug("header", `page ${shortId(pageId)}: height=${height}px (scrollH=${el.scrollHeight})`);
+          onHeaderChange == null ? void 0 : onHeaderChange(editorState.toJSON(), height);
+        }
+      });
+    },
+    [onHeaderChange, pageId]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: "lex4-page-header border-b border-dashed border-gray-200 relative flex-shrink-0",
+      style: { maxHeight: MAX_HEADER_HEIGHT_PX, overflow: "clip" },
+      "data-testid": `page-header-${pageId}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(LexicalComposer.LexicalComposer, { initialConfig: config, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            LexicalRichTextPlugin.RichTextPlugin,
+            {
+              contentEditable: /* @__PURE__ */ jsxRuntime.jsx(
+                LexicalContentEditable.ContentEditable,
+                {
+                  ref: contentRef,
+                  className: `outline-none p-2 text-sm text-gray-600 min-h-[24px] ${hasPageCounter ? "pr-24" : ""}`
+                }
+              ),
+              placeholder: /* @__PURE__ */ jsxRuntime.jsx("div", { className: `absolute top-0 left-0 text-gray-400 pointer-events-none select-none p-2 text-sm ${hasPageCounter ? "pr-24" : ""}`, children: "Header" }),
+              ErrorBoundary: LexicalErrorBoundary.LexicalErrorBoundary
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(ActiveEditorPlugin, { pageId, region: "header" }),
+          /* @__PURE__ */ jsxRuntime.jsx(HistoryCapturePlugin, { pageId, region: "header" }),
+          /* @__PURE__ */ jsxRuntime.jsx(HeightLimitPlugin, { maxHeight: MAX_HEADER_HEIGHT_PX, channel: "header" }),
+          /* @__PURE__ */ jsxRuntime.jsx(LexicalOnChangePlugin.OnChangePlugin, { onChange: handleChange, ignoreSelectionChange: true })
+        ] }),
+        pageCounterLabel && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "pointer-events-none absolute right-2 top-2 select-none text-xs text-gray-500",
+            "data-testid": `page-counter-header-${pageId}`,
+            children: pageCounterLabel
+          }
+        )
+      ]
+    }
+  );
+};
+const PageFooter = ({
+  pageId,
+  initialFooterState,
+  pageCounterLabel,
+  onFooterChange
+}) => {
+  const hasPageCounter = !!pageCounterLabel;
+  const config = React.useMemo(
+    () => {
+      const baseConfig = createEditorConfig("footer", pageId);
+      if (initialFooterState) {
+        return { ...baseConfig, editorState: JSON.stringify(initialFooterState) };
+      }
+      return baseConfig;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- syncVersion forces remount via key, only used at init
+    [pageId]
+  );
+  const contentRef = React.useRef(null);
+  const handleChange = React.useCallback(
+    (editorState) => {
+      requestAnimationFrame(() => {
+        const el = contentRef.current;
+        if (el) {
+          if (el.scrollHeight > MAX_FOOTER_HEIGHT_PX) {
+            debug(
+              "footer",
+              `page ${shortId(pageId)}: skipped external sync at ${el.scrollHeight}px > max ${MAX_FOOTER_HEIGHT_PX}px`
+            );
+            return;
+          }
+          const height = Math.min(el.scrollHeight, MAX_FOOTER_HEIGHT_PX);
+          debug("footer", `page ${shortId(pageId)}: height=${height}px (scrollH=${el.scrollHeight})`);
+          onFooterChange == null ? void 0 : onFooterChange(editorState.toJSON(), height);
+        }
+      });
+    },
+    [onFooterChange, pageId]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: "lex4-page-footer border-t border-dashed border-gray-200 relative flex-shrink-0",
+      style: { maxHeight: MAX_FOOTER_HEIGHT_PX, overflow: "clip" },
+      "data-testid": `page-footer-${pageId}`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(LexicalComposer.LexicalComposer, { initialConfig: config, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            LexicalRichTextPlugin.RichTextPlugin,
+            {
+              contentEditable: /* @__PURE__ */ jsxRuntime.jsx(
+                LexicalContentEditable.ContentEditable,
+                {
+                  ref: contentRef,
+                  className: `outline-none p-2 text-sm text-gray-600 min-h-[24px] ${hasPageCounter ? "pr-24" : ""}`
+                }
+              ),
+              placeholder: /* @__PURE__ */ jsxRuntime.jsx("div", { className: `absolute top-0 left-0 text-gray-400 pointer-events-none select-none p-2 text-sm ${hasPageCounter ? "pr-24" : ""}`, children: "Footer" }),
+              ErrorBoundary: LexicalErrorBoundary.LexicalErrorBoundary
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(ActiveEditorPlugin, { pageId, region: "footer" }),
+          /* @__PURE__ */ jsxRuntime.jsx(HistoryCapturePlugin, { pageId, region: "footer" }),
+          /* @__PURE__ */ jsxRuntime.jsx(HeightLimitPlugin, { maxHeight: MAX_FOOTER_HEIGHT_PX, channel: "footer" }),
+          /* @__PURE__ */ jsxRuntime.jsx(LexicalOnChangePlugin.OnChangePlugin, { onChange: handleChange, ignoreSelectionChange: true })
+        ] }),
+        pageCounterLabel && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "pointer-events-none absolute right-2 top-2 select-none text-xs text-gray-500",
+            "data-testid": `page-counter-footer-${pageId}`,
+            children: pageCounterLabel
+          }
+        )
+      ]
+    }
+  );
+};
+const PageView = React.memo(({
+  pageId,
+  pageIndex,
+  onOverflow,
+  onBackspaceAtStart,
+  onDeleteAtEnd,
+  onMoveToPreviousPage,
+  onMoveToNextPage
+}) => {
+  const { document: document2, dispatch, setActivePageId } = useDocument();
+  const page = document2.pages.find((p) => p.id === pageId);
+  const showHeaderFooter = document2.headerFooterEnabled;
+  const pageCounterMode = document2.pageCounterMode;
+  const pageCounterLabel = `Page ${pageIndex + 1} of ${document2.pages.length}`;
+  if (!page) return null;
+  const handleBodyChange = React.useCallback(
+    (bodyState) => {
+      dispatch({ type: "UPDATE_PAGE_BODY", pageId, bodyState });
+    },
+    [dispatch, pageId]
+  );
+  const handleHeaderChange = React.useCallback(
+    (headerState, height) => {
+      dispatch({ type: "UPDATE_PAGE_HEADER_CONTENT", pageId, headerState, height });
+    },
+    [dispatch, pageId]
+  );
+  const handleFooterChange = React.useCallback(
+    (footerState, height) => {
+      dispatch({ type: "UPDATE_PAGE_FOOTER_CONTENT", pageId, footerState, height });
+    },
+    [dispatch, pageId]
+  );
+  const handleFocus = React.useCallback(() => {
+    setActivePageId(pageId);
+  }, [setActivePageId, pageId]);
+  const handleOverflow = React.useCallback(
+    (overflowContent, cause) => {
+      onOverflow == null ? void 0 : onOverflow(overflowContent, cause);
+    },
+    [onOverflow]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: "lex4-page bg-white shadow-sm flex flex-col",
+      style: {
+        width: A4_WIDTH_PX,
+        height: A4_HEIGHT_PX,
+        padding: PAGE_MARGIN_PX
+      },
+      "data-testid": `page-${pageIndex}`,
+      "data-page-id": pageId,
+      children: [
+        showHeaderFooter && /* @__PURE__ */ jsxRuntime.jsx(
+          PageHeader,
+          {
+            pageId,
+            initialHeaderState: page.headerState,
+            pageCounterLabel: pageCounterMode === "header" || pageCounterMode === "both" ? pageCounterLabel : void 0,
+            onHeaderChange: handleHeaderChange
+          },
+          `header-${page.headerSyncVersion}`
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          PageBody,
+          {
+            pageId,
+            initialBodyState: page.bodyState,
+            onBodyChange: handleBodyChange,
+            onOverflow: handleOverflow,
+            onFocus: handleFocus,
+            onBackspaceAtStart: () => onBackspaceAtStart == null ? void 0 : onBackspaceAtStart(pageIndex, pageId),
+            onDeleteAtEnd: () => onDeleteAtEnd == null ? void 0 : onDeleteAtEnd(pageIndex, pageId),
+            onMoveToPreviousPage: () => onMoveToPreviousPage == null ? void 0 : onMoveToPreviousPage(pageIndex),
+            onMoveToNextPage: () => onMoveToNextPage == null ? void 0 : onMoveToNextPage(pageIndex)
+          },
+          `body-${page.bodySyncVersion}`
+        ),
+        showHeaderFooter && /* @__PURE__ */ jsxRuntime.jsx(
+          PageFooter,
+          {
+            pageId,
+            initialFooterState: page.footerState,
+            pageCounterLabel: pageCounterMode === "footer" || pageCounterMode === "both" ? pageCounterLabel : void 0,
+            onFooterChange: handleFooterChange
+          },
+          `footer-${page.footerSyncVersion}`
+        )
+      ]
+    }
+  );
+});
+PageView.displayName = "PageView";
+const DocumentView = () => {
+  const {
+    document: document2,
+    dispatch,
+    editorRegistry,
+    requestFocusAtEnd,
+    runHistoryAction,
+    setActiveEditor,
+    setActivePageId
+  } = useDocument();
+  const { handlePageUnderflow, reflowAll } = usePagination(document2, dispatch);
+  const previousBodyHeightsRef = React.useRef(null);
+  const pasteOverflowSequenceRef = React.useRef(false);
+  const pasteOverflowReleaseTimerRef = React.useRef(null);
+  const defaultPageTemplate = React.useMemo(
+    () => ({
+      headerState: document2.defaultHeaderState,
+      footerState: document2.defaultFooterState,
+      headerHeight: document2.defaultHeaderHeight,
+      footerHeight: document2.defaultFooterHeight
+    }),
+    [
+      document2.defaultFooterHeight,
+      document2.defaultFooterState,
+      document2.defaultHeaderHeight,
+      document2.defaultHeaderState
+    ]
+  );
+  const bodyHeights = React.useMemo(
+    () => document2.pages.map((page) => computeBodyHeight(
+      document2.headerFooterEnabled ? page.headerHeight : 0,
+      document2.headerFooterEnabled ? page.footerHeight : 0
+    )),
+    [document2.headerFooterEnabled, document2.pages]
+  );
+  React.useEffect(() => {
+    const previousBodyHeights = previousBodyHeightsRef.current;
+    previousBodyHeightsRef.current = bodyHeights;
+    if (!previousBodyHeights) {
+      return;
+    }
+    const bodySpaceExpanded = bodyHeights.some((height, index) => {
+      const previousHeight = previousBodyHeights[index];
+      return previousHeight !== void 0 && height > previousHeight;
+    });
+    if (bodySpaceExpanded) {
+      debug("page", "body space expanded — running full reflow");
+      reflowAll();
+    }
+  }, [bodyHeights, reflowAll]);
+  React.useEffect(
+    () => () => {
+      if (pasteOverflowReleaseTimerRef.current) {
+        clearTimeout(pasteOverflowReleaseTimerRef.current);
+      }
+    },
+    []
+  );
+  const focusBodyEditor = React.useCallback(
+    (pageId, boundary) => {
+      let attempts = 0;
+      const focusWhenReady = () => {
+        const editor = editorRegistry.get(pageId);
+        if (!editor) {
+          if (attempts < 4) {
+            attempts += 1;
+            requestAnimationFrame(focusWhenReady);
+          }
+          return;
+        }
+        const caretPosition = { pageId, region: "body" };
+        setActivePageId(pageId);
+        setActiveEditor(editor, caretPosition);
+        editor.focus(() => {
+          editor.update(() => {
+            if (boundary === "start") {
+              lexical.$getRoot().selectStart();
+            } else {
+              lexical.$getRoot().selectEnd();
+            }
+          });
+        });
+      };
+      requestAnimationFrame(focusWhenReady);
+    },
+    [editorRegistry, setActiveEditor, setActivePageId]
+  );
+  const handlePageOverflow = React.useCallback(
+    (pageIndex, overflowContent, cause) => {
+      var _a, _b, _c, _d;
+      const nextPageIndex = pageIndex + 1;
+      const overflowChildCount = ((_b = (_a = overflowContent.root) == null ? void 0 : _a.children) == null ? void 0 : _b.length) ?? 0;
+      debug("page", `handlePageOverflow: pageIndex=${pageIndex} overflowChildren=${overflowChildCount} totalPages=${document2.pages.length}`);
+      if (cause === "paste") {
+        pasteOverflowSequenceRef.current = true;
+      }
+      if (pasteOverflowSequenceRef.current) {
+        if (pasteOverflowReleaseTimerRef.current) {
+          clearTimeout(pasteOverflowReleaseTimerRef.current);
+        }
+        pasteOverflowReleaseTimerRef.current = setTimeout(() => {
+          pasteOverflowSequenceRef.current = false;
+          pasteOverflowReleaseTimerRef.current = null;
+        }, 800);
+      }
+      if (nextPageIndex < document2.pages.length) {
+        const nextPage = document2.pages[nextPageIndex];
+        const nextEditor = editorRegistry.get(nextPage.id);
+        if (nextEditor) {
+          const currentState = nextEditor.getEditorState().toJSON();
+          const existingChildren = ((_c = currentState.root) == null ? void 0 : _c.children) ?? [];
+          const overflowChildren = ((_d = overflowContent.root) == null ? void 0 : _d.children) ?? [];
+          debug("page", `prepending ${overflowChildren.length} nodes to existing page ${shortId(nextPage.id)} (had ${existingChildren.length} children)`);
+          const mergedState = {
+            root: {
+              ...currentState.root,
+              children: [...overflowChildren, ...existingChildren]
+            }
+          };
+          const newEditorState = nextEditor.parseEditorState(JSON.stringify(mergedState));
+          nextEditor.setEditorState(newEditorState);
+          if (pasteOverflowSequenceRef.current) {
+            requestFocusAtEnd({ pageId: nextPage.id, region: "body" });
+          }
+        } else {
+          debug("page", `editor not found in registry for page ${shortId(nextPage.id)} — falling back to ADD_PAGE`);
+          const newPage = createPageFromTemplate(defaultPageTemplate);
+          newPage.bodyState = overflowContent;
+          runHistoryAction(
+            {
+              label: "Overflow created new page",
+              source: "overflow",
+              region: "document"
+            },
+            () => {
+              dispatch({ type: "ADD_PAGE", afterIndex: pageIndex, page: newPage });
+            }
+          );
+          if (pasteOverflowSequenceRef.current) {
+            requestFocusAtEnd({ pageId: newPage.id, region: "body" });
+          }
+        }
+      } else {
+        const newPage = createPageFromTemplate(defaultPageTemplate);
+        newPage.bodyState = overflowContent;
+        debug("page", `creating new page ${shortId(newPage.id)} with ${overflowChildCount} overflow children`);
+        runHistoryAction(
+          {
+            label: "Overflow created new page",
+            source: "overflow",
+            region: "document"
+          },
+          () => {
+            dispatch({ type: "ADD_PAGE", page: newPage });
+          }
+        );
+        if (pasteOverflowSequenceRef.current) {
+          requestFocusAtEnd({ pageId: newPage.id, region: "body" });
+        }
+      }
+    },
+    [defaultPageTemplate, document2.pages, dispatch, editorRegistry, requestFocusAtEnd, runHistoryAction]
+  );
+  const handleBackspaceAtPageStart = React.useCallback(
+    (pageIndex, pageId) => {
+      if (pageIndex <= 0) {
+        return;
+      }
+      const previousPage = document2.pages[pageIndex - 1];
+      if (!previousPage) {
+        return;
+      }
+      runHistoryAction(
+        {
+          label: `Deleted backward - Page ${pageIndex + 1}`,
+          source: "body",
+          pageId,
+          region: "body"
+        },
+        () => {
+          handlePageUnderflow(pageIndex - 1);
+        }
+      );
+      focusBodyEditor(previousPage.id, "end");
+    },
+    [document2.pages, focusBodyEditor, handlePageUnderflow, runHistoryAction]
+  );
+  const handleDeleteAtPageEnd = React.useCallback(
+    (pageIndex, pageId) => {
+      const currentPage = document2.pages[pageIndex];
+      const nextPage = document2.pages[pageIndex + 1];
+      if (!currentPage || !nextPage) {
+        return;
+      }
+      runHistoryAction(
+        {
+          label: `Deleted forward - Page ${pageIndex + 1}`,
+          source: "body",
+          pageId,
+          region: "body"
+        },
+        () => {
+          handlePageUnderflow(pageIndex);
+        }
+      );
+      focusBodyEditor(currentPage.id, "end");
+    },
+    [document2.pages, focusBodyEditor, handlePageUnderflow, runHistoryAction]
+  );
+  const handleMoveToPreviousPage = React.useCallback(
+    (pageIndex) => {
+      if (pageIndex <= 0) {
+        return;
+      }
+      const previousPage = document2.pages[pageIndex - 1];
+      if (!previousPage) {
+        return;
+      }
+      focusBodyEditor(previousPage.id, "end");
+    },
+    [document2.pages, focusBodyEditor]
+  );
+  const handleMoveToNextPage = React.useCallback(
+    (pageIndex) => {
+      const nextPage = document2.pages[pageIndex + 1];
+      if (!nextPage) {
+        return;
+      }
+      focusBodyEditor(nextPage.id, "start");
+    },
+    [document2.pages, focusBodyEditor]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: "lex4-document-view flex flex-col items-center gap-8 py-8 min-h-full",
+      "data-testid": "document-view",
+      tabIndex: -1,
+      children: document2.pages.map((page, index) => /* @__PURE__ */ jsxRuntime.jsx(
+        PageView,
+        {
+          pageId: page.id,
+          pageIndex: index,
+          onOverflow: (content, cause) => handlePageOverflow(index, content, cause),
+          onBackspaceAtStart: handleBackspaceAtPageStart,
+          onDeleteAtEnd: handleDeleteAtPageEnd,
+          onMoveToPreviousPage: handleMoveToPreviousPage,
+          onMoveToNextPage: handleMoveToNextPage
+        },
+        page.id
+      ))
+    }
+  );
+};
+function selectEntireDocument(rootElement, selectionBuffer) {
+  if (!rootElement || !selectionBuffer) {
+    return;
+  }
+  const bodyRoots = Array.from(
+    rootElement.querySelectorAll('[data-testid^="page-body-"] [data-lexical-editor="true"]')
+  );
+  if (bodyRoots.length === 0) {
+    return;
+  }
+  selectionBuffer.value = bodyRoots.map((bodyRoot) => bodyRoot.innerText.trim()).filter(Boolean).join("\n");
+  selectionBuffer.focus();
+  selectionBuffer.select();
+}
+const GLOBAL_SELECTION_BACKGROUND = "rgb(191, 219, 254)";
+const GLOBAL_SELECTION_FOREGROUND = "rgb(30, 64, 175)";
+function isFormFieldTarget(target) {
+  const element = target;
+  const tagName = element == null ? void 0 : element.tagName;
+  return tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT";
+}
+const EditorChrome = ({
+  captureHistoryShortcutsOnWindow,
+  className
+}) => {
+  const {
+    document: document2,
+    dispatch,
+    globalSelectionActive,
+    setGlobalSelectionActive,
+    undo,
+    redo
+  } = useDocument();
+  const rootRef = React.useRef(null);
+  const selectionBufferRef = React.useRef(null);
+  const clearGlobalSelection = React.useCallback(() => {
+    var _a;
+    setGlobalSelectionActive(false);
+    (_a = selectionBufferRef.current) == null ? void 0 : _a.blur();
+  }, [setGlobalSelectionActive]);
+  const handleHistoryShortcut = React.useCallback((event) => {
+    var _a, _b;
+    const key = event.key.toLowerCase();
+    if (key === "z") {
+      event.preventDefault();
+      (_a = event.stopPropagation) == null ? void 0 : _a.call(event);
+      clearGlobalSelection();
+      if (event.shiftKey) {
+        redo();
+      } else {
+        undo();
+      }
+      return true;
+    }
+    if (key === "y") {
+      event.preventDefault();
+      (_b = event.stopPropagation) == null ? void 0 : _b.call(event);
+      clearGlobalSelection();
+      redo();
+      return true;
+    }
+    return false;
+  }, [clearGlobalSelection, redo, undo]);
+  const handleKeyDownCapture = React.useCallback((event) => {
+    const target = event.target;
+    const isGlobalSelectionBufferTarget = target === selectionBufferRef.current;
+    if (!isGlobalSelectionBufferTarget && isFormFieldTarget(target)) {
+      return;
+    }
+    const key = event.key.toLowerCase();
+    if (isGlobalSelectionBufferTarget && (key === "backspace" || key === "delete")) {
+      event.preventDefault();
+      event.stopPropagation();
+      dispatch({ type: "CLEAR_DOCUMENT_CONTENT" });
+      clearGlobalSelection();
+      return;
+    }
+    const hasModifier = event.metaKey || event.ctrlKey;
+    if (!hasModifier) {
+      return;
+    }
+    if (key === "a") {
+      event.preventDefault();
+      event.stopPropagation();
+      requestAnimationFrame(() => {
+        const activeElement = window.document.activeElement;
+        if (activeElement instanceof HTMLElement && activeElement.isContentEditable) {
+          activeElement.blur();
+        }
+        selectEntireDocument(rootRef.current, selectionBufferRef.current);
+        setGlobalSelectionActive(true);
+      });
+      return;
+    }
+    if (handleHistoryShortcut(event)) {
+      return;
+    }
+  }, [
+    dispatch,
+    handleHistoryShortcut,
+    setGlobalSelectionActive
+  ]);
+  const handleMouseDownCapture = React.useCallback((event) => {
+    if (!globalSelectionActive) {
+      return;
+    }
+    const target = event.target;
+    const clickedToolbar = target == null ? void 0 : target.closest('[data-testid="toolbar"]');
+    if (event.target !== selectionBufferRef.current && !clickedToolbar) {
+      clearGlobalSelection();
+    }
+  }, [clearGlobalSelection, globalSelectionActive]);
+  React.useEffect(() => {
+    var _a;
+    const editableRoots = ((_a = rootRef.current) == null ? void 0 : _a.querySelectorAll(
+      '[data-testid^="page-body-"] [data-lexical-editor="true"]'
+    )) ?? [];
+    editableRoots.forEach((editableRoot) => {
+      editableRoot.style.backgroundColor = globalSelectionActive ? GLOBAL_SELECTION_BACKGROUND : "";
+      editableRoot.style.color = globalSelectionActive ? GLOBAL_SELECTION_FOREGROUND : "";
+      editableRoot.style.caretColor = globalSelectionActive ? "transparent" : "";
+    });
+  }, [globalSelectionActive, document2.pages.length]);
+  React.useEffect(() => {
+    if (!captureHistoryShortcutsOnWindow) {
+      return;
+    }
+    const handleWindowKeyDown = (event) => {
+      const hasModifier = event.metaKey || event.ctrlKey;
+      if (!hasModifier) {
+        return;
+      }
+      handleHistoryShortcut(event);
+    };
+    window.addEventListener("keydown", handleWindowKeyDown, { capture: true });
+    const handleWindowBeforeInput = (event) => {
+      if (event.inputType === "historyUndo") {
+        event.preventDefault();
+        clearGlobalSelection();
+        undo();
+      } else if (event.inputType === "historyRedo") {
+        event.preventDefault();
+        clearGlobalSelection();
+        redo();
+      }
+    };
+    window.addEventListener("beforeinput", handleWindowBeforeInput, { capture: true });
+    return () => {
+      window.removeEventListener("keydown", handleWindowKeyDown, { capture: true });
+      window.removeEventListener("beforeinput", handleWindowBeforeInput, { capture: true });
+    };
+  }, [captureHistoryShortcutsOnWindow, clearGlobalSelection, handleHistoryShortcut, redo, undo]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref: rootRef,
+      className: `lex4-editor flex flex-col h-full ${className ?? ""}`,
+      "data-testid": "lex4-editor",
+      "data-global-selection-active": globalSelectionActive ? "true" : "false",
+      onKeyDownCapture: handleKeyDownCapture,
+      onMouseDownCapture: handleMouseDownCapture,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "textarea",
+          {
+            ref: selectionBufferRef,
+            "aria-hidden": "true",
+            "data-testid": "global-selection-buffer",
+            readOnly: true,
+            tabIndex: -1,
+            className: "pointer-events-none fixed -left-[9999px] top-0 h-0 w-0 opacity-0"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(Toolbar, {}),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex min-h-0 flex-1 overflow-hidden bg-gray-200", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "min-w-0 flex-1 overflow-auto", children: /* @__PURE__ */ jsxRuntime.jsx(DocumentView, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsx(HistorySidebar, {})
+        ] })
+      ]
+    }
+  );
+};
+const Lex4Editor = ({
+  captureHistoryShortcutsOnWindow = true,
+  initialDocument,
+  onDocumentChange,
+  className
+}) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DocumentProvider,
+    {
+      initialDocument,
+      onDocumentChange,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        EditorChrome,
+        {
+          captureHistoryShortcutsOnWindow,
+          className
+        }
+      )
+    }
+  );
+};
+function useOverflowDetection(bodyHeight, onOverflow, debounceMs = 100) {
+  const timerRef = React.useRef(null);
+  const observerRef = React.useRef(null);
+  const check = React.useCallback(
+    (el) => {
+      if (!onOverflow) return;
+      if (el.scrollHeight > bodyHeight + 2) {
+        onOverflow();
+      }
+    },
+    [bodyHeight, onOverflow]
+  );
+  const attachRef = React.useCallback(
+    (el) => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
+      if (!el || !onOverflow) return;
+      observerRef.current = new ResizeObserver(() => {
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => check(el), debounceMs);
+      });
+      observerRef.current.observe(el);
+    },
+    [check, debounceMs, onOverflow]
+  );
+  React.useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      if (observerRef.current) observerRef.current.disconnect();
+    };
+  }, []);
+  return { attachRef };
+}
+function useHeaderFooter(maxHeight, onHeightChange) {
+  const observerRef = React.useRef(null);
+  const lastHeightRef = React.useRef(0);
+  const attachRef = React.useCallback(
+    (el) => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
+      if (!el) return;
+      const measure = () => {
+        const height = Math.min(el.scrollHeight, maxHeight);
+        if (height !== lastHeightRef.current) {
+          lastHeightRef.current = height;
+          onHeightChange(height);
+        }
+      };
+      observerRef.current = new ResizeObserver(measure);
+      observerRef.current.observe(el);
+      measure();
+    },
+    [maxHeight, onHeightChange]
+  );
+  React.useEffect(() => {
+    return () => {
+      if (observerRef.current) observerRef.current.disconnect();
+    };
+  }, []);
+  return { attachRef };
+}
+exports.A4_HEIGHT_MM = A4_HEIGHT_MM;
+exports.A4_HEIGHT_PX = A4_HEIGHT_PX;
+exports.A4_WIDTH_MM = A4_WIDTH_MM;
+exports.A4_WIDTH_PX = A4_WIDTH_PX;
+exports.Lex4Editor = Lex4Editor;
+exports.MAX_FOOTER_HEIGHT_PX = MAX_FOOTER_HEIGHT_PX;
+exports.MAX_HEADER_HEIGHT_PX = MAX_HEADER_HEIGHT_PX;
+exports.createEmptyDocument = createEmptyDocument;
+exports.createEmptyPage = createEmptyPage;
+exports.useHeaderFooter = useHeaderFooter;
+exports.useOverflowDetection = useOverflowDetection;
+exports.usePagination = usePagination;
+//# sourceMappingURL=lex4-editor.cjs.map