@beyondwork/docx-react-component 1.0.105 → 1.0.108

package/src/model/canonical-hash.ts

@@ -0,0 +1,221 @@
+const SHA256_INITIAL_STATE = [
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+  0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+] as const;
+
+const SHA256_CONSTANTS = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+] as const;
+
+const HEX_DIGITS = "0123456789abcdef";
+
+/**
+ * Synchronous, dependency-free SHA-256 for Layer 02 evidence refs.
+ *
+ * This intentionally does not import `node:crypto` or Web Crypto:
+ * `src/model/**` must stay browser-safe and independent of host APIs, while
+ * `collectCanonicalLayoutInputs()` is synchronous. Web Crypto is async, and a
+ * Node-only import would leak a server runtime dependency into the canonical
+ * model bundle. Keep this module small and covered by Node crypto vectors.
+ */
+export function sha256TextHex(text: string): string {
+  return sha256Hex(utf8Bytes(text));
+}
+
+export function sha256Hex(bytes: Uint8Array): string {
+  const padded = padSha256Message(bytes);
+  const schedule = new Uint32Array(64);
+  let state0: number = SHA256_INITIAL_STATE[0];
+  let state1: number = SHA256_INITIAL_STATE[1];
+  let state2: number = SHA256_INITIAL_STATE[2];
+  let state3: number = SHA256_INITIAL_STATE[3];
+  let state4: number = SHA256_INITIAL_STATE[4];
+  let state5: number = SHA256_INITIAL_STATE[5];
+  let state6: number = SHA256_INITIAL_STATE[6];
+  let state7: number = SHA256_INITIAL_STATE[7];
+
+  for (let chunkOffset = 0; chunkOffset < padded.byteLength; chunkOffset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const wordOffset = chunkOffset + index * 4;
+      schedule[index] =
+        (((padded[wordOffset] ?? 0) << 24) |
+          ((padded[wordOffset + 1] ?? 0) << 16) |
+          ((padded[wordOffset + 2] ?? 0) << 8) |
+          (padded[wordOffset + 3] ?? 0)) >>>
+        0;
+    }
+
+    for (let index = 16; index < 64; index += 1) {
+      schedule[index] = add32(
+        lowerSigma1(schedule[index - 2] ?? 0),
+        schedule[index - 7] ?? 0,
+        lowerSigma0(schedule[index - 15] ?? 0),
+        schedule[index - 16] ?? 0,
+      );
+    }
+
+    let a = state0;
+    let b = state1;
+    let c = state2;
+    let d = state3;
+    let e = state4;
+    let f = state5;
+    let g = state6;
+    let h = state7;
+
+    for (let index = 0; index < 64; index += 1) {
+      const t1 = add32(
+        h,
+        upperSigma1(e),
+        choose(e, f, g),
+        SHA256_CONSTANTS[index] ?? 0,
+        schedule[index] ?? 0,
+      );
+      const t2 = add32(upperSigma0(a), majority(a, b, c));
+
+      h = g;
+      g = f;
+      f = e;
+      e = add32(d, t1);
+      d = c;
+      c = b;
+      b = a;
+      a = add32(t1, t2);
+    }
+
+    state0 = add32(state0, a);
+    state1 = add32(state1, b);
+    state2 = add32(state2, c);
+    state3 = add32(state3, d);
+    state4 = add32(state4, e);
+    state5 = add32(state5, f);
+    state6 = add32(state6, g);
+    state7 = add32(state7, h);
+  }
+
+  return wordsToHex(state0, state1, state2, state3, state4, state5, state6, state7);
+}
+
+function utf8Bytes(text: string): Uint8Array {
+  const bytes: number[] = [];
+  for (let index = 0; index < text.length; index += 1) {
+    let codePoint = text.codePointAt(index) ?? 0;
+    if (codePoint > 0xffff) index += 1;
+    if (codePoint <= 0x7f) {
+      bytes.push(codePoint);
+    } else if (codePoint <= 0x7ff) {
+      bytes.push(0xc0 | (codePoint >>> 6), 0x80 | (codePoint & 0x3f));
+    } else if (codePoint <= 0xffff) {
+      bytes.push(
+        0xe0 | (codePoint >>> 12),
+        0x80 | ((codePoint >>> 6) & 0x3f),
+        0x80 | (codePoint & 0x3f),
+      );
+    } else {
+      bytes.push(
+        0xf0 | (codePoint >>> 18),
+        0x80 | ((codePoint >>> 12) & 0x3f),
+        0x80 | ((codePoint >>> 6) & 0x3f),
+        0x80 | (codePoint & 0x3f),
+      );
+    }
+  }
+  return new Uint8Array(bytes);
+}
+
+function padSha256Message(bytes: Uint8Array): Uint8Array {
+  const bitLength = bytes.byteLength * 8;
+  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.byteLength] = 0x80;
+
+  const lengthOffset = paddedLength - 8;
+  for (let index = 0; index < 8; index += 1) {
+    const shift = (7 - index) * 8;
+    padded[lengthOffset + index] = Math.floor(bitLength / 2 ** shift) & 0xff;
+  }
+
+  return padded;
+}
+
+function rotateRight(value: number, shift: number): number {
+  return ((value >>> shift) | (value << (32 - shift))) >>> 0;
+}
+
+function add32(...values: number[]): number {
+  let total = 0;
+  for (const value of values) {
+    total = (total + value) >>> 0;
+  }
+  return total;
+}
+
+function wordsToHex(
+  word0: number,
+  word1: number,
+  word2: number,
+  word3: number,
+  word4: number,
+  word5: number,
+  word6: number,
+  word7: number,
+): string {
+  return (
+    wordToHex(word0) +
+    wordToHex(word1) +
+    wordToHex(word2) +
+    wordToHex(word3) +
+    wordToHex(word4) +
+    wordToHex(word5) +
+    wordToHex(word6) +
+    wordToHex(word7)
+  );
+}
+
+function wordToHex(word: number): string {
+  let hex = "";
+  for (let shift = 28; shift >= 0; shift -= 4) {
+    hex += HEX_DIGITS[(word >>> shift) & 0xf];
+  }
+  return hex;
+}
+
+function choose(x: number, y: number, z: number): number {
+  return ((x & y) ^ (~x & z)) >>> 0;
+}
+
+function majority(x: number, y: number, z: number): number {
+  return ((x & y) ^ (x & z) ^ (y & z)) >>> 0;
+}
+
+function upperSigma0(value: number): number {
+  return (rotateRight(value, 2) ^ rotateRight(value, 13) ^ rotateRight(value, 22)) >>> 0;
+}
+
+function upperSigma1(value: number): number {
+  return (rotateRight(value, 6) ^ rotateRight(value, 11) ^ rotateRight(value, 25)) >>> 0;
+}
+
+function lowerSigma0(value: number): number {
+  return (rotateRight(value, 7) ^ rotateRight(value, 18) ^ (value >>> 3)) >>> 0;
+}
+
+function lowerSigma1(value: number): number {
+  return (rotateRight(value, 17) ^ rotateRight(value, 19) ^ (value >>> 10)) >>> 0;
+}

