@beyondwork/docx-react-component 1.0.58 → 1.0.60

package/src/io/export/serialize-revisions.ts

@@ -97,13 +97,27 @@ function serializeMarkup(
 
   switch (revision.kind) {
     case "move":
+      return serializeMoveMarkup(markup, revision.status);
     case "formatting":
+      if (
+        markup.originalRevisionType === "cellIns" ||
+        markup.originalRevisionType === "cellDel" ||
+        markup.originalRevisionType === "cellMerge"
+      ) {
+        return serializeStructuralTableMarkup(markup.rawXml, revision.status);
+      }
       return markup.rawXml;
     case "property-change":
       return serializePropertyChangeMarkup(markup.rawXml, revision.status);
     case "insertion":
+      if (markup.originalRevisionType === "row-ins") {
+        return serializeStructuralRowMarkup(markup.rawXml, revision.status);
+      }
       return serializeInsertionMarkup(markup.rawXml, revision.status);
     case "deletion":
+      if (markup.originalRevisionType === "row-del") {
+        return serializeStructuralRowMarkup(markup.rawXml, revision.status);
+      }
       return serializeDeletionMarkup(markup.rawXml, revision.status);
   }
 }
@@ -346,6 +360,91 @@ function serializePropertyChangeMarkup(
   }
 }
 
