@beyondwork/docx-react-component 1.0.71 → 1.0.72

package/src/api/v3/runtime/workflow.ts

@@ -4,7 +4,8 @@
  * queryScopes (live) / getMarkup (live) / getGuard (live) /
  * createScope (live-with-adapter) / attachMetadata (live-with-adapter) /
  * getVisibilityPolicy · getVisibilityPolicies · setVisibilityPolicy ·
- * clearVisibilityPolicy (live — W10 state-classes X1).
+ * clearVisibilityPolicy (live — W10 state-classes X1) /
+ * scopeTags (live — coord-10 L11-4 tag-catalog read).
  */
 
 import type { RuntimeApiHandle } from "../_runtime-handle.ts";
@@ -17,6 +18,13 @@ import type {
 import { emitUxResponse } from "../_ux-response.ts";
 import { createScopeFromBlockId } from "../../../runtime/workflow/scope-writer.ts";
 import { attachScopeMetadata } from "../../../runtime/workflow/metadata-writer.ts";
+import {
+  DEFAULT_REGISTRY_ENTRIES,
+  DEFAULT_UNKNOWN_BEHAVIOR,
+  createScopeTagRegistry,
+  type ScopeTagBehavior,
+  type ScopeTagRegistry,
+} from "../../../runtime/workflow/scope-tag-registry.ts";
 
 export const queryScopesMetadata: ApiV3FnMetadata = {
   name: "runtime.workflow.queryScopes",
@@ -79,6 +87,25 @@ export interface CreateScopeInput {
    * leak in). Agents pick per scope family per coord-09 §1.14.
    */
   readonly assoc?: { readonly start: -1 | 1; readonly end: -1 | 1 };
+  /**
+   * Coord-08 §9 / coord-09 §1.13 (A3) — caller-steerable identity
+   * strategy for the enumerated scope's `ScopeHandle.stableRef`.
+   * Passthrough to L06 scope-writer + L08 compiler. Honored for
+   * `"scope-id"` and `"semantic-path"` today; `"bookmark"` and
+   * `"runtime-handle"` fall back to the compiler default (bookmark
+   * lookup not wired in phase 1). See
+   * `src/runtime/scopes/enumerate-scopes.ts::stableRefHintForScopeId`.
+   *
+   * Ownership: L08 owns the selection policy; L06 owns the primitive
+   * (`scope-writer.ts::CreateScopeFromBlockIdInput.stableRefHint`);
+   * L07 is passthrough (this field); L02 owns the `ScopeStableRef`
+   * value shape.
+   */
+  readonly stableRefHint?:
+    | "scope-id"
+    | "bookmark"
+    | "semantic-path"
+    | "runtime-handle";
 }
 
 export interface CreateScopeResult {
@@ -273,6 +300,68 @@ export const subscribeMarkupModePolicyMetadata: ApiV3FnMetadata = {
   rwdReference: "§Runtime API § runtime.workflow.subscribeMarkupModePolicy",
 };
 
+// ---------------------------------------------------------------------------
+// Coord-10 L11-4 — scope-tag catalog read, graduating the pragmatic
+// `createScopeTagRegistry` re-export through `src/api/public-types.ts`
+// (refactor/11 §4.17 commit `7a2d2fc0`, 2026-04-24) to a proper v3 family
+// entry. Three methods: factory + catalog enumeration + per-tag peek. All
+// A-canonical — the catalog is code-derived but describes canonical-shape
+// invariants: every tag it catalogs is encoded into customXml (via scope-
+// marker / bookmark / comment structures) and broadcast via crdt along
+// with scope-marker commits.
+// ---------------------------------------------------------------------------
+
+export const createScopeTagRegistryMetadata: ApiV3FnMetadata = {
+  name: "runtime.workflow.createScopeTagRegistry",
+  status: "live",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/runtime/workflow-scope-tags.test.ts",
+    commit: "coord-10-l11-4",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: { readOrMutate: "read", boundedScope: "session", auditCategory: "scope-tag-catalog" },
+  stateClass: "A-canonical",
+  persistsTo: "customXml",
+  broadcastsVia: "crdt",
+  rwdReference:
+    "§Runtime API § runtime.workflow.createScopeTagRegistry. Mints a fresh default-seeded ScopeTagRegistry. Hosts register custom annotation families on the returned registry via `.register(...)`. Retires the pragmatic `createScopeTagRegistry` re-export through public-types.ts (refactor/11 §4.17 2026-04-24) — the v3 family is the long-term home per coord-10 L11-4.",
+};
+
+export const listScopeTagsMetadata: ApiV3FnMetadata = {
+  name: "runtime.workflow.listScopeTags",
+  status: "live",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/runtime/workflow-scope-tags.test.ts",
+    commit: "coord-10-l11-4",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: { readOrMutate: "read", boundedScope: "session", auditCategory: "scope-tag-catalog" },
+  stateClass: "A-canonical",
+  persistsTo: "customXml",
+  broadcastsVia: "crdt",
+  rwdReference:
+    "§Runtime API § runtime.workflow.listScopeTags. Enumerates the shipped default catalog as `[tagType, behavior]` pairs without constructing a registry. Does not reflect host-registered custom tags — callers that want those iterate `createScopeTagRegistry().list()` on their own instance.",
+};
+
+export const getScopeTagMetadata: ApiV3FnMetadata = {
+  name: "runtime.workflow.getScopeTag",
+  status: "live",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/runtime/workflow-scope-tags.test.ts",
+    commit: "coord-10-l11-4",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: { readOrMutate: "read", boundedScope: "session", auditCategory: "scope-tag-catalog" },
+  stateClass: "A-canonical",
+  persistsTo: "customXml",
+  broadcastsVia: "crdt",
+  rwdReference:
+    "§Runtime API § runtime.workflow.getScopeTag. Peeks a default tag's behavior by name. Returns DEFAULT_UNKNOWN_BEHAVIOR for unknown tag types (bail-on-cross) — matches `createScopeTagRegistry().get(unknownTagType)`.",
+};
+
 export function createWorkflowFamily(runtime: RuntimeApiHandle) {
   return {
     queryScopes(filter?: unknown) {
@@ -301,6 +390,9 @@ export function createWorkflowFamily(runtime: RuntimeApiHandle) {
         mode: input.mode,
         label: input.label,
         ...(input.assoc ? { assoc: input.assoc } : {}),
+        ...(input.stableRefHint
+          ? { stableRefHint: input.stableRefHint }
+          : {}),
       });
       emitUxResponse(runtime, {
         apiFn: createScopeMetadata.name,
@@ -430,5 +522,26 @@ export function createWorkflowFamily(runtime: RuntimeApiHandle) {
       }
       return { status: "scope-not-found" };
     },
+
+    createScopeTagRegistry(): ScopeTagRegistry {
+      // @endStateApi — live. Coord-10 L11-4. Mints a fresh default-
+      // seeded registry. Hosts register custom annotation families on
+      // the returned registry via `.register(...)`.
+      return createScopeTagRegistry();
+    },
+
+    listScopeTags(): readonly (readonly [string, ScopeTagBehavior])[] {
+      // @endStateApi — live. Coord-10 L11-4. Enumerates the shipped
+      // default catalog as `[tagType, behavior]` pairs. Does not
+      // reflect host-registered customs on any specific registry.
+      return Object.entries(DEFAULT_REGISTRY_ENTRIES);
+    },
+
+    getScopeTag(tagType: string): ScopeTagBehavior {
+      // @endStateApi — live. Coord-10 L11-4. Peeks a default tag's
+      // behavior by name. Returns `DEFAULT_UNKNOWN_BEHAVIOR` (bail-on-
+      // cross) for unknown tag types.
+      return DEFAULT_REGISTRY_ENTRIES[tagType] ?? DEFAULT_UNKNOWN_BEHAVIOR;
+    },
   };
 }

package/src/api/v3/ui/_types.ts

@@ -233,6 +233,26 @@ export type ScrollTarget =
   | { kind: "revision"; value: string; behavior?: ScrollTargetBehavior }
   | { kind: "page"; value: number; behavior?: ScrollTargetBehavior };
 
+/**
+ * Result of `ui.viewport.scrollToPage(n)` — the settled state after
+ * the scroll dispatch lands.
+ *
+ *   - `actualPage` is the 1-based page number that was actually
+ *     targeted. Differs from the requested `pageNumber` when the caller
+ *     asked for a page beyond the document's resolved bounds —
+ *     implementation clamps and reports the clamped value here.
+ *   - `scrollY` is the document-relative Y offset (in CSS px) of the
+ *     target page's top edge, sourced from
+ *     `handle.geometry.getPage(index).frame.topPx`. Useful for consumers
+ *     that want to verify their own scroll container landed at the
+ *     expected coordinate (visual-fidelity harness: deterministic
+ *     per-page capture).
+ */
+export interface ScrollToPageResult {
+  readonly actualPage: number;
+  readonly scrollY: number;
+}
+
 export interface SelectionRangeInput {
   readonly anchor: number;
   readonly head: number;
@@ -369,6 +389,21 @@ export interface ApiV3UiViewport {
   get(): ViewportState;
   subscribe(listener: UiListener<ViewportState>): UiUnsubscribe;
 
+  /**
+   * Scroll the mounted surface to a specific 1-based page number.
+   * Resolves via `handle.geometry.getPage`; dispatches through the
+   * bound controller's `dispatchScroll` hook. Returns the settled
+   * `{ actualPage, scrollY }` or `null` when geometry cannot resolve
+   * any page / no controller bound / no dispatchScroll hook.
+   * Clamps pageNumber to the document's valid range; `actualPage`
+   * reflects the clamp. coord-10 §γ first-class replacement for the
+   * visual-fidelity harness's DOM-scrape fallback.
+   */
+  scrollToPage(
+    pageNumber: number,
+    opts?: { behavior?: ScrollTargetBehavior },
+  ): Promise<ScrollToPageResult | null>;
+
   /**
    * X5 · Composed effective markup mode. Merges L06's class-A
    * `WorkflowMarkupModePolicy` (via `handle.getMarkupModePolicy()`)

package/src/api/v3/ui/index.ts

@@ -24,6 +24,7 @@ export type {
   ViewportState,
   ScrollTarget,
   ScrollTargetBehavior,
+  ScrollToPageResult,
   SelectionRangeInput,
   OverlayAnchorQuery,
   OverlayKind,

package/src/api/v3/ui/viewport.ts

@@ -27,6 +27,8 @@ import type {
   UiListener,
   UiUnsubscribe,
   WorkflowMarkupMode,
+  ScrollTargetBehavior,
+  ScrollToPageResult,
 } from "./_types.ts";
 import type { UiApiContext } from "./_context.ts";
 import { readComposedViewport } from "./_context.ts";
@@ -84,6 +86,35 @@ export const subscribeMetadata: ApiV3FnMetadata = {
   rwdReference: "§UI API § ui.viewport.subscribe. Adapter delegates to UiController.subscribeViewport; throws when the active binding has no hook. Subscribe call emits one `ux.response.ui.viewport.subscribe` acknowledgement; per-tick ViewportState deliveries flow through the listener (rAF-coalesced, U7).",
 };
 
+// ----- scrollToPage (coord-10 §γ — visual-fidelity / Go-to-page UX) -----
+
+export const scrollToPageMetadata: ApiV3FnMetadata = {
+  name: "ui.viewport.scrollToPage",
+  status: "live-with-adapter",
+  sourceLayer: "presentation",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ui/scroll-to-page.test.ts",
+    commit: "refactor-10-slice-scroll-to-page",
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "surface-refresh",
+    expectedDelta: "mounted surface scrolls to the target page's top edge",
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "session",
+    auditCategory: "ui-viewport-scroll",
+  },
+  // Scroll position is a class-C local view state (per-session /
+  // per-mounted-instance); changing it doesn't mutate canonical document
+  // state and is not broadcast across collab peers.
+  stateClass: "C-local",
+  persistsTo: "none",
+  rwdReference:
+    "§UI API § ui.viewport.scrollToPage. Resolves pageNumber → scrollY via handle.geometry.getPage(pageIndex); dispatches through controller.dispatchScroll({ kind:'page', value, behavior }); returns the settled {actualPage, scrollY}. 1-based page numbers; clamps to [1, pageCount]. First-class API for visual-fidelity harness + 'Go to page N' UX — replaces DOM-scrape fallback (coord-10 §γ). When L07 ships runtime.viewport.getPageAnchor / getPageGeometry (coord-07 §2.9), this wrapper may be simplified to delegate to those primitives; the public shape stays stable.",
+};
+
 // ----- X5 markup-mode metadata (state-classes cross-cutting Slice X5) -----
 
 /**
@@ -249,6 +280,87 @@ export function createViewportFamily(ctx: UiApiContext) {
       return unsubscribe;
     },
 
+    // ----- scrollToPage (coord-10 §γ) -----
+
+    /**
+     * Scroll the mounted surface to a specific 1-based page number.
+     *
+     * Resolution: `handle.geometry.getPage(pageNumber - 1)` supplies the
+     * page's `frame.topPx` (deterministic, renderer-frame coordinates).
+     * Dispatch: `controller.dispatchScroll({ kind: "page", value, behavior })`
+     * — same seam as `ui.surface.scrollTo`, so any consumer-specific
+     * scroll-container routing lives on the shell side.
+     *
+     * Clamping: `pageNumber < 1` resolves to page 1. A request beyond
+     * the document's page count returns the last valid page's scrollY;
+     * `actualPage` reflects the clamp so callers can detect it.
+     *
+     * Returns `null` when (a) no controller is bound, (b) the controller
+     * has no `dispatchScroll` hook, or (c) geometry cannot resolve any
+     * page (pre-paint / empty doc). Callers that need explicit failure
+     * handling check `result !== null` before trusting the scroll.
+     */
+    async scrollToPage(
+      pageNumber: number,
+      opts?: { behavior?: ScrollTargetBehavior },
+    ): Promise<ScrollToPageResult | null> {
+      const controller = ctx.binding?.controller;
+      if (!controller) {
+        throw new Error(
+          "ui.viewport.scrollToPage: no controller bound — call ui.session.bind(controller) first",
+        );
+      }
+      if (!controller.dispatchScroll) {
+        throw new Error(
+          `ui.viewport.scrollToPage: controller of kind "${controller.kind}" did not provide a dispatchScroll hook`,
+        );
+      }
+
+      // Clamp to [1, pageCount]. The geometry facet's `getPage(index)`
+      // takes a 0-based index; we accept 1-based input and convert.
+      // Walk forward from the clamped target to find the first page the
+      // facet actually resolves — this handles sparse / pre-paint
+      // states where higher indices may be null.
+      const getPage = ctx.handle.geometry?.getPage;
+      if (typeof getPage !== "function") return null;
+
+      const requestedClampedLow = Math.max(1, Math.floor(pageNumber));
+      // Try the requested page; if null, scan downward through lower
+      // indices to land on the largest resolvable page (the doc's last
+      // populated page). If nothing resolves, return null.
+      let resolved: { pageIndex: number; scrollY: number } | null = null;
+      for (let i = requestedClampedLow - 1; i >= 0; i--) {
+        const page = getPage.call(ctx.handle.geometry, i);
+        if (page) {
+          resolved = { pageIndex: i, scrollY: page.frame.topPx };
+          break;
+        }
+      }
+      if (!resolved) return null;
+
+      const actualPage = resolved.pageIndex + 1;
+      const behavior = opts?.behavior;
+      await controller.dispatchScroll({
+        kind: "page",
+        value: actualPage,
+        ...(behavior ? { behavior } : {}),
+      });
+
+      emitUxResponse(ctx.handle, {
+        apiFn: scrollToPageMetadata.name,
+        intent: scrollToPageMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live-with-adapter",
+        uiVisible: true,
+        expectedDelta: scrollToPageMetadata.uxIntent.expectedDelta,
+        actualDelta: {
+          kind: "surface-refresh",
+          payload: { page: actualPage, scrollY: resolved.scrollY },
+        },
+      });
+
+      return { actualPage, scrollY: resolved.scrollY };
+    },
+
     // ----- X5 markup-mode (state-classes cross-cutting Slice X5) -----
 
     getEffectiveMarkupMode(): WorkflowMarkupMode {

package/src/compare/diff-engine.ts

@@ -509,6 +509,7 @@ function getInlineLength(node: InlineNode): number {
     case "tab":
     case "hard_break":
     case "column_break":
+    case "page_break":
     case "symbol":
     case "image":
     case "opaque_inline":
@@ -555,6 +556,7 @@ function getInlineDisplayText(node: InlineNode): string {
       return "\t";
     case "hard_break":
     case "column_break":
+    case "page_break":
       return "\n";
     case "symbol":
       return node.char;

package/src/core/commands/formatting-commands.ts

@@ -1030,6 +1030,7 @@ function inlineNodeLength(node: InlineNode): number {
       );
     case "hard_break":
     case "column_break":
+    case "page_break":
     case "tab":
     case "symbol":
     case "image":

package/src/core/commands/table-structure-commands.ts

@@ -329,6 +329,7 @@ export function getTableStructureContext(
     columnCount,
     selectedCellCount,
     isSimpleTable: simpleTable,
+    alignment: target.alignment ?? null,
     currentCell: {
       rowIndex: effectiveSelection.anchorCell.rowIndex,
       columnIndex: effectiveSelection.anchorCell.columnIndex,

package/src/io/export/serialize-headers-footers.ts

@@ -284,6 +284,7 @@ function serializeInlineNode(node: InlineNode): string {
       throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
     case "image":
     case "column_break":
+    case "page_break":
     case "symbol":
     default:
       throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);

package/src/io/export/serialize-main-document.ts

@@ -581,6 +581,8 @@ function serializeTableInlineNode(
       return "<w:r><w:tab/></w:r>";
     case "column_break":
       return "<w:r><w:br w:type=\"column\"/></w:r>";
+    case "page_break":
+      return "<w:r><w:br w:type=\"page\"/></w:r>";
     case "hard_break":
       return "<w:r><w:br/></w:r>";
     case "symbol": {
@@ -1010,6 +1012,17 @@ function serializeInlineNode(
         boundaries,
       };
     }
+    case "page_break": {
+      const xml = `<w:r><w:br w:type="page"/></w:r>`;
+      const boundaries = new Map<number, number>();
+      boundaries.set(cursor, xmlOffset);
+      boundaries.set(cursor + 1, xmlOffset + xml.length);
+      return {
+        xml,
+        cursor: cursor + 1,
+        boundaries,
+      };
+    }
     case "hard_break": {
       const xml = serializeRun({ kind: "hard_break" });
       const boundaries = new Map<number, number>();

package/src/io/export/serialize-paragraph-formatting.ts

@@ -6,6 +6,7 @@
 
 import type {
   CanonicalParagraphFormatting,
+  FrameProperties,
   ParagraphBorders,
   ParagraphIndentation,
   ParagraphShading,
@@ -92,6 +93,34 @@ function buildSpacingXml(s: ParagraphSpacing | undefined): string {
   return attrs.length > 0 ? `<w:spacing ${attrs.join(" ")}/>` : "";
 }
 
+function buildFrameXml(f: FrameProperties | undefined): string {
+  if (!f) return "";
+  // Prefer parsed rawXml when available — preserves extension attributes
+  // (`w14:*`, `w15:*`, `mc:Ignorable`) that the typed field set doesn't
+  // cover. When rawXml isn't present (parser couldn't capture the source
+  // string), emit from typed fields only; extension attrs are lost in
+  // that round-trip path, but every CCEP-class framed paragraph we've
+  // seen uses only modelled attributes.
+  if (f.rawXml) return f.rawXml;
+  const attrs: string[] = [];
+  if (f.widthTwips !== undefined) attrs.push(`w:w="${f.widthTwips}"`);
+  if (f.heightTwips !== undefined) attrs.push(`w:h="${f.heightTwips}"`);
+  if (f.hRule) attrs.push(`w:hRule="${escXml(f.hRule)}"`);
+  if (f.xTwips !== undefined) attrs.push(`w:x="${f.xTwips}"`);
+  if (f.yTwips !== undefined) attrs.push(`w:y="${f.yTwips}"`);
+  if (f.xAlign) attrs.push(`w:xAlign="${escXml(f.xAlign)}"`);
+  if (f.yAlign) attrs.push(`w:yAlign="${escXml(f.yAlign)}"`);
+  if (f.hAnchor) attrs.push(`w:hAnchor="${escXml(f.hAnchor)}"`);
+  if (f.vAnchor) attrs.push(`w:vAnchor="${escXml(f.vAnchor)}"`);
+  if (f.wrap) attrs.push(`w:wrap="${escXml(f.wrap)}"`);
+  if (f.hSpaceTwips !== undefined) attrs.push(`w:hSpace="${f.hSpaceTwips}"`);
+  if (f.vSpaceTwips !== undefined) attrs.push(`w:vSpace="${f.vSpaceTwips}"`);
+  if (f.dropCap) attrs.push(`w:dropCap="${escXml(f.dropCap)}"`);
+  if (f.lines !== undefined) attrs.push(`w:lines="${f.lines}"`);
+  if (f.anchorLock !== undefined) attrs.push(`w:anchorLock="${f.anchorLock ? "1" : "0"}"`);
+  return attrs.length > 0 ? `<w:framePr ${attrs.join(" ")}/>` : "";
+}
+
 function buildIndentXml(i: ParagraphIndentation | undefined): string {
   if (!i) return "";
   const attrs: string[] = [];
@@ -114,6 +143,11 @@ export function buildParagraphPropertiesXml(
   parts.push(toggleEl("keepLines", pPr.keepLines));
   parts.push(toggleEl("pageBreakBefore", pPr.pageBreakBefore));
 
+  // 2. framePr (ECMA-376 §17.3.1 canonical order slot, between pageBreakBefore
+  // and pBdr). Emit before pBdr so the OpenXML SDK validator accepts a framed
+  // paragraph that also carries borders (coord-04 §1.18.d).
+  parts.push(buildFrameXml(pPr.frameProperties));
+
   // 4. pBdr
   parts.push(buildBordersXml(pPr.borders));
 

package/src/io/export/split-review-boundaries.ts

@@ -340,6 +340,7 @@ function measureInlineNodeForReviewBoundaries(node: InlineNode): number {
     case "tab":
     case "hard_break":
     case "column_break":
+    case "page_break":
     case "footnote_ref":
     case "image":
     case "opaque_inline":

package/src/io/normalize/normalize-text.ts

@@ -481,6 +481,17 @@ function normalizeInlineChildren(
         normalized.push({ type: "column_break" });
         state.cursor += 1;
         break;
+      case "page_break":
+        // coord-04 §1.18.5 follow-up: the fde93da3 cross-layer page_break
+        // ship added parse + surface-projection + pagination but missed
+        // this normalize-text switch. Without this case, every
+        // `<w:br w:type="page"/>` run parsed by L01 falls through and gets
+        // silently dropped during canonical assembly — so L04's
+        // `hasPageBreak` never fires on real documents. Mirrors the
+        // `column_break` branch.
+        normalized.push({ type: "page_break" });
+        state.cursor += 1;
+        break;
       case "chart_preview":
         registerComplexPreviewMedia(state, node);
         normalized.push({

package/src/io/ooxml/parse-main-document.ts

@@ -271,6 +271,7 @@ export type ParsedInlineNode =
   | ParsedTextNode
   | ParsedBreakNode
   | ParsedColumnBreakNode
+  | ParsedPageBreakNode
   | ParsedTabNode
   | ParsedSymbolNode
   | ParsedImageNode
@@ -306,6 +307,10 @@ export interface ParsedColumnBreakNode {
   type: "column_break";
 }
 
+export interface ParsedPageBreakNode {
+  type: "page_break";
+}
+
 export interface ParsedTabNode {
   type: "tab";
 }
@@ -350,7 +355,7 @@ export interface ParsedImageNode {
 export interface ParsedHyperlinkNode {
   type: "hyperlink";
   href: string;
-  children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode>;
+  children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode>;
   rawXml: string;
 }
 
@@ -606,7 +611,7 @@ interface XmlTextNode {
 type XmlNode = XmlElementNode | XmlTextNode;
 
 interface RunParseResult {
-  nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode>;
+  nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode>;
   supported: boolean;
 }
 
@@ -2390,7 +2395,9 @@ function parseRun(
         break;
       }
       case "br":
-        if (isColumnBreak(child)) {
+        if (isPageBreak(child)) {
+          result.push({ type: "page_break" });
+        } else if (isColumnBreak(child)) {
           result.push({ type: "column_break" });
         } else if (isSimpleLineBreak(child)) {
           result.push({ type: "hard_break" });
@@ -2714,7 +2721,7 @@ function parseHyperlink(
     };
   }
 
-  const children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
+  const children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
 
   for (const child of node.children) {
     if (child.type !== "element") {
@@ -2764,7 +2771,7 @@ function parseRunContentOnly(
   }
 
   const marks = marksResult.marks;
-  const nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
+  const nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedPageBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
 
   for (const child of node.children) {
     if (child.type !== "element") {
@@ -2812,6 +2819,10 @@ function parseRunContentOnly(
         break;
       }
       case "br":
+        if (isPageBreak(child)) {
+          nodes.push({ type: "page_break" });
+          break;
+        }
         if (isColumnBreak(child)) {
           nodes.push({ type: "column_break" });
           break;
@@ -3149,6 +3160,11 @@ function isColumnBreak(node: XmlElementNode): boolean {
   return value === "column";
 }
 
+function isPageBreak(node: XmlElementNode): boolean {
+  const value = (node.attributes["w:type"] ?? node.attributes.type ?? "").toLowerCase();
+  return value === "page";
+}
+
 function findChildElement(node: XmlElementNode, childLocalName: string): XmlElementNode {
   const child = node.children.find(
     (entry): entry is XmlElementNode =>