@beyondwork/docx-react-component 1.0.103 → 1.0.105

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

@@ -127,6 +127,21 @@ export interface UiController {
   readonly subscribeOverlays?: (
     listener: UiListener<OverlayAnchorQuery>,
   ) => UiUnsubscribe;
+  /**
+   * PE2 overlay-lane snapshot resolver. This is the mounted-surface lane
+   * contract for selection/caret/redline/scope/comment/table/object/search
+   * and presence overlays. The bind-side supplies already-projected lane
+   * entries; L10 owns the observable shape, not layout or geometry caches.
+   */
+  readonly getOverlayLane?: (kind: UiOverlayLaneKind) => UiOverlayLaneSnapshot;
+  /**
+   * PE2 overlay-lane subscription. Must fan out lane changes without
+   * dispatching PM document transactions or invalidating L04 layout.
+   */
+  readonly subscribeOverlayLane?: (
+    kind: UiOverlayLaneKind,
+    listener: UiListener<UiOverlayLaneSnapshot>,
+  ) => UiUnsubscribe;
   /**
    * Overlay anchor resolver. Expected to be a direct projection of the
    * geometry facet (U4 — overlays derive from geometry, not DOM). Returns
@@ -267,6 +282,60 @@ export type OverlayAnchorQuery =
   | { kind: "page"; value: number }
   | { kind: "selection" };
 
+/* ================================================================== */
+/*  PE2 overlay lanes                                                  */
+/* ================================================================== */
+
+export type UiOverlayLaneKind =
+  | "selection"
+  | "caret"
+  | "redlines"
+  | "field-scopes"
+  | "broad-scopes"
+  | "comments"
+  | "issues"
+  | "tables"
+  | "objects"
+  | "search"
+  | "presence";
+
+export type UiOverlayLaneStatus =
+  | "resolved"
+  | "requires-rehydration"
+  | "unavailable";
+
+export type UiOverlayLaneSource =
+  | "geometry"
+  | "workflow"
+  | "search"
+  | "awareness"
+  | "controller"
+  | "unavailable";
+
+export interface UiOverlayLaneEntry {
+  readonly id: string;
+  readonly status: UiOverlayLaneStatus;
+  readonly anchor?: OverlayAnchorQuery;
+  readonly rects?: readonly GeometryRect[];
+  readonly reason?: string;
+  /**
+   * Lane-specific plain payload. Examples: peer identity for presence,
+   * issue severity, search rank, table/object classification. Kept plain
+   * so non-React consumers and debug runners can serialize snapshots.
+   */
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+
+export interface UiOverlayLaneSnapshot {
+  readonly __mock?: true;
+  readonly kind: UiOverlayLaneKind;
+  readonly status: UiOverlayLaneStatus;
+  readonly entries: readonly UiOverlayLaneEntry[];
+  readonly revision: number;
+  readonly source: UiOverlayLaneSource;
+  readonly reason?: string;
+}
+
 /* ================================================================== */
 /*  Overlay visibility — U9 (state-classes X3)                        */
 /* ================================================================== */
@@ -453,6 +522,23 @@ export interface ApiV3UiOverlays {
     query: OverlayAnchorQuery,
     listener: UiListener<GeometryRect | null>,
   ): UiUnsubscribe;
+  /**
+   * PE2 overlay-lane read. Returns a plain snapshot for a mounted lane
+   * such as selection, caret, redlines, comments, tables, objects,
+   * search, or presence. When the host has not wired a lane yet, returns
+   * an explicit `unavailable` snapshot instead of measuring DOM or
+   * forcing geometry rehydration.
+   */
+  getLane(kind: UiOverlayLaneKind): UiOverlayLaneSnapshot;
+  /**
+   * PE2 overlay-lane subscription. The listener receives lane snapshots,
+   * never PM transactions. Presence/awareness updates must travel through
+   * this channel without invalidating L04 layout.
+   */
+  subscribeLane(
+    kind: UiOverlayLaneKind,
+    listener: UiListener<UiOverlayLaneSnapshot>,
+  ): UiUnsubscribe;
 
   /**
    * U9 · Composed overlay visibility. Merges the class-A policy from

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

@@ -43,6 +43,11 @@ export type {
   DebugSession,
   DebugAttachment,
   GeometryRect,
+  UiOverlayLaneEntry,
+  UiOverlayLaneKind,
+  UiOverlayLaneSnapshot,
+  UiOverlayLaneSource,
+  UiOverlayLaneStatus,
 } from "./_types.ts";
 
 // Chrome composition types (U5.b) — relocated to layer 10 in Slice 8.

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

@@ -42,6 +42,8 @@ import type {
   GeometryRect,
   OverlayAnchorQuery,
   OverlayVisibility,
+  UiOverlayLaneKind,
+  UiOverlayLaneSnapshot,
   UiListener,
   UiUnsubscribe,
 } from "./_types.ts";
@@ -195,6 +197,57 @@ export const subscribeQueryMetadata: ApiV3FnMetadata = {
   rwdReference: "§UI API § ui.overlays.subscribeQuery (KI-006 close). Per-query coalesced variant of `subscribe`. Registers a shared coarse `controller.subscribeOverlays` tick on the first query subscription; re-resolves each attached query on every tick via `getAnchor(query)` (memoized); fires per-query listeners only when the rect actually changes. Torn down on last unsubscribe. Listener receives the new `GeometryRect | null` value. Callers that need the full invalidation stream keep using `subscribe(listener)`.",
 };
 
+// ----- PE2 overlay-lane contract -------------------------------------------
+
+export const getLaneMetadata: ApiV3FnMetadata = {
+  name: "ui.overlays.getLane",
+  status: "live-with-adapter",
+  sourceLayer: "presentation",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ui/overlays-lanes.test.ts",
+    commit: "refactor-10-pe2-overlay-lanes",
+  },
+  mockShape: {
+    deterministic: true,
+    seededFrom: "fixed",
+    shapeDescription:
+      "Unavailable UiOverlayLaneSnapshot with entries:[] and revision:0 when the mounted controller has not wired the requested PE2 overlay lane yet.",
+    carriesMockFlag: true,
+  },
+  uxIntent: { uiVisible: false },
+  agentMetadata: { readOrMutate: "read", boundedScope: "session", auditCategory: "ui-overlays-lane-read" },
+  stateClass: "C-local",
+  persistsTo: "none",
+  rwdReference:
+    "§UI API § PE2 overlay lanes. Reads the mounted controller's lane snapshot for selection/caret/redlines/field-scopes/broad-scopes/comments/issues/tables/objects/search/presence. Returns explicit status:'unavailable' when the lane is not wired; never measures DOM or wakes layout.",
+};
+
+export const subscribeLaneMetadata: ApiV3FnMetadata = {
+  name: "ui.overlays.subscribeLane",
+  status: "live-with-adapter",
+  sourceLayer: "presentation",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ui/overlays-lanes.test.ts",
+    commit: "refactor-10-pe2-overlay-lanes",
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "surface-refresh",
+    expectedDelta: "overlay-lane subscriber attached; future lane snapshots propagate through the listener without PM document transactions",
+  },
+  agentMetadata: { readOrMutate: "read", boundedScope: "session", auditCategory: "ui-overlays-lane-subscribe" },
+  stateClass: "C-local",
+  persistsTo: "none",
+  bidirectional: true,
+  subscriptionShape: {
+    eventType: "ui.overlays.lane_changed",
+    payloadType: "UiOverlayLaneSnapshot",
+    coalescing: "raf",
+  },
+  rwdReference:
+    "§UI API § PE2 overlay lanes. Adapter delegates to UiController.subscribeOverlayLane(kind, listener). Presence/awareness, selection, search, and review lane updates are observable UI state only; this method does not dispatch PM document transactions or invalidate L04 layout.",
+};
+
 // ----- U9 overlay-visibility metadata (state-classes X3) -----
 
 export const getVisibilityMetadata: ApiV3FnMetadata = {
@@ -354,6 +407,21 @@ export function createOverlaysFamily(ctx: UiApiContext) {
   const queryChannels = new Map<string, QueryChannel>();
   let queryCoarseUnsubscribe: (() => void) | null = null;
 
+  function unavailableLane(
+    kind: UiOverlayLaneKind,
+    reason = "overlay lane is not wired on the active controller",
+  ): UiOverlayLaneSnapshot {
+    return {
+      __mock: true,
+      kind,
+      status: "unavailable",
+      entries: Object.freeze([]),
+      revision: 0,
+      source: "unavailable",
+      reason,
+    };
+  }
+
   function queryKey(q: OverlayAnchorQuery): string {
     // `selection` is a singleton kind with no `value` — key by kind alone.
     return q.kind === "selection" ? "selection" : `${q.kind}:${q.value}`;
@@ -560,6 +628,42 @@ export function createOverlaysFamily(ctx: UiApiContext) {
       };
     },
 
+    // ----- PE2 overlay lanes -----
+
+    getLane(kind: UiOverlayLaneKind): UiOverlayLaneSnapshot {
+      const hook = ctx.binding?.controller.getOverlayLane;
+      return hook
+        ? hook(kind)
+        : unavailableLane(kind);
+    },
+
+    subscribeLane(
+      kind: UiOverlayLaneKind,
+      listener: UiListener<UiOverlayLaneSnapshot>,
+    ): UiUnsubscribe {
+      const controller = ctx.binding?.controller;
+      if (!controller) {
+        throw new Error(
+          "ui.overlays.subscribeLane: no controller bound — call ui.session.bind(controller) first",
+        );
+      }
+      if (!controller.subscribeOverlayLane) {
+        throw new Error(
+          `ui.overlays.subscribeLane: controller of kind "${controller.kind}" did not provide a subscribeOverlayLane hook`,
+        );
+      }
+      const unsubscribe = controller.subscribeOverlayLane(kind, listener);
+      emitUxResponse(ctx.handle, {
+        apiFn: subscribeLaneMetadata.name,
+        intent: subscribeLaneMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live-with-adapter",
+        uiVisible: true,
+        expectedDelta: subscribeLaneMetadata.uxIntent.expectedDelta,
+        actualDelta: { kind: "surface-refresh", payload: { subscribed: "ui.overlays.lane", lane: kind } },
+      });
+      return unsubscribe;
+    },
+
     // ----- U9 overlay-visibility (state-classes X3) -----
 
     getVisibility(kind: OverlayKind): OverlayVisibility {

package/src/io/ooxml/parse-drawing.ts

@@ -2,7 +2,12 @@ import type { OpcRelationship } from "./part-manifest.ts";
 import { normalizePartPath, resolveRelationshipTarget } from "./part-manifest.ts";
 import type { InlineMediaPart } from "./parse-inline-media.ts";
 import type { ChartPartLookup } from "./parse-complex-content.ts";
-import type { AnchorGeometry, DrawingFrameNode, Mutable } from "../../model/canonical-document.ts";
+import type {
+  AnchorGeometry,
+  DrawingFrameNode,
+  Mutable,
+  PreserveOnlyObjectSizing,
+} from "../../model/canonical-document.ts";
 import { parseAnchorGeometry } from "./parse-anchor.ts";
 import { parsePicture } from "./parse-picture.ts";
 import { parseShapeContent, type TxbxBlockParser } from "./parse-shapes.ts";
@@ -144,6 +149,13 @@ function resolveFromBranch(
   if (uri === WPS_SHAPE_GRAPHIC_URI && isWordArtGraphicData(graphicData)) return null;
 
   const content = resolveContent(uri, graphicData, outerRawXml, opts);
+  attachPreserveOnlyObjectSizing(content, {
+    anchor: geometry,
+    container,
+    fallbackHint: fallbackHintForContent(content, geometry),
+    rawXml: outerRawXml,
+    sourcePartPath: opts.sourcePartPath,
+  });
   return { type: "drawing_frame", anchor: geometry, content };
 }
 
@@ -231,6 +243,92 @@ function resolveContent(
   return { type: "opaque", rawXml };
 }
 
+function attachPreserveOnlyObjectSizing(
+  content: DrawingFrameNode["content"],
+  context: {
+    anchor: AnchorGeometry;
+    container: XmlElementNode;
+    fallbackHint: PreserveOnlyObjectSizing["fallbackHint"] | null;
+    rawXml: string;
+    sourcePartPath: string | undefined;
+  },
+): void {
+  if (content.type === "picture" || context.fallbackHint === null) {
+    return;
+  }
+
+  (content as Mutable<typeof content>).preserveOnlyObject = {
+    sourceId: createPreserveOnlyObjectSourceId(
+      context.sourcePartPath,
+      context.anchor,
+      context.rawXml,
+    ),
+    display: context.anchor.display,
+    extentEmu: {
+      widthEmu: context.anchor.extent.widthEmu,
+      heightEmu: context.anchor.extent.heightEmu,
+    },
+    fallbackHint: context.fallbackHint,
+    relationshipIds: collectRelationshipIds(context.container),
+  };
+}
+
+function fallbackHintForContent(
+  content: DrawingFrameNode["content"],
+  anchor: AnchorGeometry,
+): PreserveOnlyObjectSizing["fallbackHint"] | null {
+  switch (content.type) {
+    case "picture":
+      return null;
+    case "chart_preview":
+      return "chart";
+    case "smartart_preview":
+      return "smartart";
+    case "shape":
+      return "shape";
+    case "opaque":
+      return anchor.display === "floating" ? "drawing-floating" : "drawing-inline";
+  }
+}
+
+function createPreserveOnlyObjectSourceId(
+  sourcePartPath: string | undefined,
+  anchor: AnchorGeometry,
+  rawXml: string,
+): string {
+  const part = sourcePartPath ?? "/word/document.xml";
+  const docPrId = anchor.docPr?.id;
+  if (docPrId) return `part:${part}#drawing-docPr:${docPrId}`;
+  return `part:${part}#drawing:${hashString(rawXml)}`;
+}
+
+function collectRelationshipIds(node: XmlElementNode): string[] {
+  const ids = new Set<string>();
+  const visit = (current: XmlElementNode): void => {
+    const id =
+      current.attributes["r:id"] ??
+      current.attributes["r:embed"] ??
+      current.attributes.embed ??
+      current.attributes["r:link"] ??
+      current.attributes.link;
+    if (id) ids.add(id);
+    for (const child of current.children) {
+      if (child.type === "element") visit(child);
+    }
+  };
+  visit(node);
+  return [...ids].sort();
+}
+
+function hashString(value: string): string {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
 function extractChartRelId(graphicData: XmlElementNode | undefined): string | null {
   if (!graphicData) return null;
   const chart = findFirstDescendant(graphicData, "chart");

package/src/io/ooxml/parse-fields.ts

@@ -330,6 +330,11 @@ import type {
   TocStructure,
   Mutable,
 } from "../../model/canonical-document.ts";
+import {
+  MAIN_STORY_KEY,
+  createHeaderFooterStoryKey,
+  createNoteStoryKey,
+} from "../../model/canonical-layout-inputs.ts";
 import { parseFieldSwitches } from "./parse-field-switches.ts";
 
 const FIELD_FAMILY_PATTERN =
@@ -439,6 +444,7 @@ export function buildFieldRegistry(
         ...(classification.target ? { fieldTarget: classification.target } : {}),
         displayText,
         paragraphIndex,
+        storyKey: MAIN_STORY_KEY,
         refreshStatus: node.refreshStatus ?? (classification.supported ? "stale" : "preserve-only"),
         ...(classification.switches ? { switches: classification.switches } : {}),
       };
@@ -454,7 +460,7 @@ export function buildFieldRegistry(
     }
   });
   if (document.subParts) {
-    walkSubPartFields(document.subParts, (node, pIdx) => {
+    walkSubPartFields(document.subParts, (node, pIdx, storyKey) => {
       paragraphIndex = pIdx;
       if (node.type === "field") {
         const classification = node.fieldFamily
@@ -469,6 +475,7 @@ export function buildFieldRegistry(
           ...(classification.target ? { fieldTarget: classification.target } : {}),
           displayText,
           paragraphIndex,
+          storyKey,
           refreshStatus: node.refreshStatus ?? (classification.supported ? "stale" : "preserve-only"),
           ...(classification.switches ? { switches: classification.switches } : {}),
         };
@@ -1062,27 +1069,41 @@ function walkFieldDocument(
 
 function walkSubPartFields(
   subParts: Mutable<SubPartsCatalog>,
-  visit: (node: DocumentNode, paragraphIndex: number) => void,
+  visit: (node: DocumentNode, paragraphIndex: number, storyKey: string) => void,
 ): void {
   for (const header of subParts.headers) {
+    const storyKey = createHeaderFooterStoryKey({
+      kind: "header",
+      relationshipId: header.relationshipId,
+      variant: header.variant,
+      ...(header.sectionIndex !== undefined ? { sectionIndex: header.sectionIndex } : {}),
+    });
     for (const block of header.blocks) {
-      walkFieldDocument(block, visit);
+      walkFieldDocument(block, (node, paragraphIndex) => visit(node, paragraphIndex, storyKey));
     }
   }
   for (const footer of subParts.footers) {
+    const storyKey = createHeaderFooterStoryKey({
+      kind: "footer",
+      relationshipId: footer.relationshipId,
+      variant: footer.variant,
+      ...(footer.sectionIndex !== undefined ? { sectionIndex: footer.sectionIndex } : {}),
+    });
     for (const block of footer.blocks) {
-      walkFieldDocument(block, visit);
+      walkFieldDocument(block, (node, paragraphIndex) => visit(node, paragraphIndex, storyKey));
     }
   }
   if (subParts.footnoteCollection) {
     for (const note of Object.values(subParts.footnoteCollection.footnotes)) {
+      const storyKey = createNoteStoryKey("footnote", note.noteId);
       for (const block of note.blocks) {
-        walkFieldDocument(block, visit);
+        walkFieldDocument(block, (node, paragraphIndex) => visit(node, paragraphIndex, storyKey));
       }
     }
     for (const note of Object.values(subParts.footnoteCollection.endnotes)) {
+      const storyKey = createNoteStoryKey("endnote", note.noteId);
       for (const block of note.blocks) {
-        walkFieldDocument(block, visit);
+        walkFieldDocument(block, (node, paragraphIndex) => visit(node, paragraphIndex, storyKey));
       }
     }
   }

package/src/io/ooxml/parse-shapes.ts

@@ -15,6 +15,7 @@ import type {
   ShapeContent,
   TextBoxBodyProperties,
   Mutable,
+  PreserveOnlyObjectSizing,
 } from "../../model/canonical-document.ts";
 import { parseFill } from "./parse-fill.ts";
 import {
@@ -52,6 +53,7 @@ export interface ParsedWpsShape {
   geometry?: string;
   /** Original drawing XML for lossless round-trip export. */
   rawXml: string;
+  preserveOnlyObject?: PreserveOnlyObjectSizing;
 }
 
 export interface ParsedWordArt {
@@ -62,6 +64,7 @@ export interface ParsedWordArt {
   geometry?: string;
   /** Original drawing XML for lossless round-trip export. */
   rawXml: string;
+  preserveOnlyObject?: PreserveOnlyObjectSizing;
 }
 
 export interface ParsedVmlShape {
@@ -72,6 +75,7 @@ export interface ParsedVmlShape {
   text?: string;
   /** Original w:pict XML for lossless round-trip export. */
   rawXml: string;
+  preserveOnlyObject?: PreserveOnlyObjectSizing;
 }
 
 export type ParsedShape = ParsedWpsShape | ParsedWordArt | ParsedVmlShape;
@@ -113,6 +117,11 @@ export function parseShapeXml(
       text: text ?? "",
       ...(prst ? { geometry: prst } : {}),
       rawXml: drawingXml,
+      preserveOnlyObject: createDrawingPreserveOnlyObject(
+        drawingXml,
+        "wordart",
+        collectRelationshipIds(root),
+      ),
     };
   }
 
@@ -158,6 +167,11 @@ export function parseShapeXml(
     ...(txbxBlocks && txbxBlocks.length > 0 ? { txbxBlocks } : {}),
     ...(prst ? { geometry: prst } : {}),
     rawXml: drawingXml,
+    preserveOnlyObject: createDrawingPreserveOnlyObject(
+      drawingXml,
+      "shape",
+      collectRelationshipIds(root),
+    ),
   };
 }
 
@@ -200,6 +214,11 @@ export function parseVmlXml(pictXml: string): ParsedVmlShape | null {
     ...(shapeType ? { shapeType } : {}),
     ...(text ? { text } : {}),
     rawXml: pictXml,
+    preserveOnlyObject: createVmlPreserveOnlyObject(
+      pictXml,
+      vmlNode,
+      collectRelationshipIds(root),
+    ),
   };
 }
 
