@beyondwork/docx-react-component 1.0.11 → 1.0.13

package/src/io/docx-session.ts

@@ -26,6 +26,9 @@ import { readOpcPackage, type OpcPackage } from "./opc/package-reader.ts";
 import { parseMainDocumentXml } from "./ooxml/parse-main-document.ts";
 import { normalizeParsedTextDocument } from "./normalize/normalize-text.ts";
 import {
+  CONTENT_TYPES_PATH,
+  PACKAGE_RELATIONSHIPS_PATH,
+  getRelationshipsPartPath,
   normalizePartPath,
   resolveRelationshipTarget,
   type OpcRelationship,
@@ -58,6 +61,7 @@ import {
   type ImportDiagnosticsResult,
 } from "../validation/import-diagnostics.ts";
 import type {
+  BlockNode,
   FootnoteCollection,
   HeaderDocument,
   FooterDocument,
@@ -97,6 +101,7 @@ import {
   WORD_FOOTNOTES_CONTENT_TYPE,
   WORD_ENDNOTES_CONTENT_TYPE,
 } from "./export/serialize-footnotes.ts";
+import { createPersistedSourcePackage } from "./source-package-provenance.ts";
 
 const MAIN_DOCUMENT_PATH = "/word/document.xml";
 const NUMBERING_PART_PATH = "/word/numbering.xml";
@@ -104,8 +109,14 @@ const COMMENTS_PART_PATH = "/word/comments.xml";
 const COMMENTS_EXTENDED_PART_PATH = "/word/commentsExtended.xml";
 const COMMENTS_IDS_PART_PATH = "/word/commentsIds.xml";
 const PEOPLE_PART_PATH = "/word/people.xml";
+const APP_PROPERTIES_PART_PATH = "/docProps/app.xml";
+const CORE_PROPERTIES_PART_PATH = "/docProps/core.xml";
 const MAIN_DOCUMENT_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+const APP_PROPERTIES_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.extended-properties+xml";
+const CORE_PROPERTIES_CONTENT_TYPE =
+  "application/vnd.openxmlformats-package.core-properties+xml";
 const NUMBERING_RELATIONSHIP_TYPE =
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
 const COMMENTS_CONTENT_TYPE =
@@ -124,6 +135,12 @@ const COMMENTS_IDS_RELATIONSHIP_TYPE =
   "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds";
 const PEOPLE_RELATIONSHIP_TYPE =
   "http://schemas.microsoft.com/office/2011/relationships/people";
+const APP_PROPERTIES_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties";
+const CORE_PROPERTIES_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+const OFFICE_DOCUMENT_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
 const HEADER_RELATIONSHIP_TYPE =
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header";
 const FOOTER_RELATIONSHIP_TYPE =
@@ -155,6 +172,7 @@ export interface LoadedDocxEditorSession {
 interface ImportedDocxState {
   sourceBytes: Uint8Array;
   sourcePackage: OpcPackage;
+  sourceDocumentPartPath: string;
   sourceDocumentRelationships: readonly OpcRelationship[];
   sourceDocumentAttributes: Record<string, string>;
   sourceNumberingPartPath?: string;
@@ -216,7 +234,11 @@ export function loadDocxEditorSession(
     );
   }
 
-  const brokenRelationshipIssues = collectBrokenInternalRelationshipIssues(sourcePackage);
+  const mainDocumentPath = resolveMainDocumentPartPath(sourcePackage);
+  const brokenRelationshipIssues = collectBrokenInternalRelationshipIssues(
+    sourcePackage,
+    mainDocumentPath,
+  );
   if (brokenRelationshipIssues.length > 0) {
     return createDiagnosticsSession(
       options,
@@ -233,8 +255,7 @@ export function loadDocxEditorSession(
     );
   }
 
-  const documentPart = sourcePackage.parts.get(MAIN_DOCUMENT_PATH);
-  if (!documentPart) {
+  if (!mainDocumentPath) {
     return createDiagnosticsSession(
       options,
       createPackageImportDiagnostics({
@@ -243,11 +264,30 @@ export function loadDocxEditorSession(
     );
   }
 
+  const documentPart = sourcePackage.parts.get(mainDocumentPath);
+  if (!documentPart) {
+    return createDiagnosticsSession(
+      options,
+      createPackageImportDiagnostics({
+        issue: createMissingPartIssue(mainDocumentPath),
+      }),
+    );
+  }
+  if (documentPart.contentType !== MAIN_DOCUMENT_CONTENT_TYPE) {
+    return createDiagnosticsSession(
+      options,
+      createValidationImportDiagnostics({
+        message: `DOCX main document part ${mainDocumentPath} must use content type ${MAIN_DOCUMENT_CONTENT_TYPE}.`,
+      }),
+    );
+  }
+
   try {
     const sourceDocumentXml = decodeUtf8(documentPart.bytes);
     const importedRevisions = parseRevisionsFromDocumentXml(sourceDocumentXml);
     const numberingPartPath = resolveDocumentRelatedPartPath(
       sourcePackage,
+      mainDocumentPath,
       documentPart.relationships,
       NUMBERING_RELATIONSHIP_TYPE,
       NUMBERING_PART_PATH,
@@ -262,27 +302,34 @@ export function loadDocxEditorSession(
       sourceDocumentXml,
       documentPart.relationships,
       mediaParts,
-      MAIN_DOCUMENT_PATH,
+      mainDocumentPath,
     );
     const normalizedDocument = normalizeParsedTextDocument(
       parsedDocument,
-      MAIN_DOCUMENT_PATH,
+      mainDocumentPath,
+    );
+    const commentsPartPath = resolveCommentsPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
     );
-    const commentsPartPath = resolveCommentsPartPath(sourcePackage, documentPart.relationships);
     const commentsExtendedPartPath = resolveDocumentRelatedPartPath(
       sourcePackage,
+      mainDocumentPath,
       documentPart.relationships,
       COMMENTS_EXTENDED_RELATIONSHIP_TYPE,
       COMMENTS_EXTENDED_PART_PATH,
     );
     const commentsIdsPartPath = resolveDocumentRelatedPartPath(
       sourcePackage,
+      mainDocumentPath,
       documentPart.relationships,
       COMMENTS_IDS_RELATIONSHIP_TYPE,
       COMMENTS_IDS_PART_PATH,
     );
     const peoplePartPath = resolveDocumentRelatedPartPath(
       sourcePackage,
+      mainDocumentPath,
       documentPart.relationships,
       PEOPLE_RELATIONSHIP_TYPE,
       PEOPLE_PART_PATH,
@@ -344,7 +391,7 @@ export function loadDocxEditorSession(
         continue;
       }
 
-      const partPath = resolveRelationshipTarget(MAIN_DOCUMENT_PATH, relationship);
+      const partPath = resolveRelationshipTarget(mainDocumentPath, relationship);
       const partBytes = sourcePackage.parts.get(partPath)?.bytes;
       if (!partBytes) {
         continue;
@@ -374,6 +421,7 @@ export function loadDocxEditorSession(
 
     const footnotesPartPath = resolveDocumentRelatedPartPath(
       sourcePackage,
+      mainDocumentPath,
       documentPart.relationships,
       FOOTNOTES_RELATIONSHIP_TYPE,
       FOOTNOTES_PART_PATH,
@@ -383,6 +431,7 @@ export function loadDocxEditorSession(
     )?.id;
     const endnotesPartPath = resolveDocumentRelatedPartPath(
       sourcePackage,
+      mainDocumentPath,
       documentPart.relationships,
       ENDNOTES_RELATIONSHIP_TYPE,
       ENDNOTES_PART_PATH,
@@ -409,7 +458,7 @@ export function loadDocxEditorSession(
         r.targetMode === "internal",
     );
     const themePartPath = themeRelationship
-      ? resolveRelationshipTarget(MAIN_DOCUMENT_PATH, themeRelationship)
+      ? resolveRelationshipTarget(mainDocumentPath, themeRelationship)
       : undefined;
     const parsedTheme =
       themePartPath && sourcePackage.parts.has(themePartPath)
@@ -444,6 +493,7 @@ export function loadDocxEditorSession(
         packageParts: {
           ...normalizedDocument.preservation.packageParts,
           ...collectPreservedPackageParts(sourcePackage, [
+            mainDocumentPath,
             numberingPartPath,
             commentsPartPath,
             commentsExtendedPartPath,
@@ -454,6 +504,7 @@ export function loadDocxEditorSession(
       },
       diagnostics: {
         warnings: [
+          ...createBrokenRelationshipWarnings(sourcePackage, mainDocumentPath),
           ...normalizedDocument.diagnostics.warnings,
           ...normalizedRevisions.diagnostics.map((diagnostic, index) => ({
             diagnosticId: `diagnostic:revision-import-${index + 1}`,
@@ -485,10 +536,12 @@ export function loadDocxEditorSession(
       timestamp,
       document,
       compatibility: toPublicCompatibilityReport(compatibility),
+      sourcePackage: createPersistedSourcePackage(sourceBytes, options.sourceLabel),
     });
     const importedState: ImportedDocxState = {
       sourceBytes: new Uint8Array(sourceBytes),
       sourcePackage,
+      sourceDocumentPartPath: mainDocumentPath,
       sourceDocumentRelationships: documentPart.relationships,
       sourceDocumentAttributes: extractDocumentRootAttributes(sourceDocumentXml),
       sourceNumberingPartPath: numberingPartPath,
@@ -736,7 +789,9 @@ function exportDocxEditorSession(
   }
 
   const exportSession = createExportSession(state.sourcePackage, [
-    MAIN_DOCUMENT_PATH,
+    state.sourceDocumentPartPath,
+    APP_PROPERTIES_PART_PATH,
+    CORE_PROPERTIES_PART_PATH,
     numberingPartPath,
     commentsPartPath,
     commentsExtendedPartPath,
@@ -746,7 +801,7 @@ function exportDocxEditorSession(
   ]);
 
   exportSession.replaceOwnedPart({
-    path: MAIN_DOCUMENT_PATH,
+    path: state.sourceDocumentPartPath,
     bytes: new TextEncoder().encode(annotatedDocument.documentXml),
     contentType: MAIN_DOCUMENT_CONTENT_TYPE,
     relationships: nextRelationships,
@@ -863,6 +918,8 @@ function exportDocxEditorSession(
     }
   }
 
+  ensureHostMetadataParts(exportSession, state.sourcePackage, currentDocument);
+
   return {
     bytes: exportSession.serialize(),
     mimeType: DOCX_MIME_TYPE,
@@ -881,6 +938,19 @@ function createImportedCanonicalDocument(input: {
   diagnostics: CanonicalDocumentEnvelope["diagnostics"];
   review: CanonicalDocumentEnvelope["review"];
 }): CanonicalDocumentEnvelope {
+  const paragraphStyles = Object.fromEntries(
+    [...collectReferencedParagraphStyleIds(input.content, input.subParts)]
+      .sort((left, right) => left.localeCompare(right))
+      .map((styleId) => [
+        styleId,
+        {
+          styleId,
+          displayName: styleId,
+          kind: "paragraph" as const,
+          isDefault: styleId === "Normal",
+        },
+      ]),
+  );
   return {
     schemaVersion: "cds/1.0.0",
     docId: createCanonicalDocumentId(input.documentId),
@@ -890,7 +960,7 @@ function createImportedCanonicalDocument(input: {
       customProperties: {},
     },
     styles: {
-      paragraphs: {},
+      paragraphs: paragraphStyles,
       characters: {},
       tables: {},
     },
@@ -904,15 +974,60 @@ function createImportedCanonicalDocument(input: {
   };
 }
 
+function collectReferencedParagraphStyleIds(
+  content: CanonicalDocumentEnvelope["content"],
+  subParts?: SubPartsCatalog,
+): Set<string> {
+  const styleIds = new Set<string>();
+
+  const visitBlocks = (blocks: ReadonlyArray<BlockNode>) => {
+    for (const block of blocks) {
+      if ("styleId" in block && typeof block.styleId === "string" && block.styleId.length > 0) {
+        styleIds.add(block.styleId);
+      }
+      if (block.type === "table") {
+        for (const row of block.rows) {
+          for (const cell of row.cells) {
+            visitBlocks(cell.children);
+          }
+        }
+      } else if (block.type === "sdt" || block.type === "custom_xml") {
+        visitBlocks(block.children);
+      }
+    }
+  };
+
+  visitBlocks(content.children);
+  if (subParts) {
+    for (const header of subParts.headers) {
+      visitBlocks(header.blocks);
+    }
+    for (const footer of subParts.footers) {
+      visitBlocks(footer.blocks);
+    }
+    if (subParts.footnoteCollection) {
+      for (const note of Object.values(subParts.footnoteCollection.footnotes)) {
+        visitBlocks(note.blocks);
+      }
+      for (const note of Object.values(subParts.footnoteCollection.endnotes)) {
+        visitBlocks(note.blocks);
+      }
+    }
+  }
+
+  return styleIds;
+}
+
 function createImportedSnapshot(input: {
   documentId: string;
   editorBuild: string;
   timestamp: string;
   document: CanonicalDocumentEnvelope;
   compatibility: PersistedEditorSnapshot["compatibility"];
+  sourcePackage?: PersistedEditorSnapshot["sourcePackage"];
 }): PersistedEditorSnapshot {
   return {
-    snapshotVersion: "persisted-editor-snapshot/1",
+    snapshotVersion: "persisted-editor-snapshot/2",
     schemaVersion: input.document.schemaVersion,
     documentId: input.documentId,
     docId: input.document.docId,
@@ -923,6 +1038,7 @@ function createImportedSnapshot(input: {
     canonicalDocument: input.document,
     compatibility: input.compatibility,
     warningLog: input.compatibility.warnings,
+    sourcePackage: input.sourcePackage,
   };
 }
 
@@ -1292,10 +1408,12 @@ function rangesIntersect(
 
 function resolveCommentsPartPath(
   sourcePackage: OpcPackage,
+  sourceDocumentPartPath: string,
   relationships: readonly OpcRelationship[],
 ): string | undefined {
   return resolveDocumentRelatedPartPath(
     sourcePackage,
+    sourceDocumentPartPath,
     relationships,
     COMMENTS_RELATIONSHIP_TYPE,
     COMMENTS_PART_PATH,
@@ -1304,6 +1422,7 @@ function resolveCommentsPartPath(
 
 function resolveDocumentRelatedPartPath(
   sourcePackage: OpcPackage,
+  sourceDocumentPartPath: string,
   relationships: readonly OpcRelationship[],
   relationshipType: string,
   fallbackPartPath: string,
@@ -1317,10 +1436,23 @@ function resolveDocumentRelatedPartPath(
     return sourcePackage.parts.has(fallbackPartPath) ? fallbackPartPath : undefined;
   }
 
-  const targetPath = resolveRelationshipTarget(MAIN_DOCUMENT_PATH, relationship);
+  const targetPath = resolveRelationshipTarget(sourceDocumentPartPath, relationship);
   return sourcePackage.parts.has(targetPath) ? targetPath : undefined;
 }
 
+function resolveMainDocumentPartPath(sourcePackage: OpcPackage): string | undefined {
+  const relationship = sourcePackage.manifest.packageRelationships.find(
+    (candidate) =>
+      candidate.type === OFFICE_DOCUMENT_RELATIONSHIP_TYPE &&
+      candidate.targetMode === "internal",
+  );
+  if (relationship) {
+    return resolveRelationshipTarget(null, relationship);
+  }
+
+  return sourcePackage.parts.has(MAIN_DOCUMENT_PATH) ? MAIN_DOCUMENT_PATH : undefined;
+}
+
 function toRuntimeCommentRecords(
   threads: readonly CommentThread[],
 ): Record<string, CommentThreadRecord> {
@@ -1547,6 +1679,7 @@ function hasNumberingEntries(catalog: NumberingCatalog): boolean {
 
 function collectBrokenInternalRelationshipIssues(
   sourcePackage: OpcPackage,
+  mainDocumentPath?: string,
 ): ReturnType<typeof createBrokenRelationshipIssue>[] {
   const brokenTargets = new Map<string, ReturnType<typeof createBrokenRelationshipIssue>>();
 
@@ -1556,7 +1689,15 @@ function collectBrokenInternalRelationshipIssues(
     }
 
     const target = resolveRelationshipTarget(null, relationship);
-    if (!sourcePackage.parts.has(target)) {
+    if (
+      !sourcePackage.parts.has(target) &&
+      isFatalBrokenRelationship({
+        relationshipSourcePath: null,
+        relationship,
+        targetPartPath: target,
+        mainDocumentPath,
+      })
+    ) {
       brokenTargets.set(
         `package:${relationship.id}:${target}`,
         createBrokenRelationshipIssue({
@@ -1575,7 +1716,15 @@ function collectBrokenInternalRelationshipIssues(
       }
 
       const target = resolveRelationshipTarget(part.path, relationship);
-      if (!sourcePackage.parts.has(target)) {
+      if (
+        !sourcePackage.parts.has(target) &&
+        isFatalBrokenRelationship({
+          relationshipSourcePath: part.path,
+          relationship,
+          targetPartPath: target,
+          mainDocumentPath,
+        })
+      ) {
         brokenTargets.set(
           `${part.path}:${relationship.id}:${target}`,
           createBrokenRelationshipIssue({
@@ -1604,6 +1753,82 @@ function summarizeBrokenRelationshipIssues(
     .join(", ")}${issues.length > 3 ? ", ..." : ""}.`;
 }
 
+function createBrokenRelationshipWarnings(
+  sourcePackage: OpcPackage,
+  mainDocumentPath?: string,
+): CanonicalDocumentEnvelope["diagnostics"]["warnings"] {
+  const warnings = new Map<string, CanonicalDocumentEnvelope["diagnostics"]["warnings"][number]>();
+
+  for (const relationship of sourcePackage.manifest.packageRelationships) {
+    if (relationship.targetMode !== "internal") {
+      continue;
+    }
+
+    const target = resolveRelationshipTarget(null, relationship);
+    if (
+      sourcePackage.parts.has(target) ||
+      isFatalBrokenRelationship({
+        relationshipSourcePath: null,
+        relationship,
+        targetPartPath: target,
+        mainDocumentPath,
+      })
+    ) {
+      continue;
+    }
+
+    warnings.set(`package:${relationship.id}:${target}`, {
+      diagnosticId: `diagnostic:broken-relationship-package-${relationship.id}`,
+      warningId: `warning:broken-relationship:${relationship.id}`,
+      source: "preservation",
+      message: `DOCX package has unresolved internal relationships outside the editor-owned graph: ${target}.`,
+    });
+  }
+
+  for (const part of sourcePackage.parts.values()) {
+    for (const relationship of part.relationships) {
+      if (relationship.targetMode !== "internal") {
+        continue;
+      }
+
+      const target = resolveRelationshipTarget(part.path, relationship);
+      if (
+        sourcePackage.parts.has(target) ||
+        isFatalBrokenRelationship({
+          relationshipSourcePath: part.path,
+          relationship,
+          targetPartPath: target,
+          mainDocumentPath,
+        })
+      ) {
+        continue;
+      }
+
+      warnings.set(`${part.path}:${relationship.id}:${target}`, {
+        diagnosticId: `diagnostic:broken-relationship-${relationship.id}`,
+        warningId: `warning:broken-relationship:${relationship.id}`,
+        source: "preservation",
+        message: `DOCX package has unresolved internal relationships outside the editor-owned graph: ${target}.`,
+      });
+    }
+  }
+
+  return [...warnings.values()];
+}
+
+function isFatalBrokenRelationship(input: {
+  relationshipSourcePath: string | null;
+  relationship: OpcRelationship;
+  targetPartPath: string;
+  mainDocumentPath?: string;
+}): boolean {
+  return (
+    input.relationshipSourcePath === null &&
+    input.relationship.type === OFFICE_DOCUMENT_RELATIONSHIP_TYPE &&
+    input.targetPartPath === input.mainDocumentPath
+  );
+}
+
 function shouldPreservePackagePart(
   partPath: string,
   surfaceKind: OpcPackage["parts"] extends Map<string, infer T>
@@ -1618,7 +1843,6 @@ function shouldPreservePackagePart(
   }
 
   if (
-    partPath === MAIN_DOCUMENT_PATH ||
     ownedPartPaths.has(partPath) ||
     partPath.startsWith("/word/media/") ||
     CORE_NON_PRESERVED_PART_PATHS.has(partPath)
@@ -1700,13 +1924,7 @@ function isPackageImportError(error: unknown): boolean {
 const CORE_NON_PRESERVED_PART_PATHS = new Set([
   "/docProps/app.xml",
   "/docProps/core.xml",
-  "/docProps/custom.xml",
-  "/word/fontTable.xml",
   "/word/numbering.xml",
-  "/word/settings.xml",
-  "/word/styles.xml",
-  "/word/stylesWithEffects.xml",
-  "/word/webSettings.xml",
 ]);
 
 function createCommentsRelationshipId(
@@ -1751,6 +1969,10 @@ function canReuseSourceBytesForCurrentDocument(
   state: ImportedDocxState,
   document: CanonicalDocumentEnvelope,
 ): boolean {
+  if (requiresHostMetadataNormalization(state.sourcePackage, state.sourceDocumentPartPath)) {
+    return false;
+  }
+
   const commentThreads = Object.values(document.review.comments);
   const hasLiveComments = commentThreads.some((thread) => thread.anchor.kind !== "detached");
   if (!hasLiveComments) {
@@ -1764,3 +1986,151 @@ function canReuseSourceBytesForCurrentDocument(
       state.sourcePeoplePartPath,
   );
 }
+
+function requiresHostMetadataNormalization(
+  sourcePackage: OpcPackage,
+  sourceDocumentPartPath: string,
+): boolean {
+  return (
+    isSuspiciouslySkeletalWordPackage(sourcePackage, sourceDocumentPartPath) &&
+    !hasHostSafeMetadataPackageStructure(sourcePackage)
+  );
+}
+
+function ensureHostMetadataParts(
+  exportSession: ReturnType<typeof createExportSession>,
+  sourcePackage: OpcPackage,
+  document: CanonicalDocumentEnvelope,
+): void {
+  const corePropertiesPart = sourcePackage.parts.get(CORE_PROPERTIES_PART_PATH);
+  if (!corePropertiesPart || corePropertiesPart.contentType !== CORE_PROPERTIES_CONTENT_TYPE) {
+    exportSession.replaceOwnedPart({
+      path: CORE_PROPERTIES_PART_PATH,
+      bytes: corePropertiesPart?.bytes ?? new TextEncoder().encode(buildCorePropertiesXml(document)),
+      contentType: CORE_PROPERTIES_CONTENT_TYPE,
+      compression: corePropertiesPart?.compression,
+    });
+  }
+
+  const appPropertiesPart = sourcePackage.parts.get(APP_PROPERTIES_PART_PATH);
+  if (!appPropertiesPart || appPropertiesPart.contentType !== APP_PROPERTIES_CONTENT_TYPE) {
+    exportSession.replaceOwnedPart({
+      path: APP_PROPERTIES_PART_PATH,
+      bytes: appPropertiesPart?.bytes ?? new TextEncoder().encode(buildAppPropertiesXml()),
+      contentType: APP_PROPERTIES_CONTENT_TYPE,
+      compression: appPropertiesPart?.compression,
+    });
+  }
+
+  exportSession.ensurePackageRelationship({
+    type: CORE_PROPERTIES_RELATIONSHIP_TYPE,
+    target: CORE_PROPERTIES_PART_PATH,
+    preferredId: "rIdDocPropsCore",
+  });
+  exportSession.ensurePackageRelationship({
+    type: APP_PROPERTIES_RELATIONSHIP_TYPE,
+    target: APP_PROPERTIES_PART_PATH,
+    preferredId: "rIdDocPropsApp",
+  });
+}
+
+function hasHostSafeMetadataPackageStructure(sourcePackage: OpcPackage): boolean {
+  const corePropertiesPart = sourcePackage.parts.get(CORE_PROPERTIES_PART_PATH);
+  const appPropertiesPart = sourcePackage.parts.get(APP_PROPERTIES_PART_PATH);
+  return (
+    corePropertiesPart?.contentType === CORE_PROPERTIES_CONTENT_TYPE &&
+    appPropertiesPart?.contentType === APP_PROPERTIES_CONTENT_TYPE &&
+    hasPackageRelationshipTarget(
+      sourcePackage,
+      CORE_PROPERTIES_RELATIONSHIP_TYPE,
+      CORE_PROPERTIES_PART_PATH,
+    ) &&
+    hasPackageRelationshipTarget(
+      sourcePackage,
+      APP_PROPERTIES_RELATIONSHIP_TYPE,
+      APP_PROPERTIES_PART_PATH,
+    )
+  );
+}
+
+function hasPackageRelationshipTarget(
+  sourcePackage: OpcPackage,
+  relationshipType: string,
+  targetPartPath: string,
+): boolean {
+  return sourcePackage.manifest.packageRelationships.some(
+    (relationship) =>
+      relationship.type === relationshipType &&
+      relationship.targetMode === "internal" &&
+      resolveRelationshipTarget(null, relationship) === targetPartPath,
+  );
+}
+
+function isSuspiciouslySkeletalWordPackage(
+  sourcePackage: OpcPackage,
+  sourceDocumentPartPath: string,
+): boolean {
+  const allowedPaths = new Set<string>([
+    CONTENT_TYPES_PATH,
+    PACKAGE_RELATIONSHIPS_PATH,
+    sourceDocumentPartPath,
+  ]);
+  const relationshipsPartPath = getRelationshipsPartPath(sourceDocumentPartPath);
+  if (relationshipsPartPath) {
+    allowedPaths.add(relationshipsPartPath);
+  }
+
+  return [...sourcePackage.parts.keys()].every((partPath) => allowedPaths.has(partPath));
+}
+
+function buildCorePropertiesXml(document: CanonicalDocumentEnvelope): string {
+  const { metadata } = document;
+  const keywords =
+    Array.isArray(metadata.keywords) && metadata.keywords.length > 0
+      ? metadata.keywords.join(", ")
+      : undefined;
+  const propertyLines = [
+    xmlNode("dc:title", metadata.title),
+    xmlNode("dc:subject", metadata.subject),
+    xmlNode("dc:description", metadata.description),
+    xmlNode("dc:language", metadata.language),
+    xmlNode("cp:keywords", keywords),
+    xmlNode("cp:category", metadata.category),
+    xmlNode('dcterms:created xsi:type="dcterms:W3CDTF"', document.createdAt),
+    xmlNode('dcterms:modified xsi:type="dcterms:W3CDTF"', document.updatedAt),
+  ].filter((line): line is string => Boolean(line));
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">`,
+    ...propertyLines.map((line) => `  ${line}`),
+    `</cp:coreProperties>`,
+  ].join("\n");
+}
+
+function buildAppPropertiesXml(): string {
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">`,
+    `  <Application>React OOXML Office</Application>`,
+    `  <AppVersion>1.0</AppVersion>`,
+    `</Properties>`,
+  ].join("\n");
+}
+
+function xmlNode(tagName: string, value: string | undefined): string | undefined {
+  if (typeof value !== "string" || value.length === 0) {
+    return undefined;
+  }
+
+  return `<${tagName}>${escapeXml(value)}</${tagName.split(" ", 1)[0]}>`;
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/\"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}