@beyondwork/docx-react-component 1.0.42 → 1.0.43

package/src/io/load-scheduler.ts

@@ -0,0 +1,230 @@
+/**
+ * Load scheduler — main-thread time-slicing primitive for the staged
+ * document-load pipeline.
+ *
+ * The loader calls `scheduler.yield()` between parse stages so the browser
+ * can paint, service input, and run React commits. `scheduleIdle(task)`
+ * queues low-priority work (e.g., sub-part hydration, compatibility report)
+ * for post-skeleton execution.
+ *
+ * Backend cascade (first available wins):
+ *   1. `globalThis.scheduler.yield()` — native browser API (Chrome 129+, Edge).
+ *   2. `MessageChannel.postMessage` — universal DOM fallback, ~0.1ms per yield.
+ *   3. `setTimeout(0)` — last-resort fallback.
+ *   4. `sync` — SSR / Node test harness. `yield()` resolves immediately;
+ *      `scheduleIdle` runs inline.
+ *
+ * The `sync` backend is selected when `typeof document === "undefined"` so
+ * existing Node-side tests drive the staged pipeline with byte-identical
+ * behavior to the eager pipeline (no real yielding, no idle deferral).
+ */
+
+export type LoadSchedulerBackend =
+  | "scheduler-api"
+  | "message-channel"
+  | "timeout"
+  | "sync";
+
+export interface LoadScheduler {
+  readonly backend: LoadSchedulerBackend;
+  /** Yield to the browser. Resolves on next scheduled task / microtask. */
+  yield(): Promise<void>;
+  /** Schedule low-priority work for post-skeleton execution. */
+  scheduleIdle(task: () => void): void;
+  /** Cancel pending idle tasks. Must be called on unmount / dispose. */
+  dispose(): void;
+}
+
+export interface CreateLoadSchedulerOptions {
+  /** Frame deadline in ms. Default 4ms (keeps browser at 60fps). */
+  frameDeadlineMs?: number;
+  /**
+   * Force a specific backend (test-only). When omitted, the scheduler
+   * detects the best available backend at construction time.
+   */
+  backendOverride?: LoadSchedulerBackend;
+}
+
+const DEFAULT_FRAME_DEADLINE_MS = 4;
+
+/**
+ * Returns true when the elapsed time since `lastYieldAt` exceeds the
+ * scheduler's frame deadline. Callers use this inside tight loops to decide
+ * when to `await scheduler.yield()`.
+ */
+export function shouldYield(
+  scheduler: LoadScheduler & { readonly frameDeadlineMs?: number },
+  lastYieldAt: number,
+): boolean {
+  const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const deadline = scheduler.frameDeadlineMs ?? DEFAULT_FRAME_DEADLINE_MS;
+  return now - lastYieldAt >= deadline;
+}
+
+/**
+ * Returns a monotonic timestamp suitable for `shouldYield` comparisons.
+ */
+export function nowMs(): number {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+
+interface InternalScheduler extends LoadScheduler {
+  readonly frameDeadlineMs: number;
+}
+
+export function createLoadScheduler(
+  options: CreateLoadSchedulerOptions = {},
+): LoadScheduler {
+  const frameDeadlineMs = options.frameDeadlineMs ?? DEFAULT_FRAME_DEADLINE_MS;
+  const backend = options.backendOverride ?? detectBackend();
+
+  switch (backend) {
+    case "scheduler-api":
+      return createSchedulerApiBackend(frameDeadlineMs);
+    case "message-channel":
+      return createMessageChannelBackend(frameDeadlineMs);
+    case "timeout":
+      return createTimeoutBackend(frameDeadlineMs);
+    case "sync":
+      return createSyncBackend(frameDeadlineMs);
+  }
+}
+
+function detectBackend(): LoadSchedulerBackend {
+  if (typeof document === "undefined") {
+    return "sync";
+  }
+  const g = globalThis as unknown as {
+    scheduler?: { yield?: () => Promise<void> };
+  };
+  if (typeof g.scheduler?.yield === "function") {
+    return "scheduler-api";
+  }
+  if (typeof MessageChannel !== "undefined") {
+    return "message-channel";
+  }
+  return "timeout";
+}
+
+function createSchedulerApiBackend(frameDeadlineMs: number): InternalScheduler {
+  const g = globalThis as unknown as {
+    scheduler: { yield: () => Promise<void> };
+  };
+  const pendingIdleHandles = new Set<number>();
+  return {
+    backend: "scheduler-api",
+    frameDeadlineMs,
+    yield: () => g.scheduler.yield(),
+    scheduleIdle(task) {
+      const handle = scheduleIdleCallback(task, pendingIdleHandles);
+      pendingIdleHandles.add(handle);
+    },
+    dispose() {
+      disposeIdleHandles(pendingIdleHandles);
+    },
+  };
+}
+
+function createMessageChannelBackend(frameDeadlineMs: number): InternalScheduler {
+  const pendingIdleHandles = new Set<number>();
+  return {
+    backend: "message-channel",
+    frameDeadlineMs,
+    yield() {
+      return new Promise<void>((resolve) => {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = () => {
+          channel.port1.close();
+          channel.port2.close();
+          resolve();
+        };
+        channel.port2.postMessage(null);
+      });
+    },
+    scheduleIdle(task) {
+      const handle = scheduleIdleCallback(task, pendingIdleHandles);
+      pendingIdleHandles.add(handle);
+    },
+    dispose() {
+      disposeIdleHandles(pendingIdleHandles);
+    },
+  };
+}
+
+function createTimeoutBackend(frameDeadlineMs: number): InternalScheduler {
+  const pendingIdleHandles = new Set<number>();
+  return {
+    backend: "timeout",
+    frameDeadlineMs,
+    yield() {
+      return new Promise<void>((resolve) => {
+        setTimeout(resolve, 0);
+      });
+    },
+    scheduleIdle(task) {
+      const handle = setTimeout(task, 0) as unknown as number;
+      pendingIdleHandles.add(handle);
+    },
+    dispose() {
+      for (const handle of pendingIdleHandles) {
+        clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
+      }
+      pendingIdleHandles.clear();
+    },
+  };
+}
+
+function createSyncBackend(frameDeadlineMs: number): InternalScheduler {
+  return {
+    backend: "sync",
+    frameDeadlineMs,
+    yield: () => Promise.resolve(),
+    scheduleIdle(task) {
+      task();
+    },
+    dispose() {
+      /* no-op */
+    },
+  };
+}
+
+type IdleHandle = number;
+
+function scheduleIdleCallback(
+  task: () => void,
+  store: Set<IdleHandle>,
+): IdleHandle {
+  const g = globalThis as unknown as {
+    requestIdleCallback?: (cb: () => void, options?: { timeout: number }) => number;
+    cancelIdleCallback?: (handle: number) => void;
+  };
+  if (typeof g.requestIdleCallback === "function") {
+    const handle = g.requestIdleCallback(
+      () => {
+        store.delete(handle);
+        task();
+      },
+      { timeout: 50 },
+    );
+    return handle;
+  }
+  const handle = setTimeout(() => {
+    store.delete(handle as unknown as number);
+    task();
+  }, 0) as unknown as number;
+  return handle;
+}
+
+function disposeIdleHandles(store: Set<IdleHandle>): void {
+  const g = globalThis as unknown as {
+    cancelIdleCallback?: (handle: number) => void;
+  };
+  for (const handle of store) {
+    if (typeof g.cancelIdleCallback === "function") {
+      g.cancelIdleCallback(handle);
+    } else {
+      clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
+    }
+  }
+  store.clear();
+}

package/src/io/normalize/normalize-text.ts

@@ -36,6 +36,11 @@ import type {
   ParsedTableRowNode,
 } from "../ooxml/parse-main-document.ts";
 import { classifyFieldInstruction, buildFieldRegistry } from "../ooxml/parse-fields.ts";
+import {
+  type LoadScheduler,
+  nowMs,
+  shouldYield,
+} from "../load-scheduler.ts";
 
 export interface NormalizedTextDocument {
   content: DocumentRootNode;
@@ -115,6 +120,84 @@ export function normalizeParsedTextDocument(
   };
 }
 
+/**
+ * Fastload P6: async sibling of `normalizeParsedTextDocument` that yields to
+ * the browser every {@link NORMALIZE_YIELD_STRIDE} top-level blocks when
+ * {@link shouldYield} fires against the scheduler's frame deadline. Shares
+ * the private normalizeBlocks / normalizeParagraph / normalizeInlineChildren
+ * helpers with the sync export — only the outermost block walk is duplicated.
+ *
+ * Byte-equivalent to the sync export on any corpus (fixture parity is asserted
+ * in `test/io/normalize-text-async.test.ts` across every F*.docx fixture).
+ */
+const NORMALIZE_YIELD_STRIDE = 256;
+
+export async function normalizeParsedTextDocumentAsync(
+  document: ParsedMainDocument,
+  packagePartName = "/word/document.xml",
+  scheduler: LoadScheduler,
+  options?: { styles?: import("../../model/canonical-document.ts").StylesCatalog },
+): Promise<NormalizedTextDocument> {
+  const state: NormalizationState = {
+    nextFragmentIndex: 1,
+    nextWarningIndex: 1,
+    nextDiagnosticIndex: 1,
+    cursor: 0,
+    media: {
+      items: {},
+    },
+    preservation: {
+      opaqueFragments: {},
+      packageParts: {},
+    },
+    diagnostics: {
+      warnings: [],
+      errors: [],
+    },
+  };
+
+  const children: BlockNode[] = [];
+  let previousParagraph = false;
+  let lastYieldAt = nowMs();
+
+  for (let i = 0; i < document.blocks.length; i += 1) {
+    const block = document.blocks[i];
+    const normalizedBlocks = normalizeBlocks(block, state, packagePartName);
+    for (const normalizedBlock of normalizedBlocks) {
+      if (previousParagraph && normalizedBlock.type === "paragraph") {
+        state.cursor += 1;
+      }
+      children.push(normalizedBlock);
+      previousParagraph = normalizedBlock.type === "paragraph";
+    }
+    if (
+      i > 0 &&
+      i % NORMALIZE_YIELD_STRIDE === 0 &&
+      shouldYield(scheduler, lastYieldAt)
+    ) {
+      await scheduler.yield();
+      lastYieldAt = nowMs();
+    }
+  }
+
+  const content: DocumentRootNode = { type: "doc", children };
+
+  const styles = options?.styles ?? { paragraphs: {}, characters: {}, tables: {} };
+  const fieldRegistry = buildFieldRegistry({ content, styles });
+  const hasFields = fieldRegistry.supported.length > 0 || fieldRegistry.preserveOnly.length > 0;
+
+  return {
+    content,
+    media: state.media,
+    preservation: state.preservation,
+    diagnostics: state.diagnostics,
+    ...(document.finalSectionProperties !== undefined
+      ? { finalSectionProperties: document.finalSectionProperties }
+      : {}),
+    ...(hasFields ? { fieldRegistry } : {}),
+  };
+}
+
 function normalizeBlocks(
   block: ParsedBlockNode,
   state: NormalizationState,

package/src/io/ooxml/workflow-payload-validator.ts

@@ -19,7 +19,14 @@ export type ValidatorIssueCode =
   | "external_field_body_ignored"
   | "internal_entry_unexpected_storage_ref"
   | "internal_field_unexpected_storage_ref"
-  | "unsupported_version";
+  | "unsupported_version"
+  // Schema 1.2 editor-state codes
+  | "editor_state_unknown_namespace"
+  | "editor_state_duplicate_content"
+  | "editor_state_empty_content"
+  | "editor_state_invalid_inline_json"
+  | "editor_state_missing_entry_key"
+  | "editor_state_invalid_location";
 
 export type ValidatorIssueSeverity = "error" | "warning";
 
@@ -145,6 +152,95 @@ export function validateWorkflowPayloadEnvelope(xml: string): ValidatorIssue[] {
     }
   }
 
+  // Schema 1.2: <bw:editorState> checks.
+  const editorStateMatch = xml.match(/<bw:editorState\b[^>]*>([\s\S]*?)<\/bw:editorState>/u);
+  if (editorStateMatch) {
+    const editorStateBody = editorStateMatch[1] ?? "";
+    const nsRe = /<bw:namespace\b([^>]*)>([\s\S]*?)<\/bw:namespace>/gu;
+    for (const nsMatch of editorStateBody.matchAll(nsRe)) {
+      const attrsStr = nsMatch[1] ?? "";
+      const nsBody = nsMatch[2] ?? "";
+      const attrs = parseAttrs(attrsStr);
+      const name = attrs.name ?? "";
+      const nsPath = `bw:editorState/bw:namespace[@name='${name}']`;
+
+      // 1. Unknown namespace name (not in closed set) → warning.
+      const knownNames = ["hostAnnotations", "workflowOverlay", "workflowMetadata", "workItems"];
+      if (!knownNames.includes(name)) {
+        issues.push({
+          code: "editor_state_unknown_namespace",
+          path: nsPath,
+          severity: "warning",
+          value: name,
+        });
+        // Still check structural rules below for forward-compat awareness.
+      }
+
+      // 2. Detect presence of storageRef and inline.
+      const hasStorageRef = /<bw:storageRef\b/u.test(nsBody);
+      const hasInline = /<bw:inline\b/u.test(nsBody);
+
+      if (hasStorageRef && hasInline) {
+        // Both present → duplicate_content error.
+        issues.push({
+          code: "editor_state_duplicate_content",
+          path: nsPath,
+          severity: "error",
+        });
+      } else if (!hasStorageRef && !hasInline) {
+        // Neither present → empty_content error.
+        issues.push({
+          code: "editor_state_empty_content",
+          path: nsPath,
+          severity: "error",
+        });
+      } else if (hasStorageRef) {
+        // 3a. storageRef checks.
+        const refMatch = nsBody.match(/<bw:storageRef\b([^>]*)\/>/u);
+        if (refMatch) {
+          const refAttrs = parseAttrs(refMatch[1] ?? "");
+          const entryKey = refAttrs.entryKey ?? "";
+          const location = refAttrs.location ?? "";
+
+          if (entryKey === "") {
+            issues.push({
+              code: "editor_state_missing_entry_key",
+              path: `${nsPath}/bw:storageRef`,
+              severity: "error",
+            });
+          }
+
+          const knownLocations = ["rowstore", "key-only"];
+          if (location !== "" && !knownLocations.includes(location)) {
+            issues.push({
+              code: "editor_state_invalid_location",
+              path: `${nsPath}/bw:storageRef/@location`,
+              severity: "warning",
+              value: location,
+            });
+          }
+        }
+      } else if (hasInline) {
+        // 3b. inline JSON parse check.
+        const inlineMatch = nsBody.match(/<bw:inline\b[^>]*>([\s\S]*?)<\/bw:inline>/u);
+        if (inlineMatch) {
+          const rawContent = inlineMatch[1] ?? "";
+          // Strip CDATA markers (handles split CDATA too).
+          const text = rawContent.replace(/<!\[CDATA\[|\]\]>/g, "").trim();
+          try {
+            JSON.parse(text);
+          } catch {
+            issues.push({
+              code: "editor_state_invalid_inline_json",
+              path: `${nsPath}/bw:inline`,
+              severity: "error",
+            });
+          }
+        }
+      }
+    }
+  }
+
   // Top-level entries (bw:metadata body, outside scopes).
   // These resolve against overlay-only (no scope context available unless
   // the entry carries its own `scope="scope:{id}"` attribute, in which case

package/src/io/ooxml/workflow-payload.ts

@@ -12,11 +12,36 @@ import type {
   WorkflowScope,
   WorkflowWorkItem,
 } from "../../api/public-types.ts";
+import type { EditorStateNamespace, EditorStateLocation } from "../../api/editor-state-types.ts";
 import {
   validateWorkflowPayloadEnvelope,
   type ValidatorIssue,
 } from "./workflow-payload-validator.ts";
 
+// ---------------------------------------------------------------------------
+// Schema 1.2 editor-state types (edge-of-module shape, channel-free)
+// ---------------------------------------------------------------------------
+
+export interface EditorStatePayloadNamespaceEntry {
+  namespace: EditorStateNamespace;
+  schemaVersion: string;
+  /** JSON-serializable blob (CDATA-wrapped on serialize). Exactly one of inline/storageRef. */
+  inline?: unknown;
+  storageRef?: { location: Exclude<EditorStateLocation, "in-document">; entryKey: string };
+  /**
+   * Parser-internal flag: set when the `<bw:inline>` CDATA block contained
+   * malformed JSON.  Hydration surfaces this as `editor_state_part_load_failed`
+   * rather than silently dropping the entry.
+   */
+  malformedInline?: boolean;
+}
+
+export interface EditorStatePayload {
+  entries: EditorStatePayloadNamespaceEntry[];
+  /** Unknown namespaces preserved for round-trip — raw XML fragment per entry, keyed by name. */
+  unknownNamespaces?: Array<{ name: string; rawXml: string }>;
+}
+
 // ---------------------------------------------------------------------------
 // Schema 1.1 parser helpers (fail-closed per spec §8.2)
 // ---------------------------------------------------------------------------
@@ -62,6 +87,8 @@ type EmbeddedWorkflowPayloadDescriptor = {
 export interface WorkflowPayloadEnvelope {
   workflowMetadata: WorkflowMetadataSnapshot;
   workflowOverlay?: WorkflowOverlay;
+  /** Present only when the payload was version 1.2+ and carried a non-empty <bw:editorState> block. */
+  editorState?: EditorStatePayload;
   validatorIssues?: readonly ValidatorIssue[];
 }
 
@@ -87,6 +114,8 @@ export function buildWorkflowPayloadParts(input: {
   sourcePackage: OpcPackage;
   workflowMetadata: WorkflowMetadataSnapshot | undefined;
   workflowOverlay?: WorkflowOverlay;
+  /** Optional schema 1.2 editor-state block. Omitted when empty. */
+  editorState?: EditorStatePayload;
   documentId: string;
   createdAt: string;
   updatedAt: string;
@@ -126,6 +155,7 @@ export function buildWorkflowPayloadParts(input: {
     producerVersion: input.producerVersion,
     workflowMetadata,
     workflowOverlay: input.workflowOverlay,
+    editorState: input.editorState,
     preservedExtensionsXml: getPreservedExtensionsXml(input.sourcePackage, descriptor.payloadPartPath),
   });
   const itemPropsXml = buildItemPropsXml(descriptor.itemId);
@@ -238,12 +268,14 @@ export function parseWorkflowPayloadEnvelopeFromPackage(
   }
 
   const validatorIssues = validateWorkflowPayloadEnvelope(xml);
+  const editorState = parseEditorStateXml(xml);
   return {
     workflowMetadata: {
       definitions,
       entries,
     },
     workflowOverlay: parseWorkflowOverlay(xml),
+    ...(editorState !== undefined ? { editorState } : {}),
     ...(validatorIssues.length > 0 ? { validatorIssues } : {}),
   };
 }
@@ -287,6 +319,136 @@ function needsSchemaV11(input: {
   return false;
 }
 
+/** Returns true when the payload has at least one namespace entry or unknown namespace to emit. */
+function hasNonEmptyEditorState(es: EditorStatePayload | undefined): boolean {
+  if (!es) return false;
+  return (es.entries.length > 0) || ((es.unknownNamespaces?.length ?? 0) > 0);
+}
+
+// ---------------------------------------------------------------------------
+// Known namespace names (closed set for round-trip; unknown names are opaque)
+// ---------------------------------------------------------------------------
+
+const KNOWN_EDITOR_STATE_NAMESPACES: readonly EditorStateNamespace[] = [
+  "hostAnnotations",
+  "workflowOverlay",
+  "workflowMetadata",
+  "workItems",
+];
+
+const KNOWN_STORAGE_LOCATIONS: ReadonlyArray<Exclude<EditorStateLocation, "in-document">> = [
+  "rowstore",
+  "key-only",
+];
+
+/**
+ * Escapes `]]>` inside CDATA content using the standard XML split:
+ * `]]>` → `]]]]><![CDATA[>`
+ */
+function escapeCdata(text: string): string {
+  return text.replace(/\]\]>/g, "]]]]><![CDATA[>");
+}
+
+/**
+ * Builds the `<bw:editorState>…</bw:editorState>` block.
+ * Returns an empty string when both entries and unknownNamespaces are empty.
+ */
+export function buildEditorStateXml(payload: EditorStatePayload): string {
+  if (!hasNonEmptyEditorState(payload)) {
+    return "";
+  }
+
+  const knownLines = payload.entries.map((entry) => {
+    const nsOpen = `<bw:namespace name="${escapeXml(entry.namespace)}" schemaVersion="${escapeXml(entry.schemaVersion)}">`;
+    let content: string;
+    if (entry.storageRef !== undefined) {
+      content = `<bw:storageRef location="${escapeXml(entry.storageRef.location)}" entryKey="${escapeXml(entry.storageRef.entryKey)}" />`;
+    } else {
+      const json = escapeCdata(JSON.stringify(entry.inline));
+      content = `<bw:inline><![CDATA[${json}]]></bw:inline>`;
+    }
+    return `${nsOpen}${content}</bw:namespace>`;
+  });
+
+  const unknownLines = (payload.unknownNamespaces ?? []).map((u) => u.rawXml);
+
+  const innerXml = [...knownLines, ...unknownLines].join("\n");
+  return `<bw:editorState>\n${indentLines(innerXml, 2)}\n</bw:editorState>`;
+}
+
+/**
+ * Parses the `<bw:editorState>` block from a full workflow payload XML string.
+ * Returns `undefined` when no block is present.
+ * Malformed JSON is silently skipped (validator flags it separately).
+ */
+export function parseEditorStateXml(xml: string): EditorStatePayload | undefined {
+  const blockMatch = xml.match(/<bw:editorState\b[^>]*>([\s\S]*?)<\/bw:editorState>/u);
+  if (!blockMatch) {
+    return undefined;
+  }
+  const blockBody = blockMatch[1] ?? "";
+
+  const entries: EditorStatePayloadNamespaceEntry[] = [];
+  const unknownNamespaces: Array<{ name: string; rawXml: string }> = [];
+
+  // Match each <bw:namespace ... > ... </bw:namespace>
+  const nsRe = /<bw:namespace\b([^>]*)>([\s\S]*?)<\/bw:namespace>/gu;
+  for (const nsMatch of blockBody.matchAll(nsRe)) {
+    const attrsStr = nsMatch[1] ?? "";
+    const nsBody = nsMatch[2] ?? "";
+    const rawXml = nsMatch[0] ?? "";
+    const attrs = parseAttributes(attrsStr);
+    const name = attrs.name ?? "";
+    const schemaVersion = attrs.schemaVersion ?? "";
+
+    if (!(KNOWN_EDITOR_STATE_NAMESPACES as readonly string[]).includes(name)) {
+      unknownNamespaces.push({ name, rawXml });
+      continue;
+    }
+
+    const namespace = name as EditorStateNamespace;
+
+    // Parse <bw:storageRef ... />
+    const storageRefMatch = nsBody.match(/<bw:storageRef\b([^>]*)\/>/u);
+    if (storageRefMatch) {
+      const refAttrs = parseAttributes(storageRefMatch[1] ?? "");
+      const location = refAttrs.location as Exclude<EditorStateLocation, "in-document"> | undefined;
+      const entryKey = refAttrs.entryKey ?? "";
+      entries.push({
+        namespace,
+        schemaVersion,
+        storageRef: { location: location ?? "rowstore", entryKey },
+      });
+      continue;
+    }
+
+    // Parse <bw:inline>...</bw:inline> — extract CDATA content
+    const inlineMatch = nsBody.match(/<bw:inline\b[^>]*>([\s\S]*?)<\/bw:inline>/u);
+    if (inlineMatch) {
+      const raw = inlineMatch[1] ?? "";
+      // Extract CDATA content — handles split CDATA sections from ]]> escaping
+      const cdataText = raw.replace(/<!\[CDATA\[|\]\]>/g, "").trim();
+      try {
+        const parsed = JSON.parse(cdataText) as unknown;
+        entries.push({ namespace, schemaVersion, inline: parsed });
+      } catch {
+        // Malformed JSON: surface to the runtime so the host sees a
+        // load-failure event rather than silently losing the entry.
+        entries.push({ namespace, schemaVersion, malformedInline: true });
+      }
+    }
+  }
+
+  if (entries.length === 0 && unknownNamespaces.length === 0) {
+    return undefined;
+  }
+
+  return {
+    entries,
+    ...(unknownNamespaces.length > 0 ? { unknownNamespaces } : {}),
+  };
+}
+
 function buildPayloadXml(input: {
   descriptor: EmbeddedWorkflowPayloadDescriptor;
   createdAt: string;
@@ -294,9 +456,15 @@ function buildPayloadXml(input: {
   producerVersion: string;
   workflowMetadata: WorkflowMetadataSnapshot;
   workflowOverlay?: WorkflowOverlay;
+  editorState?: EditorStatePayload;
   preservedExtensionsXml: string;
 }): string {
-  const schemaVersion = needsSchemaV11(input) ? "1.1" : "1.0";
+  const hasEditorState = hasNonEmptyEditorState(input.editorState);
+  const schemaVersion = hasEditorState
+    ? "1.2"
+    : needsSchemaV11(input)
+      ? "1.1"
+      : "1.0";
 
   const definitionEntriesXml = input.workflowMetadata.definitions
     .map((definition) => [
@@ -351,6 +519,8 @@ function buildPayloadXml(input: {
     .filter((value) => value.trim().length > 0)
     .join("\n");
 
+  const editorStateXml = hasEditorState ? buildEditorStateXml(input.editorState!) : "";
+
   return [
     `<?xml version="1.0" encoding="UTF-8"?>`,
     `<bw:workflowPayload xmlns:bw="urn:beyondwork:workflow-payload:1" version="${schemaVersion}" payloadId="${escapeXml(input.descriptor.payloadId)}" itemId="${escapeXml(input.descriptor.itemId)}" documentId="${escapeXml(input.descriptor.documentId)}" createdAt="${escapeXml(input.createdAt)}" updatedAt="${escapeXml(input.updatedAt)}">`,
@@ -362,6 +532,7 @@ function buildPayloadXml(input: {
     definitionEntriesXml ? indentLines(definitionEntriesXml, 4) : "",
     metadataEntriesXml ? indentLines(metadataEntriesXml, 4) : "",
     `  </bw:metadata>`,
+    editorStateXml,
     extensionsXml
       ? `  <bw:extensions>\n${indentLines(extensionsXml, 4)}\n  </bw:extensions>`
       : `  <bw:extensions />`,

package/src/runtime/collab-session.ts

@@ -64,7 +64,7 @@ export interface AttachPayloadArgs {
 
 export type SendToExternalCallArgs = Omit<
   RuntimeSendToExternalArgs,
-  "bridge" | "tamperGate" | "signer" | "role"
+  "bridge" | "tamperGate" | "signer" | "role" | "resolver"
 > & {
   role?: "author" | "reviewer" | "observer";
 };