@beyondwork/docx-react-component 1.0.85 → 1.0.87

package/src/runtime/document-runtime.ts

@@ -291,6 +291,7 @@ import type {
   ParagraphNode,
   SectionProperties,
   SubPartsCatalog,
+  TocRegion,
 } from "../model/canonical-document.ts";
 import {
   isSupportedFieldFamily,
@@ -3565,6 +3566,7 @@ export function createDocumentRuntime(
         emitError(runtimeError);
         return {
           kind: "rejected",
+          refreshClass: "blocked",
           opId: (command.origin as { opId?: string } | undefined)?.opId,
           newRevisionToken: "",
           blockedReasons: [
@@ -5319,6 +5321,7 @@ export function createDocumentRuntime(
       });
       return completeDispatch({
         kind: "rejected",
+        refreshClass: "blocked",
         opId,
         newRevisionToken: "",
         blockedReasons: [{ code: "suggesting_unsupported", message }],
@@ -5335,6 +5338,7 @@ export function createDocumentRuntime(
         });
         return completeDispatch({
           kind: "rejected",
+          refreshClass: "blocked",
           opId,
           newRevisionToken: "",
           blockedReasons: blockedReasons.map((r) => ({ code: r.code, message: r.message })),
@@ -5408,6 +5412,7 @@ export function createDocumentRuntime(
       });
       return completeDispatch({
         kind: "equivalent",
+        refreshClass: "local-text-equivalent",
         opId,
         newRevisionToken: state.revisionToken,
       });
@@ -5475,6 +5480,7 @@ export function createDocumentRuntime(
     if (meta.invalidatesStructures) {
       return {
         kind: "structural-divergence",
+        refreshClass: "full-projection",
         opId,
         newRevisionToken,
         scopeTagTouches: touches,
@@ -5499,6 +5505,7 @@ export function createDocumentRuntime(
       const adjustedRange = computeAdjustedRange(priorState, transaction);
       return {
         kind: "adjusted",
+        refreshClass: "surface-only",
         opId,
         newRevisionToken,
         adjustedRange,
@@ -5508,6 +5515,7 @@ export function createDocumentRuntime(
 
     return {
       kind: "equivalent",
+      refreshClass: "local-text-equivalent",
       opId,
       newRevisionToken,
       scopeTagTouches: touches,
@@ -5685,6 +5693,10 @@ export function createDocumentRuntime(
       emit({
         type: "toc_auto_refreshed",
         documentId: state.documentId,
+        ...(refreshed.result.tocId ? { tocId: refreshed.result.tocId } : {}),
+        ...(refreshed.document.fieldRegistry?.tocRegions
+          ? { regionCount: refreshed.document.fieldRegistry.tocRegions.length }
+          : {}),
         entryCount: refreshed.result.entryCount,
         trigger: flushedTrigger,
       });
@@ -7161,6 +7173,29 @@ function refreshDocumentTableOfContents(
   changed: boolean;
   protectionSelection?: import("../core/state/editor-state.ts").SelectionSnapshot;
 } {
+  const selectedRegion = selectTocRegion(document.fieldRegistry?.tocRegions, options?.tocId);
+  const refreshMode = options?.mode ?? "regenerate";
+  if (refreshMode === "preserveCached") {
+    const cachedEntries = selectedRegion?.cachedEntries ?? [];
+    return {
+      document,
+      result: {
+        ...(selectedRegion ? { tocId: selectedRegion.tocId } : {}),
+        mode: "preserveCached",
+        status: selectedRegion?.status ?? (cachedEntries.length > 0 ? "stale" : "missing"),
+        entryCount: cachedEntries.length,
+        entries: cachedEntries.map((entry) => ({
+          level: entry.level,
+          text: entry.text,
+          pageIndex: tocPageTextToPageIndex(entry.pageText),
+          ...(entry.pageText ? { pageText: entry.pageText } : {}),
+          source: "cached",
+        })),
+      },
+      changed: false,
+    };
+  }
+
   const navigation = createDocumentNavigationSnapshot(document, selectionHead, activeStory);
   // Build a single O(N) map from paragraph offset → bookmark name so the
   // per-heading lookup below is O(1) instead of O(N) per heading.
@@ -7189,16 +7224,16 @@ function refreshDocumentTableOfContents(
     }
   }
   let changed = false;
-  let resultEntries: Array<{ level: number; text: string; pageIndex: number; bookmarkName?: string }> = [];
+  let resultEntries: RuntimeTocEntry[] = [];
   let changedFrom: number | undefined;
   let changedTo: number | undefined;
-  const nextChildren = refreshBlocksWithCursor(document.content.children, (field, range) => {
-    if (field.fieldFamily !== "TOC") {
-      return field;
-    }
+
+  const buildEntriesForField = (field: FieldNode): RuntimeTocEntry[] => {
     const levelRange = options?.maxLevel
       ? { from: 1, to: options.maxLevel }
-      : parseTocLevelRange(field.instruction);
+      : selectedRegion && normalizeTocInstruction(selectedRegion.instruction.raw) === normalizeTocInstruction(field.instruction)
+        ? selectedRegion.instruction.outlineRange
+        : parseTocLevelRange(field.instruction);
     const entries = navigation.headings
       .filter((heading) => heading.level >= levelRange.from && heading.level <= levelRange.to)
       .map((heading) => {
@@ -7213,6 +7248,30 @@ function refreshDocumentTableOfContents(
     if (resultEntries.length === 0) {
       resultEntries = entries;
     }
+    return entries;
+  };
+
+  const tocRangeRefresh = refreshTocBlockRanges(
+    document.content.children,
+    buildEntriesForField,
+    resolveDisplayPageNumber,
+    selectedRegion,
+  );
+  if (tocRangeRefresh.changed) {
+    changed = true;
+  }
+
+  const nextChildren = refreshBlocksWithCursor(tocRangeRefresh.blocks, (field, range) => {
+    if (field.fieldFamily !== "TOC") {
+      return field;
+    }
+    if (selectedRegion && normalizeTocInstruction(field.instruction) !== normalizeTocInstruction(selectedRegion.instruction.raw)) {
+      return field;
+    }
+    if (field.refreshStatus === "current" && field.children.length === 0) {
+      return field;
+    }
+    const entries = buildEntriesForField(field);
     const nextField: FieldNode = {
       ...field,
       children: buildTocInlineNodes(entries, resolveDisplayPageNumber),
@@ -7228,7 +7287,7 @@ function refreshDocumentTableOfContents(
   if (!changed) {
     return {
       document,
-      result: { entryCount: resultEntries.length, entries: resultEntries },
+      result: buildTocRefreshResult(selectedRegion, "regenerate", resultEntries, "current"),
       changed: false,
     };
   }
@@ -7245,13 +7304,24 @@ function refreshDocumentTableOfContents(
     styles: nextDocument.styles,
     subParts: nextDocument.subParts,
   });
-  nextDocument.fieldRegistry = nextRegistry.tocStructure
+  const nextTocRegions = nextRegistry.tocRegions?.map((region) => {
+    if (!selectedRegion || normalizeTocInstruction(region.instruction.raw) === normalizeTocInstruction(selectedRegion.instruction.raw)) {
+      return { ...region, status: "current" as const };
+    }
+    return region;
+  });
+  nextDocument.fieldRegistry = nextRegistry.tocStructure || nextTocRegions
     ? {
         ...nextRegistry,
-        tocStructure: {
-          ...nextRegistry.tocStructure,
-          status: "current",
-        },
+        ...(nextTocRegions ? { tocRegions: nextTocRegions } : {}),
+        ...(nextRegistry.tocStructure
+          ? {
+              tocStructure: {
+                ...nextRegistry.tocStructure,
+                status: "current",
+              },
+            }
+          : {}),
       }
     : nextRegistry;
   let protectionSelection:
@@ -7263,12 +7333,267 @@ function refreshDocumentTableOfContents(
 
   return {
     document: nextDocument,
-    result: { entryCount: resultEntries.length, entries: resultEntries },
+    result: buildTocRefreshResult(selectedRegion, "regenerate", resultEntries, "current"),
     changed: true,
     ...(protectionSelection ? { protectionSelection } : {}),
   };
 }
 
+type RuntimeTocEntry = {
+  level: number;
+  text: string;
+  pageIndex: number;
+  bookmarkName?: string;
+};
+
+function selectTocRegion(
+  regions: readonly TocRegion[] | undefined,
+  tocId: string | undefined,
+): TocRegion | undefined {
+  if (!regions || regions.length === 0) {
+    return undefined;
+  }
+  if (!tocId) {
+    return regions[0];
+  }
+  return regions.find((region) => region.tocId === tocId);
+}
+
+function buildTocRefreshResult(
+  region: TocRegion | undefined,
+  mode: "preserveCached" | "regenerate",
+  entries: readonly RuntimeTocEntry[],
+  status: "current" | "stale" | "missing",
+): TocRefreshResult {
+  return {
+    ...(region ? { tocId: region.tocId } : {}),
+    mode,
+    status,
+    entryCount: entries.length,
+    entries: entries.map((entry) => ({
+      level: entry.level,
+      text: entry.text,
+      pageIndex: entry.pageIndex,
+      source: "generated",
+    })),
+  };
+}
+
+function tocPageTextToPageIndex(pageText: string | undefined): number {
+  const value = Number.parseInt(pageText ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value - 1 : 0;
+}
+
+function normalizeTocInstruction(instruction: string): string {
+  return instruction.replace(/\s+/gu, " ").trim();
+}
+
+function refreshTocBlockRanges(
+  blocks: readonly BlockNode[],
+  buildEntriesForField: (field: FieldNode) => RuntimeTocEntry[],
+  resolveDisplayPageNumber?: (pageIndex: number) => number | null,
+  selectedRegion?: TocRegion,
+): { blocks: BlockNode[]; changed: boolean } {
+  const nextBlocks: BlockNode[] = [];
+  let changed = false;
+
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index];
+
+    if (block.type === "paragraph") {
+      const tocField = findTocFieldNode(block);
+      if (
+        tocField &&
+        (!selectedRegion || normalizeTocInstruction(tocField.instruction) === normalizeTocInstruction(selectedRegion.instruction.raw)) &&
+        startsTocParagraphRegion(blocks, index)
+      ) {
+        const endIndex = findTocParagraphRegionEnd(blocks, index);
+        const region = blocks.slice(index, endIndex + 1).filter(
+          (candidate): candidate is ParagraphNode => candidate.type === "paragraph",
+        );
+        const replacement = buildTocRegionParagraphs(
+          region,
+          tocField,
+          buildEntriesForField(tocField),
+          resolveDisplayPageNumber,
+        );
+        if (tocRegionSignature(region) !== tocRegionSignature(replacement)) {
+          changed = true;
+        }
+        nextBlocks.push(...replacement);
+        index = endIndex;
+        continue;
+      }
+      nextBlocks.push(block);
+      continue;
+    }
+
+    if (block.type === "sdt" || block.type === "custom_xml") {
+      const refreshed = refreshTocBlockRanges(
+        block.children,
+        buildEntriesForField,
+        resolveDisplayPageNumber,
+        selectedRegion,
+      );
+      if (refreshed.changed) {
+        changed = true;
+        nextBlocks.push({ ...block, children: refreshed.blocks });
+      } else {
+        nextBlocks.push(block);
+      }
+      continue;
+    }
+
+    if (block.type === "table") {
+      let tableChanged = false;
+      const rows = block.rows.map((row) => {
+        let rowChanged = false;
+        const cells = row.cells.map((cell) => {
+          const refreshed = refreshTocBlockRanges(
+            cell.children,
+            buildEntriesForField,
+            resolveDisplayPageNumber,
+            selectedRegion,
+          );
+          if (!refreshed.changed) {
+            return cell;
+          }
+          tableChanged = true;
+          rowChanged = true;
+          return { ...cell, children: refreshed.blocks };
+        });
+        return rowChanged ? { ...row, cells } : row;
+      });
+      nextBlocks.push(tableChanged ? { ...block, rows } : block);
+      changed = changed || tableChanged;
+      continue;
+    }
+
+    nextBlocks.push(block);
+  }
+
+  return { blocks: nextBlocks, changed };
+}
+
+function startsTocParagraphRegion(blocks: readonly BlockNode[], index: number): boolean {
+  const current = blocks[index];
+  if (current?.type === "paragraph" && isTocParagraphStyle(current.styleId)) {
+    return true;
+  }
+  const next = blocks[index + 1];
+  return next?.type === "paragraph" && isTocParagraphStyle(next.styleId);
+}
+
+function findTocParagraphRegionEnd(blocks: readonly BlockNode[], startIndex: number): number {
+  let endIndex = startIndex;
+  while (endIndex + 1 < blocks.length) {
+    const next = blocks[endIndex + 1];
+    if (next?.type !== "paragraph" || !isTocParagraphStyle(next.styleId)) {
+      break;
+    }
+    endIndex += 1;
+  }
+  return endIndex;
+}
+
+function isTocParagraphStyle(styleId: string | undefined): boolean {
+  return /^TOC\d+$/u.test(styleId ?? "");
+}
+
+function findTocFieldNode(paragraph: ParagraphNode): FieldNode | undefined {
+  return paragraph.children.find(
+    (child): child is FieldNode => child.type === "field" && child.fieldFamily === "TOC",
+  );
+}
+
+function buildTocRegionParagraphs(
+  existingRegion: readonly ParagraphNode[],
+  tocField: FieldNode,
+  entries: readonly RuntimeTocEntry[],
+  resolveDisplayPageNumber?: (pageIndex: number) => number | null,
+): ParagraphNode[] {
+  const firstTemplate = existingRegion[0];
+  if (!firstTemplate) {
+    return [];
+  }
+  const templateByStyle = new Map<string, ParagraphNode>();
+  for (const paragraph of existingRegion) {
+    if (paragraph.styleId && !templateByStyle.has(paragraph.styleId)) {
+      templateByStyle.set(paragraph.styleId, paragraph);
+    }
+  }
+  const refreshedField: FieldNode = {
+    ...tocField,
+    children: [],
+    refreshStatus: "current",
+  };
+
+  if (entries.length === 0) {
+    return [{ ...firstTemplate, children: [refreshedField] }];
+  }
+
+  return entries.map((entry, index) => {
+    const styleId = `TOC${Math.max(1, Math.min(9, entry.level))}`;
+    const template = templateByStyle.get(styleId) ?? firstTemplate;
+    const children = buildTocEntryInlineNodes(entry, resolveDisplayPageNumber);
+    return {
+      ...template,
+      styleId,
+      children: index === 0 ? [refreshedField, ...children] : children,
+    };
+  });
+}
+
+function buildTocEntryInlineNodes(
+  entry: RuntimeTocEntry,
+  resolveDisplayPageNumber?: (pageIndex: number) => number | null,
+): InlineNode[] {
+  const children: InlineNode[] = [];
+  if (entry.bookmarkName) {
+    children.push({
+      type: "hyperlink",
+      href: `#${entry.bookmarkName}`,
+      children: [{ type: "text", text: entry.text }],
+    });
+  } else {
+    children.push({ type: "text", text: entry.text });
+  }
+  children.push({ type: "tab" });
+  const displayed = resolveDisplayPageNumber?.(entry.pageIndex);
+  children.push({
+    type: "text",
+    text: String(displayed ?? entry.pageIndex + 1),
+  });
+  return children;
+}
+
+function tocRegionSignature(paragraphs: readonly ParagraphNode[]): string {
+  return paragraphs
+    .map((paragraph) => `${paragraph.styleId ?? ""}\u0001${tocInlineSignature(paragraph.children)}`)
+    .join("\u0002");
+}
+
+function tocInlineSignature(children: readonly InlineNode[]): string {
+  return children
+    .map((child) => {
+      switch (child.type) {
+        case "text":
+          return `t:${child.text}`;
+        case "tab":
+          return "tab";
+        case "hard_break":
+          return "br";
+        case "hyperlink":
+          return `link:${child.href}:${tocInlineSignature(child.children)}`;
+        case "field":
+          return `field:${child.fieldFamily ?? ""}:${child.refreshStatus ?? ""}:${child.instruction}:${tocInlineSignature(child.children)}`;
+        default:
+          return child.type;
+      }
+    })
+    .join("\u0001");
+}
+
 function refreshBlocksWithCursor(
   blocks: readonly BlockNode[],
   visitField: (field: FieldNode, range: { from: number; to: number }) => FieldNode,

package/src/runtime/formatting/field/page-number-format.ts

@@ -205,3 +205,52 @@ export function formatPageNumber(n: number, format: string | undefined): string
       return String(n);
   }
 }
+
+export interface ChapterPageNumberFormatOptions {
+  format?: string;
+  chapterNumber?: string;
+  chapterSeparator?: string;
+}
+
+/**
+ * Format a PAGE/PAGEREF value using section page-numbering settings.
+ *
+ * `chapStyle` names the heading level/style whose numbering contributes the
+ * chapter marker; pagination resolves that marker per page and stores it as
+ * `chapterNumber`. When no marker is available, the display degrades to the
+ * normal page number instead of inventing a chapter prefix.
+ */
+export function formatPageNumberWithChapter(
+  n: number,
+  options: ChapterPageNumberFormatOptions | undefined,
+): string {
+  const pageNumber = formatPageNumber(n, options?.format);
+  const chapterNumber = normalizeChapterNumber(options?.chapterNumber);
+  if (!chapterNumber) {
+    return pageNumber;
+  }
+  return `${chapterNumber}${chapterSeparatorToText(options?.chapterSeparator)}${pageNumber}`;
+}
+
+function normalizeChapterNumber(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+
+function chapterSeparatorToText(value: string | undefined): string {
+  switch (value) {
+    case "period":
+      return ".";
+    case "colon":
+      return ":";
+    case "emDash":
+      return "—";
+    case "enDash":
+      return "–";
+    case "hyphen":
+    case undefined:
+      return "-";
+    default:
+      return "-";
+  }
+}

package/src/runtime/formatting/field/resolver.ts

@@ -15,7 +15,6 @@ import type {
 } from "../../../model/canonical-document.ts";
 import { resolvePageFieldDisplayText } from "../../layout/resolve-page-fields.ts";
 import type { RuntimePageGraph, RuntimePageNode } from "../../layout/page-graph.ts";
-import { formatPageNumber } from "./page-number-format.ts";
 
 /**
  * Layer-03 alias for the layout module's `RuntimePageGraph`. Exists so
@@ -214,18 +213,27 @@ export function createFieldResolver(input: FieldResolverInput): FieldResolver {
         // preserve the existing display text unchanged.
         return undefined;
 
-      case "NOTEREF":
-        // NOTEREF is classified as SupportedFieldFamily (see
-        // `src/model/canonical-document.ts::SupportedFieldFamily`) but
-        // is NOT implemented in the resolver yet. Returning
-        // `refreshStatus: "unresolvable"` is the honest answer — the
-        // caller knows the family is recognized but the runtime has
-        // no resolution path. This distinguishes them from TOC
-        // (intentional `undefined` = preserve existing display) and
-        // from PreserveOnlyFieldFamily (parse-only, no refresh slot).
-        // Tracked in L03 audit 2026-04-22 as Task-4 follow-up: implement
-        // NOTEREF via footnote/endnote anchor lookup.
-        return { displayText: "", refreshStatus: "unresolvable" };
+      case "NOTEREF": {
+        if (!entry.fieldTarget) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const bookmark = bookmarkMap.get(entry.fieldTarget);
+        if (!bookmark) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const paragraph = findParagraphByIndex(contentRoot, bookmark.paragraphIndex);
+        if (!paragraph) {
+          return { displayText: "", refreshStatus: "unresolvable" };
+        }
+        const noteText = resolveNoteReferenceText(paragraph, bookmark.bookmarkId);
+        return noteText !== undefined
+          ? {
+              displayText: noteText,
+              refreshStatus: "current",
+              ...(entry.switches?.hyperlink ? { asHyperlink: true as const } : {}),
+            }
+          : { displayText: "", refreshStatus: "unresolvable" };
+      }
 
       default:
         return undefined;
@@ -284,33 +292,7 @@ function resolvePageGraphFieldText(
   page: RuntimePageNode,
   graph: RuntimePageGraph,
 ): string {
-  switch (family) {
-    case "PAGE":
-      return formatPageNumber(
-        page.stories.displayPageNumber,
-        page.layout?.pageNumbering?.format,
-      );
-    case "NUMPAGES":
-      return String(graph.contentPageCount);
-    case "SECTIONPAGES":
-      return formatPageNumber(
-        countContentPagesInSection(graph, page.sectionIndex),
-        page.layout?.pageNumbering?.format,
-      );
-  }
-}
-
-function countContentPagesInSection(
-  graph: RuntimePageGraph,
-  sectionIndex: number,
-): number {
-  let count = 0;
-  for (const page of graph.pages) {
-    if (page.sectionIndex === sectionIndex && !page.isBlankFiller) {
-      count += 1;
-    }
-  }
-  return count;
+  return resolvePageFieldDisplayText(family, "", { page, graph });
 }
 
 /**
@@ -411,6 +393,45 @@ function resolveRefText(
   return result;
 }
 
+function findParagraphByIndex(
+  root: DocumentContainerNode,
+  paragraphIndex: number,
+): ParagraphNode | undefined {
+  let index = -1;
+  let result: ParagraphNode | undefined;
+  walkParagraphs(root, (para) => {
+    if (result !== undefined) return;
+    index += 1;
+    if (index === paragraphIndex) {
+      result = para;
+    }
+  });
+  return result;
+}
+
+function resolveNoteReferenceText(
+  paragraph: ParagraphNode,
+  bookmarkId: string,
+): string | undefined {
+  let inside = false;
+  for (const child of paragraph.children) {
+    if (child.type === "bookmark_start" && child.bookmarkId === bookmarkId) {
+      inside = true;
+      continue;
+    }
+    if (child.type === "bookmark_end" && child.bookmarkId === bookmarkId) {
+      break;
+    }
+    if (!inside) {
+      continue;
+    }
+    if (child.type === "footnote_ref") {
+      return child.noteId;
+    }
+  }
+  return undefined;
+}
+
 /**
  * Resolve a STYLEREF field by finding the first paragraph whose `styleId`
  * matches `styleId` and returning its flattened text (trimmed).

package/src/runtime/layout/layout-engine-instance.ts

@@ -56,7 +56,10 @@ import {
   type RuntimePageGraph,
   type RuntimePageNode,
 } from "./page-graph.ts";
-import { projectSurfaceBlocksToPageFragments } from "./project-block-fragments.ts";
+import {
+  projectLineBoxesForPageFragments,
+  projectSurfaceBlocksToPageFragments,
+} from "./project-block-fragments.ts";
 import {
   resolvePageStories,
   resolveTotalPageCount,
@@ -466,6 +469,12 @@ export function createLayoutEngine(
       pages,
       pageStack.splits,
       pageStack.columnByBlockIdByPageIndex,
+      pageStack.fragmentMeasurementsByPageIndex,
+    );
+    const lineBoxesByPageIndex = projectLineBoxesForPageFragments(
+      pages,
+      bodyFragmentsByPageIndex,
+      pageStack.fragmentMeasurementsByPageIndex,
     );
     // P8.1b — merge per-note fragments (regionKind: "footnote-area") into the
     // main fragments map so buildPageGraph sees them alongside body fragments.
@@ -479,6 +488,7 @@ export function createLayoutEngine(
       sections,
       stories,
       fragmentsByPageIndex,
+      lineBoxesByPageIndex,
       noteAllocationsByPageIndex: pageStack.noteAllocationsByPageIndex,
     });
 
@@ -638,6 +648,12 @@ export function createLayoutEngine(
       freshSnapshotsToRebuild,
       freshResult.splits,
       freshResult.columnByBlockIdByPageIndex,
+      freshResult.fragmentMeasurementsByPageIndex,
+    );
+    const freshLineBoxesByPageIndex = projectLineBoxesForPageFragments(
+      freshSnapshotsToRebuild,
+      freshBodyFragmentsByPageIndex,
+      freshResult.fragmentMeasurementsByPageIndex,
     );
     // P8.1b — merge per-note fragments into the fresh fragments map.
     const freshFragmentsByPageIndex = new Map(freshBodyFragmentsByPageIndex);
@@ -651,6 +667,7 @@ export function createLayoutEngine(
       sections,
       stories: freshStories,
       fragmentsByPageIndex: freshFragmentsByPageIndex,
+      lineBoxesByPageIndex: freshLineBoxesByPageIndex,
       noteAllocationsByPageIndex: freshResult.noteAllocationsByPageIndex,
     });
     const freshNodes = freshGraph.pages;