package/src/model/canonical-layout-inputs.ts

@@ -2,6 +2,8 @@ import type {
   AnchorGeometry,
   BlockNode,
   CanonicalDocument,
+  CanonicalFieldEvidenceRef,
+  CanonicalSourceRef,
   DrawingFrameNode,
   FieldFamily,
   FieldRefreshStatus,
@@ -9,12 +11,15 @@ import type {
   HeaderFooterVariant,
   ImageNode,
   InlineNode,
+  ParagraphNode,
   SectionProperties,
   TableCellNode,
   TableNode,
   TableRowNode,
   TocRegion,
+  ParagraphStyleNumberingReference,
 } from "./canonical-document.ts";
+import { sha256TextHex } from "./canonical-hash.ts";
 
 export const MAIN_STORY_KEY = "main";
 
@@ -39,16 +44,19 @@ export interface CanonicalStoryIdentity {
   readonly noteId?: string;
 }
 
-export type CanonicalFieldRegionKind = "field" | "toc-region";
+export type CanonicalFieldRegionKind = "field" | "toc-region" | "hyperlink-field";
 
 export interface CanonicalFieldRegionIdentity {
   readonly regionId: string;
+  readonly canonicalFieldId: string;
   readonly kind: CanonicalFieldRegionKind;
   readonly storyKey: string;
   readonly fieldIndex: number;
   readonly fieldFamily: FieldFamily;
   readonly refreshStatus: FieldRefreshStatus;
   readonly paragraphIndex: number;
+  readonly sourceRef?: CanonicalSourceRef;
+  readonly fieldEvidence?: CanonicalFieldEvidenceRef;
   readonly tocId?: string;
   readonly sourcePath?: string;
   readonly parentKind?: TocRegion["parentKind"];
@@ -61,15 +69,33 @@ export interface CanonicalFieldRegionIdentity {
 export interface CanonicalLayoutInputs {
   readonly stories: readonly CanonicalStoryIdentity[];
   readonly fieldRegions: readonly CanonicalFieldRegionIdentity[];
+  readonly numbering: readonly CanonicalNumberingLayoutInput[];
   readonly tables: readonly CanonicalTableLayoutInput[];
   readonly anchors: readonly CanonicalAnchorLayoutInput[];
   readonly scopes: readonly CanonicalScopeLayoutInput[];
 }
 
+export interface CanonicalNumberingLayoutInput {
+  readonly numberingKey: string;
+  readonly storyKey: string;
+  readonly blockPath: string;
+  readonly paragraphIndex: number;
+  readonly sourceRef?: CanonicalSourceRef;
+  readonly numberingSourceRef?: CanonicalSourceRef;
+  readonly numberingOrigin?: "paragraph" | "paragraph-style";
+  readonly paragraphStyleId?: string;
+  readonly numberingInstanceId: string;
+  readonly numberingInstanceSourceRef?: CanonicalSourceRef;
+  readonly abstractNumberingId?: string;
+  readonly abstractNumberingSourceRef?: CanonicalSourceRef;
+  readonly level: number;
+}
+
 export interface CanonicalTableLayoutInput {
   readonly tableKey: string;
   readonly storyKey: string;
   readonly blockPath: string;
+  readonly sourceRef?: CanonicalSourceRef;
   readonly rowCount: number;
   readonly columnCount: number;
   readonly gridColumns: readonly number[];
@@ -141,6 +167,7 @@ export interface CanonicalAnchorLayoutInput {
   readonly storyKey: string;
   readonly blockPath: string;
   readonly inlinePath: string;
+  readonly sourceRef?: CanonicalSourceRef;
   readonly objectKind: CanonicalAnchorObjectKind;
   readonly editPosture: CanonicalAnchorEditPosture;
   readonly display?: "inline" | "floating";
@@ -218,6 +245,7 @@ export function collectCanonicalLayoutInputs(
   return {
     stories: collectCanonicalStoryIdentities(doc),
     fieldRegions: collectCanonicalFieldRegionIdentities(doc),
+    numbering: collectCanonicalNumberingLayoutInputs(doc, blockContexts),
     tables: collectCanonicalTableLayoutInputs(blockContexts),
     anchors: collectCanonicalAnchorLayoutInputs(doc, blockContexts),
     scopes: collectCanonicalScopeLayoutInputs(blockContexts),
@@ -319,14 +347,89 @@ export function collectCanonicalStoryIdentities(
   return stories;
 }
 
+export function collectCanonicalNumberingLayoutInputs(
+  doc: CanonicalDocument,
+  contexts: readonly CanonicalStoryBlockContext[] = collectStoryBlockContexts(doc),
+): CanonicalNumberingLayoutInput[] {
+  const inputs: CanonicalNumberingLayoutInput[] = [];
+
+  for (const context of contexts) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      paragraph(paragraph, blockPath) {
+        const styleNumbering =
+          paragraph.numbering === undefined && paragraph.styleId !== undefined
+            ? resolveParagraphStyleNumbering(doc, paragraph.styleId)
+            : undefined;
+        const numbering = paragraph.numbering ?? styleNumbering;
+        if (numbering === undefined) {
+          return;
+        }
+        const instance = doc.numbering.instances[numbering.numberingInstanceId];
+        const abstractDefinition =
+          instance?.abstractNumberingId === undefined
+            ? undefined
+            : doc.numbering.abstractDefinitions[instance.abstractNumberingId];
+        inputs.push({
+          numberingKey: `${context.storyKey}:${blockPath}:numbering`,
+          storyKey: context.storyKey,
+          blockPath,
+          paragraphIndex: blockIndexFromPath(blockPath),
+          ...(paragraph.sourceRef !== undefined ? { sourceRef: paragraph.sourceRef } : {}),
+          ...(paragraph.numbering?.sourceRef !== undefined
+            ? { numberingSourceRef: paragraph.numbering.sourceRef }
+            : {}),
+          numberingOrigin: paragraph.numbering === undefined ? "paragraph-style" : "paragraph",
+          ...(paragraph.numbering === undefined && paragraph.styleId !== undefined
+            ? { paragraphStyleId: paragraph.styleId }
+            : {}),
+          numberingInstanceId: numbering.numberingInstanceId,
+          ...(instance?.sourceRef !== undefined
+            ? { numberingInstanceSourceRef: instance.sourceRef }
+            : {}),
+          ...(instance?.abstractNumberingId !== undefined
+            ? { abstractNumberingId: instance.abstractNumberingId }
+            : {}),
+          ...(abstractDefinition?.sourceRef !== undefined
+            ? { abstractNumberingSourceRef: abstractDefinition.sourceRef }
+            : {}),
+          level: numbering.level ?? 0,
+        });
+      },
+    });
+  }
+
+  return inputs;
+}
+
+function resolveParagraphStyleNumbering(
+  doc: CanonicalDocument,
+  styleId: string,
+): ParagraphStyleNumberingReference | undefined {
+  const visited = new Set<string>();
+  let currentStyleId: string | undefined = styleId;
+
+  while (currentStyleId !== undefined && !visited.has(currentStyleId)) {
+    visited.add(currentStyleId);
+    const style: CanonicalDocument["styles"]["paragraphs"][string] | undefined =
+      doc.styles.paragraphs[currentStyleId];
+    if (style === undefined) {
+      return undefined;
+    }
+    if (style.numbering !== undefined) {
+      return style.numbering;
+    }
+    currentStyleId = style.basedOn;
+  }
+
+  return undefined;
+}
+
 export function collectCanonicalFieldRegionIdentities(
   doc: CanonicalDocument,
 ): CanonicalFieldRegionIdentity[] {
   const registry = doc.fieldRegistry;
-  if (!registry) return [];
-
   const byFieldIndex = new Map(
-    [...registry.supported, ...registry.preserveOnly].map((entry) => [
+    [...(registry?.supported ?? []), ...(registry?.preserveOnly ?? [])].map((entry) => [
       entry.fieldIndex,
       entry,
     ]),
@@ -334,23 +437,47 @@ export function collectCanonicalFieldRegionIdentities(
   const regions: CanonicalFieldRegionIdentity[] = [];
 
   for (const entry of byFieldIndex.values()) {
+    const canonicalFieldId =
+      entry.canonicalFieldId ??
+      createCanonicalFieldId({
+        fieldIndex: entry.fieldIndex,
+        storyKey: entry.storyKey,
+        sourceRef: entry.sourceRef,
+      });
     regions.push({
       regionId: `field:${entry.fieldIndex}`,
+      canonicalFieldId,
       kind: "field",
       storyKey: entry.storyKey ?? MAIN_STORY_KEY,
       fieldIndex: entry.fieldIndex,
       fieldFamily: entry.fieldFamily,
       refreshStatus: entry.refreshStatus,
       paragraphIndex: entry.paragraphIndex,
+      ...(entry.sourceRef !== undefined ? { sourceRef: entry.sourceRef } : {}),
+      fieldEvidence: createFieldEvidenceRef({
+        instruction: entry.instruction,
+        result: entry.displayText,
+        sourceRef: entry.sourceRef,
+        locked: entry.locked,
+        dirty: entry.dirty,
+      }),
     });
   }
 
-  for (const toc of registry.tocRegions ?? []) {
+  for (const toc of registry?.tocRegions ?? []) {
     const field = byFieldIndex.get(toc.sourceFieldIndex);
+    const storyKey = field?.storyKey ?? MAIN_STORY_KEY;
     regions.push({
       regionId: `toc:${toc.tocId}`,
+      canonicalFieldId:
+        field?.canonicalFieldId ??
+        createCanonicalFieldId({
+          fieldIndex: toc.sourceFieldIndex,
+          storyKey,
+          sourceRef: field?.sourceRef,
+        }),
       kind: "toc-region",
-      storyKey: field?.storyKey ?? MAIN_STORY_KEY,
+      storyKey,
       fieldIndex: toc.sourceFieldIndex,
       fieldFamily: field?.fieldFamily ?? "TOC",
       refreshStatus: field?.refreshStatus ?? "stale",
@@ -365,9 +492,102 @@ export function collectCanonicalFieldRegionIdentities(
     });
   }
 
+  regions.push(...collectHyperlinkFieldRegionIdentities(doc, regions.length));
+
+  return regions;
+}
+
+function collectHyperlinkFieldRegionIdentities(
+  doc: CanonicalDocument,
+  startIndex: number,
+): CanonicalFieldRegionIdentity[] {
+  const regions: CanonicalFieldRegionIdentity[] = [];
+  for (const context of collectStoryBlockContexts(doc)) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      inline(inline, blockPath, inlinePath) {
+        if (inline.type !== "hyperlink" || inline.fieldCarrier === undefined) {
+          return;
+        }
+        const evidence = createFieldEvidenceRef({
+          sourceRef: inline.fieldCarrier.sourceRef ?? inline.sourceRef,
+          instructionHash: inline.fieldCarrier.instructionHash,
+          resultHash: inline.fieldCarrier.resultHash,
+          locked: inline.fieldCarrier.locked,
+          dirty: inline.fieldCarrier.dirty,
+        });
+        const sourceRef = evidence.sourceRef;
+        const fieldIndex = startIndex + regions.length;
+        const canonicalFieldId = createCanonicalFieldId({
+          fieldIndex,
+          storyKey: context.storyKey,
+          sourceRef,
+        });
+        regions.push({
+          regionId: `hyperlink-field:${sourceRef?.sourceId ?? `${context.storyKey}:${inlinePath}`}`,
+          canonicalFieldId,
+          kind: "hyperlink-field",
+          storyKey: context.storyKey,
+          fieldIndex,
+          fieldFamily: inline.fieldCarrier.fieldFamily ?? "HYPERLINK",
+          refreshStatus: inline.fieldCarrier.refreshStatus ?? "preserve-only",
+          paragraphIndex: blockIndexFromPath(blockPath),
+          ...(sourceRef !== undefined ? { sourceRef } : {}),
+          fieldEvidence: evidence,
+        });
+      },
+    });
+  }
   return regions;
 }
 
+function createFieldEvidenceRef(input: {
+  readonly instruction?: string;
+  readonly result?: string;
+  readonly instructionHash?: string;
+  readonly resultHash?: string;
+  readonly sourceRef?: CanonicalSourceRef;
+  readonly locked?: boolean;
+  readonly dirty?: boolean;
+}): CanonicalFieldEvidenceRef {
+  return {
+    ...(input.sourceRef !== undefined ? { sourceRef: input.sourceRef } : {}),
+    ...(input.instructionHash !== undefined
+      ? { instructionHash: input.instructionHash }
+      : input.instruction !== undefined
+        ? { instructionHash: hashText(input.instruction) }
+        : {}),
+    ...(input.resultHash !== undefined
+      ? { resultHash: input.resultHash }
+      : input.result !== undefined
+        ? { resultHash: hashText(input.result) }
+        : {}),
+    ...(input.locked !== undefined ? { locked: input.locked } : {}),
+    ...(input.dirty !== undefined ? { dirty: input.dirty } : {}),
+  };
+}
+
+function hashText(text: string): string {
+  return sha256TextHex(text);
+}
+
+export function createCanonicalFieldId(input: {
+  readonly fieldIndex: number;
+  readonly storyKey?: string | undefined;
+  readonly sourceRef?: CanonicalSourceRef | undefined;
+}): string {
+  const sourceId = input.sourceRef?.sourceId;
+  if (sourceId !== undefined && sourceId.length > 0) {
+    return `canonical-field:source:${sourceId}`;
+  }
+  return `canonical-field:story:${input.storyKey ?? MAIN_STORY_KEY}:field:${input.fieldIndex}`;
+}
+
+function blockIndexFromPath(blockPath: string): number {
+  const matches = [...blockPath.matchAll(/\/block\[(\d+)\]/g)];
+  const last = matches.at(-1);
+  return last ? Number.parseInt(last[1]!, 10) : 0;
+}
+
 export function collectCanonicalTableLayoutInputs(
   contexts: readonly CanonicalStoryBlockContext[],
 ): CanonicalTableLayoutInput[] {
@@ -473,6 +693,7 @@ export function collectStoryBlockContexts(
 }
 
 interface BlockWalkVisitor {
+  readonly paragraph?: (paragraph: ParagraphNode, blockPath: string) => void;
   readonly table?: (table: TableNode, blockPath: string) => void;
   readonly inline?: (
     inline: InlineNode,
@@ -512,6 +733,7 @@ function walkBlocks(
     }
 
     if (block.type === "paragraph") {
+      visitor.paragraph?.(block, blockPath);
       walkInlines(block.children, storyKey, blockPath, `${blockPath}/inline`, visitor);
       continue;
     }
@@ -568,6 +790,7 @@ function projectTableLayoutInput(
     tableKey,
     storyKey,
     blockPath,
+    ...(table.sourceRef !== undefined ? { sourceRef: table.sourceRef } : {}),
     rowCount: table.rows.length,
     columnCount: table.gridColumns.length,
     gridColumns: [...table.gridColumns],
@@ -673,11 +896,13 @@ function projectDrawingFrameAnchor(
   const content = node.content;
   const shapeBlocks = content.type === "shape" ? content.txbxBlocks : undefined;
   const objectKind = drawingContentKind(content);
+  const sourceRef = node.sourceRef ?? drawingContentSourceRef(content);
   return {
     objectKey: `${storyKey}:${inlinePath}`,
     storyKey,
     blockPath,
     inlinePath,
+    ...(sourceRef !== undefined ? { sourceRef } : {}),
     objectKind,
     editPosture: drawingEditPosture(node),
     display: anchor.display,
@@ -753,12 +978,26 @@ function projectLegacyImageAnchor(
       ? { allowOverlap: node.floating.allowOverlap }
       : {}),
     mediaId: node.mediaId,
+    ...(node.sourceRef !== undefined ? { sourceRef: node.sourceRef } : {}),
     ...(media?.packagePartName !== undefined ? { packagePartName: media.packagePartName } : {}),
     ...(media?.relationshipId !== undefined ? { relationshipId: media.relationshipId } : {}),
     ...(node.placementXml !== undefined ? { rawXmlPreserved: true } : {}),
   };
 }
 
+function preserveOnlySourceRef(sourceId: string | undefined): CanonicalSourceRef | undefined {
+  return sourceId === undefined ? undefined : { sourceId };
+}
+
+function drawingContentSourceRef(
+  content: DrawingFrameNode["content"],
+): CanonicalSourceRef | undefined {
+  if ("preserveOnlyObject" in content) {
+    return preserveOnlySourceRef(content.preserveOnlyObject?.sourceId);
+  }
+  return undefined;
+}
+
 function normalizeFloatingAxis(
   axis: NonNullable<ImageNode["floating"]>["horizontalPosition"],
 ): AnchorGeometry["positionH"] {

package/src/model/layout/index.ts

@@ -65,6 +65,7 @@ export type {
   RuntimeLayoutDivergenceKind,
   RuntimeLayoutDivergence,
   RuntimePageFrame,
+  RuntimePageFrameCompleteness,
   RuntimePageLocalStoryInstance,
   RuntimeResolvedStoryField,
   RuntimeStoryAnchoredObject,