@beyondwork/docx-react-component 1.0.42 → 1.0.43

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@beyondwork/docx-react-component",
   "publisher": "beyondwork",
-  "version": "1.0.42",
+  "version": "1.0.43",
   "description": "Embeddable React Word (docx) editor with review, comments, tracked changes, and round-trip OOXML fidelity.",
-  "packageManager": "pnpm@10.30.3",
   "type": "module",
   "sideEffects": [
     "**/*.css"
@@ -93,35 +92,6 @@
     "./ui-tailwind/theme/editor-theme.css": "./src/ui-tailwind/theme/editor-theme.css"
   },
   "types": "./src/index.ts",
-  "scripts": {
-    "build": "tsup",
-    "test": "bash scripts/run-workspace-tests.sh",
-    "test:repo": "node scripts/run-repo-tests.mjs core",
-    "test:repo:all": "node scripts/run-repo-tests.mjs all",
-    "test:repo:optional": "node scripts/run-repo-tests.mjs optional",
-    "test:repo:browser-ui": "node scripts/run-repo-tests.mjs browser-ui",
-    "test:wcag-audit": "node scripts/run-repo-tests.mjs wcag-audit",
-    "test:harness": "pnpm --filter @docx-react-component/react-word-editor-harness test",
-    "test:visual": "VISUAL_SMOKE_PROFILE=bare pnpm exec playwright test --project=chromium",
-    "test:visual:chrome": "VISUAL_SMOKE_PROFILE=chrome-cycle pnpm exec playwright test --project=chromium",
-    "visual:list-runs": "node scripts/visual-smoke-list-runs.mjs",
-    "mcp:visual-smoke": "node scripts/visual-smoke-mcp.mjs",
-    "lint": "pnpm run lint:no-authored-js && pnpm run lint:docs-contracts && pnpm run lint:tsgo && pnpm run lint:tsgo:harness",
-    "lint:docs-contracts": "bash scripts/check-reference-load-contract.sh",
-    "lint:no-authored-js": "bash scripts/check-no-authored-js.sh",
-    "lint:tsgo": "tsgo --noEmit -p tsconfig.build.json",
-    "lint:tsgo:harness": "pnpm --filter @docx-react-component/react-word-editor-harness lint:tsgo",
-    "context7:api-check": "bash scripts/context7-export-env.sh run bash scripts/context7-api-check.sh",
-    "wave:doctor": "bash scripts/context7-export-env.sh run pnpm exec wave doctor --json",
-    "wave:dry-run": "bash scripts/context7-export-env.sh run pnpm exec wave launch --lane main --dry-run --no-dashboard",
-    "wave:launch": "bash scripts/context7-export-env.sh run pnpm exec wave launch --lane main",
-    "wave:launch:managed": "bash scripts/wave-launch.sh",
-    "wave:status": "bash scripts/wave-status.sh",
-    "wave:watch": "bash scripts/wave-watch.sh --follow",
-    "wave:dashboard:current": "bash scripts/wave-dashboard-attach.sh current",
-    "wave:dashboard:global": "bash scripts/wave-dashboard-attach.sh global",
-    "harness:dev": "pnpm --filter @docx-react-component/react-word-editor-harness dev"
-  },
   "keywords": [
     "docx",
     "word",
@@ -204,14 +174,33 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.30"
   },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild",
