@beyondwork/docx-react-component 1.0.66 → 1.0.69

package/src/session/import/loader.ts

@@ -0,0 +1,1834 @@
+/**
+ * `loadDocxSessionAsync` — session-layer owner of the async load path.
+ *
+ * Slice 5e-7.e.1 relocates the body of `loadDocxEditorSessionAsync` from
+ * `src/io/docx-session.ts` into this module. The legacy symbol in
+ * `docx-session.ts` now delegates here in one function call so existing
+ * consumers (tests, services/debug, `DocxSession.open`) observe
+ * byte-identical behavior while the orchestration lives under
+ * `src/session/**`.
+ *
+ * Slice 5e-7.f: the export pipeline (`runStatefulExport` at
+ * `src/session/export/stateful-export.ts`) is imported directly —
+ * both load and export now live under `src/session/**`, so the earlier
+ * `LoaderDependencies` injection pattern was removed. The
+ * `session.ts → docx-session.ts` debt exception remains the only
+ * cross-layer transit; the loader body is fully in-session.
+ *
+ * Runtime-type seams:
+ *   - `laycacheEnvelope` is `unknown` on `LoadDocxEditorSessionAsyncOptions`
+ *     (the concrete `CacheEnvelope` lives at
+ *     `src/runtime/prerender/cache-envelope.ts`). This module narrows it
+ *     to a structural subset `LaycacheEnvelopeSubset` defined locally —
+ *     only the fields the loader actually reads (`canonicalDocument`,
+ *     `compatibilityReport`). Zero runtime-layer imports.
+ *   - `telemetryBus` is `unknown` on the same options. This module
+ *     narrows to `Parameters<typeof setActiveParseTelemetryBus>[0]`
+ *     (the parser's own type for its bus parameter) at the single
+ *     call site. Zero runtime-layer imports.
+ *
+ * Performance invariants preserved verbatim from the legacy body:
+ *   - Invariant 8 — `onProgressiveSnapshot` fires after the body-normalize
+ *     stage + post-yield, only on the cold path (no laycache envelope).
+ *   - Invariant 9 — chart-preview resolution deferred off critical path
+ *     when `onChartPreviewsReady` is supplied; inline otherwise.
+ *   - Invariant 10 — no blocking work between the laycache probe (run
+ *     in `DocxSession.open` before this function is called) and the
+ *     loader body. The short-circuit branch is the first work this
+ *     function does after the OPC read + relationship resolve.
+ */
+
+import type {
+  CompatibilityReport,
+  EditorSessionState,
+} from "../../api/public-types.ts";
+import { runStatefulExport } from "../export/stateful-export.ts";
+import { editorSessionStateFromPersistedSnapshot } from "../../api/session-state.ts";
+// `src/api/diagnostic-conversion.ts` deleted 2026-04-22 when the
+// Internal* diagnostic types collapsed to public-type aliases (see
+// `docs/plans/cross-layer-coord-02.md §8`). Compatibility reports
+// flow through as-is — no conversion needed.
+import type { CanonicalDocument } from "../../model/canonical-document.ts";
+import type {
+  CommentImportDiagnostic,
+  ImportedCommentDefinition,
+  ParsedCommentsResult,
+} from "../../io/ooxml/parse-comments.ts";
+import type {
+  BlockNode as _BlockNode,
+  FootnoteCollection,
+  HeaderDocument,
+  FooterDocument,
+  InlineNode as _InlineNode,
+  MediaCatalog as _MediaCatalog,
+  NumberingCatalog as _NumberingCatalog,
+  OpaqueFragmentRecord as _OpaqueFragmentRecord,
+  PreservedPackagePart as _PreservedPackagePart,
+  SubPartsCatalog,
+} from "../../model/canonical-document.ts";
+import { readOpcPackage, type OpcPackage } from "../../io/opc/package-reader.ts";
+import {
+  parseMainDocumentXml,
+  setActiveParseTelemetryBus,
+} from "../../io/ooxml/parse-main-document.ts";
+import {
+  normalizeParsedTextDocument,
+  normalizeParsedTextDocumentAsync,
+} from "../../io/normalize/normalize-text.ts";
+import {
+  createChartPartLookup,
+  resolveChartPreviewsForDocument,
+  scheduleChartPreviewResolution,
+} from "../../io/chart-preview-resolver.ts";
+import {
+  resolveRelationshipTarget,
+} from "../../io/ooxml/part-manifest.ts";
+import {
+  parseWorkflowPayloadEnvelopeFromPackage,
+} from "../../io/ooxml/workflow-payload.ts";
+import {
+  classifyCorruptPackageError,
+  createMissingPartIssue,
+} from "../../io/opc/corrupt-package.ts";
+import {
+  parseRevisionsFromDocumentXml,
+  parseRevisionsFromStoryXml,
+  type ParsedRevisionsResult,
+} from "../../io/ooxml/parse-revisions.ts";
+import { parseCommentsFromOoxml } from "../../io/ooxml/parse-comments.ts";
+import { parseNumberingXml } from "../../io/ooxml/parse-numbering.ts";
+import {
+  parseHeaderFooterReferences,
+  parseHeaderXml,
+  parseFooterXml,
+} from "../../io/ooxml/parse-headers-footers.ts";
+import {
+  parseFootnotesXml,
+  parseEndnotesXml,
+} from "../../io/ooxml/parse-footnotes.ts";
+import {
+  materializeCanonicalTheme,
+  parseThemeXml,
+  resolveTheme,
+} from "../../io/ooxml/parse-theme.ts";
+import { parseSettingsXml } from "../../io/ooxml/parse-settings.ts";
+import { parseStylesXml } from "../../io/ooxml/parse-styles.ts";
+import { parseFontTable } from "../../io/ooxml/parse-font-table.ts";
+import { createPersistedSourcePackage } from "../../io/source-package-provenance.ts";
+import { validatePersistedEditorSnapshot } from "../../model/snapshot.ts";
+import { buildCompatibilityReport } from "../../validation/compatibility-engine.ts";
+import {
+  createPackageImportDiagnostics,
+  createValidationImportDiagnostics,
+} from "../../validation/import-diagnostics.ts";
+import {
+  extractDocumentProtection,
+  extractProtectionRanges,
+  buildProtectionSnapshot,
+} from "../shared/protection.ts";
+import {
+  createEmptyNumberingCatalog,
+  decodeUtf8,
+  extractDocumentRootAttributes,
+  serializeCanonicalDocumentForExport,
+  toUint8Array,
+} from "../shared/session-utils.ts";
+import {
+  createImportDiagnosticsFromError,
+  createStageEmitter,
+} from "./parse-orchestration.ts";
+import { mergeSecondaryStoryMediaCatalog } from "./styles-consolidation.ts";
+import {
+  createImportedCanonicalDocument,
+  createImportedSnapshot,
+} from "./canonical-assembly.ts";
+import {
+  normalizeImportedCommentThreads,
+  normalizeImportedRevisionRecords,
+  toRuntimeCommentRecords,
+  toRuntimeRevisionRecords,
+} from "./review-import.ts";
+import { translateClmCommentsToWorkflow } from "./workflow-scope-import.ts";
+import {
+  mapCommentDiagnosticsToWarnings,
+  mapRevisionDiagnosticsToWarnings,
+  mapStoryRevisionDiagnosticsToWarnings,
+} from "./import-diagnostics.ts";
+import { buildImportPreservation } from "./preservation-index.ts";
+import {
+  hydrateOffloadEntriesFromPayload,
+  processEmbeddedOffload,
+  type EmbeddingOffloadEntry,
+} from "./embedded-offload.ts";
+import {
+  COMMENTS_PART_PATH,
+  COMMENTS_RELATIONSHIP_TYPE,
+  MAIN_DOCUMENT_PATH,
+  resolveCommentsPartPath,
+  resolveDocumentRelatedPartPath,
+  resolveMainDocumentPartPath,
+} from "./part-discovery.ts";
+import {
+  collectBrokenInternalRelationshipIssues,
+  createBrokenRelationshipWarnings,
+  summarizeBrokenRelationshipIssues,
+} from "./package-read.ts";
+import {
+  createSubPartOpaqueImportState,
+  normalizeFootnoteCollectionOpaqueBlocks,
+  normalizeSubPartOpaqueBlocks,
+} from "./normalize.ts";
+import {
+  collectInlineMediaParts,
+} from "./package-parts.ts";
+import { createDiagnosticsSession } from "./diagnostics-session.ts";
+import { collectEmbeddedDocuments } from "./embedded-discovery.ts";
+import type { CommentThread } from "../../model/review/comment-types.ts";
+import type { RevisionRecord as ReviewRevisionRecord } from "../../model/review/revision-types.ts";
+import {
+  BLOCKING_COMMENT_DIAGNOSTIC_CODES,
+  PROGRESSIVE_VIEWPORT_BLOCKS,
+  type ImportedDocxState,
+  type LoadDocxEditorSessionAsyncOptions,
+  type LoadDocxEditorSessionOptions,
+  type LoadedDocxEditorSession,
+} from "./loader-types.ts";
+import {
+  COMMENTS_EXTENDED_PART_PATH,
+  COMMENTS_EXTENDED_RELATIONSHIP_TYPE,
+  COMMENTS_IDS_PART_PATH,
+  COMMENTS_IDS_RELATIONSHIP_TYPE,
+  ENDNOTES_PART_PATH,
+  ENDNOTES_RELATIONSHIP_TYPE,
+  FONT_TABLE_PART_PATH,
+  FONT_TABLE_RELATIONSHIP_TYPE,
+  FOOTNOTES_PART_PATH,
+  FOOTNOTES_RELATIONSHIP_TYPE,
+  MAIN_DOCUMENT_CONTENT_TYPE,
+  NUMBERING_PART_PATH,
+  NUMBERING_RELATIONSHIP_TYPE,
+  PEOPLE_PART_PATH,
+  PEOPLE_RELATIONSHIP_TYPE,
+  SETTINGS_PART_PATH,
+  SETTINGS_RELATIONSHIP_TYPE,
+  STYLES_PART_PATH,
+  STYLES_RELATIONSHIP_TYPE,
+} from "./part-constants.ts";
+
+/**
+ * Structural subset of `CacheEnvelope` (from
+ * `src/runtime/prerender/cache-envelope.ts`) that the loader reads.
+ *
+ * Defined locally so this module stays §P6-clean — the concrete
+ * `CacheEnvelope` type is owned by the runtime/prerender layer and may
+ * not be imported here. Callers cast to this subset at the single
+ * consumption site (`options.laycacheEnvelope as LaycacheEnvelopeSubset
+ * | undefined`); the envelope carries additional fields (graph,
+ * surface, hashes) that this module does not consume.
+ */
+interface LaycacheEnvelopeSubset {
+  readonly canonicalDocument: CanonicalDocument;
+  /**
+   * Concrete type at the boundary is the `Internal*` flavor of
+   * `CompatibilityReport` (from `src/core/state/editor-state.ts`) that
+   * the runtime-layer `CacheEnvelope` carries. We keep it as `unknown`
+   * here so this module does not transit `src/core/**` (§P6); the one
+   * consumption site narrows via `Parameters<typeof
+   * toPublicCompatibilityReport>[0]` at call time.
+   */
+  readonly compatibilityReport?: unknown;
+}
+
+/**
+ * Narrow type for the caller-supplied telemetry bus. The concrete
+ * `TelemetryBus` type lives at `src/runtime/debug/telemetry-bus.ts`
+ * (runtime-layer, forbidden here by §P6). We reach the parser's own
+ * parameter type via `Parameters<typeof setActiveParseTelemetryBus>[0]`
+ * so the single bracketing call site passes a strongly-typed value
+ * without this module transiting runtime internals.
+ */
+type ParseTelemetryBusParam = Parameters<typeof setActiveParseTelemetryBus>[0];
+
+/**
+ * Session-layer owner of the async load path. Body is byte-identical to
+ * the pre-5e-7.e.1 `loadDocxEditorSessionAsync` in
+ * `src/io/docx-session.ts`; only the imports were renamed to point at
+ * the already-extracted session-layer modules and the two runtime-type
+ * casts were replaced with the local `LaycacheEnvelopeSubset` + the
+ * `ParseTelemetryBusParam` narrow.
+ *
+ * Slice 5e-7.f removed the `deps` parameter — the stateful export
+ * pipeline now lives in-session at
+ * `src/session/export/stateful-export.ts` and is imported directly.
+ */
+export async function loadDocxSessionAsync(
+  options: LoadDocxEditorSessionAsyncOptions,
+): Promise<LoadedDocxEditorSession> {
+  const { scheduler } = options;
+  const editorBuild =
+    typeof options.editorBuild === "string" && options.editorBuild.length > 0
+      ? options.editorBuild
+      : "dev";
+  const sourceBytes = toUint8Array(options.bytes);
+
+  const stages = createStageEmitter(options.onLoadStage);
+
+  let sourcePackage: OpcPackage;
+
+  try {
+    sourcePackage = readOpcPackage(sourceBytes);
+  } catch (error) {
+    return createDiagnosticsSession(
+      options,
+      createPackageImportDiagnostics({
+        issue: classifyCorruptPackageError(error),
+      }),
+    );
+  }
+  stages.emit("opc");
+  await scheduler.yield();
+  const embeddedWorkflowPayload = parseWorkflowPayloadEnvelopeFromPackage(sourcePackage);
+  const embeddedWorkflowMetadata = embeddedWorkflowPayload?.workflowMetadata;
+  const embeddedWorkflowOverlay = embeddedWorkflowPayload?.workflowOverlay;
+
+  const mainDocumentPath = resolveMainDocumentPartPath(sourcePackage);
+  const brokenRelationshipIssues = collectBrokenInternalRelationshipIssues(
+    sourcePackage,
+    mainDocumentPath,
+  );
+  if (brokenRelationshipIssues.length > 0) {
+    return createDiagnosticsSession(
+      options,
+      createPackageImportDiagnostics({
+        issue: {
+          ...brokenRelationshipIssues[0],
+          message: summarizeBrokenRelationshipIssues(brokenRelationshipIssues),
+          details: {
+            issueCount: brokenRelationshipIssues.length,
+            targets: brokenRelationshipIssues.map((issue) => issue.targetPartPath).filter(Boolean),
+          },
+        },
+      }),
+    );
+  }
+
+  if (!mainDocumentPath) {
+    return createDiagnosticsSession(
+      options,
+      createPackageImportDiagnostics({
+        issue: createMissingPartIssue(MAIN_DOCUMENT_PATH),
+      }),
+    );
+  }
+
+  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 {
+    // L7 Phase 2.5 Plan B B.6b — loader short-circuit. Hand
+    // `envelope.canonicalDocument` through reference-equal and skip the
+    // five expensive parse stages. The four `onLoadStage` callbacks still
+    // fire in order — `body` and `styles-numbering-comments` emit with
+    // near-zero duration — so host progress bars are unaffected.
+    const laycacheEnvelope = options.laycacheEnvelope as
+      | LaycacheEnvelopeSubset
+      | undefined;
+    if (laycacheEnvelope) {
+      stages.emit("body");
+      stages.emit("styles-numbering-comments");
+
+      const canonicalDocument = laycacheEnvelope.canonicalDocument;
+
+      // `extractProtectionRanges` needs `parsedDocument.blocks` (which we
+      // are skipping), so the short-circuit uses an empty ranges list;
+      // document-level `editType` / `enforcement` still come from
+      // settings.xml so read-only docs stay read-only.
+      const settingsPartPath = resolveDocumentRelatedPartPath(
+        sourcePackage,
+        mainDocumentPath,
+        documentPart.relationships,
+        SETTINGS_RELATIONSHIP_TYPE,
+        SETTINGS_PART_PATH,
+      );
+      const settingsXml =
+        settingsPartPath && sourcePackage.parts.has(settingsPartPath)
+          ? decodeUtf8(
+              sourcePackage.parts.get(settingsPartPath)?.bytes ?? new Uint8Array(),
+            )
+          : "";
+      const documentProtection = extractDocumentProtection(settingsXml);
+      const protectionSnapshot = buildProtectionSnapshot(documentProtection, []);
+
+      // Chart previews (`previewMediaId` is host-dependent) aren't cached
+      // in the envelope. C3b: when onChartPreviewsReady is provided, defer
+      // resolution out of the critical path. Otherwise block (legacy behavior).
+      let documentWithChartPreviews: CanonicalDocument;
+      if (options.onChartPreviewsReady) {
+        scheduleChartPreviewResolution(
+          canonicalDocument,
+          sourcePackage,
+          options.hostAdapter,
+          options.onChartPreviewsReady,
+        );
+        documentWithChartPreviews = canonicalDocument as CanonicalDocument;
+      } else {
+        documentWithChartPreviews = (await resolveChartPreviewsForDocument(
+          canonicalDocument,
+          sourcePackage,
+          options.hostAdapter,
+        )) as CanonicalDocument;
+      }
+
+      const timestamp = new Date().toISOString();
+      // Phase 2 Finale C3: skip `buildCompatibilityReport` (60–100 ms on
+      // extra-large) when the envelope carries a pre-computed report.
+      // Pure-function determinism of the report is enforced by
+      // `canonicalDocumentHash` (5th input to `deriveCacheKey`): any
+      // change to the canonical doc flips the hash and rejects the
+      // envelope on load.
+      //
+      // The cached report's `generatedAt` is a fixed sentinel
+      // (`CACHE_NORMALIZED_GENERATED_AT`) for envelope byte-identity.
+      // Swap it for the live ISO8601 timestamp here because downstream
+      // `validatePersistedEditorSnapshot` requires
+      // `$.compatibility.generatedAt` to be ISO 8601.
+      const cachedReport = laycacheEnvelope?.compatibilityReport as
+        | CompatibilityReport
+        | undefined;
+      const compatibility = cachedReport
+        ? { ...cachedReport, generatedAt: timestamp }
+        : buildCompatibilityReport({
+            document: documentWithChartPreviews,
+            generatedAt: timestamp,
+          });
+      await scheduler.yield();
+
+      const snapshot = createImportedSnapshot({
+        documentId: options.documentId,
+        editorBuild,
+        timestamp,
+        document: documentWithChartPreviews,
+        compatibility,
+        protectionSnapshot,
+        sourcePackage: createPersistedSourcePackage(sourceBytes, options.sourceLabel),
+        workflowOverlay: embeddedWorkflowOverlay,
+        workflowMetadata: embeddedWorkflowMetadata,
+        visibilityPolicies: embeddedWorkflowPayload?.visibilityPolicies,
+        markupModePolicy: embeddedWorkflowPayload?.markupModePolicy ?? undefined,
+      });
+      const snapshotIssues = validatePersistedEditorSnapshot(snapshot);
+      if (snapshotIssues.length > 0) {
+        const firstIssue = snapshotIssues[0];
+        return createDiagnosticsSession(
+          options,
+          createValidationImportDiagnostics({
+            message: `DOCX import produced an invalid editor state during validation${firstIssue ? ` (${firstIssue.path}: ${firstIssue.message})` : "."}`,
+            source: "import",
+            details: {
+              issueCount: snapshotIssues.length,
+              firstIssuePath: firstIssue?.path,
+            },
+          }),
+        );
+      }
+
+      // Build `initialSessionState` inline — bypassing
+      // `editorSessionStateFromPersistedSnapshot`'s structuredClone so
+      // `session.initialSessionState.canonicalDocument` is reference-equal
+      // to `envelope.canonicalDocument` (cloning a large canonical document
+      // defeats part of the cache gain).
+      const sessionState: EditorSessionState = {
+        sessionVersion: "editor-session-state/1",
+        schemaVersion: snapshot.schemaVersion,
+        documentId: snapshot.documentId,
+        docId: snapshot.docId,
+        createdAt: snapshot.createdAt,
+        updatedAt: snapshot.updatedAt,
+        editorBuild: snapshot.editorBuild,
+        canonicalDocument: snapshot.canonicalDocument,
+        compatibility: snapshot.compatibility,
+        warningLog: snapshot.warningLog,
+        protectionSnapshot: snapshot.protectionSnapshot,
+        sourcePackage: snapshot.sourcePackage,
+        workflowOverlay: snapshot.workflowOverlay,
+        workflowMetadata: snapshot.workflowMetadata,
+      };
+
+      // The short-circuit path does not carry an `ImportedDocxState`, so
+      // `exportDocx` lazily re-runs the cold path on first invocation and
+      // memoizes. Keeps the warm-load fast while preserving byte-exact
+      // export correctness.
+      let lazyColdExport: LoadedDocxEditorSession["exportDocx"] | undefined;
+      const exportDocx: LoadedDocxEditorSession["exportDocx"] = async (
+        nextSessionStateOrSnapshot,
+        exportOptions,
+      ) => {
+        if (!lazyColdExport) {
+          const { laycacheEnvelope: _unused, ...coldOptions } = options;
+          void _unused;
+          const coldSession = await loadDocxSessionAsync(coldOptions);
+          if (coldSession.fatalError) {
+            throw new Error(
+              `DOCX export via short-circuit fallback failed cold load: ${coldSession.fatalError.message ?? "fatal error"}`,
+            );
+          }
+          lazyColdExport = coldSession.exportDocx;
+        }
+        return lazyColdExport(nextSessionStateOrSnapshot, exportOptions);
+      };
+
+      stages.emit("skeleton-ready");
+      return {
+        initialSessionState: sessionState,
+        initialSnapshot: snapshot,
+        readOnly: false,
+        protectionSnapshot,
+        exportDocx,
+        ...(embeddedWorkflowPayload?.editorState
+          ? { initialEditorStatePayload: embeddedWorkflowPayload.editorState }
+          : {}),
+      };
+    }
+
+    const sourceDocumentXml = decodeUtf8(documentPart.bytes);
+    const importedRevisions = parseRevisionsFromDocumentXml(sourceDocumentXml);
+    const numberingPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      NUMBERING_RELATIONSHIP_TYPE,
+      NUMBERING_PART_PATH,
+    );
+    const parsedNumbering = numberingPartPath
+      ? parseNumberingXml(
+          decodeUtf8(sourcePackage.parts.get(numberingPartPath)?.bytes ?? new Uint8Array()),
+          {
+            relationships: sourcePackage.parts.get(numberingPartPath)?.relationships,
+            partPath: numberingPartPath,
+          },
+        )
+      : createEmptyNumberingCatalog();
+    const mediaParts = collectInlineMediaParts(sourcePackage);
+    const chartPartLookup = createChartPartLookup(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+    );
+    if (options.telemetryBus) {
+      setActiveParseTelemetryBus(options.telemetryBus as ParseTelemetryBusParam);
+    }
+    let parsedDocument;
+    try {
+      parsedDocument = parseMainDocumentXml(
+        sourceDocumentXml,
+        documentPart.relationships,
+        mediaParts,
+        mainDocumentPath,
+        chartPartLookup,
+      );
+    } finally {
+      if (options.telemetryBus) setActiveParseTelemetryBus(undefined);
+    }
+    await scheduler.yield();
+    const protectionRanges = extractProtectionRanges(parsedDocument.blocks);
+    const normalizedDocument = await normalizeParsedTextDocumentAsync(
+      parsedDocument,
+      mainDocumentPath,
+      scheduler,
+    );
+    stages.emit("body");
+    await scheduler.yield();
+
+    // L7 Phase 2 Finale C2 — progressive initial mount.
+    //
+    // Fire `onProgressiveSnapshot` exactly once, after the body stage and
+    // its post-yield. At this point `normalizedDocument.content` carries
+    // the full block tree with per-block runProperties already resolved
+    // during `normalizeParsedTextDocumentAsync`. We synthesize a
+    // throw-away `CanonicalDocument` using the normalized content
+    // + empty style/review/preservation catalogs, then project a
+    // viewport-windowed `EditorSurfaceSnapshot` (first `PROGRESSIVE_VIEWPORT_BLOCKS`
+    // blocks real, rest as culled placeholders via the Phase 2.9 flag).
+    //
+    // The bench's measured signal: time from `loadDocxEditorSessionAsync`
+    // entry to this callback's fire is `firstViewportCommitMs` — the
+    // metric C2 gates on.
+    //
+    // Skipped on the Plan B short-circuit: `laycacheEnvelope !== undefined`
+    // already completes ~376 ms faster than cold — adding a progressive
+    // synthesis on top costs more than it saves. The short-circuit path
+    // returns the real snapshot fast enough.
+    if (
+      options.onProgressiveSnapshot !== undefined &&
+      options.laycacheEnvelope === undefined
+    ) {
+      const blocksTotal = normalizedDocument.content.children.length;
+      const blocksRealized = Math.min(
+        PROGRESSIVE_VIEWPORT_BLOCKS,
+        blocksTotal,
+      );
+      const progressiveSurface = options.surfaceProjector
+        ? options.surfaceProjector({
+            rootContent: normalizedDocument.content,
+            documentId: options.documentId,
+            blocksRealized,
+            blocksTotal,
+          })
+        : undefined;
+      try {
+        options.onProgressiveSnapshot({
+          ...(progressiveSurface !== undefined
+            ? { surface: progressiveSurface }
+            : {}),
+          phase: "viewport",
+          blocksRealized,
+          blocksTotal,
+        });
+      } catch {
+        // A throwing consumer must not abort the load. Progressive is
+        // a best-effort optimization; errors on the callback side
+        // silently fall through to the normal full-commit path.
+      }
+    }
+
+    const commentsPartPath = resolveCommentsPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      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,
+    );
+    const parsedComments = commentsPartPath
+      ? parseCommentsFromOoxml(
+          sourceDocumentXml,
+          {
+            commentsXml: decodeUtf8(sourcePackage.parts.get(commentsPartPath)?.bytes ?? new Uint8Array()),
+            commentsExtendedXml: decodeUtf8(
+              sourcePackage.parts.get(commentsExtendedPartPath ?? "")?.bytes ?? new Uint8Array(),
+            ),
+            commentsIdsXml: decodeUtf8(
+              sourcePackage.parts.get(commentsIdsPartPath ?? "")?.bytes ?? new Uint8Array(),
+            ),
+            peopleXml: decodeUtf8(
+              sourcePackage.parts.get(peoplePartPath ?? "")?.bytes ?? new Uint8Array(),
+            ),
+          },
+        )
+      : {
+          threads: [] as CommentThread[],
+          diagnostics: [] as CommentImportDiagnostic[],
+          definitions: [] as ImportedCommentDefinition[],
+          sourceRootTag: undefined,
+          sourceExtendedRootTag: undefined,
+          sourceIdsRootTag: undefined,
+          sourcePeopleRootTag: undefined,
+          peopleAuthors: [] as string[],
+        };
+    const normalizedRevisions = normalizeImportedRevisionRecords(
+      importedRevisions,
+      normalizedDocument.content,
+      normalizedDocument.preservation.opaqueFragments,
+    );
+    const normalizedComments = normalizeImportedCommentThreads(
+      parsedComments,
+      normalizedDocument.preservation.opaqueFragments,
+      normalizedRevisions.revisions,
+    );
+    stages.emit("styles-numbering-comments");
+    const importedStoryRevisions: ReviewRevisionRecord[] = [];
+    const importedStoryRevisionDiagnostics: ParsedRevisionsResult["diagnostics"] = [];
+    const subPartOpaqueState = createSubPartOpaqueImportState(
+      normalizedDocument.preservation.opaqueFragments,
+      normalizedDocument.diagnostics.warnings,
+    );
+    // ---- Parse sub-parts: headers, footers, footnotes, endnotes, theme ----
+    const headerFooterRefs = parseHeaderFooterReferences(sourceDocumentXml);
+    const parsedHeaders: HeaderDocument[] = [];
+    const parsedFooters: FooterDocument[] = [];
+    const sourceHeaderPaths: Array<{ partPath: string; relationshipId: string }> = [];
+    const sourceFooterPaths: Array<{ partPath: string; relationshipId: string }> = [];
+    const seenSubPartKeys = new Set<string>();
+
+    for (const ref of headerFooterRefs) {
+      const dedupeKey = `${ref.kind}:${ref.variant}:${ref.relationshipId}`;
+      if (seenSubPartKeys.has(dedupeKey)) {
+        continue;
+      }
+      seenSubPartKeys.add(dedupeKey);
+
+      const relationship = documentPart.relationships.find(
+        (r) => r.id === ref.relationshipId && r.targetMode === "internal",
+      );
+      if (!relationship) {
+        continue;
+      }
+
+      const partPath = resolveRelationshipTarget(mainDocumentPath, relationship);
+      const part = sourcePackage.parts.get(partPath);
+      const partBytes = part?.bytes;
+      if (!partBytes) {
+        continue;
+      }
+
+      await scheduler.yield();
+      const xml = decodeUtf8(partBytes);
+      const subPartRelationships = part?.relationships ?? [];
+      const subPartChartPartLookup = createChartPartLookup(
+        sourcePackage,
+        partPath,
+        subPartRelationships,
+      );
+      if (ref.kind === "header") {
+        const parsedHeaderRevisions = parseRevisionsFromStoryXml(xml);
+        const parsed = parseHeaderXml(xml, {
+          relationships: subPartRelationships,
+          mediaParts,
+          sourcePartPath: partPath,
+          chartPartLookup: subPartChartPartLookup,
+        });
+        parsedHeaders.push({
+          variant: ref.variant,
+          partPath,
+          relationshipId: ref.relationshipId,
+          ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+          blocks: normalizeSubPartOpaqueBlocks(
+            parsed.blocks,
+            normalizedDocument.preservation.opaqueFragments,
+            normalizedDocument.diagnostics.warnings,
+            partPath,
+            subPartOpaqueState,
+          ),
+        });
+        importedStoryRevisions.push(
+          ...parsedHeaderRevisions.revisions.map((revision): ReviewRevisionRecord => ({
+            ...revision,
+            metadata: {
+              ...revision.metadata,
+              storyTarget: {
+                kind: "header" as const,
+                relationshipId: ref.relationshipId,
+                variant: ref.variant,
+                ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+              },
+            },
+          })),
+        );
+        importedStoryRevisionDiagnostics.push(...parsedHeaderRevisions.diagnostics);
+        sourceHeaderPaths.push({ partPath, relationshipId: ref.relationshipId });
+      } else {
+        const parsedFooterRevisions = parseRevisionsFromStoryXml(xml);
+        const parsed = parseFooterXml(xml, {
+          relationships: subPartRelationships,
+          mediaParts,
+          sourcePartPath: partPath,
+          chartPartLookup: subPartChartPartLookup,
+        });
+        parsedFooters.push({
+          variant: ref.variant,
+          partPath,
+          relationshipId: ref.relationshipId,
+          ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+          blocks: normalizeSubPartOpaqueBlocks(
+            parsed.blocks,
+            normalizedDocument.preservation.opaqueFragments,
+            normalizedDocument.diagnostics.warnings,
+            partPath,
+            subPartOpaqueState,
+          ),
+        });
+        importedStoryRevisions.push(
+          ...parsedFooterRevisions.revisions.map((revision): ReviewRevisionRecord => ({
+            ...revision,
+            metadata: {
+              ...revision.metadata,
+              storyTarget: {
+                kind: "footer" as const,
+                relationshipId: ref.relationshipId,
+                variant: ref.variant,
+                ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+              },
+            },
+          })),
+        );
+        importedStoryRevisionDiagnostics.push(...parsedFooterRevisions.diagnostics);
+        sourceFooterPaths.push({ partPath, relationshipId: ref.relationshipId });
+      }
+    }
+
+    const footnotesPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      FOOTNOTES_RELATIONSHIP_TYPE,
+      FOOTNOTES_PART_PATH,
+    );
+    const footnotesRelationshipId = documentPart.relationships.find(
+      (r) => r.type === FOOTNOTES_RELATIONSHIP_TYPE && r.targetMode === "internal",
+    )?.id;
+    const endnotesPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      ENDNOTES_RELATIONSHIP_TYPE,
+      ENDNOTES_PART_PATH,
+    );
+    const endnotesRelationshipId = documentPart.relationships.find(
+      (r) => r.type === ENDNOTES_RELATIONSHIP_TYPE && r.targetMode === "internal",
+    )?.id;
+
+    let footnoteCollection: FootnoteCollection | undefined;
+    if (footnotesPartPath) {
+      footnoteCollection = parseFootnotesXml(
+        decodeUtf8(sourcePackage.parts.get(footnotesPartPath)?.bytes ?? new Uint8Array()),
+      );
+      normalizeFootnoteCollectionOpaqueBlocks(
+        footnoteCollection,
+        "footnote",
+        normalizedDocument.preservation.opaqueFragments,
+        normalizedDocument.diagnostics.warnings,
+        footnotesPartPath,
+        subPartOpaqueState,
+      );
+    }
+    if (endnotesPartPath) {
+      footnoteCollection = parseEndnotesXml(
+        decodeUtf8(sourcePackage.parts.get(endnotesPartPath)?.bytes ?? new Uint8Array()),
+        footnoteCollection,
+      );
+      normalizeFootnoteCollectionOpaqueBlocks(
+        footnoteCollection,
+        "endnote",
+        normalizedDocument.preservation.opaqueFragments,
+        normalizedDocument.diagnostics.warnings,
+        endnotesPartPath,
+        subPartOpaqueState,
+      );
+    }
+    await scheduler.yield();
+
+    const themeRelationship = documentPart.relationships.find(
+      (r) => r.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" &&
+        r.targetMode === "internal",
+    );
+    const themePartPath = themeRelationship
+      ? resolveRelationshipTarget(mainDocumentPath, themeRelationship)
+      : undefined;
+    const parsedTheme =
+      themePartPath && sourcePackage.parts.has(themePartPath)
+        ? parseThemeXml(
+            decodeUtf8(sourcePackage.parts.get(themePartPath)?.bytes ?? new Uint8Array()),
+          )
+        : undefined;
+    const resolvedTheme = parsedTheme ? resolveTheme(parsedTheme) : undefined;
+    const settingsPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      SETTINGS_RELATIONSHIP_TYPE,
+      SETTINGS_PART_PATH,
+    );
+    const parsedSettings =
+      settingsPartPath && sourcePackage.parts.has(settingsPartPath)
+        ? parseSettingsXml(
+            decodeUtf8(sourcePackage.parts.get(settingsPartPath)?.bytes ?? new Uint8Array()),
+          )
+        : undefined;
+    const canonicalTheme =
+      parsedTheme !== undefined
+        ? materializeCanonicalTheme(
+            parsedTheme,
+            parsedSettings?.clrSchemeMapping ?? {},
+          )
+        : undefined;
+    const settingsXmlForProtection =
+      settingsPartPath && sourcePackage.parts.has(settingsPartPath)
+        ? decodeUtf8(sourcePackage.parts.get(settingsPartPath)?.bytes ?? new Uint8Array())
+        : "";
+    const documentProtection = extractDocumentProtection(settingsXmlForProtection);
+    const importedProtectionSnapshot = buildProtectionSnapshot(documentProtection, protectionRanges);
+
+    // ---- Parse styles.xml for canonical style catalog ----
+    const stylesPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      STYLES_RELATIONSHIP_TYPE,
+      STYLES_PART_PATH,
+    );
+    const parsedStyles =
+      stylesPartPath && sourcePackage.parts.has(stylesPartPath)
+        ? parseStylesXml(
+            decodeUtf8(sourcePackage.parts.get(stylesPartPath)?.bytes ?? new Uint8Array()),
+          )
+        : parseStylesXml("");
+    await scheduler.yield();
+
+    // ---- Parse fontTable.xml for canonical font catalog ----
+    const fontTablePartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      FONT_TABLE_RELATIONSHIP_TYPE,
+      FONT_TABLE_PART_PATH,
+    );
+    const parsedFontTable =
+      fontTablePartPath && sourcePackage.parts.has(fontTablePartPath)
+        ? parseFontTable(
+            decodeUtf8(sourcePackage.parts.get(fontTablePartPath)?.bytes ?? new Uint8Array()),
+          )
+        : undefined;
+
+    const mergedMedia = mergeSecondaryStoryMediaCatalog(normalizedDocument.media, {
+      headers: parsedHeaders,
+      footers: parsedFooters,
+      footnoteCollection,
+      mediaParts,
+    });
+
+    const subParts: SubPartsCatalog | undefined =
+      parsedHeaders.length > 0 ||
+      parsedFooters.length > 0 ||
+      footnoteCollection !== undefined ||
+      parsedTheme !== undefined ||
+      normalizedDocument.finalSectionProperties !== undefined ||
+      resolvedTheme !== undefined ||
+      canonicalTheme !== undefined ||
+      parsedSettings !== undefined
+        ? {
+            headers: parsedHeaders,
+            footers: parsedFooters,
+            ...(footnoteCollection !== undefined ? { footnoteCollection } : {}),
+            ...(parsedTheme !== undefined ? { theme: parsedTheme } : {}),
+            ...(normalizedDocument.finalSectionProperties !== undefined
+              ? { finalSectionProperties: normalizedDocument.finalSectionProperties }
+              : {}),
+            ...(resolvedTheme !== undefined ? { resolvedTheme } : {}),
+            ...(canonicalTheme !== undefined ? { canonicalTheme } : {}),
+            ...(parsedSettings !== undefined ? { settings: parsedSettings } : {}),
+          }
+        : undefined;
+
+    const timestamp = new Date().toISOString();
+    const translatedWorkflowState = translateClmCommentsToWorkflow({
+      comments: normalizedComments.threads,
+      workflowOverlay: embeddedWorkflowOverlay,
+      workflowMetadata: embeddedWorkflowMetadata,
+      timestamp,
+    });
+    // P8 Step 7 — embedded-document offload. First, check whether the
+    // source package already carries a `bw:embeddings` customXml
+    // namespace from a prior offload (reopen path). If so, skip the
+    // fresh `storeEmbeddedDocument` pass and reuse the hydrated
+    // entries. Otherwise run discovery + offload; entries are empty
+    // when no adapter is present, when zero offloadable manifests
+    // were found, or when every adapter call failed (fall-through to
+    // store-only semantics). See architecture §P8 and
+    // `src/session/import/embedded-offload.ts`.
+    const embeddedDocumentManifestsEarly = collectEmbeddedDocuments(
+      sourcePackage,
+      mainDocumentPath,
+    ).manifests;
+    const rehydratedOffload = hydrateOffloadEntriesFromPayload(
+      embeddedWorkflowPayload?.editorState,
+    );
+    let offloadEntries: readonly EmbeddingOffloadEntry[];
+    let offloadOwnedPartPaths: readonly string[];
+    if (rehydratedOffload.entries.length > 0) {
+      // REOPEN path — entries already exist in customXml; no fresh
+      // adapter call, no sha / base64 work on the critical path.
+      offloadEntries = rehydratedOffload.entries;
+      offloadOwnedPartPaths = rehydratedOffload.ownedPartPaths;
+    } else if (options.offloadEmbeddedDocuments === true) {
+      // Fresh offload opt-in. Hosts that want offload pay the cold-
+      // open cost only when they explicitly set the flag. Supplying
+      // `hostAdapter` alone (for chart-preview / save-session /
+      // log-event etc.) does NOT trigger offload — offload is a
+      // separate decision from adapter presence per refactor/04's
+      // cross-lane perf finding (cross-layer-coord-04 §1.13): sha256
+      // + base64 of large offloadable embeddings costs ~300 ms per
+      // MB on the critical path.
+      const offloadResult = await processEmbeddedOffload({
+        parentDocumentId: options.documentId,
+        manifests: embeddedDocumentManifestsEarly,
+        hostAdapter: options.hostAdapter,
+        resolvePartPath: (rId) => {
+          const rel = documentPart.relationships.find(
+            (r) => r.id === rId && r.targetMode === "internal",
+          );
+          return rel ? resolveRelationshipTarget(mainDocumentPath, rel) : undefined;
+        },
+        resolveContentType: (path) =>
+          sourcePackage.parts.get(path)?.contentType ?? undefined,
+      });
+      offloadEntries = offloadResult.entries;
+      offloadOwnedPartPaths = offloadResult.ownedPartPaths;
+    } else {
+      // Default path — no offload. Offloadable manifests fall
+      // through to the preservation store (same as store-only
+      // behavior). Zero-cost; hosts that never opt in never pay.
+      offloadEntries = [];
+      offloadOwnedPartPaths = [];
+    }
+    const importedDocument = createImportedCanonicalDocument({
+      documentId: options.documentId,
+      timestamp,
+      numbering: parsedNumbering,
+      media: mergedMedia,
+      content: normalizedDocument.content,
+      subParts,
+      parsedStyles,
+      fontTable: parsedFontTable,
+      preservation: buildImportPreservation(normalizedDocument.preservation, sourcePackage, [
+        mainDocumentPath,
+        numberingPartPath,
+        commentsPartPath,
+        commentsExtendedPartPath,
+        commentsIdsPartPath,
+        peoplePartPath,
+        ...offloadOwnedPartPaths,
+      ]),
+      diagnostics: {
+        warnings: [
+          ...createBrokenRelationshipWarnings(sourcePackage, mainDocumentPath),
+          ...normalizedDocument.diagnostics.warnings,
+          ...mapRevisionDiagnosticsToWarnings(normalizedRevisions.diagnostics),
+          ...mapStoryRevisionDiagnosticsToWarnings(importedStoryRevisionDiagnostics),
+          ...mapCommentDiagnosticsToWarnings(normalizedComments.diagnostics),
+        ],
+        errors: [],
+      },
+      review: {
+        comments: toRuntimeCommentRecords(translatedWorkflowState.comments),
+        revisions: toRuntimeRevisionRecords([
+          ...normalizedRevisions.revisions,
+          ...importedStoryRevisions,
+        ]),
+      },
+    });
+    // Stage 0B.1: if the host implements `renderChartPreview`, resolve
+    // chart_preview nodes inline so the first snapshot already carries the
+    // synthesized `previewMediaId`. Fallback-safe: returning null or throwing
+    // is per-chart — the typed badge renders as if the adapter weren't set.
+    // C3b: when onChartPreviewsReady is provided, defer resolution out of
+    // the critical path (same pattern as the short-circuit branch above).
+    let document: CanonicalDocument;
+    if (options.onChartPreviewsReady) {
+      scheduleChartPreviewResolution(
+        importedDocument,
+        sourcePackage,
+        options.hostAdapter,
+        options.onChartPreviewsReady,
+      );
+      document = importedDocument as CanonicalDocument;
+    } else {
+      document = (await resolveChartPreviewsForDocument(
+        importedDocument,
+        sourcePackage,
+        options.hostAdapter,
+      )) as CanonicalDocument;
+    }
+    const compatibility = buildCompatibilityReport({
+      document,
+      generatedAt: timestamp,
+    });
+    await scheduler.yield();
+    const snapshot = createImportedSnapshot({
+      documentId: options.documentId,
+      editorBuild,
+      timestamp,
+      document,
+      compatibility,
+      protectionSnapshot: importedProtectionSnapshot,
+      sourcePackage: createPersistedSourcePackage(sourceBytes, options.sourceLabel),
+      workflowOverlay: translatedWorkflowState.workflowOverlay,
+      workflowMetadata: translatedWorkflowState.workflowMetadata,
+      visibilityPolicies: embeddedWorkflowPayload?.visibilityPolicies,
+      markupModePolicy: embeddedWorkflowPayload?.markupModePolicy ?? undefined,
+    });
+    const snapshotIssues = validatePersistedEditorSnapshot(snapshot);
+    if (snapshotIssues.length > 0) {
+      const firstIssue = snapshotIssues[0];
+      return createDiagnosticsSession(
+        options,
+        createValidationImportDiagnostics({
+          message: `DOCX import produced an invalid editor state during validation${firstIssue ? ` (${firstIssue.path}: ${firstIssue.message})` : "."}`,
+          source: "import",
+          details: {
+            issueCount: snapshotIssues.length,
+            firstIssuePath: firstIssue?.path,
+          },
+        }),
+      );
+    }
+    const initialSessionState = editorSessionStateFromPersistedSnapshot(snapshot);
+    const importedState: ImportedDocxState = {
+      sourceBytes: new Uint8Array(sourceBytes),
+      sourcePackage,
+      sourceDocumentXml,
+      sourceDocumentPartPath: mainDocumentPath,
+      sourceDocumentRelationships: documentPart.relationships,
+      sourceDocumentAttributes: extractDocumentRootAttributes(sourceDocumentXml),
+      sourceNumberingPartPath: numberingPartPath,
+      sourceNumberingRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === NUMBERING_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceSettingsPartPath: settingsPartPath,
+      sourceSettingsXml:
+        settingsXmlForProtection.length > 0 ? settingsXmlForProtection : undefined,
+      sourceCommentsPartPath: commentsPartPath,
+      sourceCommentsRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === COMMENTS_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceCommentsRootTag: normalizedComments.sourceRootTag,
+      sourceCommentsExtendedPartPath: commentsExtendedPartPath,
+      sourceCommentsExtendedRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === COMMENTS_EXTENDED_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceCommentsExtendedRootTag: normalizedComments.sourceExtendedRootTag,
+      sourceCommentsIdsPartPath: commentsIdsPartPath,
+      sourceCommentsIdsRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === COMMENTS_IDS_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceCommentsIdsRootTag: normalizedComments.sourceIdsRootTag,
+      sourcePeoplePartPath: peoplePartPath,
+      sourcePeopleRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === PEOPLE_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourcePeopleRootTag: normalizedComments.sourcePeopleRootTag,
+      sourcePeopleAuthors: normalizedComments.peopleAuthors,
+      protectionSnapshot: buildProtectionSnapshot(documentProtection, protectionRanges),
+      preservedCommentDefinitions: normalizedComments.preservedDefinitions,
+      blockingCommentDiagnostics: normalizedComments.diagnostics.filter((diagnostic) =>
+        BLOCKING_COMMENT_DIAGNOSTIC_CODES.has(diagnostic.code),
+      ),
+      initialCanonicalSignature: serializeCanonicalDocumentForExport(document),
+      sourceSubPartPaths: {
+        headers: sourceHeaderPaths,
+        footers: sourceFooterPaths,
+        footnotesPartPath,
+        footnotesRelationshipId,
+        endnotesPartPath,
+        endnotesRelationshipId,
+        themePartPath,
+        themeRelationshipId: themeRelationship?.id,
+      },
+      embeddingOffloadEntries: offloadEntries,
+      ...(options.hostAdapter !== undefined
+        ? { hostAdapter: options.hostAdapter }
+        : {}),
+    };
+
+    stages.emit("skeleton-ready");
+    return {
+      initialSessionState,
+      initialSnapshot: snapshot,
+      readOnly: false,
+      protectionSnapshot: importedProtectionSnapshot,
+      exportDocx: async (nextSessionState, exportOptions) =>
+        runStatefulExport(importedState, nextSessionState, exportOptions),
+      embeddedDocumentManifests: embeddedDocumentManifestsEarly,
+      ...(embeddedWorkflowPayload?.editorState
+        ? { initialEditorStatePayload: embeddedWorkflowPayload.editorState }
+        : {}),
+    };
+  } catch (error) {
+    return createDiagnosticsSession(
+      options,
+      createImportDiagnosticsFromError(error),
+    );
+  }
+}
+
+/**
+ * Session-layer owner of the sync load path.
+ *
+ * Slice 5e-7.e.2 relocates the body of `loadDocxEditorSession` from
+ * `src/io/docx-session.ts` into this module. Body mirrors
+ * `loadDocxSessionAsync` minus the async-only orchestration shell:
+ *   - No `scheduler.yield()` calls (sync execution).
+ *   - No laycache short-circuit branch (`laycacheEnvelope` is not on
+ *     `LoadDocxEditorSessionOptions`).
+ *   - No progressive-snapshot branch (`onProgressiveSnapshot` / 
+ *     `surfaceProjector` not on `LoadDocxEditorSessionOptions`).
+ *   - Uses `normalizeParsedTextDocument` (sync).
+ *
+ * Byte-equivalence with the async path is asserted by
+ * `test/io/fastload-parity.test.ts` on every F*.docx fixture. Drift
+ * between the two sync/async bodies will fail that test.
+ */
+export function loadDocxSessionSync(
+  options: LoadDocxEditorSessionOptions,
+): LoadedDocxEditorSession {
+  const editorBuild =
+    typeof options.editorBuild === "string" && options.editorBuild.length > 0
+      ? options.editorBuild
+      : "dev";
+  const sourceBytes = toUint8Array(options.bytes);
+
+  const stages = createStageEmitter(options.onLoadStage);
+
+  let sourcePackage: OpcPackage;
+
+  try {
+    sourcePackage = readOpcPackage(sourceBytes);
+  } catch (error) {
+    return createDiagnosticsSession(
+      options,
+      createPackageImportDiagnostics({
+        issue: classifyCorruptPackageError(error),
+      }),
+    );
+  }
+  stages.emit("opc");
+  const embeddedWorkflowPayload = parseWorkflowPayloadEnvelopeFromPackage(sourcePackage);
+  const embeddedWorkflowMetadata = embeddedWorkflowPayload?.workflowMetadata;
+  const embeddedWorkflowOverlay = embeddedWorkflowPayload?.workflowOverlay;
+
+  const mainDocumentPath = resolveMainDocumentPartPath(sourcePackage);
+  const brokenRelationshipIssues = collectBrokenInternalRelationshipIssues(
+    sourcePackage,
+    mainDocumentPath,
+  );
+  if (brokenRelationshipIssues.length > 0) {
+    return createDiagnosticsSession(
+      options,
+      createPackageImportDiagnostics({
+        issue: {
+          ...brokenRelationshipIssues[0],
+          message: summarizeBrokenRelationshipIssues(brokenRelationshipIssues),
+          details: {
+            issueCount: brokenRelationshipIssues.length,
+            targets: brokenRelationshipIssues.map((issue) => issue.targetPartPath).filter(Boolean),
+          },
+        },
+      }),
+    );
+  }
+
+  if (!mainDocumentPath) {
+    return createDiagnosticsSession(
+      options,
+      createPackageImportDiagnostics({
+        issue: createMissingPartIssue(MAIN_DOCUMENT_PATH),
+      }),
+    );
+  }
+
+  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,
+    );
+    const parsedNumbering = numberingPartPath
+      ? parseNumberingXml(
+          decodeUtf8(sourcePackage.parts.get(numberingPartPath)?.bytes ?? new Uint8Array()),
+          {
+            relationships: sourcePackage.parts.get(numberingPartPath)?.relationships,
+            partPath: numberingPartPath,
+          },
+        )
+      : createEmptyNumberingCatalog();
+    const mediaParts = collectInlineMediaParts(sourcePackage);
+    const chartPartLookup = createChartPartLookup(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+    );
+    if (options.telemetryBus) {
+      setActiveParseTelemetryBus(options.telemetryBus as ParseTelemetryBusParam);
+    }
+    let parsedDocument;
+    try {
+      parsedDocument = parseMainDocumentXml(
+        sourceDocumentXml,
+        documentPart.relationships,
+        mediaParts,
+        mainDocumentPath,
+        chartPartLookup,
+      );
+    } finally {
+      if (options.telemetryBus) setActiveParseTelemetryBus(undefined);
+    }
+    const protectionRanges = extractProtectionRanges(parsedDocument.blocks);
+    const normalizedDocument = normalizeParsedTextDocument(
+      parsedDocument,
+      mainDocumentPath,
+    );
+    stages.emit("body");
+    const commentsPartPath = resolveCommentsPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      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,
+    );
+    const parsedComments = commentsPartPath
+      ? parseCommentsFromOoxml(
+          sourceDocumentXml,
+          {
+            commentsXml: decodeUtf8(sourcePackage.parts.get(commentsPartPath)?.bytes ?? new Uint8Array()),
+            commentsExtendedXml: decodeUtf8(
+              sourcePackage.parts.get(commentsExtendedPartPath ?? "")?.bytes ?? new Uint8Array(),
+            ),
+            commentsIdsXml: decodeUtf8(
+              sourcePackage.parts.get(commentsIdsPartPath ?? "")?.bytes ?? new Uint8Array(),
+            ),
+            peopleXml: decodeUtf8(
+              sourcePackage.parts.get(peoplePartPath ?? "")?.bytes ?? new Uint8Array(),
+            ),
+          },
+        )
+      : {
+          threads: [] as CommentThread[],
+          diagnostics: [] as CommentImportDiagnostic[],
+          definitions: [] as ImportedCommentDefinition[],
+          sourceRootTag: undefined,
+          sourceExtendedRootTag: undefined,
+          sourceIdsRootTag: undefined,
+          sourcePeopleRootTag: undefined,
+          peopleAuthors: [] as string[],
+        };
+    const normalizedRevisions = normalizeImportedRevisionRecords(
+      importedRevisions,
+      normalizedDocument.content,
+      normalizedDocument.preservation.opaqueFragments,
+    );
+    const normalizedComments = normalizeImportedCommentThreads(
+      parsedComments,
+      normalizedDocument.preservation.opaqueFragments,
+      normalizedRevisions.revisions,
+    );
+    stages.emit("styles-numbering-comments");
+    const importedStoryRevisions: ReviewRevisionRecord[] = [];
+    const importedStoryRevisionDiagnostics: ParsedRevisionsResult["diagnostics"] = [];
+    const subPartOpaqueState = createSubPartOpaqueImportState(
+      normalizedDocument.preservation.opaqueFragments,
+      normalizedDocument.diagnostics.warnings,
+    );
+    // ---- Parse sub-parts: headers, footers, footnotes, endnotes, theme ----
+    const headerFooterRefs = parseHeaderFooterReferences(sourceDocumentXml);
+    const parsedHeaders: HeaderDocument[] = [];
+    const parsedFooters: FooterDocument[] = [];
+    const sourceHeaderPaths: Array<{ partPath: string; relationshipId: string }> = [];
+    const sourceFooterPaths: Array<{ partPath: string; relationshipId: string }> = [];
+    const seenSubPartKeys = new Set<string>();
+
+    for (const ref of headerFooterRefs) {
+      const dedupeKey = `${ref.kind}:${ref.variant}:${ref.relationshipId}`;
+      if (seenSubPartKeys.has(dedupeKey)) {
+        continue;
+      }
+      seenSubPartKeys.add(dedupeKey);
+
+      const relationship = documentPart.relationships.find(
+        (r) => r.id === ref.relationshipId && r.targetMode === "internal",
+      );
+      if (!relationship) {
+        continue;
+      }
+
+      const partPath = resolveRelationshipTarget(mainDocumentPath, relationship);
+      const part = sourcePackage.parts.get(partPath);
+      const partBytes = part?.bytes;
+      if (!partBytes) {
+        continue;
+      }
+
+      const xml = decodeUtf8(partBytes);
+      const subPartRelationships = part?.relationships ?? [];
+      const subPartChartPartLookup = createChartPartLookup(
+        sourcePackage,
+        partPath,
+        subPartRelationships,
+      );
+      if (ref.kind === "header") {
+        const parsedHeaderRevisions = parseRevisionsFromStoryXml(xml);
+        const parsed = parseHeaderXml(xml, {
+          relationships: subPartRelationships,
+          mediaParts,
+          sourcePartPath: partPath,
+          chartPartLookup: subPartChartPartLookup,
+        });
+        parsedHeaders.push({
+          variant: ref.variant,
+          partPath,
+          relationshipId: ref.relationshipId,
+          ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+          blocks: normalizeSubPartOpaqueBlocks(
+            parsed.blocks,
+            normalizedDocument.preservation.opaqueFragments,
+            normalizedDocument.diagnostics.warnings,
+            partPath,
+            subPartOpaqueState,
+          ),
+        });
+        importedStoryRevisions.push(
+          ...parsedHeaderRevisions.revisions.map((revision): ReviewRevisionRecord => ({
+            ...revision,
+            metadata: {
+              ...revision.metadata,
+              storyTarget: {
+                kind: "header" as const,
+                relationshipId: ref.relationshipId,
+                variant: ref.variant,
+                ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+              },
+            },
+          })),
+        );
+        importedStoryRevisionDiagnostics.push(...parsedHeaderRevisions.diagnostics);
+        sourceHeaderPaths.push({ partPath, relationshipId: ref.relationshipId });
+      } else {
+        const parsedFooterRevisions = parseRevisionsFromStoryXml(xml);
+        const parsed = parseFooterXml(xml, {
+          relationships: subPartRelationships,
+          mediaParts,
+          sourcePartPath: partPath,
+          chartPartLookup: subPartChartPartLookup,
+        });
+        parsedFooters.push({
+          variant: ref.variant,
+          partPath,
+          relationshipId: ref.relationshipId,
+          ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+          blocks: normalizeSubPartOpaqueBlocks(
+            parsed.blocks,
+            normalizedDocument.preservation.opaqueFragments,
+            normalizedDocument.diagnostics.warnings,
+            partPath,
+            subPartOpaqueState,
+          ),
+        });
+        importedStoryRevisions.push(
+          ...parsedFooterRevisions.revisions.map((revision): ReviewRevisionRecord => ({
+            ...revision,
+            metadata: {
+              ...revision.metadata,
+              storyTarget: {
+                kind: "footer" as const,
+                relationshipId: ref.relationshipId,
+                variant: ref.variant,
+                ...(ref.sectionIndex !== undefined ? { sectionIndex: ref.sectionIndex } : {}),
+              },
+            },
+          })),
+        );
+        importedStoryRevisionDiagnostics.push(...parsedFooterRevisions.diagnostics);
+        sourceFooterPaths.push({ partPath, relationshipId: ref.relationshipId });
+      }
+    }
+
+    const footnotesPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      FOOTNOTES_RELATIONSHIP_TYPE,
+      FOOTNOTES_PART_PATH,
+    );
+    const footnotesRelationshipId = documentPart.relationships.find(
+      (r) => r.type === FOOTNOTES_RELATIONSHIP_TYPE && r.targetMode === "internal",
+    )?.id;
+    const endnotesPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      ENDNOTES_RELATIONSHIP_TYPE,
+      ENDNOTES_PART_PATH,
+    );
+    const endnotesRelationshipId = documentPart.relationships.find(
+      (r) => r.type === ENDNOTES_RELATIONSHIP_TYPE && r.targetMode === "internal",
+    )?.id;
+
+    let footnoteCollection: FootnoteCollection | undefined;
+    if (footnotesPartPath) {
+      footnoteCollection = parseFootnotesXml(
+        decodeUtf8(sourcePackage.parts.get(footnotesPartPath)?.bytes ?? new Uint8Array()),
+      );
+      normalizeFootnoteCollectionOpaqueBlocks(
+        footnoteCollection,
+        "footnote",
+        normalizedDocument.preservation.opaqueFragments,
+        normalizedDocument.diagnostics.warnings,
+        footnotesPartPath,
+        subPartOpaqueState,
+      );
+    }
+    if (endnotesPartPath) {
+      footnoteCollection = parseEndnotesXml(
+        decodeUtf8(sourcePackage.parts.get(endnotesPartPath)?.bytes ?? new Uint8Array()),
+        footnoteCollection,
+      );
+      normalizeFootnoteCollectionOpaqueBlocks(
+        footnoteCollection,
+        "endnote",
+        normalizedDocument.preservation.opaqueFragments,
+        normalizedDocument.diagnostics.warnings,
+        endnotesPartPath,
+        subPartOpaqueState,
+      );
+    }
+
+    const themeRelationship = documentPart.relationships.find(
+      (r) => r.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" &&
+        r.targetMode === "internal",
+    );
+    const themePartPath = themeRelationship
+      ? resolveRelationshipTarget(mainDocumentPath, themeRelationship)
+      : undefined;
+    const parsedTheme =
+      themePartPath && sourcePackage.parts.has(themePartPath)
+        ? parseThemeXml(
+            decodeUtf8(sourcePackage.parts.get(themePartPath)?.bytes ?? new Uint8Array()),
+          )
+        : undefined;
+    const resolvedTheme = parsedTheme ? resolveTheme(parsedTheme) : undefined;
+    const settingsPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      SETTINGS_RELATIONSHIP_TYPE,
+      SETTINGS_PART_PATH,
+    );
+    const parsedSettings =
+      settingsPartPath && sourcePackage.parts.has(settingsPartPath)
+        ? parseSettingsXml(
+            decodeUtf8(sourcePackage.parts.get(settingsPartPath)?.bytes ?? new Uint8Array()),
+          )
+        : undefined;
+    const canonicalTheme =
+      parsedTheme !== undefined
+        ? materializeCanonicalTheme(
+            parsedTheme,
+            parsedSettings?.clrSchemeMapping ?? {},
+          )
+        : undefined;
+    const settingsXmlForProtection =
+      settingsPartPath && sourcePackage.parts.has(settingsPartPath)
+        ? decodeUtf8(sourcePackage.parts.get(settingsPartPath)?.bytes ?? new Uint8Array())
+        : "";
+    const documentProtection = extractDocumentProtection(settingsXmlForProtection);
+    const importedProtectionSnapshot = buildProtectionSnapshot(documentProtection, protectionRanges);
+
+    // ---- Parse styles.xml for canonical style catalog ----
+    const stylesPartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      STYLES_RELATIONSHIP_TYPE,
+      STYLES_PART_PATH,
+    );
+    const parsedStyles =
+      stylesPartPath && sourcePackage.parts.has(stylesPartPath)
+        ? parseStylesXml(
+            decodeUtf8(sourcePackage.parts.get(stylesPartPath)?.bytes ?? new Uint8Array()),
+          )
+        : parseStylesXml("");
+
+    // ---- Parse fontTable.xml for canonical font catalog ----
+    const fontTablePartPath = resolveDocumentRelatedPartPath(
+      sourcePackage,
+      mainDocumentPath,
+      documentPart.relationships,
+      FONT_TABLE_RELATIONSHIP_TYPE,
+      FONT_TABLE_PART_PATH,
+    );
+    const parsedFontTable =
+      fontTablePartPath && sourcePackage.parts.has(fontTablePartPath)
+        ? parseFontTable(
+            decodeUtf8(sourcePackage.parts.get(fontTablePartPath)?.bytes ?? new Uint8Array()),
+          )
+        : undefined;
+
+    const mergedMedia = mergeSecondaryStoryMediaCatalog(normalizedDocument.media, {
+      headers: parsedHeaders,
+      footers: parsedFooters,
+      footnoteCollection,
+      mediaParts,
+    });
+
+    const subParts: SubPartsCatalog | undefined =
+      parsedHeaders.length > 0 ||
+      parsedFooters.length > 0 ||
+      footnoteCollection !== undefined ||
+      parsedTheme !== undefined ||
+      normalizedDocument.finalSectionProperties !== undefined ||
+      resolvedTheme !== undefined ||
+      canonicalTheme !== undefined ||
+      parsedSettings !== undefined
+        ? {
+            headers: parsedHeaders,
+            footers: parsedFooters,
+            ...(footnoteCollection !== undefined ? { footnoteCollection } : {}),
+            ...(parsedTheme !== undefined ? { theme: parsedTheme } : {}),
+            ...(normalizedDocument.finalSectionProperties !== undefined
+              ? { finalSectionProperties: normalizedDocument.finalSectionProperties }
+              : {}),
+            ...(resolvedTheme !== undefined ? { resolvedTheme } : {}),
+            ...(canonicalTheme !== undefined ? { canonicalTheme } : {}),
+            ...(parsedSettings !== undefined ? { settings: parsedSettings } : {}),
+          }
+        : undefined;
+
+    const timestamp = new Date().toISOString();
+    const translatedWorkflowState = translateClmCommentsToWorkflow({
+      comments: normalizedComments.threads,
+      workflowOverlay: embeddedWorkflowOverlay,
+      workflowMetadata: embeddedWorkflowMetadata,
+      timestamp,
+    });
+    // P8 Step 7 — sync loader path never calls `storeEmbeddedDocument`
+    // (the host adapter is async, and this entire loader is sync by
+    // contract — it's the SSR / Node fallback used by
+    // `editor-runtime-boundary`'s `createRuntime`). The REOPEN path
+    // is still supported: if the package already carries a
+    // `bw:embeddings` customXml namespace from a prior offload, we
+    // hydrate entries so the export reconstitute path runs correctly.
+    const rehydratedOffloadSync = hydrateOffloadEntriesFromPayload(
+      embeddedWorkflowPayload?.editorState,
+    );
+    const embeddedDocumentManifestsSync = collectEmbeddedDocuments(
+      sourcePackage,
+      mainDocumentPath,
+    ).manifests;
+    const document = createImportedCanonicalDocument({
+      documentId: options.documentId,
+      timestamp,
+      numbering: parsedNumbering,
+      media: mergedMedia,
+      content: normalizedDocument.content,
+      subParts,
+      parsedStyles,
+      fontTable: parsedFontTable,
+      preservation: buildImportPreservation(normalizedDocument.preservation, sourcePackage, [
+        mainDocumentPath,
+        numberingPartPath,
+        commentsPartPath,
+        commentsExtendedPartPath,
+        commentsIdsPartPath,
+        peoplePartPath,
+        ...rehydratedOffloadSync.ownedPartPaths,
+      ]),
+      diagnostics: {
+        warnings: [
+          ...createBrokenRelationshipWarnings(sourcePackage, mainDocumentPath),
+          ...normalizedDocument.diagnostics.warnings,
+          ...mapRevisionDiagnosticsToWarnings(normalizedRevisions.diagnostics),
+          ...mapStoryRevisionDiagnosticsToWarnings(importedStoryRevisionDiagnostics),
+          ...mapCommentDiagnosticsToWarnings(normalizedComments.diagnostics),
+        ],
+        errors: [],
+      },
+      review: {
+        comments: toRuntimeCommentRecords(translatedWorkflowState.comments),
+        revisions: toRuntimeRevisionRecords([
+          ...normalizedRevisions.revisions,
+          ...importedStoryRevisions,
+        ]),
+      },
+    });
+    const compatibility = buildCompatibilityReport({
+      document,
+      generatedAt: timestamp,
+    });
+    const snapshot = createImportedSnapshot({
+      documentId: options.documentId,
+      editorBuild,
+      timestamp,
+      document,
+      compatibility,
+      protectionSnapshot: importedProtectionSnapshot,
+      sourcePackage: createPersistedSourcePackage(sourceBytes, options.sourceLabel),
+      workflowOverlay: translatedWorkflowState.workflowOverlay,
+      workflowMetadata: translatedWorkflowState.workflowMetadata,
+      visibilityPolicies: embeddedWorkflowPayload?.visibilityPolicies,
+      markupModePolicy: embeddedWorkflowPayload?.markupModePolicy ?? undefined,
+    });
+    const snapshotIssues = validatePersistedEditorSnapshot(snapshot);
+    if (snapshotIssues.length > 0) {
+      const firstIssue = snapshotIssues[0];
+      return createDiagnosticsSession(
+        options,
+        createValidationImportDiagnostics({
+          message: `DOCX import produced an invalid editor state during validation${firstIssue ? ` (${firstIssue.path}: ${firstIssue.message})` : "."}`,
+          source: "import",
+          details: {
+            issueCount: snapshotIssues.length,
+            firstIssuePath: firstIssue?.path,
+          },
+        }),
+      );
+    }
+    const initialSessionState = editorSessionStateFromPersistedSnapshot(snapshot);
+    const importedState: ImportedDocxState = {
+      sourceBytes: new Uint8Array(sourceBytes),
+      sourcePackage,
+      sourceDocumentXml,
+      sourceDocumentPartPath: mainDocumentPath,
+      sourceDocumentRelationships: documentPart.relationships,
+      sourceDocumentAttributes: extractDocumentRootAttributes(sourceDocumentXml),
+      sourceNumberingPartPath: numberingPartPath,
+      sourceNumberingRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === NUMBERING_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceSettingsPartPath: settingsPartPath,
+      sourceSettingsXml:
+        settingsXmlForProtection.length > 0 ? settingsXmlForProtection : undefined,
+      sourceCommentsPartPath: commentsPartPath,
+      sourceCommentsRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === COMMENTS_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceCommentsRootTag: normalizedComments.sourceRootTag,
+      sourceCommentsExtendedPartPath: commentsExtendedPartPath,
+      sourceCommentsExtendedRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === COMMENTS_EXTENDED_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceCommentsExtendedRootTag: normalizedComments.sourceExtendedRootTag,
+      sourceCommentsIdsPartPath: commentsIdsPartPath,
+      sourceCommentsIdsRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === COMMENTS_IDS_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourceCommentsIdsRootTag: normalizedComments.sourceIdsRootTag,
+      sourcePeoplePartPath: peoplePartPath,
+      sourcePeopleRelationshipId: documentPart.relationships.find(
+        (relationship) =>
+          relationship.type === PEOPLE_RELATIONSHIP_TYPE &&
+          relationship.targetMode === "internal",
+      )?.id,
+      sourcePeopleRootTag: normalizedComments.sourcePeopleRootTag,
+      sourcePeopleAuthors: normalizedComments.peopleAuthors,
+      protectionSnapshot: buildProtectionSnapshot(documentProtection, protectionRanges),
+      preservedCommentDefinitions: normalizedComments.preservedDefinitions,
+      blockingCommentDiagnostics: normalizedComments.diagnostics.filter((diagnostic) =>
+        BLOCKING_COMMENT_DIAGNOSTIC_CODES.has(diagnostic.code),
+      ),
+      initialCanonicalSignature: serializeCanonicalDocumentForExport(document),
+      sourceSubPartPaths: {
+        headers: sourceHeaderPaths,
+        footers: sourceFooterPaths,
+        footnotesPartPath,
+        footnotesRelationshipId,
+        endnotesPartPath,
+        endnotesRelationshipId,
+        themePartPath,
+        themeRelationshipId: themeRelationship?.id,
+      },
+      embeddingOffloadEntries: rehydratedOffloadSync.entries,
+      ...(options.hostAdapter !== undefined
+        ? { hostAdapter: options.hostAdapter }
+        : {}),
+    };
+
+    stages.emit("skeleton-ready");
+    return {
+      initialSessionState,
+      initialSnapshot: snapshot,
+      readOnly: false,
+      protectionSnapshot: importedProtectionSnapshot,
+      exportDocx: async (nextSessionState, exportOptions) =>
+        runStatefulExport(importedState, nextSessionState, exportOptions),
+      embeddedDocumentManifests: embeddedDocumentManifestsSync,
+      ...(embeddedWorkflowPayload?.editorState
+        ? { initialEditorStatePayload: embeddedWorkflowPayload.editorState }
+        : {}),
+    };
+  } catch (error) {
+    return createDiagnosticsSession(
+      options,
+      createImportDiagnosticsFromError(error),
+    );
+  }
+}