@@ -361,3 +380,114 @@ function readIntAttr(node: XmlElementNode, attr: string): number | undefined {
   const parsed = parseInt(raw, 10);
   return Number.isFinite(parsed) ? parsed : undefined;
 }
+
+function createDrawingPreserveOnlyObject(
+  rawXml: string,
+  fallbackHint: PreserveOnlyObjectSizing["fallbackHint"],
+  relationshipIds: string[],
+): PreserveOnlyObjectSizing {
+  const extentEmu = readDrawingExtentEmu(rawXml);
+  return {
+    sourceId: `drawing:${hashString(rawXml)}`,
+    display: rawXml.includes("<wp:anchor") ? "floating" : "inline",
+    ...(extentEmu ? { extentEmu } : {}),
+    fallbackHint,
+    ...(relationshipIds.length > 0 ? { relationshipIds } : {}),
+  };
+}
+
+function createVmlPreserveOnlyObject(
+  rawXml: string,
+  node: XmlElementNode,
+  relationshipIds: string[],
+): PreserveOnlyObjectSizing {
+  const extentEmu = readVmlExtentEmu(node.attributes.style);
+  return {
+    sourceId: `vml:${node.attributes.id ?? hashString(rawXml)}`,
+    display: "unknown",
+    ...(extentEmu ? { extentEmu } : {}),
+    fallbackHint: "vml-shape",
+    ...(relationshipIds.length > 0 ? { relationshipIds } : {}),
+  };
+}
+
+function readDrawingExtentEmu(
+  rawXml: string,
+): { widthEmu: number; heightEmu: number } | undefined {
+  const extentMatch = /<wp:extent\b[^>]*\bcx=["']([0-9]+)["'][^>]*\bcy=["']([0-9]+)["'][^>]*\/?>/u.exec(rawXml);
+  if (extentMatch) {
+    return {
+      widthEmu: Number.parseInt(extentMatch[1] ?? "0", 10),
+      heightEmu: Number.parseInt(extentMatch[2] ?? "0", 10),
+    };
+  }
+  const xfrmMatch = /<a:ext\b[^>]*\bcx=["']([0-9]+)["'][^>]*\bcy=["']([0-9]+)["'][^>]*\/?>/u.exec(rawXml);
+  if (!xfrmMatch) return undefined;
+  return {
+    widthEmu: Number.parseInt(xfrmMatch[1] ?? "0", 10),
+    heightEmu: Number.parseInt(xfrmMatch[2] ?? "0", 10),
+  };
+}
+
+function readVmlExtentEmu(
+  style: string | undefined,
+): { widthEmu: number; heightEmu: number } | undefined {
+  if (!style) return undefined;
+  const widthTwips = readCssLengthTwips(style, "width");
+  const heightTwips = readCssLengthTwips(style, "height");
+  if (widthTwips === undefined || heightTwips === undefined) return undefined;
+  return {
+    widthEmu: Math.round(widthTwips * 635),
+    heightEmu: Math.round(heightTwips * 635),
+  };
+}
+
+function readCssLengthTwips(style: string, property: "width" | "height"): number | undefined {
+  const match = new RegExp(`(?:^|;)\\s*${property}\\s*:\\s*([0-9.]+)\\s*(pt|in|cm|mm|px)?`, "iu")
+    .exec(style);
+  if (!match) return undefined;
+  const value = Number.parseFloat(match[1] ?? "");
+  if (!Number.isFinite(value)) return undefined;
+  const unit = (match[2] ?? "pt").toLowerCase();
+  switch (unit) {
+    case "pt":
+      return Math.round(value * 20);
+    case "in":
+      return Math.round(value * 1440);
+    case "cm":
+      return Math.round(value * 567);
+    case "mm":
+      return Math.round(value * 56.7);
+    case "px":
+      return Math.round(value * 15);
+    default:
+      return undefined;
+  }
+}
+
+function collectRelationshipIds(node: XmlElementNode): string[] {
+  const ids = new Set<string>();
+  const visit = (current: XmlElementNode): void => {
+    const id =
+      current.attributes["r:id"] ??
+      current.attributes["r:embed"] ??
+      current.attributes.embed ??
+      current.attributes["r:link"] ??
+      current.attributes.link;
+    if (id) ids.add(id);
+    for (const child of current.children) {
+      if (child.type === "element") visit(child);
+    }
+  };
+  visit(node);
+  return [...ids].sort();
+}
+
+function hashString(value: string): string {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}