-      "sharp"
-    ],
-    "overrides": {
-      "react": "19.2.4",
-      "react-dom": "19.2.4"
-    }
+  "scripts": {
+    "build": "tsup",
+    "test": "bash scripts/run-workspace-tests.sh",
+    "test:repo": "node scripts/run-repo-tests.mjs core",
+    "test:repo:all": "node scripts/run-repo-tests.mjs all",
+    "test:repo:optional": "node scripts/run-repo-tests.mjs optional",
+    "test:repo:browser-ui": "node scripts/run-repo-tests.mjs browser-ui",
+    "test:wcag-audit": "node scripts/run-repo-tests.mjs wcag-audit",
+    "test:harness": "pnpm --filter @docx-react-component/react-word-editor-harness test",
+    "test:visual": "VISUAL_SMOKE_PROFILE=bare pnpm exec playwright test --project=chromium",
+    "test:visual:chrome": "VISUAL_SMOKE_PROFILE=chrome-cycle pnpm exec playwright test --project=chromium",
+    "visual:list-runs": "node scripts/visual-smoke-list-runs.mjs",
+    "mcp:visual-smoke": "node scripts/visual-smoke-mcp.mjs",
+    "lint": "pnpm run lint:no-authored-js && pnpm run lint:docs-contracts && pnpm run lint:tsgo && pnpm run lint:tsgo:harness",
+    "lint:docs-contracts": "bash scripts/check-reference-load-contract.sh",
+    "lint:no-authored-js": "bash scripts/check-no-authored-js.sh",
+    "lint:tsgo": "tsgo --noEmit -p tsconfig.build.json",
+    "lint:tsgo:harness": "pnpm --filter @docx-react-component/react-word-editor-harness lint:tsgo",
+    "context7:api-check": "bash scripts/context7-export-env.sh run bash scripts/context7-api-check.sh",
+    "wave:doctor": "bash scripts/context7-export-env.sh run pnpm exec wave doctor --json",
+    "wave:dry-run": "bash scripts/context7-export-env.sh run pnpm exec wave launch --lane main --dry-run --no-dashboard",
+    "wave:launch": "bash scripts/context7-export-env.sh run pnpm exec wave launch --lane main",
+    "wave:launch:managed": "bash scripts/wave-launch.sh",
+    "wave:status": "bash scripts/wave-status.sh",
+    "wave:watch": "bash scripts/wave-watch.sh --follow",
+    "wave:dashboard:current": "bash scripts/wave-dashboard-attach.sh current",
+    "wave:dashboard:global": "bash scripts/wave-dashboard-attach.sh global",
+    "harness:dev": "pnpm --filter @docx-react-component/react-word-editor-harness dev"
   }
-}
+}

package/src/api/editor-state-types.ts

@@ -0,0 +1,110 @@
+/**
+ * Editor-State Persistence Channel (schema 1.2).
+ *
+ * Makes the .docx act as a load/save API for editor-level overlay
+ * state (host annotations, workflow overlay, workflow metadata, work
+ * items, and future subsystems).  Storage policy per subsystem is
+ * host-controlled across three locations:
+ *
+ * - `"in-document"`  — full blob serialized into /customXml/item1.xml
+ * - `"rowstore"`     — doc carries a key reference; host persists the blob
+ * - `"key-only"`     — doc carries only a correlation key; host rehydrates
+ *
+ * See docs/plans/editor-state-persistence.md for the full design.  1.2
+ * extends schema 1.1 additively (unknown namespaces are preserved
+ * opaquely per existing forward-compat rules).
+ */
+export type EditorStateNamespace =
+  | "hostAnnotations"
+  | "workflowOverlay"
+  | "workflowMetadata"
+  | "workItems";
+
+export type EditorStateLocation = "in-document" | "rowstore" | "key-only";
+
+export type EditorStateResolveErrorMode = "block" | "empty" | "retain-last-known";
+
+/**
+ * Host-configured per-namespace persistence policy.  Default (when
+ * absent) is {location: "in-document", onResolveError: "block",
+ * debounceMs: 250}, which preserves current behavior.
+ */
+export interface EditorStatePolicyEntry {
+  location: EditorStateLocation;
+  /** Host-provided correlation key (e.g. review_session_id). Editor generates a UUID if absent. */
+  key?: string;
+  onResolveError?: EditorStateResolveErrorMode;
+  debounceMs?: number;
+}
+
+export type EditorStatePolicy = Partial<
+  Record<EditorStateNamespace, EditorStatePolicyEntry>
+>;
+
+/**
+ * Reference stored in the docx when the subsystem is backed by a
+ * host-owned store.  The editor never interprets entryKey — it round-
+ * trips verbatim via resolver + persister callbacks.
+ */
+export interface EditorStateStorageRef {
+  namespace: EditorStateNamespace;
+  location: Exclude<EditorStateLocation, "in-document">;
+  entryKey: string;
+  schemaVersion: string;
+}
+
+/**
+ * Typed blob the resolver returns and the persister accepts.
+ * `data` is the subsystem-specific payload (e.g. a HostAnnotationOverlay
+ * for the "hostAnnotations" namespace).  Use `schemaVersion` to pin the
+ * blob shape so older hosts don't silently load newer blobs.
+ */
+export interface EditorStateBlob {
+  namespace: EditorStateNamespace;
+  schemaVersion: string;
+  data: unknown;
+}
+
+/**
+ * Host-supplied pull-resolver.  Returns `null` when the entry key is
+ * unknown or revoked.  Matches the ScopeMetadataResolver undefined
+ * convention but allows null explicitly per the design doc §5 for
+ * symmetry with Promise<T | null> idioms.  Either is acceptable as
+ * "not found"; internal code normalizes.
+ */
+export type EditorStateResolver = (
+  namespace: EditorStateNamespace,
+  entryKey: string,
+) => Promise<EditorStateBlob | null>;
+
+/**
+ * Host-supplied persister.  Called after the editor's debounce window
+ * when a subsystem's state has changed under `rowstore` or `key-only`
+ * policy.  Must be idempotent within the debounce window.
+ */
+export type EditorStatePersister = (
+  namespace: EditorStateNamespace,
+  entryKey: string,
+  blob: EditorStateBlob,
+) => Promise<void>;
+
+export interface EditorStatePolicyMigration {
+  namespace: EditorStateNamespace;
+  from: EditorStateLocation;
+  to: EditorStateLocation;
+  key?: string;
+}
+
+export interface EditorStatePartLoadFailure {
+  namespace: EditorStateNamespace;
+  entryKey?: string;
+  error: Error;
+  fallback: "empty" | "retain-last-known";
+}
+
+export interface EditorStatePartPersistFailure {
+  namespace: EditorStateNamespace;
+  entryKey: string;
+  error: Error;
+  attemptCount: number;
+}

