@beyondwork/docx-react-component 1.0.66 → 1.0.69

package/src/session/export/stateful-export.ts

@@ -0,0 +1,684 @@
+/**
+ * `runStatefulExport` — session-layer owner of the stateful export
+ * pipeline.
+ *
+ * Slice 5e-7.f relocates the body of `exportDocxEditorSession` from
+ * `src/io/docx-session.ts` into this module. Legacy callers reach the
+ * pipeline through `LoadedDocxEditorSession.exportDocx` (closure
+ * captured at open time by the session-layer loader) or directly via
+ * `DocxSession.export()` — no public `exportDocxEditorSession` export
+ * exists anymore; the function was private to `docx-session.ts`.
+ *
+ * Stateful: the pipeline needs the `ImportedDocxState` captured at
+ * open time (source bytes, `OpcPackage`, per-part relationships,
+ * preserved-part manifest, `sourceDocumentRelationships`,
+ * `sourceDocumentAttributes`, `initialCanonicalSignature`, etc.). The
+ * byte-reuse fast path (signature match + `canReuseSourceBytesForCurrentDocument`)
+ * returns the original bytes unchanged when no edits have been made.
+ */
+
+import type {
+  EditorSessionState,
+  ExportDocxOptions,
+  ExportResult,
+  PersistedEditorSnapshot,
+} from "../../api/public-types.ts";
+import type {
+  CanonicalDocument,
+  MediaCatalog,
+  NumberingCatalog,
+  SubPartsCatalog,
+} from "../../model/canonical-document.ts";
+import {
+  commentRecordsToReviewThreads,
+} from "../../model/review/comment-types.ts";
+import {
+  getRevisionActionability,
+} from "../../model/review/revision-types.ts";
+import { DOCX_MIME_TYPE } from "../../io/opc/docx-package.ts";
+import { createExportSession } from "../../io/export/export-session.ts";
+import { serializeMainDocument } from "../../io/export/serialize-main-document.ts";
+import {
+  serializeSettingsXml,
+  WORD_SETTINGS_CONTENT_TYPE,
+} from "../../io/export/serialize-settings.ts";
+import {
+  createCommentExportIdMap,
+  serializeCommentAnchorsIntoDocumentXml,
+  serializeMergedCommentsXml,
+} from "../../io/export/serialize-comments.ts";
+import { splitDocumentAtReviewBoundaries } from "../../io/export/split-review-boundaries.ts";
+import { splitStoryBlocksForRuntimeRevisions } from "../../io/export/split-story-blocks-for-runtime-revisions.ts";
+import {
+  serializeRuntimeRevisionsIntoDocumentXml,
+} from "../../io/export/serialize-runtime-revisions.ts";
+import {
+  WORD_NUMBERING_CONTENT_TYPE,
+  hasSerializableNumberingEntries,
+  serializeNumberingXml,
+} from "../../io/export/serialize-numbering.ts";
+import {
+  serializeHeaderXmlWithRevisions,
+  serializeFooterXmlWithRevisions,
+  WORD_HEADER_CONTENT_TYPE,
+  WORD_FOOTER_CONTENT_TYPE,
+} from "../../io/export/serialize-headers-footers.ts";
+import {
+  serializeFootnotesXml,
+  serializeEndnotesXml,
+  WORD_FOOTNOTES_CONTENT_TYPE,
+  WORD_ENDNOTES_CONTENT_TYPE,
+} from "../../io/export/serialize-footnotes.ts";
+import {
+  getDocumentBackedWorkflowMetadata,
+  resolvePayloadPartPath,
+  resolveWorkflowPayloadPartPaths,
+  WORKFLOW_PAYLOAD_CUSTOM_PROPS_PART_PATH,
+} from "../../io/ooxml/workflow-payload.ts";
+import {
+  serializeSecondaryStoryWithRuntimeRevisions,
+  stripCommentMarkup,
+  toReviewRevisionRecords,
+} from "../import/review-import.ts";
+import { toEditorSessionState } from "../import/canonical-assembly.ts";
+import {
+  serializeCanonicalDocumentForExport,
+} from "../shared/session-utils.ts";
+import { withDocumentRelatedParts } from "../import/package-parts.ts";
+import {
+  APP_PROPERTIES_PART_PATH,
+  CORE_PROPERTIES_PART_PATH,
+  canReuseSourceBytesForCurrentDocument,
+  ensureHostMetadataParts,
+  ensureWorkflowPayloadParts,
+  serializeProtectionRangesIntoDocumentXml,
+} from "./stateful-export-pipeline.ts";
+import {
+  assertExportNotBlockedByCompatibility,
+  assertNoBlockingPreservedComments,
+  assertNoBlockingSkippedComments,
+  assertNoSkippedRevisions,
+} from "./export-validation.ts";
+import {
+  groupFooterRevisionsByPartPath,
+  groupHeaderRevisionsByPartPath,
+  groupNoteRevisionsByNoteId,
+} from "./serialize-dispatch.ts";
+import {
+  COMMENTS_CONTENT_TYPE,
+  COMMENTS_EXTENDED_CONTENT_TYPE,
+  COMMENTS_EXTENDED_PART_PATH,
+  COMMENTS_EXTENDED_RELATIONSHIP_TYPE,
+  COMMENTS_IDS_CONTENT_TYPE,
+  COMMENTS_IDS_PART_PATH,
+  COMMENTS_IDS_RELATIONSHIP_TYPE,
+  MAIN_DOCUMENT_CONTENT_TYPE,
+  NUMBERING_PART_PATH,
+  NUMBERING_RELATIONSHIP_TYPE,
+  PEOPLE_CONTENT_TYPE,
+  PEOPLE_PART_PATH,
+  PEOPLE_RELATIONSHIP_TYPE,
+  SETTINGS_PART_PATH,
+} from "../import/part-constants.ts";
+import {
+  COMMENTS_PART_PATH,
+  COMMENTS_RELATIONSHIP_TYPE,
+} from "../import/part-discovery.ts";
+import type { ImportedDocxState } from "../import/loader-types.ts";
+import {
+  buildEmbeddingsInlinePayload,
+  type EmbeddingOffloadEntry,
+} from "../import/embedded-offload.ts";
+import { reconstituteEmbeddedDocuments } from "./embedded-reconstitute.ts";
+
+/**
+ * Stateful export orchestrator. Body is byte-for-byte the pre-5e-7.f
+ * `exportDocxEditorSession` that was private to
+ * `src/io/docx-session.ts`; only the imports were redirected to
+ * session-layer homes.
+ */
+export async function runStatefulExport(
+  state: ImportedDocxState,
+  sessionStateOrSnapshot: EditorSessionState | PersistedEditorSnapshot,
+  options?: ExportDocxOptions,
+): Promise<ExportResult> {
+  const sessionState = toEditorSessionState(sessionStateOrSnapshot);
+
+  assertExportNotBlockedByCompatibility(sessionState.compatibility);
+
+  const currentDocument = sessionState.canonicalDocument as CanonicalDocument;
+  const signatureMatch = serializeCanonicalDocumentForExport(currentDocument) ===
+      state.initialCanonicalSignature;
+  const canReuse = canReuseSourceBytesForCurrentDocument(state, currentDocument);
+  const durableWorkflowMetadata = getDocumentBackedWorkflowMetadata(sessionState.workflowMetadata);
+  const hasWorkflowOverlay = Boolean(sessionState.workflowOverlay);
+  const sourceHasWorkflowPayload = resolvePayloadPartPath(state.sourcePackage) !== null;
+  // Schema 1.2: runtime may have registered metadata entries via
+  // `setWorkflowMetadataEntries` (or `addScope({persistence:'document-metadata'})`)
+  // that don't pass the document-backed filter but still represent session
+  // state that must survive export → reload via the editorState namespace.
+  // W10: class-A overlay-visibility policies also force a rewrite —
+  // otherwise authored policy set via `handle.workflow.setVisibilityPolicy`
+  // on an unchanged document silently drops on export.
+  const hasRuntimeWorkflowMetadata = Boolean(
+    (sessionState.workflowMetadata?.definitions.length ?? 0) > 0 ||
+      (sessionState.workflowMetadata?.entries.length ?? 0) > 0 ||
+      (sessionState.visibilityPolicies?.length ?? 0) > 0 ||
+      sessionState.markupModePolicy != null,
+  );
+  const commentCount = Object.keys(currentDocument.review?.comments ?? {}).length;
+  const currentRevisions = toReviewRevisionRecords(currentDocument.review.revisions);
+  const hasActiveImportedPreserveOnlyRevisions = currentRevisions.some(
+    (revision) =>
+      revision.status === "active" &&
+      revision.metadata.source === "import" &&
+      typeof revision.metadata.preserveOnlyReason === "string" &&
+      revision.metadata.preserveOnlyReason.length > 0,
+  );
+
+  if (
+    signatureMatch &&
+    canReuse &&
+    durableWorkflowMetadata.definitions.length === 0 &&
+    durableWorkflowMetadata.entries.length === 0 &&
+    !hasWorkflowOverlay &&
+    !sourceHasWorkflowPayload &&
+    !hasRuntimeWorkflowMetadata
+  ) {
+    return {
+      bytes: new Uint8Array(state.sourceBytes),
+      mimeType: DOCX_MIME_TYPE,
+      fileName: options?.fileName ?? `${sessionState.documentId}.docx`,
+      delivery: {
+        mode: "exported-bytes-only",
+      },
+    };
+  }
+  const preservedCommentIds = new Set(
+    state.preservedCommentDefinitions.map((definition) => definition.commentId),
+  );
+  const blockingCommentCount = Math.max(
+    state.blockingCommentDiagnostics.length,
+    preservedCommentIds.size,
+  );
+  assertNoBlockingPreservedComments(
+    blockingCommentCount,
+    [...preservedCommentIds],
+  );
+  const actionableRevisions = currentRevisions.filter(
+    (revision) => getRevisionActionability(revision) === "actionable",
+  );
+  const mainStoryActionableRevisions = actionableRevisions.filter((revision) =>
+    !revision.metadata.storyTarget?.kind || revision.metadata.storyTarget.kind === "main"
+  );
+  const commentThreads = commentRecordsToReviewThreads(
+    currentDocument.review.comments,
+  );
+  const ownedCommentThreads = commentThreads.filter(
+    (thread) => !preservedCommentIds.has(thread.commentId),
+  );
+  const revisionReadyMainContent = {
+    ...currentDocument.content,
+    children: splitStoryBlocksForRuntimeRevisions(
+      currentDocument.content.children,
+      mainStoryActionableRevisions,
+    ),
+  };
+  const serialized = serializeMainDocument(
+    splitDocumentAtReviewBoundaries(
+      revisionReadyMainContent as never,
+      ownedCommentThreads,
+      mainStoryActionableRevisions,
+    ) as never,
+    currentDocument.preservation as never,
+    state.sourceDocumentRelationships,
+    {
+      documentAttributes: state.sourceDocumentAttributes,
+      media: currentDocument.media as MediaCatalog,
+      finalSectionProperties: currentDocument.subParts?.finalSectionProperties,
+      namespaceFlavor: options?.exportStrictOoxml ? "strict" : "transitional",
+    },
+  );
+  const revisionDocument = serializeRuntimeRevisionsIntoDocumentXml(
+    serialized.documentXml,
+    mainStoryActionableRevisions,
+  );
+  assertNoSkippedRevisions(revisionDocument.skippedRevisionIds);
+
+  const strippedDocumentXml = stripCommentMarkup(
+    revisionDocument.documentXml,
+    ownedCommentThreads.map((thread) => thread.commentId),
+  );
+  const exportCommentIds = createCommentExportIdMap(
+    ownedCommentThreads,
+    state.preservedCommentDefinitions,
+  );
+  const serializedComments = serializeMergedCommentsXml(ownedCommentThreads, {
+    exportCommentIds,
+    preservedDefinitions: state.preservedCommentDefinitions,
+    sourceRootTag: state.sourceCommentsRootTag,
+    sourceExtendedRootTag: state.sourceCommentsExtendedRootTag,
+    sourceIdsRootTag: state.sourceCommentsIdsRootTag,
+    sourcePeopleRootTag: state.sourcePeopleRootTag,
+    peopleAuthors: state.sourcePeopleAuthors,
+  });
+  const annotatedDocument = serializeCommentAnchorsIntoDocumentXml(
+    strippedDocumentXml,
+    ownedCommentThreads,
+    undefined,
+    {
+      exportCommentIds,
+    },
+  );
+  const protectedDocumentXml = serializeProtectionRangesIntoDocumentXml(
+    annotatedDocument.documentXml,
+    state.protectionSnapshot,
+  );
+  const blockingSkippedCommentIds = annotatedDocument.skippedCommentIds.filter((commentId) => {
+    const thread = ownedCommentThreads.find((candidate) => candidate.commentId === commentId);
+    return !thread || thread.anchor.kind !== "detached";
+  });
+  assertNoBlockingSkippedComments(blockingSkippedCommentIds);
+  const commentsPartPath =
+    state.sourceCommentsPartPath ?? COMMENTS_PART_PATH;
+  const commentsExtendedPartPath =
+    state.sourceCommentsExtendedPartPath ?? COMMENTS_EXTENDED_PART_PATH;
+  const commentsIdsPartPath =
+    state.sourceCommentsIdsPartPath ?? COMMENTS_IDS_PART_PATH;
+  const peoplePartPath =
+    state.sourcePeoplePartPath ?? PEOPLE_PART_PATH;
+  const numberingPartPath =
+    state.sourceNumberingPartPath ?? NUMBERING_PART_PATH;
+  const serializedNumberingXml = hasSerializableNumberingEntries(
+    currentDocument.numbering as NumberingCatalog,
+  )
+    ? serializeNumberingXml(currentDocument.numbering as NumberingCatalog)
+    : undefined;
+  const nextRelationships = withDocumentRelatedParts(
+    serialized.relationships,
+    [
+      {
+        relationshipType: NUMBERING_RELATIONSHIP_TYPE,
+        partPath: numberingPartPath,
+        existingRelationshipId: state.sourceNumberingRelationshipId,
+        include:
+          Boolean(serializedNumberingXml) ||
+          Boolean(state.sourceNumberingPartPath),
+      },
+      {
+        relationshipType: COMMENTS_RELATIONSHIP_TYPE,
+        partPath: commentsPartPath,
+        existingRelationshipId: state.sourceCommentsRelationshipId,
+        include:
+          serializedComments.serializedCommentIds.length > 0 ||
+          Boolean(state.sourceCommentsPartPath),
+      },
+      {
+        relationshipType: COMMENTS_EXTENDED_RELATIONSHIP_TYPE,
+        partPath: commentsExtendedPartPath,
+        existingRelationshipId: state.sourceCommentsExtendedRelationshipId,
+        include:
+          Boolean(serializedComments.commentsExtendedXml) ||
+          Boolean(state.sourceCommentsExtendedPartPath),
+      },
+      {
+        relationshipType: COMMENTS_IDS_RELATIONSHIP_TYPE,
+        partPath: commentsIdsPartPath,
+        existingRelationshipId: state.sourceCommentsIdsRelationshipId,
+        include:
+          Boolean(serializedComments.commentsIdsXml) ||
+          Boolean(state.sourceCommentsIdsPartPath),
+      },
+      {
+        relationshipType: PEOPLE_RELATIONSHIP_TYPE,
+        partPath: peoplePartPath,
+        existingRelationshipId: state.sourcePeopleRelationshipId,
+        include:
+          Boolean(serializedComments.peopleXml) ||
+          Boolean(state.sourcePeoplePartPath),
+      },
+    ],
+  );
+
+  const exportedSubParts = currentDocument.subParts as SubPartsCatalog | undefined;
+  const subPartOwnedPaths: string[] = [];
+  if (exportedSubParts) {
+    for (const header of exportedSubParts.headers) {
+      subPartOwnedPaths.push(header.partPath);
+    }
+    for (const footer of exportedSubParts.footers) {
+      subPartOwnedPaths.push(footer.partPath);
+    }
+    if (exportedSubParts.footnoteCollection) {
+      if (state.sourceSubPartPaths.footnotesPartPath) {
+        subPartOwnedPaths.push(state.sourceSubPartPaths.footnotesPartPath);
+      }
+      if (state.sourceSubPartPaths.endnotesPartPath) {
+        subPartOwnedPaths.push(state.sourceSubPartPaths.endnotesPartPath);
+      }
+    }
+    if (exportedSubParts.theme && state.sourceSubPartPaths.themePartPath) {
+      subPartOwnedPaths.push(state.sourceSubPartPaths.themePartPath);
+    }
+  }
+
+  // Settings.xml is owned when the source package carried one OR the canonical
+  // model carries settings we need to re-emit. The `canReuse && signatureMatch`
+  // short-circuit above already skips re-export entirely for no-edit sessions,
+  // so every path that reaches here is willing to emit a rebuilt settings.xml.
+  const settingsPartPath =
+    state.sourceSettingsPartPath ?? SETTINGS_PART_PATH;
+  const hasSettingsSurface =
+    Boolean(state.sourceSettingsPartPath) ||
+    exportedSubParts?.settings !== undefined;
+  const workflowPayloadPartPaths = resolveWorkflowPayloadPartPaths(
+    state.sourcePackage,
+    sessionState.documentId,
+  );
+  const internalEditorState = (
+    options as { _editorState?: import("../../io/ooxml/workflow-payload.ts").EditorStatePayload } | undefined
+  )?._editorState;
+
+  // P8 Step 7: narrow the opaque `state.embeddingOffloadEntries` list
+  // (typed `readonly unknown[]` on `ImportedDocxState` to keep the
+  // session-layer types file P6-clean) into the concrete entry shape
+  // the reconstitute pass needs. The entries were already validated
+  // by `hydrateOffloadEntriesFromPayload` or produced by
+  // `processEmbeddedOffload` — they are structurally sound.
+  const offloadEntries = state.embeddingOffloadEntries as readonly EmbeddingOffloadEntry[];
+  const offloadOwnedPaths = offloadEntries.map((entry) => entry.sourcePartPath);
+
+  const exportSession = createExportSession(state.sourcePackage, [
+    state.sourceDocumentPartPath,
+    APP_PROPERTIES_PART_PATH,
+    CORE_PROPERTIES_PART_PATH,
+    workflowPayloadPartPaths.payloadPartPath,
+    workflowPayloadPartPaths.itemPropsPartPath,
+    WORKFLOW_PAYLOAD_CUSTOM_PROPS_PART_PATH,
+    numberingPartPath,
+    commentsPartPath,
+    commentsExtendedPartPath,
+    commentsIdsPartPath,
+    peoplePartPath,
+    ...(hasSettingsSurface ? [settingsPartPath] : []),
+    ...subPartOwnedPaths,
+    ...offloadOwnedPaths,
+  ]);
+
+  const mainDocumentXmlForExport =
+    signatureMatch &&
+    durableWorkflowMetadata.definitions.length === 0 &&
+    durableWorkflowMetadata.entries.length === 0 &&
+    !hasWorkflowOverlay &&
+    commentCount === 0 &&
+    hasActiveImportedPreserveOnlyRevisions
+      ? state.sourceDocumentXml
+      : protectedDocumentXml;
+
+  exportSession.replaceOwnedPart({
+    path: state.sourceDocumentPartPath,
+    bytes: new TextEncoder().encode(mainDocumentXmlForExport),
+    contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+    relationships: nextRelationships,
+  });
+
+  if (serializedNumberingXml || state.sourceNumberingPartPath) {
+    exportSession.replaceOwnedPart({
+      path: numberingPartPath,
+      bytes: new TextEncoder().encode(
+        serializedNumberingXml ??
+          `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"></w:numbering>`,
+      ),
+      contentType:
+        state.sourcePackage.parts.get(numberingPartPath)?.contentType ??
+        WORD_NUMBERING_CONTENT_TYPE,
+    });
+  }
+
+  if (hasSettingsSurface) {
+    // Canonical settings ∅ + no source settings → omit the owned-part write
+    // (hasSettingsSurface is already false in that case). Otherwise route
+    // through the graft serializer so unmodelled children round-trip via
+    // source bytes while canonical mutations land.
+    const canonicalSettings = exportedSubParts?.settings ?? {};
+    const settingsXml = serializeSettingsXml(canonicalSettings, state.sourceSettingsXml);
+    exportSession.replaceOwnedPart({
+      path: settingsPartPath,
+      bytes: new TextEncoder().encode(settingsXml),
+      contentType:
+        state.sourcePackage.parts.get(settingsPartPath)?.contentType ??
+        WORD_SETTINGS_CONTENT_TYPE,
+    });
+  }
+
+  if (serializedComments.serializedCommentIds.length > 0 || state.sourceCommentsPartPath) {
+    exportSession.replaceOwnedPart({
+      path: commentsPartPath,
+      bytes: new TextEncoder().encode(serializedComments.commentsXml),
+      contentType:
+        state.sourcePackage.parts.get(commentsPartPath)?.contentType ?? COMMENTS_CONTENT_TYPE,
+    });
+  }
+
+  if (serializedComments.commentsExtendedXml || state.sourceCommentsExtendedPartPath) {
+    exportSession.replaceOwnedPart({
+      path: commentsExtendedPartPath,
+      bytes: new TextEncoder().encode(
+        serializedComments.commentsExtendedXml ?? `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w15:commentsEx xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml"></w15:commentsEx>`,
+      ),
+      contentType:
+        state.sourcePackage.parts.get(commentsExtendedPartPath)?.contentType ??
+        COMMENTS_EXTENDED_CONTENT_TYPE,
+    });
+  }
+
+  if (serializedComments.commentsIdsXml || state.sourceCommentsIdsPartPath) {
+    exportSession.replaceOwnedPart({
+      path: commentsIdsPartPath,
+      bytes: new TextEncoder().encode(
+        serializedComments.commentsIdsXml ?? `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w16cid:commentsIds xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid"></w16cid:commentsIds>`,
+      ),
+      contentType:
+        state.sourcePackage.parts.get(commentsIdsPartPath)?.contentType ??
+        COMMENTS_IDS_CONTENT_TYPE,
+    });
+  }
+
+  if (serializedComments.peopleXml || state.sourcePeoplePartPath) {
+    exportSession.replaceOwnedPart({
+      path: peoplePartPath,
+      bytes: new TextEncoder().encode(
+        serializedComments.peopleXml ?? `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w15:people xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml"></w15:people>`,
+      ),
+      contentType:
+        state.sourcePackage.parts.get(peoplePartPath)?.contentType ??
+        PEOPLE_CONTENT_TYPE,
+    });
+  }
+
+  if (exportedSubParts) {
+    const headersByPartPath = groupHeaderRevisionsByPartPath(
+      exportedSubParts.headers,
+      actionableRevisions,
+      (revision) => revision.metadata.storyTarget,
+    );
+    for (const { header, revisions } of headersByPartPath.values()) {
+      const serializedHeaderXml = serializeSecondaryStoryWithRuntimeRevisions(
+        serializeHeaderXmlWithRevisions(header, revisions),
+        revisions,
+        `header ${header.partPath}`,
+      );
+      exportSession.replaceOwnedPart({
+        path: header.partPath,
+        bytes: new TextEncoder().encode(serializedHeaderXml),
+        contentType:
+          state.sourcePackage.parts.get(header.partPath)?.contentType ?? WORD_HEADER_CONTENT_TYPE,
+      });
+    }
+    const footersByPartPath = groupFooterRevisionsByPartPath(
+      exportedSubParts.footers,
+      actionableRevisions,
+      (revision) => revision.metadata.storyTarget,
+    );
+    for (const { footer, revisions } of footersByPartPath.values()) {
+      const serializedFooterXml = serializeSecondaryStoryWithRuntimeRevisions(
+        serializeFooterXmlWithRevisions(footer, revisions),
+        revisions,
+        `footer ${footer.partPath}`,
+      );
+      exportSession.replaceOwnedPart({
+        path: footer.partPath,
+        bytes: new TextEncoder().encode(serializedFooterXml),
+        contentType:
+          state.sourcePackage.parts.get(footer.partPath)?.contentType ?? WORD_FOOTER_CONTENT_TYPE,
+      });
+    }
+    if (exportedSubParts.footnoteCollection) {
+      if (state.sourceSubPartPaths.footnotesPartPath) {
+        const serializedFootnotesXml = serializeFootnotesXml(
+          exportedSubParts.footnoteCollection,
+          groupNoteRevisionsByNoteId(
+            actionableRevisions,
+            "footnote",
+            (revision) => revision.metadata.storyTarget,
+          ),
+        );
+        exportSession.replaceOwnedPart({
+          path: state.sourceSubPartPaths.footnotesPartPath,
+          bytes: new TextEncoder().encode(serializedFootnotesXml),
+          contentType:
+            state.sourcePackage.parts.get(state.sourceSubPartPaths.footnotesPartPath)?.contentType ??
+            WORD_FOOTNOTES_CONTENT_TYPE,
+        });
+      }
+      if (state.sourceSubPartPaths.endnotesPartPath) {
+        const serializedEndnotesXml = serializeEndnotesXml(
+          exportedSubParts.footnoteCollection,
+          groupNoteRevisionsByNoteId(
+            actionableRevisions,
+            "endnote",
+            (revision) => revision.metadata.storyTarget,
+          ),
+        );
+        exportSession.replaceOwnedPart({
+          path: state.sourceSubPartPaths.endnotesPartPath,
+          bytes: new TextEncoder().encode(serializedEndnotesXml),
+          contentType:
+            state.sourcePackage.parts.get(state.sourceSubPartPaths.endnotesPartPath)?.contentType ??
+            WORD_ENDNOTES_CONTENT_TYPE,
+          });
+      }
+    }
+    if (exportedSubParts.theme && state.sourceSubPartPaths.themePartPath) {
+      const sourceThemePart = state.sourcePackage.parts.get(state.sourceSubPartPaths.themePartPath);
+      if (sourceThemePart) {
+        exportSession.replaceOwnedPart({
+          path: state.sourceSubPartPaths.themePartPath,
+          bytes: sourceThemePart.bytes,
+          contentType:
+            sourceThemePart.contentType ??
+            "application/vnd.openxmlformats-officedocument.theme+xml",
+          relationships: sourceThemePart.relationships,
+          compression: sourceThemePart.compression,
+        });
+      }
+    }
+  }
+
+  ensureHostMetadataParts(exportSession, state.sourcePackage, currentDocument);
+
+  // P8 Step 7: reconstitute offloaded embedded documents back into
+  // the OPC package. For each entry captured at open time, try the
+  // host's `loadEmbeddedDocument` first; on null / rejection / throw,
+  // fall back to the inline-bytes base64 copy the entry carries. The
+  // source part paths were added to the export-session owned list
+  // above so `replaceOwnedPart` is valid. No-op when `offloadEntries`
+  // is empty (no offload occurred or the package carried no
+  // offloadable embeddings).
+  await reconstituteEmbeddedDocuments({
+    exportSession,
+    entries: offloadEntries,
+    hostAdapter: state.hostAdapter,
+  });
+
+  // P8 Step 7: fold the offload entries into the editor-state payload
+  // so the `bw:embeddings` customXml namespace round-trips to the
+  // next open. When no offload happened we pass through whatever the
+  // runtime collected unchanged.
+  const editorStateWithEmbeddings = extendEditorStateWithEmbeddings(
+    internalEditorState,
+    offloadEntries,
+  );
+
+  // Schema 1.2: pass through editorState payload collected by the
+  // runtime channel, with any offload entries folded in above.
+  ensureWorkflowPayloadParts(
+    exportSession,
+    sessionState,
+    currentDocument,
+    state.sourcePackage,
+    workflowPayloadPartPaths,
+    editorStateWithEmbeddings,
+  );
+
+  return {
+    bytes: exportSession.serialize(),
+    mimeType: DOCX_MIME_TYPE,
+    fileName: options?.fileName ?? `${sessionState.documentId}.docx`,
+    delivery: {
+      mode: "exported-bytes-only",
+    },
+  };
+}
+
+/**
+ * Fold P8 offload entries into the editor-state payload that
+ * `ensureWorkflowPayloadParts` writes into `customXml/item1.xml`.
+ *
+ * Schema: the `"embeddings"` namespace entry carries an inline JSON
+ * blob matching `EmbeddingsInlineSchema` (shape:
+ * `{ version: 1, entries: EmbeddingOffloadEntry[] }`). On reopen,
+ * `hydrateOffloadEntriesFromPayload` parses it back and the session
+ * skips the fresh `storeEmbeddedDocument` pass.
+ *
+ * Three cases:
+ *   1. No offload entries AND no existing payload — return undefined;
+ *      nothing to write, the customXml namespace is omitted.
+ *   2. No offload entries BUT there is a runtime-supplied payload —
+ *      pass it through unchanged.
+ *   3. Offload entries present — ensure the payload has an
+ *      `"embeddings"` namespace entry with the inline schema. Any
+ *      runtime-supplied `"embeddings"` entry is replaced (the
+ *      session owns this namespace per §P8).
+ */
+function extendEditorStateWithEmbeddings(
+  payload:
+    | import("../../io/ooxml/workflow-payload.ts").EditorStatePayload
+    | undefined,
+  offloadEntries: readonly EmbeddingOffloadEntry[],
+):
+  | import("../../io/ooxml/workflow-payload.ts").EditorStatePayload
+  | undefined {
+  if (offloadEntries.length === 0) {
+    return payload;
+  }
+  const inlineSchema = buildEmbeddingsInlinePayload(offloadEntries);
+  const embeddingsEntry: import(
+    "../../io/ooxml/workflow-payload.ts"
+  ).EditorStatePayloadNamespaceEntry = {
+    namespace: "embeddings",
+    schemaVersion: "bw-embeddings/1",
+    inline: inlineSchema,
+  };
+  if (!payload) {
+    return { entries: [embeddingsEntry] };
+  }
+  const filtered = payload.entries.filter(
+    (entry) => entry.namespace !== "embeddings",
+  );
+  const next = {
+    ...payload,
+    entries: [...filtered, embeddingsEntry],
+  };
+  return next;
+}