@open-press/core 0.5.0 → 0.7.0

package/src/openpress/numbering/index.ts

@@ -0,0 +1,294 @@
+// @open-press/core/numbering — label formatters for AI authoring layer.
+//
+// Core stays neutral about how chapter / section / topic numbers should look.
+// Source resolution exposes raw integers via outline items
+// (`chapterNumber`, `sectionIndex`, `topicIndex`). This module is a toolbox
+// of pure functions that turn those integers into human-readable labels —
+// Chinese numerals, Roman numerals, alphabet letters, padded decimals, etc.
+//
+// Workspaces import what they need and compose them inside their own
+// `<Page>` / `<Toc>` components. The core engine never calls these.
+
+// ---------------------------------------------------------------------------
+// CJK numeral systems
+// ---------------------------------------------------------------------------
+
+const CJK_INFORMAL = ["〇", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
+const CJK_FORMAL = ["零", "壹", "貳", "參", "肆", "伍", "陸", "柒", "捌", "玖"];
+const CJK_HEAVENLY_STEMS = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"];
+const CJK_EARTHLY_BRANCHES = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"];
+
+/**
+ * Informal CJK numerals (一二三...). Handles 0 to 9999.
+ *
+ *   toCjk(1)   → "一"
+ *   toCjk(10)  → "十"
+ *   toCjk(15)  → "十五"
+ *   toCjk(23)  → "二十三"
+ *   toCjk(100) → "一百"
+ *   toCjk(108) → "一百零八"
+ *   toCjk(2024) → "二千零二十四"
+ */
+export function toCjk(n: number): string {
+  if (!Number.isFinite(n) || n < 0) return String(n);
+  return formatCjkDigits(Math.floor(n), CJK_INFORMAL);
+}
+
+/**
+ * Formal CJK numerals (壹貳參...). Used in legal / financial contexts.
+ *
+ *   toCjkFormal(1)   → "壹"
+ *   toCjkFormal(100) → "壹佰"
+ */
+export function toCjkFormal(n: number): string {
+  if (!Number.isFinite(n) || n < 0) return String(n);
+  return formatCjkDigits(Math.floor(n), CJK_FORMAL, { formal: true });
+}
+
+/**
+ * Heavenly Stems cycle (甲乙丙丁戊己庚辛壬癸 — 10 only).
+ * Cycles for n > 10; n=11 → 甲 again.
+ *
+ *   toCjkHeavenlyStem(1) → "甲"
+ *   toCjkHeavenlyStem(10) → "癸"
+ *   toCjkHeavenlyStem(11) → "甲"
+ */
+export function toCjkHeavenlyStem(n: number): string {
+  if (!Number.isFinite(n) || n < 1) return String(n);
+  return CJK_HEAVENLY_STEMS[(Math.floor(n) - 1) % 10]!;
+}
+
+/**
+ * Earthly Branches cycle (子丑寅卯辰巳午未申酉戌亥 — 12 only).
+ * Cycles for n > 12.
+ */
+export function toCjkEarthlyBranch(n: number): string {
+  if (!Number.isFinite(n) || n < 1) return String(n);
+  return CJK_EARTHLY_BRANCHES[(Math.floor(n) - 1) % 12]!;
+}
+
+// ---------------------------------------------------------------------------
+// Roman numerals
+// ---------------------------------------------------------------------------
+
+const ROMAN_TABLE: Array<[number, string]> = [
+  [1000, "M"], [900, "CM"], [500, "D"], [400, "CD"],
+  [100, "C"],  [90, "XC"],  [50, "L"],  [40, "XL"],
+  [10, "X"],   [9, "IX"],   [5, "V"],   [4, "IV"],
+  [1, "I"],
+];
+
+/**
+ * Roman numerals (I, II, III, …, MMXX). Uppercase by default.
+ * Pass `{ upper: false }` for lowercase (typical front-matter page numbering).
+ *
+ *   toRoman(1)     → "I"
+ *   toRoman(4)     → "IV"
+ *   toRoman(2024)  → "MMXXIV"
+ *   toRoman(3, { upper: false }) → "iii"
+ */
+export function toRoman(n: number, opts: { upper?: boolean } = {}): string {
+  if (!Number.isFinite(n) || n < 1) return String(n);
+  let value = Math.floor(n);
+  let out = "";
+  for (const [num, sym] of ROMAN_TABLE) {
+    while (value >= num) {
+      out += sym;
+      value -= num;
+    }
+  }
+  return opts.upper === false ? out.toLowerCase() : out;
+}
+
+// ---------------------------------------------------------------------------
+// Latin alphabet (a, b, c, …, z, aa, ab, …)
+// ---------------------------------------------------------------------------
+
+/**
+ * Spreadsheet-column-style alphabet labels.
+ *
+ *   toAlpha(1)  → "a"
+ *   toAlpha(26) → "z"
+ *   toAlpha(27) → "aa"
+ *   toAlpha(53) → "ba"
+ *   toAlpha(1, { upper: true }) → "A"
+ */
+export function toAlpha(n: number, opts: { upper?: boolean } = {}): string {
+  if (!Number.isFinite(n) || n < 1) return String(n);
+  let value = Math.floor(n);
+  let out = "";
+  while (value > 0) {
+    const rem = (value - 1) % 26;
+    out = String.fromCharCode(97 + rem) + out;
+    value = Math.floor((value - 1) / 26);
+  }
+  return opts.upper ? out.toUpperCase() : out;
+}
+
+// ---------------------------------------------------------------------------
+// Zero-padded decimal
+// ---------------------------------------------------------------------------
+
+/**
+ * Zero-padded decimal — `width` is the minimum number of digits.
+ *
+ *   toPadded(1)              → "01"
+ *   toPadded(1, { width: 3 }) → "001"
+ *   toPadded(123)            → "123"
+ */
+export function toPadded(n: number, opts: { width?: number } = {}): string {
+  if (!Number.isFinite(n)) return String(n);
+  const width = Math.max(1, opts.width ?? 2);
+  return String(Math.floor(n)).padStart(width, "0");
+}
+
+// ---------------------------------------------------------------------------
+// Composable label templates
+// ---------------------------------------------------------------------------
+
+export type NumberFormat =
+  | "decimal"
+  | "decimal-padded"
+  | "cjk"
+  | "cjk-formal"
+  | "cjk-heavenly-stem"
+  | "cjk-earthly-branch"
+  | "roman"
+  | "roman-lower"
+  | "alpha"
+  | "alpha-upper";
+
+export interface ChapterLabelOptions {
+  format?: NumberFormat;
+  prefix?: string;
+  suffix?: string;
+  width?: number;
+}
+
+/**
+ * Compose a chapter label like "第一章" / "Chapter 1" / "01" / "Part IV".
+ *
+ *   chapterLabel(1)
+ *     → "第一章" (default: cjk informal, prefix 第, suffix 章)
+ *   chapterLabel(1, { format: "decimal-padded", prefix: "Chapter " })
+ *     → "Chapter 01"
+ *   chapterLabel(4, { format: "roman", prefix: "Part " })
+ *     → "Part IV"
+ *   chapterLabel(2, { prefix: "", suffix: "" })
+ *     → "二"
+ */
+export function chapterLabel(n: number, opts: ChapterLabelOptions = {}): string {
+  const { format = "cjk", prefix = "第", suffix = "章", width } = opts;
+  return `${prefix}${formatNumber(n, format, width)}${suffix}`;
+}
+
+export interface SectionLabelOptions {
+  format?: NumberFormat;
+  separator?: string;
+  prefix?: string;
+  suffix?: string;
+}
+
+/**
+ * Compose a section label like "1.1" / "1.1.2" / "一-1".
+ *
+ * Accepts variadic counters for nesting:
+ *   sectionLabel(1, 2)
+ *     → "1.2"
+ *   sectionLabel(1, 2, 3)
+ *     → "1.2.3"
+ *   sectionLabel(1, 2, { format: "cjk", separator: "之" })
+ *     ⚠ note: pass options as last argument when using variadic counters;
+ *     prefer `sectionLabelOf([1, 2], { … })` below for clarity.
+ */
+export function sectionLabel(...counters: number[]): string {
+  return sectionLabelOf(counters);
+}
+
+/**
+ * Explicit-array variant of `sectionLabel` so options can be passed cleanly.
+ *
+ *   sectionLabelOf([1, 2], { separator: "-" })   → "1-2"
+ *   sectionLabelOf([1, 2, 3], { format: "alpha" }) → "a.b.c"
+ *   sectionLabelOf([1, 1], { format: "cjk", separator: "-" }) → "一-一"
+ */
+export function sectionLabelOf(counters: number[], opts: SectionLabelOptions = {}): string {
+  const { format = "decimal", separator = ".", prefix = "", suffix = "" } = opts;
+  const parts = counters.map((c) => formatNumber(c, format));
+  return `${prefix}${parts.join(separator)}${suffix}`;
+}
+
+// ---------------------------------------------------------------------------
+// Generic dispatch — `format` -> formatter
+// ---------------------------------------------------------------------------
+
+/**
+ * Format a single number using one of the named formats. Useful when the
+ * caller already knows which format string to use (e.g. from config).
+ *
+ *   formatNumber(7, "cjk")           → "七"
+ *   formatNumber(7, "roman-lower")   → "vii"
+ *   formatNumber(3, "decimal-padded", 3) → "003"
+ */
+export function formatNumber(n: number, format: NumberFormat, width?: number): string {
+  switch (format) {
+    case "decimal": return String(Math.floor(n));
+    case "decimal-padded": return toPadded(n, { width });
+    case "cjk": return toCjk(n);
+    case "cjk-formal": return toCjkFormal(n);
+    case "cjk-heavenly-stem": return toCjkHeavenlyStem(n);
+    case "cjk-earthly-branch": return toCjkEarthlyBranch(n);
+    case "roman": return toRoman(n, { upper: true });
+    case "roman-lower": return toRoman(n, { upper: false });
+    case "alpha": return toAlpha(n);
+    case "alpha-upper": return toAlpha(n, { upper: true });
+    default: return String(n);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CJK digit formatter (internal)
+// ---------------------------------------------------------------------------
+
+const CJK_UNITS = ["", "十", "百", "千"];
+const CJK_UNITS_FORMAL = ["", "拾", "佰", "仟"];
+
+// Gap-zero indicator used between non-zero digits when reading aloud
+// (e.g. 一百零八). Distinct from 〇/零 as a literal zero digit.
+const CJK_GAP_ZERO = "零";
+
+function formatCjkDigits(n: number, digits: string[], opts: { formal?: boolean } = {}): string {
+  if (n === 0) return digits[0]!;
+  if (n < 0) return `負${formatCjkDigits(-n, digits, opts)}`;
+  if (n >= 10000) {
+    const wan = Math.floor(n / 10000);
+    const rest = n % 10000;
+    if (rest === 0) return `${formatCjkDigits(wan, digits, opts)}萬`;
+    const restStr = formatCjkDigits(rest, digits, opts);
+    const padded = rest < 1000 ? `${CJK_GAP_ZERO}${restStr}` : restStr;
+    return `${formatCjkDigits(wan, digits, opts)}萬${padded}`;
+  }
+  const units = opts.formal ? CJK_UNITS_FORMAL : CJK_UNITS;
+  const str = String(n);
+  let out = "";
+  let zeroPending = false;
+  for (let i = 0; i < str.length; i++) {
+    const digit = Number(str[i]);
+    const unit = str.length - 1 - i;
+    if (digit === 0) {
+      zeroPending = true;
+      continue;
+    }
+    if (zeroPending && out.length > 0) {
+      out += CJK_GAP_ZERO;
+      zeroPending = false;
+    }
+    // Special case: leading "一十" usually written as just "十" in informal CJK
+    if (!opts.formal && digit === 1 && unit === 1 && i === 0) {
+      out += units[unit];
+    } else {
+      out += digits[digit] + units[unit];
+    }
+  }
+  return out;
+}

package/src/openpress/publicPage.tsx

@@ -9,13 +9,12 @@ import {
   type RefObject,
 } from "react";
 import { BookOpen, ExternalLink, X } from "lucide-react";
+import { createAnchorPageMap, resolveAnchorPageIndex } from "./anchorMap";
 import { collectBookmarkIndex } from "./indexes";
 import type { InspectorState } from "./inspector";
-import { normalizeContentCaptions, paginateSourcePages, type PaginatedPage } from "./pagination";
 import { getProjectIdentity } from "./projectIdentity";
-import { hasBuildTimePagination } from "./reactDocumentMetadata";
 import { useReaderRuntime } from "./readerRuntime";
-import { scheduleBrowserFrame, waitForBrowserFrame } from "./frameScheduler";
+import { scheduleBrowserFrame } from "./frameScheduler";
 import type { DeploymentInfo, ReaderDocument, HtmlPageBlock } from "./types";
 import { Bookmarks, CurrentPagePanel } from "./workbenchPanels";
 import type { DisplayPage } from "./workbenchTypes";
@@ -38,15 +37,9 @@ export function PublicViewer({
   deploymentInfo?: DeploymentInfo;
 }) {
   const sourceContainerRef = useRef<HTMLDivElement | null>(null);
-  const numberedPages = useMemo(() => numberSourceHeadings(pages), [pages]);
+  const displayPages = pages;
   const viewModeState = useViewMode();
   const { viewMode } = viewModeState;
-  const buildTimePaginated = hasBuildTimePagination(document);
-  const paginatedPages = usePaginatedPages(numberedPages, sourceContainerRef, viewMode === "paged" && !buildTimePaginated);
-  const displayPages: DisplayPage[] = viewMode === "paged" && !buildTimePaginated
-    ? (paginatedPages ?? numberedPages)
-    : numberedPages;
-  const paginatedReady = viewMode === "reading" || buildTimePaginated || Boolean(paginatedPages);
   const bookmarks = collectBookmarkIndex(displayPages);
   const anchorPageMap = useMemo(() => createAnchorPageMap(displayPages), [displayPages]);
   const reader = useReaderRuntime({
@@ -87,7 +80,6 @@ export function PublicViewer({
         className={appClassName}
         data-openpress-react-runtime="true"
         data-openpress-view-mode={viewMode}
-        data-openpress-pagination={paginatedReady ? "ready" : "pending"}
       >
         {drawerOpen && (
           <div className="openpress-public-scrim" aria-hidden="true" onClick={reader.toggleRightPanel} />
@@ -102,7 +94,6 @@ export function PublicViewer({
               pages={displayPages}
               currentPageIndex={reader.currentPageIndex}
               devMode={false}
-              paginatedReady={paginatedReady}
               sourceContainerRef={sourceContainerRef}
               registerPage={reader.registerPage}
               onInternalAnchorNavigate={selectPublicAnchor}
@@ -196,12 +187,8 @@ export function PrintDocument({
   pages: Array<HtmlPageBlock>;
   style: CSSProperties;
 }) {
-  const numberedPages = useMemo(() => numberSourceHeadings(pages), [pages]);
   const sourceContainerRef = useRef<HTMLDivElement | null>(null);
-  const buildTimePaginated = hasBuildTimePagination(document);
-  const paginatedPages = usePaginatedPages(numberedPages, sourceContainerRef, !buildTimePaginated);
-  const displayPages: DisplayPage[] = buildTimePaginated ? numberedPages : (paginatedPages ?? numberedPages);
-  const paginatedReady = buildTimePaginated || Boolean(paginatedPages);
+  const displayPages = pages;
   const registerPage = () => () => undefined;
 
   return (
@@ -209,14 +196,12 @@ export function PrintDocument({
       className="openpress-print-document"
       style={style}
       data-openpress-print-document="true"
-      data-openpress-pagination={paginatedReady ? "ready" : "pending"}
       aria-label={`${document.meta.title} PDF 輸出`}
     >
       <PublicPage
         pages={displayPages}
         currentPageIndex={0}
         devMode={false}
-        paginatedReady={paginatedReady}
         sourceContainerRef={sourceContainerRef}
         registerPage={registerPage}
         exposeSourceData
@@ -225,137 +210,15 @@ export function PrintDocument({
   );
 }
 
-function usePaginatedPages(
-  pages: Array<HtmlPageBlock>,
-  sourceContainerRef: RefObject<HTMLDivElement | null>,
-  enabled = true,
-) {
-  const [paginatedPages, setPaginatedPages] = useState<PaginatedPage[] | null>(null);
-
-  useLayoutEffect(() => {
-    setPaginatedPages(null);
-  }, [pages]);
-
-  useLayoutEffect(() => {
-    if (!enabled) return undefined;
-    if (paginatedPages) return undefined;
-    const sourceContainer = sourceContainerRef.current;
-    if (!sourceContainer) return undefined;
-
-    let cancelled = false;
-
-    void (async () => {
-      await waitForPaginationAssets(sourceContainer);
-      await waitForBrowserFrame();
-      if (cancelled) return;
-
-      const nextPages = paginateSourcePages(sourceContainer, pages);
-      if (!cancelled) setPaginatedPages(nextPages);
-    })();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [enabled, pages, paginatedPages, sourceContainerRef]);
-
-  return paginatedPages;
-}
-
 function viewportAllowsPagedMode() {
   if (typeof window === "undefined") return true;
   return window.innerWidth >= PAGED_VIEW_MIN_WIDTH;
 }
 
-export function numberSourceHeadings(pages: Array<HtmlPageBlock>): Array<HtmlPageBlock> {
-  if (typeof document === "undefined") return pages;
-
-  let chapterCounter = 0;
-  let sectionCounter = 0;
-  let topicCounter = 0;
-
-  const parsedPages = pages.map((page) => {
-    const template = document.createElement("template");
-    template.innerHTML = page.html;
-    const readerPage = template.content.querySelector<HTMLElement>(".reader-page");
-    if (!readerPage || !isContentPage(readerPage)) return { page, template, readerPage };
-
-    readerPage.querySelectorAll<HTMLElement>("h2, h3, h4").forEach((heading) => {
-      if (heading.tagName === "H2") {
-        chapterCounter += 1;
-        sectionCounter = 0;
-        topicCounter = 0;
-        ensureHeadingId(heading, `section-${String(chapterCounter).padStart(2, "0")}`);
-        heading.dataset.chapter = String(chapterCounter).padStart(2, "0");
-        heading.dataset.chapterMarker = `#${chapterCounter}`;
-        return;
-      }
-
-      if (heading.tagName === "H3") {
-        sectionCounter += 1;
-        topicCounter = 0;
-        ensureHeadingId(heading, `section-${chapterCounter}-${sectionCounter}`);
-        heading.dataset.section = `${chapterCounter}.${sectionCounter}`;
-        return;
-      }
-
-      if (heading.tagName === "H4") {
-        topicCounter += 1;
-        if (chapterCounter > 0 && sectionCounter > 0) {
-          ensureHeadingId(heading, `section-${chapterCounter}-${sectionCounter}-${topicCounter}`);
-          heading.dataset.topic = `${chapterCounter}.${sectionCounter}.${topicCounter}`;
-        }
-      }
-    });
-
-    return { page, template, readerPage };
-  });
-
-  normalizeContentCaptions(
-    parsedPages
-      .map((entry) => entry.readerPage)
-      .filter((page): page is HTMLElement => Boolean(page)),
-  );
-
-  return parsedPages.map(({ page, template }) => {
-    const html = template.innerHTML;
-    const anchors = collectElementIds(template.content);
-    return html === page.html && anchorsAreEqual(page.anchors, anchors) ? page : { ...page, html, anchors };
-  });
-}
-
-function isContentPage(page: HTMLElement) {
-  return page.dataset.pageKind === "content";
-}
-
-async function waitForPaginationAssets(scope: HTMLElement) {
-  await document.fonts?.ready;
-  const images = Array.from(scope.querySelectorAll<HTMLImageElement>("img"));
-  await Promise.all(images.map(waitForImage));
-  await waitForBrowserFrame();
-}
-
-async function waitForImage(img: HTMLImageElement) {
-  if (!img.complete) {
-    await new Promise<void>((resolve) => {
-      const settle = () => {
-        img.removeEventListener("load", settle);
-        img.removeEventListener("error", settle);
-        resolve();
-      };
-
-      img.addEventListener("load", settle, { once: true });
-      img.addEventListener("error", settle, { once: true });
-    });
-  }
-
-  await img.decode?.().catch(() => undefined);
-}
-
 export function PublicPage({
   pages,
   currentPageIndex,
   devMode,
-  paginatedReady,
   sourceContainerRef,
   registerPage,
   exposeSourceData = false,
@@ -365,7 +228,6 @@ export function PublicPage({
   pages: DisplayPage[];
   currentPageIndex: number;
   devMode: boolean;
-  paginatedReady: boolean;
   sourceContainerRef: RefObject<HTMLDivElement | null>;
   registerPage: (pageIndex: number) => RefCallback<HTMLElement>;
   exposeSourceData?: boolean;
@@ -408,11 +270,6 @@ export function PublicPage({
           data-source-path={exposeSourceData ? page.source?.path : undefined}
           data-source-file={exposeSourceData ? page.source?.file : undefined}
         >
-          {devMode && !paginatedReady && page.source?.path ? (
-            <div className="openpress-html-page__toolbar">
-              <code>{page.source.path}</code>
-            </div>
-          ) : null}
           <div className="openpress-html-page__html" dangerouslySetInnerHTML={{ __html: page.html }} />
         </div>
       ))}
@@ -420,45 +277,6 @@ export function PublicPage({
   );
 }
 
-export function createAnchorPageMap(pages: DisplayPage[]) {
-  const map = new Map<string, number>();
-  pages.forEach((page, index) => {
-    page.anchors?.forEach((anchor) => {
-      if (anchor && !map.has(anchor)) map.set(anchor, index);
-    });
-  });
-  return map;
-}
-
-export function resolveAnchorPageIndex(
-  anchorPageMap: Map<string, number>,
-  pageCount: number,
-  anchorId: string,
-  pageIndex?: number,
-): number | null {
-  if (typeof pageIndex === "number" && Number.isInteger(pageIndex) && pageIndex >= 0 && pageIndex < pageCount) return pageIndex;
-  const mapped = anchorPageMap.get(anchorId);
-  return mapped === undefined ? null : mapped;
-}
-
-function ensureHeadingId(heading: HTMLElement, fallbackId: string) {
-  if (heading.id) return;
-  heading.id = fallbackId;
-}
-
-function collectElementIds(scope: ParentNode) {
-  const ids: string[] = [];
-  scope.querySelectorAll<HTMLElement>("[id]").forEach((el) => {
-    if (el.id && !ids.includes(el.id)) ids.push(el.id);
-  });
-  return ids;
-}
-
-function anchorsAreEqual(left: string[] | undefined, right: string[]) {
-  if (!left || left.length !== right.length) return false;
-  return left.every((item, index) => item === right[index]);
-}
-
 function safeDecodeAnchor(value: string) {
   if (!value) return "";
   try {

package/src/openpress/reactDocumentMetadata.ts

@@ -1,26 +1,12 @@
 import type {
   ReaderDocument,
-  BuildPagination,
   SourceBlock,
 } from "./types";
 
-export const REACT_MDX_SOURCE_TYPE = "openpress-react-mdx";
-export const BUILD_TIME_PAGINATION_MODE = "build-time-block-measurement";
+export const PRESS_TREE_MDX_SOURCE_TYPE = "openpress-press-tree-mdx";
 
 export function isReactMdxDocument(document: Pick<ReaderDocument, "source"> | null | undefined) {
-  return document?.source?.type === REACT_MDX_SOURCE_TYPE;
-}
-
-export function hasBuildTimePagination(document: Pick<ReaderDocument, "source"> | null | undefined) {
-  return getBuildPagination(document)?.mode === BUILD_TIME_PAGINATION_MODE;
-}
-
-export function getBuildPagination(
-  document: Pick<ReaderDocument, "source"> | null | undefined,
-): BuildPagination | null {
-  if (!isReactMdxDocument(document)) return null;
-  const pagination = document?.source?.pagination;
-  return pagination && typeof pagination.mode === "string" ? pagination : null;
+  return document?.source?.type === PRESS_TREE_MDX_SOURCE_TYPE;
 }
 
 export function getSourceBlockMap(

package/src/openpress/types.ts

@@ -25,7 +25,6 @@ export interface DocumentSource {
   editMode?: string;
   styles?: DocumentStyle[];
   blockMap?: Record<string, SourceBlock>;
-  pagination?: BuildPagination;
 }
 
 export interface DocumentStyle {
@@ -52,21 +51,6 @@ export interface SourceBlock {
   source?: SourceLocation;
 }
 
-export interface BuildPagination {
-  mode: string;
-  pageSafeHeightPx?: number;
-  warnings?: PaginationWarning[];
-}
-
-export interface PaginationWarning {
-  code: string;
-  blockId?: string;
-  height?: number;
-  pageSafeHeightPx?: number;
-  path?: string;
-  source?: SourceLocation;
-}
-
 export interface DocumentMeta {
   title: string;
   subtitle?: string;