package/src/api/public-types.ts

@@ -9,6 +9,20 @@ import type {
   ScopeMetadataResolver,
   ScopeMetadataStorageRef,
 } from "./scope-metadata-resolver-types.ts";
+import type {
+  EditorStateNamespace,
+  EditorStateLocation,
+  EditorStateResolveErrorMode,
+  EditorStatePolicyEntry,
+  EditorStatePolicy,
+  EditorStateStorageRef,
+  EditorStateBlob,
+  EditorStateResolver,
+  EditorStatePersister,
+  EditorStatePolicyMigration,
+  EditorStatePartLoadFailure,
+  EditorStatePartPersistFailure,
+} from "./editor-state-types.ts";
 
 export type {
   MetadataPersistenceMode,
@@ -16,6 +30,20 @@ export type {
   ScopeMetadataResolver,
   ScopeMetadataStorageRef,
 };
+export type {
+  EditorStateNamespace,
+  EditorStateLocation,
+  EditorStateResolveErrorMode,
+  EditorStatePolicyEntry,
+  EditorStatePolicy,
+  EditorStateStorageRef,
+  EditorStateBlob,
+  EditorStateResolver,
+  EditorStatePersister,
+  EditorStatePolicyMigration,
+  EditorStatePartLoadFailure,
+  EditorStatePartPersistFailure,
+};
 
 export type { CanonicalParagraphFormatting, CanonicalRunFormatting };
 
@@ -34,6 +62,8 @@ export type {
   PublicPageRegion,
   PublicPageRegions,
   PublicPageSpan,
+  PublicRegionBlock,
+  PublicRegionKind,
   PublicResolvedPageStories,
   PublicResolvedParagraphFormatting,
   PublicResolvedRunFormatting,
@@ -753,7 +783,7 @@ export type SurfaceInlineSegment =
         textColor?: string;
       };
       hyperlinkHref?: string;
-      /** Cascaded run formatting for this text segment (docDefaults → paragraph style chain → character style → direct). Added in Task 11. TODO Task 15: wire up from resolveEffectiveRunFormatting in surface-projection. */
+      /** Cascaded run formatting for this text segment (docDefaults → paragraph style chain → character style → direct). Populated in `src/runtime/surface-projection.ts` via `resolveEffectiveRunFormatting`. Present only when the resolved cascade has at least one field. */
       resolvedRunFormatting?: CanonicalRunFormatting;
     }
   | {
@@ -787,6 +817,14 @@ export type SurfaceInlineSegment =
       blockedReasonCode?: "workflow_preserve_only" | "workflow_blocked_import";
       presentation?: "inline-chip" | "quiet-marker" | "text-box" | "checkbox";
       displayText?: string;
+      /**
+       * For chart/SmartArt/WordArt/VML opaque inlines, the media-catalog id
+       * of the preview bitmap extracted from `mc:Fallback` (when Word cached
+       * one). Resolved by the surface into a blob URL and rendered by the
+       * corresponding PM atom so reviewers see the chart picture instead of
+       * a text badge. Absent when the object has no cached fallback image.
+       */
+      previewMediaId?: string;
       state: "locked-preserve-only";
     }
   | {
@@ -2299,6 +2337,25 @@ export interface AutosaveConfig {
   debounceMs?: number;
 }
 
+/**
+ * Fired after a plain-text paste or drop has been dispatched through
+ * the runtime-owned input callbacks. Rich-text paste (HTML, Office
+ * clipboard) does NOT produce this event — those payloads still fire
+ * `onBlockedInput` with a distinguishing message.
+ *
+ * See `docs/plans/editor-paste-drop.md` for the full semantics.
+ */
+export interface WordReviewEditorPasteEvent {
+  type: "paste_applied";
+  documentId: string;
+  /** Count of segments dispatched across text + split + hard_break. */
+  segmentCount: number;
+  /** Total character count across all text segments in the payload. */
+  charCount: number;
+  /** Whether the event originated from a paste or a drop. */
+  source: "paste" | "drop";
+}
+
 export type WordReviewEditorEvent =
   | {
       type: "ready";
@@ -2442,6 +2499,7 @@ export type WordReviewEditorEvent =
       command: string;
       reasons: WorkflowBlockedCommandReason[];
     }
+  | WordReviewEditorPasteEvent
   | {
       /**
        * Scope card mode selector fired a mode change. Host relays to the
@@ -2520,8 +2578,82 @@ export type WordReviewEditorEvent =
         version?: number;
       } | null;
       defaultPolicy: MetadataConflictPolicy;
+    }
+  | {
+      /**
+       * Schema 1.2 — emitted when a keyed namespace fails to resolve
+       * during load.  Subsystem fallback behavior is per `onResolveError`
+       * policy.
+       */
+      type: "editor_state_part_load_failed";
+      documentId: string;
+      failure: EditorStatePartLoadFailure;
+    }
+  | {
+      /**
+       * Schema 1.2 — emitted when a debounced persist call fails.
+       * The editor retains the dirty snapshot for retry.
+       */
+      type: "editor_state_part_persist_failed";
+      documentId: string;
+      failure: EditorStatePartPersistFailure;
+    }
+  | {
+      /**
+       * Schema 1.2 — emitted when the saved location in a docx differs
+       * from the current host policy; the current policy wins and the
+       * next serialize honors it.
+       */
+      type: "editor_state_policy_migrated";
+      documentId: string;
+      migration: EditorStatePolicyMigration;
+    }
+  | {
+      /**
+       * Schema 1.2 — emitted when an unknown namespace is encountered
+       * in the payload (forward-compat warning; preserved opaquely).
+       */
+      type: "editor_state_unknown_namespace";
+      documentId: string;
+      namespace: string;
+    }
+  | {
+      /**
+       * Emitted once per load-pipeline stage when the staged loader is
+       * active. Purely observational — hosts can render a progress chip
+       * or ignore entirely. See `docs/plans/fastload.md` for the stage
+       * ordering contract.
+       */
+      type: "load-stage";
+      documentId: string;
+      stage: LoadStage;
+      durationMs: number;
+    }
+  | {
+      /**
+       * Emitted once sub-parts (headers, footers, footnotes, endnotes,
+       * theme, settings) have finished their post-ready idle hydration.
+       * Before this event fires, `canonicalDocument.subParts.*` may be
+       * empty arrays / defaults; after it fires, they carry the parsed
+       * values. Calling `ensureSubPartsHydrated` eagerly forces
+       * hydration synchronously.
+       */
+      type: "subparts-hydrated";
+      documentId: string;
     };
 
+/**
+ * Ordered list of stages emitted by the staged load pipeline. The
+ * skeleton-ready stage corresponds to the `ready` event firing.
+ */
+export type LoadStage =
+  | "opc"
+  | "body"
+  | "styles-numbering-comments"
+  | "skeleton-ready"
+  | "subparts"
+  | "compatibility";
+
 export interface LoadResult {
   source?: ExternalDocumentSource;
 }
@@ -2767,6 +2899,35 @@ export interface WordReviewEditorRef {
    * registered.
    */
   convertScopesToExternal(scopeIds: string[]): Promise<void>;
+  /**
+   * Schema 1.2 — editor-state persistence channel.  Configures which
+   * subsystems persist in-document / rowstore / key-only.  Each call
+   * merges into the current policy map.  Mismatched locations with an
+   * already-loaded docx fire `editor_state_policy_migrated` and
+   * schedule the next serialize to honor the new location.
+   */
+  configureEditorStatePolicy(policy: EditorStatePolicy): void;
+  /**
+   * Register the host's pull-resolver.  Required before the editor
+   * loads a 1.2 docx whose policy includes any keyed location.
+   */
+  registerEditorStateResolver(resolver: EditorStateResolver): void;
+  /**
+   * Register the host's persister.  Required before any subsystem
+   * mutation under keyed policy fires a debounced persist.
+   */
+  registerEditorStatePersister(persister: EditorStatePersister): void;
+  /**
+   * Return the entry key currently associated with a namespace under
+   * keyed policy, or undefined when the namespace is in-document /
+   * key not yet assigned.
+   */
+  getEditorStateKey(namespace: EditorStateNamespace): string | undefined;
+  /**
+   * Re-attempt any persists that failed since the last successful
+   * write.  Pass a namespace to scope the retry; omit to retry all.
+   */
+  retryPendingPersist(namespace?: EditorStateNamespace): Promise<void>;
   setHostAnnotationOverlay(overlay: HostAnnotationOverlay): void;
   clearHostAnnotationOverlay(): void;
   getHostAnnotationSnapshot(): HostAnnotationSnapshot;
@@ -2866,6 +3027,38 @@ export interface WordReviewEditorProps {
   currentUser: EditorUser;
   ydoc?: import('yjs').Doc;
   awareness?: import("y-protocols/awareness").Awareness;
+  /**
+   * Optional collab session built via `createCollabSession(...)`. When
+   * set, the `"collab"` chrome preset mounts the top nav (presence
+   * strip, role + audience chips, tamper banner, negotiation action
+   * bar, send-to-supplier button). P9a–f components are pure
+   * presentational; this prop is what wires them to live state. Pass
+   * `undefined` to keep the chrome in non-collab mode even when
+   * `chromePreset === "collab"`.
+   */
+  collabSession?: import("../runtime/collab-session.ts").CollabSession;
+  /**
+   * Transport status signal for the presence strip + role chip (P9b /
+   * P9c). Optional — defaults to "offline" when omitted.
+   */
+  collabTransportStatus?: "connected" | "syncing" | "offline";
+  /**
+   * Identifier for the currently-focused comment, used by the collab
+   * top nav's audience chip + negotiation action bar (P9c / P9e). The
+   * host derives this from its own selection / rail-focus signal.
+   */
+  activeCommentId?: string;
+  /**
+   * Baseline metadata for the send-to-supplier flow (P9f). Required
+   * to enable the button; when omitted, the button stays present but
+   * the confirmation modal becomes a no-op pass-through.
+   */
+  collabSendBaseline?: {
+    originDocumentId: string;
+    originPayloadId: string;
+    originContentHash: string;
+    payloadXml: string;
+  };
   initialDocx?: Uint8Array | ArrayBuffer;
   initialSessionState?: EditorSessionState;
   initialSnapshot?: PersistedEditorSnapshot;

package/src/core/commands/index.ts

@@ -1791,22 +1791,46 @@ function combineMappingSteps(
 // Suggesting mode: creates revision records instead of (or alongside) text mutations
 // ---------------------------------------------------------------------------
 
-let suggestingRevisionCounter = 0;
-
+/**
+ * Builds a suggesting-mode revision id that is deterministic across
+ * clients. The id is a pure function of `(existing, timestamp, authorId)`
+ * so that origin and replica — both of whom see the same `existing`
+ * revisions record after a Yjs-ordered replay and receive the same
+ * `timestamp` + `authorId` on the broadcast command event — produce
+ * the same id for the same authored revision.
+ *
+ * Previously this used a module-level counter; that counter was shared
+ * across every `DocumentRuntime` in a single process and drifted between
+ * origin and replica whenever either side had other suggesting-mode work
+ * bump the counter before replay. Cross-client `change.accept(changeId)`
+ * / `change.reject(changeId)` then missed because the target id only
+ * existed on one side.
+ */
 function createSuggestingRevisionId(
   existing: Record<string, unknown>,
   timestamp: string,
+  authorId: string,
 ): string {
-  suggestingRevisionCounter += 1;
   const ts = timestamp.replace(/[^0-9]/gu, "");
-  let id = `change-${ts}-s${suggestingRevisionCounter}`;
+  const authorMarker = sanitizeAuthorMarker(authorId);
+  const prefix = `change-${authorMarker}-${ts}-s`;
+  let n = 1;
+  let id = `${prefix}${n}`;
   while (existing[id]) {
-    suggestingRevisionCounter += 1;
-    id = `change-${ts}-s${suggestingRevisionCounter}`;
+    n += 1;
+    id = `${prefix}${n}`;
   }
   return id;
 }
 
+function sanitizeAuthorMarker(authorId: string): string {
+  // OOXML `w:id` accepts alphanumerics plus `._-`; keep within that set so
+  // the id survives round-trips unchanged (see `sanitizeRevisionId` on the
+  // serializer side).
+  const cleaned = authorId.replace(/[^A-Za-z0-9._-]/g, "-");
+  return cleaned.length > 0 ? cleaned : "u";
+}
+
 function createAuthoredRevision(
   existing: Record<string, unknown>,
   kind: "insertion" | "deletion",
@@ -1816,7 +1840,7 @@ function createAuthoredRevision(
   timestamp: string,
   metadata: Partial<NonNullable<CanonicalRevisionRecord["metadata"]>> = {},
 ): CanonicalRevisionRecord {
-  const changeId = createSuggestingRevisionId(existing, timestamp);
+  const changeId = createSuggestingRevisionId(existing, timestamp, authorId);
   return {
     changeId,
     kind,
@@ -2066,6 +2090,7 @@ function applySuggestingInsert(
   const replacementSuggestionId = createSuggestingRevisionId(
     reviewState.document.review.revisions,
     context.timestamp,
+    authorId,
   );
 
   // Step 3: Create deletion revision for the selected range (text stays in place).
@@ -2324,7 +2349,7 @@ function applySuggestingInsertUnit(
     result.mapping,
   );
   const replacementSuggestionId = from !== to
-    ? createSuggestingRevisionId(reviewState.document.review.revisions, context.timestamp)
+    ? createSuggestingRevisionId(reviewState.document.review.revisions, context.timestamp, authorId)
     : undefined;
 
   // If non-collapsed, mark selected range as deletion (positions are pre-mapping, content preserved)

package/src/core/search/search-text.ts

@@ -26,7 +26,7 @@ export interface SecondaryStorySearchResult extends SurfaceSearchResult {
   storyTarget: EditorStoryTarget;
 }
 
-interface ProjectedSurfaceText {
+export interface ProjectedSurfaceText {
   text: string;
   offsetMap: Array<number | null>;
 }
@@ -112,7 +112,20 @@ export function searchSurfaceBlocks(
   query: string,
   options: SearchTextOptions = {},
 ): SurfaceSearchResult[] {
-  const projection = projectSurfaceText(blocks);
+  return searchProjectedSurfaceText(projectSurfaceText(blocks), query, options);
+}
+
+/**
+ * Search a pre-projected surface text. Hoist `projectSurfaceText(blocks)` out
+ * of a per-query loop to avoid rebuilding the projection N times for N queries
+ * against the same surface — L7 Phase 1.5 discovered this cost dominates
+ * `collectFieldMarkup` on the CCEP large-tables fixture.
+ */
+export function searchProjectedSurfaceText(
+  projection: ProjectedSurfaceText,
+  query: string,
+  options: SearchTextOptions = {},
+): SurfaceSearchResult[] {
   return findSearchMatches(projection.text, query, options)
     .map((match) => {
       const range = resolveProjectedRuntimeRange(

package/src/index.ts

@@ -267,4 +267,17 @@ export type {
   ScopeMetadataPersistence,
   ScopeMetadataResolver,
   ScopeMetadataStorageRef,
+  // Schema 1.2 — editor-state persistence types
+  EditorStateNamespace,
+  EditorStateLocation,
+  EditorStateResolveErrorMode,
+  EditorStatePolicyEntry,
+  EditorStatePolicy,
+  EditorStateStorageRef,
+  EditorStateBlob,
+  EditorStateResolver,
+  EditorStatePersister,
+  EditorStatePolicyMigration,
+  EditorStatePartLoadFailure,
+  EditorStatePartPersistFailure,
 } from "./api/public-types.ts";