+function serializeMoveMarkup(
+  markup: PreservedRevisionMarkup,
+  status: RevisionRecord["status"],
+): string {
+  if (status === "active" || status === "detached") {
+    return markup.rawXml;
+  }
+
+  const direction: "from" | "to" | undefined =
+    markup.originalRevisionType === "moveFrom"
+      ? "from"
+      : markup.originalRevisionType === "moveTo"
+        ? "to"
+        : undefined;
+
+  if (!direction) {
+    return markup.rawXml;
+  }
+
+  // Accept = commit the move: source removed, destination unwrapped.
+  // Reject = cancel the move: source unwrapped, destination removed.
+  const shouldDropWrapperAndContent =
+    (status === "accepted" && direction === "from") ||
+    (status === "rejected" && direction === "to");
+
+  if (shouldDropWrapperAndContent) {
+    return "";
+  }
+
+  return unwrapMoveWrapper(markup.rawXml, direction);
+}
+
+function unwrapMoveWrapper(rawXml: string, direction: "from" | "to"): string {
+  const tag = direction === "from" ? "moveFrom" : "moveTo";
+  const selfClosingPattern = new RegExp(`^\\s*<w:${tag}\\b[^>]*/>\\s*$`);
+  if (selfClosingPattern.test(rawXml)) {
+    return "";
+  }
+  const openPattern = new RegExp(`^\\s*<w:${tag}\\b[^>]*>`);
+  const closePattern = new RegExp(`</w:${tag}>\\s*$`);
+  return rawXml.replace(openPattern, "").replace(closePattern, "");
+}
+
+function serializeStructuralRowMarkup(
+  rawXml: string,
+  status: RevisionRecord["status"],
+): string {
+  // accept(row-ins) and reject(row-del): drop the marker from trPr while
+  // leaving the enclosing row intact. The canonical-document row is
+  // unchanged in these cases.
+  // accept(row-del) and reject(row-ins): the canonical model layer already
+  // removed the entire row via `removeTableRowPure`, so the <w:tr> itself
+  // won't exist in the serialized output — this helper only runs on the
+  // surviving-row branch.
+  switch (status) {
+    case "accepted":
+    case "rejected":
+      return "";
+    case "active":
+    case "detached":
+      return rawXml;
+  }
+}
+
+function serializeStructuralTableMarkup(
+  rawXml: string,
+  status: RevisionRecord["status"],
+): string {
+  // Lane 7b/L: cellIns on rejected status means the canonical-model layer
+  // already removed the enclosing <w:tc>, so the marker never reaches the
+  // exported table. When it does fire, the marker should be dropped just
+  // like on accept (the alternative — leaving the marker in place — would
+  // round-trip back as a still-pending revision, contradicting the store
+  // status). Accept = commit the cell (drop marker). Reject = cell removed
+  // (marker also drops).
+  switch (status) {
+    case "accepted":
+    case "rejected":
+      return "";
+    case "active":
+    case "detached":
+      return rawXml;
+  }
+}
+
 function serializeInsertionMarkup(
   rawXml: string,
   status: RevisionRecord["status"],

package/src/io/export/serialize-tables.ts

@@ -229,6 +229,15 @@ function serializeCellShading(shading: ParsedCellShading): string {
   if (shading.val) attrs.push(`w:val="${shading.val}"`);
   if (shading.color) attrs.push(`w:color="${shading.color}"`);
   if (shading.fill) attrs.push(`w:fill="${shading.fill}"`);
+  // SOW gap G3 — round-trip theme-shading attributes so a doc imported with
+  // `<w:shd w:themeFill="accent5" w:themeFillTint="33"/>` serializes back to
+  // the same form instead of losing the theme reference after edit.
+  if (shading.themeFill) attrs.push(`w:themeFill="${shading.themeFill}"`);
+  if (shading.themeFillTint) attrs.push(`w:themeFillTint="${shading.themeFillTint}"`);
+  if (shading.themeFillShade) attrs.push(`w:themeFillShade="${shading.themeFillShade}"`);
+  if (shading.themeColor) attrs.push(`w:themeColor="${shading.themeColor}"`);
+  if (shading.themeColorTint) attrs.push(`w:themeColorTint="${shading.themeColorTint}"`);
+  if (shading.themeColorShade) attrs.push(`w:themeColorShade="${shading.themeColorShade}"`);
   const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
   return `<w:shd${attrsStr}/>`;
 }

package/src/io/export/split-review-boundaries.ts

@@ -348,6 +348,7 @@ function measureInlineNodeForReviewBoundaries(node: InlineNode): number {
     case "shape":
     case "wordart":
     case "vml_shape":
+    case "ole_embed":
     case "symbol":
       return 1;
     default:

package/src/io/export/table-properties-xml.ts

@@ -45,6 +45,13 @@ interface CellShadingLike {
   val?: string;
   color?: string;
   fill?: string;
+  /** SOW gap G3 — round-trip theme-shading references. */
+  themeFill?: string;
+  themeFillTint?: string;
+  themeFillShade?: string;
+  themeColor?: string;
+  themeColorTint?: string;
+  themeColorShade?: string;
 }
 
 interface TableIndentLike {
@@ -476,5 +483,12 @@ function serializeCellShading(shading: CellShadingLike): string {
   if (shading.val) attrs.push(`w:val="${escapeXmlAttribute(shading.val)}"`);
   if (shading.color) attrs.push(`w:color="${escapeXmlAttribute(shading.color)}"`);
   if (shading.fill) attrs.push(`w:fill="${escapeXmlAttribute(shading.fill)}"`);
+  // SOW gap G3 — theme-shading round-trip.
+  if (shading.themeFill) attrs.push(`w:themeFill="${escapeXmlAttribute(shading.themeFill)}"`);
+  if (shading.themeFillTint) attrs.push(`w:themeFillTint="${escapeXmlAttribute(shading.themeFillTint)}"`);
+  if (shading.themeFillShade) attrs.push(`w:themeFillShade="${escapeXmlAttribute(shading.themeFillShade)}"`);
+  if (shading.themeColor) attrs.push(`w:themeColor="${escapeXmlAttribute(shading.themeColor)}"`);
+  if (shading.themeColorTint) attrs.push(`w:themeColorTint="${escapeXmlAttribute(shading.themeColorTint)}"`);
+  if (shading.themeColorShade) attrs.push(`w:themeColorShade="${escapeXmlAttribute(shading.themeColorShade)}"`);
   return attrs.length > 0 ? `<w:shd ${attrs.join(" ")}/>` : "";
 }

package/src/io/load-scheduler.ts

@@ -25,12 +25,31 @@ export type LoadSchedulerBackend =
   | "timeout"
   | "sync";
 
+export interface ScheduleIdleOptions {
+  /**
+   * Abort the pending idle callback before it runs. If the signal is already
+   * aborted at call time, the task is not scheduled. Post-run aborts are
+   * no-ops. The idle handle is cancelled and the abort listener removed in
+   * both the run and abort paths.
+   *
+   * Typical consumer: `RuntimeCollabSyncHandle.getRemoteActivitySignal()`
+   * (Lane 4 R3). Idle prep that races with remote commit work passes the
+   * signal here so remote arrivals cancel stale prep before the document
+   * moves. See `docs/wiki/collaboration.md` §"Remote-activity abort
+   * signal (R3)" for the end-to-end narrative.
+   *
+   * Stability: advanced-supported (v2.0.0, shipped 2026-04-20 in
+   * commit c2aeaf8d).
+   */
+  signal?: AbortSignal;
+}
+
 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;
+  scheduleIdle(task: () => void, options?: ScheduleIdleOptions): void;
   /** Cancel pending idle tasks. Must be called on unmount / dispose. */
   dispose(): void;
 }
@@ -115,9 +134,8 @@ function createSchedulerApiBackend(frameDeadlineMs: number): InternalScheduler {
     backend: "scheduler-api",
     frameDeadlineMs,
     yield: () => g.scheduler.yield(),
-    scheduleIdle(task) {
-      const handle = scheduleIdleCallback(task, pendingIdleHandles);
-      pendingIdleHandles.add(handle);
+    scheduleIdle(task, options) {
+      scheduleIdleCallback(task, pendingIdleHandles, options);
     },
     dispose() {
       disposeIdleHandles(pendingIdleHandles);
@@ -141,9 +159,8 @@ function createMessageChannelBackend(frameDeadlineMs: number): InternalScheduler
         channel.port2.postMessage(null);
       });
     },
-    scheduleIdle(task) {
-      const handle = scheduleIdleCallback(task, pendingIdleHandles);
-      pendingIdleHandles.add(handle);
+    scheduleIdle(task, options) {
+      scheduleIdleCallback(task, pendingIdleHandles, options);
     },
     dispose() {
       disposeIdleHandles(pendingIdleHandles);
@@ -161,15 +178,11 @@ function createTimeoutBackend(frameDeadlineMs: number): InternalScheduler {
         setTimeout(resolve, 0);
       });
     },
-    scheduleIdle(task) {
-      const handle = setTimeout(task, 0) as unknown as number;
-      pendingIdleHandles.add(handle);
+    scheduleIdle(task, options) {
+      scheduleIdleCallback(task, pendingIdleHandles, options);
     },
     dispose() {
-      for (const handle of pendingIdleHandles) {
-        clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
-      }
-      pendingIdleHandles.clear();
+      disposeIdleHandles(pendingIdleHandles);
     },
   };
 }
@@ -179,7 +192,8 @@ function createSyncBackend(frameDeadlineMs: number): InternalScheduler {
     backend: "sync",
     frameDeadlineMs,
     yield: () => Promise.resolve(),
-    scheduleIdle(task) {
+    scheduleIdle(task, options) {
+      if (options?.signal?.aborted) return;
       task();
     },
     dispose() {
@@ -193,26 +207,54 @@ type IdleHandle = number;
 function scheduleIdleCallback(
   task: () => void,
   store: Set<IdleHandle>,
-): IdleHandle {
+  options?: ScheduleIdleOptions,
+): void {
+  const signal = options?.signal;
+  if (signal?.aborted) return;
+
   const g = globalThis as unknown as {
     requestIdleCallback?: (cb: () => void, options?: { timeout: number }) => number;
     cancelIdleCallback?: (handle: number) => void;
   };
+
+  // Forward-declared handle ref so onAbort can cancel before it's assigned.
+  let handle: IdleHandle = -1;
+  let onAbort: (() => void) | null = null;
+
+  const cleanupAbortListener = () => {
+    if (signal && onAbort) {
+      signal.removeEventListener("abort", onAbort);
+      onAbort = null;
+    }
+  };
+
+  const run = () => {
+    store.delete(handle);
+    cleanupAbortListener();
+    task();
+  };
+
   if (typeof g.requestIdleCallback === "function") {
-    const handle = g.requestIdleCallback(
-      () => {
+    handle = g.requestIdleCallback(run, { timeout: 50 });
+  } else {
+    handle = setTimeout(run, 0) as unknown as number;
+  }
+  store.add(handle);
+
+  if (signal) {
+    onAbort = () => {
+      if (store.has(handle)) {
+        if (typeof g.cancelIdleCallback === "function" && typeof g.requestIdleCallback === "function") {
+          g.cancelIdleCallback(handle);
+        } else {
+          clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
+        }
         store.delete(handle);
-        task();
-      },
-      { timeout: 50 },
-    );
-    return handle;
+      }
+      onAbort = null;
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
   }
-  const handle = setTimeout(() => {
-    store.delete(handle as unknown as number);
-    task();
-  }, 0) as unknown as number;
-  return handle;
 }
 
 function disposeIdleHandles(store: Set<IdleHandle>): void {

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

@@ -531,6 +531,18 @@ function normalizeInlineChildren(
         });
         state.cursor += 1;
         break;
+      case "ole_embed":
+        normalized.push({
+          type: "ole_embed",
+          id: node.id,
+          ...(node.progId ? { progId: node.progId } : {}),
+          embedType: node.embedType,
+          relationshipId: node.relationshipId,
+          metadata: { ...node.metadata },
+          rawXml: node.rawXml,
+        });
+        state.cursor += 1;
+        break;
       case "bookmark_start":
         normalized.push({
           type: "bookmark_start",
@@ -569,6 +581,7 @@ function normalizeInlineChildren(
           ...(classification.target ? { fieldTarget: classification.target } : {}),
           ...(classification.switches ? { switches: classification.switches } : {}),
           refreshStatus: classification.supported ? "stale" : "preserve-only",
+          ...(node.legacyFormField ? { legacyFormField: node.legacyFormField } : {}),
         });
         state.cursor += renderedLength > 0 ? renderedLength : 1;
         break;

package/src/io/ooxml/_mini-xml.ts

@@ -0,0 +1,198 @@
+/**
+ * _mini-xml.ts — Shared minimal XML parser for CO4 DrawingML modules.
+ *
+ * Consolidates the four identical copies previously duplicated across
+ * parse-anchor.ts, parse-drawing.ts, parse-picture.ts, and parse-shapes.ts.
+ *
+ * Scope: OOXML attribute-preserving walker used for decoding DrawingML
+ * fragments. Self-contained (no fast-xml-parser dependency), low allocation,
+ * preserves attribute order.
+ *
+ * Throws on unterminated tags (CO4 B4 fix). Callers in parseDrawingFrame +
+ * parseShapeContent are already try/catch-wrapped at parse-main-document.ts.
+ */
+
+export interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+export interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+export type XmlNode = XmlElementNode | XmlTextNode;
+
+export function findFirstChild(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type === "element" && localName(child.name) === local) return child;
+  }
+  return undefined;
+}
+
+export function findFirstDescendant(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName(child.name) === local) return child;
+    const found = findFirstDescendant(child, local);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+export function findDescendants(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode[] {
+  const out: XmlElementNode[] = [];
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName(child.name) === local) out.push(child);
+    out.push(...findDescendants(child, local));
+  }
+  return out;
+}
+
+export function localName(name: string): string {
+  const i = name.indexOf(":");
+  return i >= 0 ? name.slice(i + 1) : name;
+}
+
+export function extractText(node: XmlElementNode): string {
+  return node.children
+    .map((c) => (c.type === "text" ? c.text : extractText(c as XmlElementNode)))
+    .join("");
+}
+
+export function parseXml(xml: string): XmlElementNode {
+  const root: XmlElementNode = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+  };
+  const stack: XmlElementNode[] = [root];
+  let cursor = 0;
+
+  while (cursor < xml.length) {
+    if (xml.startsWith("<!--", cursor)) {
+      const end = xml.indexOf("-->", cursor);
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+    if (xml.startsWith("<?", cursor)) {
+      const end = xml.indexOf("?>", cursor);
+      cursor = end >= 0 ? end + 2 : xml.length;
+      continue;
+    }
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeEntities(xml.slice(cursor, end));
+      if (text) stack[stack.length - 1]?.children.push({ type: "text", text });
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      stack.pop();
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
+    const el: XmlElementNode = { type: "element", name, attributes, children: [] };
+    stack[stack.length - 1]?.children.push(el);
+    if (!selfClosing) stack.push(el);
+    cursor = tagEnd + 1;
+  }
+
+  return root;
+}
+
+function findTagEnd(xml: string, start: number): number {
+  let cursor = start + 1;
+  let quote: string | null = null;
+  while (cursor < xml.length) {
+    const ch = xml[cursor];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === `"` || ch === `'`) {
+      quote = ch;
+    } else if (ch === ">") {
+      return cursor;
+    }
+    cursor++;
+  }
+  // B4 — throw on unterminated tag; callers are try/catch-wrapped at the
+  // parse-main-document.ts case "drawing" dispatch so the legacy chain +
+  // opaque_inline fallback take over.
+  throw new Error(`Malformed XML: unterminated tag starting at offset ${start}`);
+}
+
+function parseTag(body: string): { name: string; attributes: Record<string, string> } {
+  let i = 0;
+  while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+  const nameStart = i;
+  while (i < body.length && !/\s/.test(body[i] ?? "")) i++;
+  const name = body.slice(nameStart, i);
+  const attributes: Record<string, string> = {};
+  while (i < body.length) {
+    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+    if (i >= body.length) break;
+    const kStart = i;
+    while (i < body.length && !/[\s=]/.test(body[i] ?? "")) i++;
+    const key = body.slice(kStart, i);
+    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+    if (body[i] !== "=") { attributes[key] = ""; continue; }
+    i++;
+    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
+    const q = body[i];
+    if (q !== `"` && q !== `'`) throw new Error(`Bad attr ${key}`);
+    i++;
+    const vStart = i;
+    while (i < body.length && body[i] !== q) i++;
+    attributes[key] = decodeEntities(body.slice(vStart, i));
+    i++;
+  }
+  return { name, attributes };
+}
+
+function decodeEntities(s: string): string {
+  return s.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (_, e) => {
+    if (e === "amp") return "&";
+    if (e === "lt") return "<";
+    if (e === "gt") return ">";
+    if (e === "quot") return `"`;
+    if (e === "apos") return "'";
+    if (e.startsWith("#x")) return String.fromCodePoint(parseInt(e.slice(2), 16));
+    if (e.startsWith("#")) return String.fromCodePoint(parseInt(e.slice(1), 10));
+    return `&${e};`;
+  });
+}
+
+function encodeEntities(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+export function serializeXmlNode(node: XmlElementNode): string {
+  const attrs = Object.entries(node.attributes)
+    .map(([k, v]) => ` ${k}="${encodeEntities(v)}"`)
+    .join("");
+  if (node.children.length === 0) return `<${node.name}${attrs}/>`;
+  const inner = node.children
+    .map((c) => (c.type === "text" ? encodeEntities(c.text) : serializeXmlNode(c)))
+    .join("");
+  return `<${node.name}${attrs}>${inner}</${node.name}>`;
+}

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

@@ -21,6 +21,7 @@
  * reader use this same routine) and self-referential (the signature
  * element is excluded from its own input).
  */
+import { localName } from "./xml-attr-helpers.ts";
 export function canonicalizePayload(xml: string): Uint8Array {
   const tree = parseXml(xml);
   const filtered = stripSignature(tree);
@@ -273,10 +274,6 @@ function preservesSpace(): boolean {
 
 // ----- Helpers --------------------------------------------------------------
 
-function localName(qname: string): string {
-  const colon = qname.indexOf(":");
-  return colon < 0 ? qname : qname.slice(colon + 1);
-}
 
 function normalizeWhitespace(value: string): string {
   return value.replace(/\s+/g, " ").trim();

package/src/io/ooxml/chart/chart-style-table.ts

@@ -27,6 +27,7 @@
  */
 
 import type { FillSpec, StrokeSpec, TextProperties } from "./types.ts";
+import { EMU_PER_PX } from "../../../runtime/units.ts";
 
 /**
  * How each series gets a color.
@@ -100,7 +101,7 @@ const GRIDLINE_STROKE_SUBTLE: StrokeSpec = {
     { kind: "lumMod", value: 15000 },
     { kind: "lumOff", value: 85000 },
   ] },
-  widthEmu: 9525, // 0.75 pt
+  widthEmu: EMU_PER_PX, // 0.75 pt
   dash: "solid",
 };
 
@@ -110,7 +111,7 @@ const SERIES_OUTLINE_NONE: StrokeSpec = {
 
 const SERIES_OUTLINE_LIGHT: StrokeSpec = {
   color: { kind: "scheme", value: "lt1" },
-  widthEmu: 9525,
+  widthEmu: EMU_PER_PX,
   dash: "solid",
 };
 
@@ -305,7 +306,7 @@ const GRIDLINE_STROKE_LIGHT: StrokeSpec = {
   color: { kind: "scheme", value: "lt1", mods: [
     { kind: "lumMod", value: 80000 },
   ] },
-  widthEmu: 9525,
+  widthEmu: EMU_PER_PX,
   dash: "solid",
 };
 

package/src/io/ooxml/chart/parse-chart-space.ts

@@ -30,6 +30,7 @@ import {
 } from "../xml-attr-helpers.ts";
 import type { XmlElementNode } from "../xml-element.ts";
 import { parseXml } from "../xml-parser.ts";
+import { ROTATION_UNITS_PER_DEGREE } from "../../../runtime/units.ts";
 
 import { parseAxisNode } from "./parse-axis.ts";
 import {
@@ -530,9 +531,6 @@ function readGroupBoolean(groupNode: XmlElementNode, local: string): boolean {
 // Pie / Doughnut
 // ---------------------------------------------------------------------------
 
-/** OOXML's angle unit is 1/60000 of a degree (sixtyThousandths). */
-const OOXML_ANGLE_UNIT = 60000;
-
 function parsePieGroup(
   groupNode: XmlElementNode,
   common: ChartCommon,
@@ -553,7 +551,7 @@ function parsePieGroup(
   const firstSliceAngleRaw = readIntVal(findChildOptional(groupNode, "firstSliceAngle"));
   const firstSliceAngle =
     firstSliceAngleRaw !== undefined
-      ? (((firstSliceAngleRaw / OOXML_ANGLE_UNIT) % 360) + 360) % 360
+      ? (((firstSliceAngleRaw / ROTATION_UNITS_PER_DEGREE) % 360) + 360) % 360
       : 0;
 
   // Doughnut hole size is a percent (0–99 typical). Missing on pieChart.

package/src/io/ooxml/chart/parse-series.ts

@@ -22,6 +22,7 @@ import {
 } from "../xml-attr-helpers.ts";
 import type { XmlElementNode } from "../xml-element.ts";
 import { parseXml } from "../xml-parser.ts";
+import { GRADIENT_STOP_UNITS } from "../../../runtime/units.ts";
 
 import type {
   BubbleSeries,
@@ -513,7 +514,7 @@ function parseGradientFill(gradNode: XmlElementNode): FillSpec | undefined {
     const color = parseColorRef(child);
     if (!color) continue;
     const pos = Number.isFinite(posPpm)
-      ? Math.max(0, Math.min(1, posPpm / 100_000))
+      ? Math.max(0, Math.min(1, posPpm / GRADIENT_STOP_UNITS))
       : stops.length / 2;
     stops.push({ pos, color });
   }

package/src/io/ooxml/chart/resolve-color.ts

@@ -19,9 +19,9 @@
 
 import type { ColorMod, ColorRef } from "./types.ts";
 import type { ResolvedTheme } from "../../../model/canonical-document.ts";
+import { GRADIENT_STOP_UNITS } from "../../../runtime/units.ts";
 
 const FALLBACK_COLOR = "#808080";
-const OOXML_UNIT = 100_000; // modifier val is in parts per 100,000
 
 /**
  * Scheme-alias map. Word often emits aliases that refer to the primary
@@ -100,7 +100,7 @@ function applyMods(rgb: Rgb, mods: readonly ColorMod[] | undefined): Rgb {
 }
 
 function applyMod(rgb: Rgb, mod: ColorMod): Rgb {
-  const frac = mod.value / OOXML_UNIT;
+  const frac = mod.value / GRADIENT_STOP_UNITS;
   switch (mod.kind) {
     case "lumMod": {
       // Scale luminance.