@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/core/commands/text-commands.cjs

@@ -0,0 +1,2391 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/commands/text-commands.ts
+var text_commands_exports = {};
+__export(text_commands_exports, {
+  deleteSelectionOrBackward: () => deleteSelectionOrBackward,
+  deleteSelectionOrForward: () => deleteSelectionOrForward,
+  insertHardBreak: () => insertHardBreak,
+  insertPageBreak: () => insertPageBreak,
+  insertTab: () => insertTab,
+  insertTable: () => insertTable,
+  insertText: () => insertText,
+  splitParagraph: () => splitParagraph
+});
+module.exports = __toCommonJS(text_commands_exports);
+
+// src/core/selection/mapping.ts
+var DEFAULT_BOUNDARY_ASSOC = {
+  start: 1,
+  end: -1
+};
+function createRangeAnchor(from, to = from, assoc = DEFAULT_BOUNDARY_ASSOC) {
+  return {
+    kind: "range",
+    range: normalizeRange({ from, to }),
+    assoc
+  };
+}
+function normalizeRange(range) {
+  return range.from <= range.to ? { from: range.from, to: range.to } : { from: range.to, to: range.from };
+}
+
+// src/core/state/editor-state.ts
+function createSelectionSnapshot(anchor = 0, head = anchor) {
+  return {
+    anchor,
+    head,
+    isCollapsed: anchor === head,
+    activeRange: createRangeAnchor(anchor, head, DEFAULT_BOUNDARY_ASSOC)
+  };
+}
+
+// src/core/schema/text-schema.ts
+function parseTextStory(content) {
+  const root = normalizeDocumentRoot(content);
+  const firstParagraphNode = root.children.find(isParagraphNode);
+  const firstParagraph = firstParagraphNode ? extractParagraphProperties(firstParagraphNode) : cloneParagraphProperties(EMPTY_PARAGRAPH_PROPERTIES);
+  const units = [];
+  for (let index = 0; index < root.children.length; index += 1) {
+    const block = root.children[index];
+    const nextBlock = root.children[index + 1];
+    if (isParagraphNode(block)) {
+      units.push(...flattenInlineNodes(block.children));
+      if (isParagraphNode(nextBlock)) {
+        units.push({
+          kind: "paragraph_break",
+          nextParagraph: extractParagraphProperties(nextBlock)
+        });
+      }
+      continue;
+    }
+    if (block.type !== "opaque_block") {
+      continue;
+    }
+    units.push({
+      kind: "opaque_block",
+      fragmentId: block.fragmentId,
+      warningId: block.warningId,
+      ...isParagraphNode(nextBlock) ? { nextParagraph: extractParagraphProperties(nextBlock) } : {}
+    });
+  }
+  return {
+    firstParagraph,
+    units,
+    size: units.length
+  };
+}
+function serializeTextStory(story) {
+  const blocks = [];
+  let currentParagraph = createParagraph(story.firstParagraph);
+  let currentHyperlink;
+  let activeTextBuffer;
+  const ensureCurrentParagraph = () => {
+    if (!currentParagraph) {
+      currentParagraph = createParagraph(EMPTY_PARAGRAPH_PROPERTIES);
+    }
+  };
+  const flushTextBuffer = () => {
+    if (!activeTextBuffer || activeTextBuffer.text.length === 0) {
+      activeTextBuffer = void 0;
+      return;
+    }
+    const textNode = {
+      type: "text",
+      text: activeTextBuffer.text,
+      ...activeTextBuffer.marks ? { marks: cloneMarks(activeTextBuffer.marks) } : {}
+    };
+    ensureCurrentParagraph();
+    if (activeTextBuffer.hyperlinkHref) {
+      if (!currentHyperlink || currentHyperlink.href !== activeTextBuffer.hyperlinkHref) {
+        flushHyperlink();
+        currentHyperlink = {
+          type: "hyperlink",
+          href: activeTextBuffer.hyperlinkHref,
+          children: []
+        };
+      }
+      currentHyperlink.children.push(textNode);
+    } else {
+      flushHyperlink();
+      currentParagraph.children.push(textNode);
+    }
+    activeTextBuffer = void 0;
+  };
+  const flushHyperlink = () => {
+    if (currentHyperlink) {
+      ensureCurrentParagraph();
+      currentParagraph.children.push(currentHyperlink);
+      currentHyperlink = void 0;
+    }
+  };
+  const flushParagraph = () => {
+    flushTextBuffer();
+    flushHyperlink();
+    if (!currentParagraph) {
+      return;
+    }
+    blocks.push(currentParagraph);
+    currentParagraph = void 0;
+  };
+  const pushInlineNode = (node, hyperlinkHref) => {
+    flushTextBuffer();
+    ensureCurrentParagraph();
+    if (hyperlinkHref) {
+      if (!currentHyperlink || currentHyperlink.href !== hyperlinkHref) {
+        flushHyperlink();
+        currentHyperlink = {
+          type: "hyperlink",
+          href: hyperlinkHref,
+          children: []
+        };
+      }
+      currentHyperlink.children.push(node);
+      return;
+    }
+    flushHyperlink();
+    currentParagraph.children.push(node);
+  };
+  for (const unit of story.units) {
+    if (unit.kind === "paragraph_break") {
+      flushParagraph();
+      currentParagraph = createParagraph(unit.nextParagraph);
+      continue;
+    }
+    if (unit.kind === "opaque_block") {
+      flushParagraph();
+      blocks.push({
+        type: "opaque_block",
+        fragmentId: unit.fragmentId,
+        warningId: unit.warningId
+      });
+      currentParagraph = unit.nextParagraph ? createParagraph(unit.nextParagraph) : void 0;
+      continue;
+    }
+    if (unit.kind === "text") {
+      const shouldExtendBuffer = activeTextBuffer && activeTextBuffer.hyperlinkHref === unit.hyperlinkHref && haveEqualMarks(activeTextBuffer.marks, unit.marks);
+      if (shouldExtendBuffer && activeTextBuffer) {
+        activeTextBuffer.text += unit.value;
+      } else {
+        flushTextBuffer();
+        activeTextBuffer = {
+          text: unit.value,
+          ...unit.marks ? { marks: cloneMarks(unit.marks) } : {},
+          ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
+        };
+      }
+      continue;
+    }
+    switch (unit.kind) {
+      case "tab":
+        pushInlineNode({ type: "tab" }, unit.hyperlinkHref);
+        break;
+      case "hard_break":
+        pushInlineNode({ type: "hard_break" }, unit.hyperlinkHref);
+        break;
+      case "image":
+        pushInlineNode({
+          type: "image",
+          mediaId: unit.mediaId,
+          ...unit.altText ? { altText: unit.altText } : {}
+        });
+        break;
+      case "opaque_inline":
+        pushInlineNode({
+          type: "opaque_inline",
+          fragmentId: unit.fragmentId,
+          warningId: unit.warningId
+        });
+        break;
+    }
+  }
+  flushParagraph();
+  if (blocks.length === 0) {
+    blocks.push(createParagraph(story.firstParagraph));
+  }
+  return {
+    type: "doc",
+    children: blocks
+  };
+}
+function createPlainText(story) {
+  return story.units.map((unit) => {
+    switch (unit.kind) {
+      case "text":
+        return unit.value;
+      case "tab":
+        return "	";
+      case "hard_break":
+        return "\n";
+      case "paragraph_break":
+        return "\n";
+      case "image":
+        return "\uFFFC";
+      case "opaque_inline":
+        return "\uFFF9";
+      case "opaque_block":
+        return "\uFFFA";
+    }
+  }).join("");
+}
+function cloneStoryUnit(unit) {
+  switch (unit.kind) {
+    case "text":
+      return {
+        kind: "text",
+        value: unit.value,
+        ...unit.marks ? { marks: cloneMarks(unit.marks) } : {},
+        ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
+      };
+    case "tab":
+      return {
+        kind: "tab",
+        ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
+      };
+    case "hard_break":
+      return {
+        kind: "hard_break",
+        ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
+      };
+    case "image":
+      return {
+        kind: "image",
+        mediaId: unit.mediaId,
+        ...unit.altText ? { altText: unit.altText } : {}
+      };
+    case "opaque_inline":
+      return {
+        kind: "opaque_inline",
+        fragmentId: unit.fragmentId,
+        warningId: unit.warningId
+      };
+    case "opaque_block":
+      return {
+        kind: "opaque_block",
+        fragmentId: unit.fragmentId,
+        warningId: unit.warningId,
+        ...unit.nextParagraph ? { nextParagraph: cloneParagraphProperties(unit.nextParagraph) } : {}
+      };
+    case "paragraph_break":
+      return {
+        kind: "paragraph_break",
+        nextParagraph: cloneParagraphProperties(unit.nextParagraph)
+      };
+  }
+}
+function cloneParagraphProperties(properties) {
+  return {
+    ...properties.styleId ? { styleId: properties.styleId } : {},
+    ...properties.numbering ? {
+      numbering: {
+        numberingInstanceId: properties.numbering.numberingInstanceId,
+        level: properties.numbering.level
+      }
+    } : {}
+  };
+}
+function normalizeDocumentRoot(content) {
+  if (isDocumentRootNode(content)) {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return {
+      type: "doc",
+      children: content.filter(
+        (block) => isParagraphNode(block) || isOpaqueBlockNode(block)
+      )
+    };
+  }
+  return {
+    type: "doc",
+    children: [createEmptyParagraph()]
+  };
+}
+function flattenInlineNodes(nodes, hyperlinkHref) {
+  const units = [];
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+        for (const character of Array.from(node.text)) {
+          units.push({
+            kind: "text",
+            value: character,
+            ...node.marks ? { marks: cloneMarks(node.marks) } : {},
+            ...hyperlinkHref ? { hyperlinkHref } : {}
+          });
+        }
+        break;
+      case "tab":
+        units.push({
+          kind: "tab",
+          ...hyperlinkHref ? { hyperlinkHref } : {}
+        });
+        break;
+      case "hard_break":
+        units.push({
+          kind: "hard_break",
+          ...hyperlinkHref ? { hyperlinkHref } : {}
+        });
+        break;
+      case "hyperlink":
+        units.push(...flattenInlineNodes(node.children, node.href));
+        break;
+      case "image":
+        units.push({
+          kind: "image",
+          mediaId: node.mediaId,
+          ...node.altText ? { altText: node.altText } : {}
+        });
+        break;
+      case "opaque_inline":
+        units.push({
+          kind: "opaque_inline",
+          fragmentId: node.fragmentId,
+          warningId: node.warningId
+        });
+        break;
+    }
+  }
+  return units;
+}
+function extractParagraphProperties(paragraph) {
+  return {
+    ...paragraph.styleId ? { styleId: paragraph.styleId } : {},
+    ...paragraph.numbering ? {
+      numbering: {
+        numberingInstanceId: paragraph.numbering.numberingInstanceId,
+        level: paragraph.numbering.level
+      }
+    } : {}
+  };
+}
+function createParagraph(properties) {
+  return {
+    type: "paragraph",
+    ...properties.styleId ? { styleId: properties.styleId } : {},
+    ...properties.numbering ? {
+      numbering: {
+        numberingInstanceId: properties.numbering.numberingInstanceId,
+        level: properties.numbering.level
+      }
+    } : {},
+    children: []
+  };
+}
+function createEmptyParagraph() {
+  return {
+    type: "paragraph",
+    children: []
+  };
+}
+var EMPTY_PARAGRAPH_PROPERTIES = {};
+function cloneMarks(marks) {
+  return marks.map((mark) => ({ ...mark }));
+}
+function haveEqualMarks(left, right) {
+  if (!left && !right) {
+    return true;
+  }
+  if (!left || !right || left.length !== right.length) {
+    return false;
+  }
+  return left.every((mark, index) => mark.type === right[index]?.type);
+}
+function isDocumentRootNode(value) {
+  return Boolean(value) && typeof value === "object" && value.type === "doc";
+}
+function isParagraphNode(value) {
+  return Boolean(value) && typeof value === "object" && value.type === "paragraph";
+}
+function isOpaqueBlockNode(value) {
+  return Boolean(value) && typeof value === "object" && value.type === "opaque_block";
+}
+
+// src/preservation/store.ts
+function getOpaqueFragment(store, fragmentId) {
+  return normalizeOpaqueFragmentMap(store)[fragmentId];
+}
+function describeOpaqueFragment(fragment) {
+  const xml = fragment.payloadReference;
+  const detail = createDetail(fragment);
+  if (/\b(?:w:)?sectPr\b/u.test(xml)) {
+    return {
+      featureKey: "sections",
+      label: "Section properties",
+      detail
+    };
+  }
+  if (/\b(?:w:)?tbl\b/u.test(xml)) {
+    return {
+      featureKey: "tables",
+      label: "Preserved table structure",
+      detail
+    };
+  }
+  if (/\b(?:w:)?hdr\b|\b(?:w:)?ftr\b/u.test(xml)) {
+    return {
+      featureKey: "headers-footers",
+      label: "Header or footer content",
+      detail
+    };
+  }
+  if (/\b(?:w:)?fldSimple\b|\b(?:w:)?fldChar\b|\b(?:w:)?instrText\b/u.test(xml)) {
+    return {
+      featureKey: "fields",
+      label: "Word field content",
+      detail
+    };
+  }
+  if (/\b(?:w:)?sdt\b/u.test(xml)) {
+    return {
+      featureKey: "content-controls",
+      label: "Content control",
+      detail
+    };
+  }
+  if (/\b(?:w:)?customXml\b/u.test(xml)) {
+    return {
+      featureKey: "custom-xml",
+      label: "Custom XML wrapper",
+      detail
+    };
+  }
+  if (/\b(?:w:)?altChunk\b/u.test(xml)) {
+    return {
+      featureKey: "alt-chunk",
+      label: "Alternate content import",
+      detail
+    };
+  }
+  if (/\b(?:w:)?object\b|\b(?:o:)?OLEObject\b/u.test(xml)) {
+    return {
+      featureKey: "embedded-objects",
+      label: "Embedded object",
+      detail
+    };
+  }
+  if (/\b(?:mc:)?AlternateContent\b/u.test(xml)) {
+    return {
+      featureKey: "alternate-content",
+      label: "Markup compatibility block",
+      detail
+    };
+  }
+  return {
+    featureKey: "unknown-ooxml",
+    label: "Unsupported OOXML fragment",
+    detail
+  };
+}
+function createDetail(fragment) {
+  const detail = [
+    `Preserved whole-unit from ${fragment.lastKnownRange.from}-${fragment.lastKnownRange.to}.`,
+    fragment.packagePartName ? `Part ${fragment.packagePartName}.` : null,
+    fragment.relationshipId ? `Relationship ${fragment.relationshipId}.` : null
+  ].filter(Boolean).join(" ");
+  return detail.length > 0 ? detail : "Preserved whole-unit to keep unsupported OOXML intact.";
+}
+function normalizeOpaqueFragmentMap(store) {
+  return store && typeof store === "object" && store.opaqueFragments && typeof store.opaqueFragments === "object" ? store.opaqueFragments : {};
+}
+
+// src/runtime/story-context.ts
+function collectSectionContexts(document) {
+  const sections = [];
+  let sectionIndex = 0;
+  for (const block of document.content.children) {
+    if (block.type !== "section_break") {
+      continue;
+    }
+    sections.push({
+      index: sectionIndex,
+      properties: block.sectionProperties
+    });
+    sectionIndex += 1;
+  }
+  sections.push({
+    index: sectionIndex,
+    properties: document.subParts?.finalSectionProperties
+  });
+  return sections;
+}
+function resolveSectionVariants(kind, sectionIndex, explicitReferences, documents) {
+  if (explicitReferences && explicitReferences.length > 0) {
+    return explicitReferences.map((ref) => ({
+      variant: ref.variant,
+      relationshipId: ref.relationshipId
+    }));
+  }
+  return documents.filter(
+    (entry) => entry.sectionIndex === void 0 || entry.sectionIndex === sectionIndex
+  ).map((entry) => ({
+    variant: entry.variant,
+    relationshipId: entry.relationshipId
+  }));
+}
+function findHeaderFooterDocumentEntry(document, target) {
+  const documents = target.kind === "header" ? document.subParts?.headers ?? [] : document.subParts?.footers ?? [];
+  const matches = documents.filter(
+    (entry) => entry.relationshipId === target.relationshipId && entry.variant === target.variant
+  );
+  if (matches.length === 0) {
+    return void 0;
+  }
+  if (target.sectionIndex !== void 0) {
+    return matches.find((entry) => entry.sectionIndex === target.sectionIndex) ?? matches.find((entry) => entry.sectionIndex === void 0) ?? matches[0];
+  }
+  return matches[0];
+}
+function sectionSupportsStoryTarget(document, sectionIndex, target) {
+  if (!findHeaderFooterDocumentEntry(document, target)) {
+    return false;
+  }
+  const section = collectSectionContexts(document).find(
+    (candidate) => candidate.index === sectionIndex
+  );
+  if (!section) {
+    return false;
+  }
+  const variants = resolveSectionVariants(
+    target.kind,
+    sectionIndex,
+    target.kind === "header" ? section.properties?.headerReferences : section.properties?.footerReferences,
+    target.kind === "header" ? document.subParts?.headers ?? [] : document.subParts?.footers ?? []
+  );
+  return variants.some(
+    (variant) => variant.relationshipId === target.relationshipId && variant.variant === target.variant
+  );
+}
+function normalizeHeaderFooterTarget(document, target, preferredSectionIndex) {
+  if (!findHeaderFooterDocumentEntry(document, target)) {
+    return void 0;
+  }
+  if (target.sectionIndex !== void 0) {
+    return sectionSupportsStoryTarget(document, target.sectionIndex, target) ? target : void 0;
+  }
+  const candidateIndexes = collectSectionContexts(document).map((section) => section.index).filter(
+    (sectionIndex) => sectionSupportsStoryTarget(document, sectionIndex, target)
+  );
+  if (candidateIndexes.length === 0) {
+    return void 0;
+  }
+  const resolvedSectionIndex = preferredSectionIndex !== void 0 && candidateIndexes.includes(preferredSectionIndex) ? preferredSectionIndex : candidateIndexes[0];
+  return {
+    ...target,
+    sectionIndex: resolvedSectionIndex
+  };
+}
+
+// src/runtime/story-targeting.ts
+function getStoryBlocks(document, target) {
+  if (target.kind === "main") {
+    return document.content.children;
+  }
+  const subParts = document.subParts;
+  if (!subParts) {
+    return [];
+  }
+  switch (target.kind) {
+    case "header": {
+      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
+      return (resolvedTarget && findHeaderFooterDocumentEntry(document, resolvedTarget)?.blocks) ?? [];
+    }
+    case "footer": {
+      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
+      return (resolvedTarget && findHeaderFooterDocumentEntry(document, resolvedTarget)?.blocks) ?? [];
+    }
+    case "footnote":
+      return subParts.footnoteCollection?.footnotes[target.noteId]?.blocks ?? [];
+    case "endnote":
+      return subParts.footnoteCollection?.endnotes[target.noteId]?.blocks ?? [];
+  }
+}
+
+// src/runtime/numbering-prefix.ts
+var DEFAULT_START_AT = 1;
+function createNumberingPrefixResolver(catalog) {
+  const sequenceStates = /* @__PURE__ */ new Map();
+  function resolveInternal(numbering) {
+    if (!numbering) {
+      return null;
+    }
+    const instance = catalog.instances[numbering.numberingInstanceId];
+    if (!instance) {
+      return null;
+    }
+    const definition = catalog.abstractDefinitions[instance.abstractNumberingId];
+    if (!definition) {
+      return null;
+    }
+    const levelDefinitions = new Map(
+      definition.levels.map((level) => [level.level, level])
+    );
+    const levelDefinition = levelDefinitions.get(numbering.level);
+    if (!levelDefinition || levelDefinition.format === "none") {
+      return null;
+    }
+    const sequenceState = getSequenceState(sequenceStates, numbering.numberingInstanceId);
+    advanceSequence(sequenceState, numbering.level, levelDefinitions, instance.overrides);
+    const effectiveLevelDefs = levelDefinition.isLegalNumbering ? new Map(Array.from(levelDefinitions.entries()).map(([k, v]) => [k, { ...v, format: "decimal" }])) : levelDefinitions;
+    const text = renderLevelText(levelDefinition.text, sequenceState.counters, effectiveLevelDefs);
+    if (text === null) return null;
+    return { text, suffix: levelDefinition.suffix };
+  }
+  return {
+    resolve(numbering) {
+      const result = resolveInternal(numbering);
+      return result?.text ?? null;
+    },
+    resolveDetailed(numbering) {
+      return resolveInternal(numbering);
+    }
+  };
+}
+function getSequenceState(states, numberingInstanceId) {
+  const existing = states.get(numberingInstanceId);
+  if (existing) {
+    return existing;
+  }
+  const created = {
+    counters: [],
+    lastLevel: null
+  };
+  states.set(numberingInstanceId, created);
+  return created;
+}
+function advanceSequence(state, currentLevel, levelDefinitions, overrides) {
+  if (state.lastLevel !== null && currentLevel <= state.lastLevel) {
+    state.counters.length = currentLevel + 1;
+  }
+  const startAt = getLevelStartAt(currentLevel, levelDefinitions, overrides);
+  const currentValue = state.counters[currentLevel];
+  state.counters[currentLevel] = currentValue === void 0 ? startAt : currentValue + 1;
+  state.lastLevel = currentLevel;
+}
+function getLevelStartAt(level, levelDefinitions, overrides) {
+  const override = overrides.find((entry) => entry.level === level);
+  if (override?.startAt !== void 0) {
+    return override.startAt;
+  }
+  return levelDefinitions.get(level)?.startAt ?? DEFAULT_START_AT;
+}
+function renderLevelText(text, counters, levelDefinitions) {
+  if (!text) {
+    return null;
+  }
+  if (!text.includes("%")) {
+    return text;
+  }
+  const rendered = text.replace(/%([1-9])/g, (_match, token) => {
+    const level = Number.parseInt(token, 10) - 1;
+    const counter = counters[level];
+    if (counter === void 0) {
+      return "";
+    }
+    const format = levelDefinitions.get(level)?.format ?? "decimal";
+    return formatCounter(counter, format);
+  });
+  return rendered.trim().length > 0 ? rendered : null;
+}
+function formatCounter(value, format) {
+  switch (format) {
+    case "decimal":
+      return String(value);
+    case "decimalZero":
+      return String(value).padStart(2, "0");
+    case "upperLetter":
+      return toAlphabetic(value).toUpperCase();
+    case "lowerLetter":
+      return toAlphabetic(value).toLowerCase();
+    case "upperRoman":
+      return toRoman(value).toUpperCase();
+    case "lowerRoman":
+      return toRoman(value).toLowerCase();
+    case "none":
+      return "";
+    default:
+      return String(value);
+  }
+}
+function toAlphabetic(value) {
+  if (value <= 0) {
+    return String(value);
+  }
+  let remainder = value;
+  let result = "";
+  while (remainder > 0) {
+    remainder -= 1;
+    result = String.fromCharCode(65 + remainder % 26) + result;
+    remainder = Math.floor(remainder / 26);
+  }
+  return result;
+}
+function toRoman(value) {
+  if (value <= 0 || value >= 4e3) {
+    return String(value);
+  }
+  const numerals = [
+    [1e3, "M"],
+    [900, "CM"],
+    [500, "D"],
+    [400, "CD"],
+    [100, "C"],
+    [90, "XC"],
+    [50, "L"],
+    [40, "XL"],
+    [10, "X"],
+    [9, "IX"],
+    [5, "V"],
+    [4, "IV"],
+    [1, "I"]
+  ];
+  let remaining = value;
+  let result = "";
+  for (const [amount, numeral] of numerals) {
+    while (remaining >= amount) {
+      remaining -= amount;
+      result += numeral;
+    }
+  }
+  return result;
+}
+
+// src/runtime/surface-projection.ts
+function createEditorSurfaceSnapshot(document, _selection, activeStory = { kind: "main" }) {
+  const root = normalizeDocumentRoot2({
+    type: "doc",
+    children: [...getStoryBlocks(document, activeStory)]
+  });
+  const blocks = [];
+  const lockedFragmentIds = [];
+  const numberingPrefixResolver = createNumberingPrefixResolver(document.numbering);
+  let cursor = 0;
+  const counters = {
+    paragraph: 0,
+    table: 0,
+    opaque: 0,
+    sdt: 0,
+    customXml: 0,
+    altChunk: 0
+  };
+  for (let index = 0; index < root.children.length; index += 1) {
+    const surfaceBlock = createSurfaceBlock(
+      root.children[index],
+      document,
+      cursor,
+      counters,
+      numberingPrefixResolver
+    );
+    blocks.push(surfaceBlock.block);
+    lockedFragmentIds.push(...surfaceBlock.lockedFragmentIds);
+    cursor = surfaceBlock.nextCursor;
+    if (index < root.children.length - 1 && root.children[index + 1]?.type === "paragraph") {
+      cursor += 1;
+    }
+  }
+  const secondaryStories = createSecondaryStorySurfaces(document);
+  return {
+    storySize: cursor,
+    plainText: createPlainText2(blocks),
+    blocks,
+    lockedFragmentIds,
+    secondaryStories
+  };
+}
+function createSurfaceBlock(block, document, cursor, counters, numberingPrefixResolver) {
+  if (block.type === "opaque_block") {
+    const fragment = getOpaqueFragment(document.preservation, block.fragmentId);
+    const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
+    const blockId = `opaque-${counters.opaque}`;
+    counters.opaque += 1;
+    return {
+      block: {
+        blockId,
+        kind: "opaque_block",
+        from: cursor,
+        to: cursor + 1,
+        fragmentId: block.fragmentId,
+        warningId: block.warningId,
+        label: descriptor?.label ?? "Unsupported OOXML fragment",
+        detail: descriptor?.detail ?? "Locked whole-unit to keep unsupported OOXML intact through export.",
+        state: "locked-preserve-only"
+      },
+      lockedFragmentIds: [block.fragmentId],
+      nextCursor: cursor + 1
+    };
+  }
+  if (block.type === "table") {
+    const tableIndex = counters.table;
+    counters.table += 1;
+    return createTableBlock(
+      tableIndex,
+      block,
+      document,
+      cursor,
+      counters,
+      numberingPrefixResolver
+    );
+  }
+  if (block.type === "sdt") {
+    const sdtIndex = counters.sdt;
+    counters.sdt += 1;
+    return createSdtBlock(
+      sdtIndex,
+      block,
+      document,
+      cursor,
+      counters,
+      numberingPrefixResolver
+    );
+  }
+  if (block.type === "custom_xml") {
+    const blockId = `custom-xml-${counters.customXml}`;
+    counters.customXml += 1;
+    return {
+      block: {
+        blockId,
+        kind: "opaque_block",
+        from: cursor,
+        to: cursor + 1,
+        fragmentId: blockId,
+        warningId: blockId,
+        label: "Custom XML block",
+        detail: block.uri || block.element ? `Custom XML wrapper ${[block.element, block.uri].filter(Boolean).join(" ")} preserved as a read-only block.` : "Custom XML wrapper preserved as a read-only block.",
+        state: "locked-preserve-only"
+      },
+      lockedFragmentIds: [],
+      nextCursor: cursor + 1
+    };
+  }
+  if (block.type === "alt_chunk") {
+    const blockId = `alt-chunk-${counters.altChunk}`;
+    counters.altChunk += 1;
+    return {
+      block: {
+        blockId,
+        kind: "opaque_block",
+        from: cursor,
+        to: cursor + 1,
+        fragmentId: blockId,
+        warningId: blockId,
+        label: "AltChunk import",
+        detail: `Alternate content import remains read-only through relationship ${block.relationshipId}.`,
+        state: "locked-preserve-only"
+      },
+      lockedFragmentIds: [],
+      nextCursor: cursor + 1
+    };
+  }
+  if (block.type === "section_break") {
+    const blockId = `section-break-${counters.opaque}`;
+    counters.opaque += 1;
+    return {
+      block: {
+        blockId,
+        kind: "opaque_block",
+        from: cursor,
+        to: cursor + 1,
+        fragmentId: blockId,
+        warningId: blockId,
+        label: "Section break",
+        detail: "Section properties preserved as a read-only boundary.",
+        state: "locked-preserve-only"
+      },
+      lockedFragmentIds: [],
+      nextCursor: cursor + 1
+    };
+  }
+  const paragraphIndex = counters.paragraph;
+  counters.paragraph += 1;
+  return createParagraphBlock(
+    paragraphIndex,
+    block,
+    document,
+    cursor,
+    numberingPrefixResolver
+  );
+}
+function createTableBlock(tableIndex, table, document, cursor, counters, numberingPrefixResolver) {
+  const lockedFragmentIds = [];
+  let innerCursor = cursor;
+  const rows = [];
+  const rowSpans = computeTableRowSpans(table);
+  for (const [rowIndex, row] of table.rows.entries()) {
+    const cells = [];
+    for (const [cellIndex, cell] of row.cells.entries()) {
+      const cellContent = [];
+      for (const child of cell.children) {
+        const result = createSurfaceBlock(
+          child,
+          document,
+          innerCursor,
+          counters,
+          numberingPrefixResolver
+        );
+        cellContent.push(result.block);
+        lockedFragmentIds.push(...result.lockedFragmentIds);
+        innerCursor = result.nextCursor;
+      }
+      const cellBorders = resolveCellBorderStyles(cell.borders);
+      cells.push({
+        gridSpan: cell.gridSpan ?? 1,
+        verticalMerge: cell.verticalMerge ?? null,
+        colspan: cell.gridSpan ?? 1,
+        rowspan: rowSpans.get(`${rowIndex}:${cellIndex}`) ?? 1,
+        ...cell.shading?.fill ? { backgroundColor: `#${cell.shading.fill}` } : {},
+        ...cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {},
+        ...cellBorders.borderTop ? { borderTop: cellBorders.borderTop } : {},
+        ...cellBorders.borderRight ? { borderRight: cellBorders.borderRight } : {},
+        ...cellBorders.borderBottom ? { borderBottom: cellBorders.borderBottom } : {},
+        ...cellBorders.borderLeft ? { borderLeft: cellBorders.borderLeft } : {},
+        content: cellContent
+      });
+    }
+    rows.push({
+      cells,
+      ...row.gridBefore !== void 0 ? { gridBefore: row.gridBefore } : {},
+      ...row.gridAfter !== void 0 ? { gridAfter: row.gridAfter } : {},
+      ...row.height !== void 0 ? { height: row.height } : {},
+      ...row.heightRule ? { heightRule: row.heightRule } : {},
+      ...row.isHeader ? { isHeader: row.isHeader } : {}
+    });
+  }
+  return {
+    block: {
+      blockId: `table-${tableIndex}`,
+      kind: "table",
+      from: cursor,
+      to: innerCursor,
+      styleId: table.styleId,
+      gridColumns: table.gridColumns,
+      ...table.alignment ? { alignment: table.alignment } : {},
+      ...table.tblLook ? { tblLook: table.tblLook } : {},
+      rows
+    },
+    lockedFragmentIds,
+    nextCursor: innerCursor
+  };
+}
+function computeTableRowSpans(table) {
+  const positionedRows = table.rows.map((row) => {
+    let startColumn = 0;
+    return row.cells.map((cell, cellIndex) => {
+      const width = cell.gridSpan ?? 1;
+      const positionedCell = {
+        cell,
+        cellIndex,
+        startColumn,
+        endColumn: startColumn + width - 1
+      };
+      startColumn += width;
+      return positionedCell;
+    });
+  });
+  const rowSpans = /* @__PURE__ */ new Map();
+  for (const [rowIndex, row] of positionedRows.entries()) {
+    for (const positionedCell of row) {
+      if (positionedCell.cell.verticalMerge !== "restart") {
+        rowSpans.set(`${rowIndex}:${positionedCell.cellIndex}`, 1);
+        continue;
+      }
+      let rowspan = 1;
+      for (let nextRowIndex = rowIndex + 1; nextRowIndex < positionedRows.length; nextRowIndex += 1) {
+        const continuedCell = positionedRows[nextRowIndex]?.find(
+          (candidate) => candidate.cell.verticalMerge === "continue" && candidate.startColumn === positionedCell.startColumn && candidate.endColumn === positionedCell.endColumn
+        );
+        if (!continuedCell) {
+          break;
+        }
+        rowspan += 1;
+      }
+      rowSpans.set(`${rowIndex}:${positionedCell.cellIndex}`, rowspan);
+    }
+  }
+  return rowSpans;
+}
+function resolveCellBorderStyles(borders) {
+  if (!borders) return {};
+  const result = {};
+  const sides = [["top", "borderTop"], ["right", "borderRight"], ["bottom", "borderBottom"], ["left", "borderLeft"]];
+  for (const [side, key] of sides) {
+    const spec = borders[side];
+    if (!spec || spec.value === "none" || spec.value === "nil") continue;
+    const width = spec.size ? `${Math.max(1, Math.round(spec.size / 8))}px` : "1px";
+    const style = spec.value === "double" ? "double" : spec.value === "dashed" || spec.value === "dashSmallGap" ? "dashed" : spec.value === "dotted" ? "dotted" : "solid";
+    const color = spec.color && spec.color !== "auto" ? `#${spec.color}` : "currentColor";
+    result[key] = `${width} ${style} ${color}`;
+  }
+  return result;
+}
+function createSdtBlock(sdtIndex, block, document, cursor, counters, numberingPrefixResolver) {
+  const children = [];
+  const lockedFragmentIds = [];
+  let innerCursor = cursor;
+  for (const child of block.children) {
+    const result = createSurfaceBlock(
+      child,
+      document,
+      innerCursor,
+      counters,
+      numberingPrefixResolver
+    );
+    children.push(result.block);
+    lockedFragmentIds.push(...result.lockedFragmentIds);
+    innerCursor = result.nextCursor;
+  }
+  return {
+    block: {
+      blockId: `sdt-${sdtIndex}`,
+      kind: "sdt_block",
+      from: cursor,
+      to: innerCursor,
+      ...block.properties.sdtType ? { sdtType: block.properties.sdtType } : {},
+      ...block.properties.alias ? { alias: block.properties.alias } : {},
+      ...block.properties.tag ? { tag: block.properties.tag } : {},
+      ...block.properties.lock ? { lock: block.properties.lock } : {},
+      ...block.properties.checkbox ? { checkboxChecked: block.properties.checkbox.checked } : {},
+      ...block.properties.datePicker?.fullDate ? { dateValue: block.properties.datePicker.fullDate } : {},
+      ...block.properties.dropdownList ? { dropdownItems: block.properties.dropdownList } : {},
+      ...block.properties.comboBox ? { comboBoxItems: block.properties.comboBox } : {},
+      ...block.properties.showingPlcHdr ? { showingPlcHdr: true } : {},
+      children
+    },
+    lockedFragmentIds,
+    nextCursor: innerCursor
+  };
+}
+function createParagraphBlock(paragraphIndex, paragraph, document, start, numberingPrefixResolver) {
+  const accumulator = {
+    blockId: `paragraph-${paragraphIndex}`,
+    kind: "paragraph",
+    from: start,
+    to: start,
+    ...paragraph.styleId ? { styleId: paragraph.styleId } : {},
+    ...paragraph.numbering ? { numbering: paragraph.numbering } : {},
+    ...paragraph.numbering ? (() => {
+      const detailed = numberingPrefixResolver.resolveDetailed(paragraph.numbering);
+      return detailed ? {
+        numberingPrefix: detailed.text,
+        ...detailed.suffix ? { numberingSuffix: detailed.suffix } : {}
+      } : {};
+    })() : {},
+    ...paragraph.alignment ? { alignment: paragraph.alignment } : {},
+    ...paragraph.spacing ? { spacing: paragraph.spacing } : {},
+    ...paragraph.contextualSpacing !== void 0 ? { contextualSpacing: paragraph.contextualSpacing } : {},
+    ...paragraph.indentation ? { indentation: paragraph.indentation } : {},
+    ...paragraph.borders ? { borders: paragraph.borders } : {},
+    ...paragraph.shading ? { shading: paragraph.shading } : {},
+    ...paragraph.tabStops && paragraph.tabStops.length > 0 ? { tabStops: paragraph.tabStops.map((tabStop) => toSurfaceTabStop(tabStop)) } : {},
+    ...paragraph.keepNext ? { keepNext: true } : {},
+    ...paragraph.keepLines ? { keepLines: true } : {},
+    ...paragraph.pageBreakBefore ? { pageBreakBefore: true } : {},
+    ...paragraph.outlineLevel !== void 0 ? { outlineLevel: paragraph.outlineLevel } : {},
+    ...paragraph.bidi ? { bidi: true } : {},
+    ...paragraph.suppressLineNumbers ? { suppressLineNumbers: true } : {},
+    segments: []
+  };
+  const lockedFragmentIds = [];
+  let cursor = start;
+  const children = Array.isArray(paragraph.children) ? paragraph.children : [];
+  for (const child of children) {
+    const result = appendInlineSegments(accumulator, child, document, cursor);
+    cursor = result.nextCursor;
+    lockedFragmentIds.push(...result.lockedFragmentIds);
+  }
+  accumulator.to = cursor;
+  return {
+    block: accumulator,
+    nextCursor: cursor,
+    lockedFragmentIds
+  };
+}
+function appendInlineSegments(paragraph, node, document, start, hyperlinkHref) {
+  switch (node.type) {
+    case "text":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "text",
+        from: start,
+        to: start + Array.from(node.text).length,
+        text: node.text,
+        ...node.marks ? (() => {
+          const result = cloneMarks2(node.marks);
+          return {
+            ...result.marks.length > 0 ? { marks: result.marks } : {},
+            ...result.markAttrs ? { markAttrs: result.markAttrs } : {}
+          };
+        })() : {},
+        ...hyperlinkHref ? { hyperlinkHref } : {}
+      });
+      return { nextCursor: start + Array.from(node.text).length, lockedFragmentIds: [] };
+    case "tab":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "tab",
+        from: start,
+        to: start + 1,
+        ...hyperlinkHref ? { hyperlinkHref } : {}
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "hard_break":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "hard_break",
+        from: start,
+        to: start + 1,
+        ...hyperlinkHref ? { hyperlinkHref } : {}
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "hyperlink": {
+      let cursor = start;
+      for (const child of node.children) {
+        const result = appendInlineSegments(paragraph, child, document, cursor, node.href);
+        cursor = result.nextCursor;
+      }
+      return { nextCursor: cursor, lockedFragmentIds: [] };
+    }
+    case "image":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "image",
+        from: start,
+        to: start + 1,
+        mediaId: node.mediaId,
+        altText: node.altText,
+        state: hasMediaItem(document.media, node.mediaId) ? "editable" : "missing",
+        ...node.display ? { display: node.display } : {},
+        detail: node.display === "floating" ? createFloatingImageDetail(node.altText, node.floating) : node.altText ? `Alt text ${node.altText}.` : "Inline image remains a whole-unit render surface."
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "opaque_inline": {
+      const fragment = getOpaqueFragment(document.preservation, node.fragmentId);
+      const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
+      const preview = fragment ? describePreservedInlinePreview(fragment.payloadReference) : null;
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "opaque_inline",
+        from: start,
+        to: start + 1,
+        fragmentId: node.fragmentId,
+        warningId: node.warningId,
+        label: preview?.label ?? descriptor?.label ?? "Unsupported inline OOXML",
+        detail: preview?.detail ?? descriptor?.detail ?? "Locked whole-unit to keep unsupported inline OOXML intact through export.",
+        ...preview?.presentation ? { presentation: preview.presentation } : {},
+        state: "locked-preserve-only"
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [node.fragmentId] };
+    }
+    case "chart_preview":
+      return appendComplexPreviewSegment(paragraph, node, start, "Embedded chart", createChartDetail(node));
+    case "smartart_preview":
+      return appendComplexPreviewSegment(paragraph, node, start, "SmartArt diagram", createSmartArtDetail(node));
+    case "shape":
+      return appendComplexPreviewSegment(
+        paragraph,
+        node,
+        start,
+        node.isTextBox ? "Text box" : "Drawing shape",
+        createShapeDetail(node)
+      );
+    case "wordart":
+      return appendComplexPreviewSegment(paragraph, node, start, "WordArt", createWordArtDetail(node));
+    case "vml_shape":
+      return appendComplexPreviewSegment(paragraph, node, start, "Legacy VML drawing", createVmlDetail(node));
+    case "symbol":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "text",
+        from: start,
+        to: start + 1,
+        text: node.char ? String.fromCodePoint(parseInt(node.char, 16)) : "\uFFFD"
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "column_break":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "opaque_inline",
+        from: start,
+        to: start + 1,
+        fragmentId: "",
+        warningId: "",
+        label: "Column break",
+        detail: "Column break marker preserved for export.",
+        state: "locked-preserve-only"
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "footnote_ref":
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "note_ref",
+        from: start,
+        to: start + 1,
+        noteKind: node.noteKind ?? "footnote",
+        noteId: node.noteId ?? "",
+        label: node.noteId ?? "*"
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    case "field": {
+      const isSupportedField = node.fieldFamily === "REF" || node.fieldFamily === "PAGEREF" || node.fieldFamily === "NOTEREF" || node.fieldFamily === "TOC";
+      if (node.children && node.children.length > 0) {
+        let cursor = start;
+        const lockedIds = [];
+        for (const child of node.children) {
+          const result = appendInlineSegments(paragraph, child, document, cursor);
+          cursor = result.nextCursor;
+          lockedIds.push(...result.lockedFragmentIds);
+        }
+        return { nextCursor: cursor, lockedFragmentIds: lockedIds };
+      }
+      if (isSupportedField) {
+        const fieldLabel = node.fieldFamily === "TOC" ? "Table of Contents" : `${node.fieldFamily ?? "Field"}: ${node.fieldTarget ?? node.instruction.trim()}`;
+        paragraph.segments.push({
+          segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+          kind: "field_ref",
+          from: start,
+          to: start + 1,
+          fieldFamily: node.fieldFamily,
+          fieldTarget: node.fieldTarget,
+          instruction: node.instruction,
+          refreshStatus: node.refreshStatus ?? "stale",
+          label: fieldLabel
+        });
+        return { nextCursor: start + 1, lockedFragmentIds: [] };
+      }
+      paragraph.segments.push({
+        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+        kind: "opaque_inline",
+        from: start,
+        to: start + 1,
+        fragmentId: "",
+        warningId: "",
+        label: "Field",
+        detail: `Preserve-only field: ${node.instruction.trim()}`,
+        state: "locked-preserve-only"
+      });
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+    }
+    case "bookmark_start":
+    case "bookmark_end":
+      return { nextCursor: start, lockedFragmentIds: [] };
+    default:
+      return { nextCursor: start + 1, lockedFragmentIds: [] };
+  }
+}
+function appendComplexPreviewSegment(paragraph, node, start, label, detail) {
+  paragraph.segments.push({
+    segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+    kind: "opaque_inline",
+    from: start,
+    to: start + 1,
+    fragmentId: `complex:${label.replace(/\s/g, "-").toLowerCase()}:${start}`,
+    warningId: `warning:complex-preview:${start}`,
+    label,
+    detail,
+    state: "locked-preserve-only"
+  });
+  return { nextCursor: start + 1, lockedFragmentIds: [] };
+}
+function createChartDetail(node) {
+  const parts = ["Embedded chart."];
+  if (node.previewMediaId) {
+    parts.push(`Preview available via fallback image (${node.previewMediaId}).`);
+  } else {
+    parts.push("No fallback preview image found; chart data preserved in package.");
+  }
+  parts.push("Edit in Word to modify chart data. Original DrawingML preserved for lossless export.");
+  return parts.join(" ");
+}
+function createSmartArtDetail(node) {
+  const parts = ["SmartArt diagram."];
+  if (node.previewMediaId) {
+    parts.push(`Preview available via fallback image (${node.previewMediaId}).`);
+  } else {
+    parts.push("No fallback preview image found; diagram structure preserved in package.");
+  }
+  parts.push("Edit in Word to modify diagram layout and content. Original DrawingML preserved for lossless export.");
+  return parts.join(" ");
+}
+function createShapeDetail(node) {
+  if (node.isTextBox) {
+    const parts2 = ["Text box."];
+    if (node.text) parts2.push(`Content: "${node.text}".`);
+    parts2.push("Text content is visible; formatting and geometry preserved for export.");
+    return parts2.join(" ");
+  }
+  const parts = ["Drawing shape."];
+  if (node.geometry) parts.push(`Geometry: ${node.geometry}.`);
+  if (node.text) parts.push(`Text content: "${node.text}".`);
+  parts.push("Visual geometry is preview-only. Original DrawingML preserved for export.");
+  return parts.join(" ");
+}
+function createWordArtDetail(node) {
+  const parts = ["WordArt decorative text."];
+  if (node.text) parts.push(`Text: "${node.text}".`);
+  if (node.geometry) parts.push(`Effect: ${node.geometry}.`);
+  parts.push("Text effect is preview-only. Edit in Word for full formatting. Original DrawingML preserved for export.");
+  return parts.join(" ");
+}
+function createVmlDetail(node) {
+  const parts = ["Legacy VML drawing."];
+  if (node.shapeType) parts.push(`Type: ${node.shapeType}.`);
+  if (node.text) parts.push(`Text content: "${node.text}".`);
+  parts.push("VML content is preview-only. Edit in Word for full control. Original VML XML preserved for export.");
+  return parts.join(" ");
+}
+function createPlainText2(blocks) {
+  const text = [];
+  for (const block of blocks) {
+    if (block.kind === "opaque_block") {
+      if (block.fragmentId.startsWith("preview:")) {
+        continue;
+      }
+      text.push("\uFFFA");
+      continue;
+    }
+    if (block.kind === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          text.push(createPlainText2(cell.content));
+        }
+      }
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      text.push(createPlainText2(block.children));
+      continue;
+    }
+    for (const segment of block.segments) {
+      switch (segment.kind) {
+        case "text":
+          text.push(segment.text);
+          break;
+        case "tab":
+          text.push("	");
+          break;
+        case "hard_break":
+          text.push("\n");
+          break;
+        case "image":
+          text.push("\uFFFC");
+          break;
+        case "opaque_inline":
+          text.push("\uFFF9");
+          break;
+      }
+    }
+  }
+  return text.join("");
+}
+function createSecondaryStorySurfaces(document) {
+  const surfaces = [];
+  const subParts = document.subParts;
+  if (!subParts) {
+    return surfaces;
+  }
+  const numberingPrefixResolver = createNumberingPrefixResolver(document.numbering);
+  for (const section of collectSectionContexts(document)) {
+    const headerVariants = resolveSectionVariants(
+      "header",
+      section.index,
+      section.properties?.headerReferences,
+      subParts.headers ?? []
+    );
+    for (const headerVariant of headerVariants) {
+      const target = {
+        kind: "header",
+        relationshipId: headerVariant.relationshipId,
+        variant: headerVariant.variant,
+        sectionIndex: section.index
+      };
+      const header = findHeaderFooterDocumentEntry(document, target);
+      if (!header) {
+        continue;
+      }
+      surfaces.push(
+        createStorySurface(
+          target,
+          `Header \xB7 ${headerVariant.variant}`,
+          header.blocks,
+          document,
+          numberingPrefixResolver
+        )
+      );
+    }
+    const footerVariants = resolveSectionVariants(
+      "footer",
+      section.index,
+      section.properties?.footerReferences,
+      subParts.footers ?? []
+    );
+    for (const footerVariant of footerVariants) {
+      const target = {
+        kind: "footer",
+        relationshipId: footerVariant.relationshipId,
+        variant: footerVariant.variant,
+        sectionIndex: section.index
+      };
+      const footer = findHeaderFooterDocumentEntry(document, target);
+      if (!footer) {
+        continue;
+      }
+      surfaces.push(
+        createStorySurface(
+          target,
+          `Footer \xB7 ${footerVariant.variant}`,
+          footer.blocks,
+          document,
+          numberingPrefixResolver
+        )
+      );
+    }
+  }
+  const footnotes = Object.values(subParts.footnoteCollection?.footnotes ?? {}).sort(compareNoteIds);
+  for (const note of footnotes) {
+    const target = { kind: "footnote", noteId: note.noteId };
+    surfaces.push(createStorySurface(target, `Footnote ${note.noteId}`, note.blocks, document, numberingPrefixResolver));
+  }
+  const endnotes = Object.values(subParts.footnoteCollection?.endnotes ?? {}).sort(compareNoteIds);
+  for (const note of endnotes) {
+    const target = { kind: "endnote", noteId: note.noteId };
+    surfaces.push(createStorySurface(target, `Endnote ${note.noteId}`, note.blocks, document, numberingPrefixResolver));
+  }
+  return surfaces;
+}
+function createStorySurface(target, label, blocks, document, numberingPrefixResolver) {
+  const surfaceBlocks = [];
+  let cursor = 0;
+  const counters = {
+    paragraph: 0,
+    table: 0,
+    opaque: 0,
+    sdt: 0,
+    customXml: 0,
+    altChunk: 0
+  };
+  for (let index = 0; index < blocks.length; index += 1) {
+    const surfaceBlock = createSurfaceBlock(
+      blocks[index],
+      document,
+      cursor,
+      counters,
+      numberingPrefixResolver
+    );
+    surfaceBlocks.push(surfaceBlock.block);
+    cursor = surfaceBlock.nextCursor;
+    if (index < blocks.length - 1 && blocks[index + 1]?.type === "paragraph") {
+      cursor += 1;
+    }
+  }
+  return {
+    target,
+    label,
+    storySize: cursor,
+    blocks: surfaceBlocks
+  };
+}
+function compareNoteIds(left, right) {
+  return Number.parseInt(left.noteId, 10) - Number.parseInt(right.noteId, 10);
+}
+function toSurfaceTabStop(tabStop) {
+  return {
+    pos: tabStop.position,
+    ...tabStop.align ? { val: tabStop.align } : {},
+    ...tabStop.leader ? { leader: tabStop.leader } : {}
+  };
+}
+function describePreservedInlinePreview(payloadReference) {
+  if (/\b(?:w:)?proofErr\b/u.test(payloadReference)) {
+    const proofType = /\bw:type="([^"]+)"/u.exec(payloadReference)?.[1];
+    return {
+      label: "Proofing marker",
+      detail: proofType && proofType.trim().length > 0 ? `Word proofing marker (${proofType}) preserved for export safety.` : "Word proofing marker preserved for export safety.",
+      presentation: "quiet-marker"
+    };
+  }
+  if (/\b(?:w:)?lastRenderedPageBreak\b/u.test(payloadReference)) {
+    return {
+      label: "Rendered page break",
+      detail: "Word rendered page-break marker preserved for export safety.",
+      presentation: "quiet-marker"
+    };
+  }
+  if (/\b(?:w:)?permStart\b/u.test(payloadReference)) {
+    const editorGroup = /\bw:edGrp="([^"]+)"/u.exec(payloadReference)?.[1];
+    return {
+      label: "Protected range start",
+      detail: editorGroup && editorGroup.trim().length > 0 ? `Protected range start for ${editorGroup} preserved for export safety.` : "Protected range start preserved for export safety.",
+      presentation: "quiet-marker"
+    };
+  }
+  if (/\b(?:w:)?permEnd\b/u.test(payloadReference)) {
+    return {
+      label: "Protected range end",
+      detail: "Protected range end preserved for export safety.",
+      presentation: "quiet-marker"
+    };
+  }
+  if (/\b(?:w:)?bookmarkStart\b/u.test(payloadReference)) {
+    const name = /\bw:name="([^"]+)"/u.exec(payloadReference)?.[1];
+    return {
+      label: name ? `Bookmark \xB7 ${name}` : "Bookmark",
+      detail: name ? `Bookmark anchor "${name}" is preserved as a read-only inline token for export safety.` : "Bookmark anchor is preserved as a read-only inline token for export safety."
+    };
+  }
+  if (/\b(?:w:)?bookmarkEnd\b/u.test(payloadReference)) {
+    return {
+      label: "Bookmark end",
+      detail: "Bookmark end marker is preserved as a read-only inline token for export safety."
+    };
+  }
+  if (/\b(?:w:)?fldSimple\b|\b(?:w:)?fldChar\b|\b(?:w:)?instrText\b/u.test(payloadReference)) {
+    const simpleInstruction = /\bw:instr="([^"]*)"/u.exec(payloadReference)?.[1];
+    const complexInstruction = [...payloadReference.matchAll(/<(?:\w+:)?instrText\b[^>]*>([\s\S]*?)<\/(?:\w+:)?instrText>/gu)].map((match) => decodeXmlEntities(match[1] ?? "")).join("").trim();
+    const instruction = (simpleInstruction ?? complexInstruction ?? "").trim();
+    const family = /^([A-Z]+)/i.exec(instruction)?.[1]?.toUpperCase();
+    const label = family === "TOC" ? "Table of Contents field" : family ? `${family} field` : "Field";
+    return {
+      label,
+      detail: instruction.length > 0 ? `Read-only field preserved for export safety. Instruction: ${instruction}.` : "Read-only field preserved for export safety."
+    };
+  }
+  return null;
+}
+function decodeXmlEntities(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function cloneMarks2(marks) {
+  const supported = [];
+  const attrs = {};
+  let shadingColor;
+  let highlightColor;
+  for (const mark of marks) {
+    switch (mark.type) {
+      case "bold":
+      case "italic":
+      case "underline":
+      case "strikethrough":
+      case "doubleStrikethrough":
+      case "vanish":
+      case "emboss":
+      case "imprint":
+      case "shadow":
+        supported.push(mark.type);
+        break;
+      case "position":
+        if (mark.val > 0) supported.push("superscript");
+        else if (mark.val < 0) supported.push("subscript");
+        break;
+      case "backgroundColor":
+        shadingColor = mark.color;
+        break;
+      case "highlight":
+        highlightColor = mark.color;
+        break;
+      case "charSpacing":
+        attrs.charSpacing = mark.val;
+        break;
+      case "kerning":
+        attrs.kerning = mark.val;
+        break;
+      case "textFill":
+        attrs.textFill = mark.xml;
+        break;
+      case "fontFamily":
+        attrs.fontFamily = mark.val;
+        break;
+      case "fontSize":
+        attrs.fontSize = mark.val;
+        break;
+      case "textColor":
+        attrs.textColor = mark.color;
+        break;
+      case "smallCaps":
+        supported.push("smallCaps");
+        break;
+      case "allCaps":
+        supported.push("allCaps");
+        break;
+      case "lang":
+        break;
+    }
+  }
+  if (highlightColor || shadingColor) {
+    attrs.backgroundColor = highlightColor ?? shadingColor;
+  }
+  const hasAttrs = Object.keys(attrs).length > 0;
+  return hasAttrs ? { marks: supported, markAttrs: attrs } : { marks: supported };
+}
+function normalizeDocumentRoot2(content) {
+  if (content && typeof content === "object" && (content.type === "doc" || content.type === "document_root")) {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return {
+      type: "doc",
+      children: content.filter(
+        (value) => Boolean(value) && typeof value === "object" && (value.type === "paragraph" || value.type === "table" || value.type === "sdt" || value.type === "custom_xml" || value.type === "alt_chunk" || value.type === "opaque_block")
+      )
+    };
+  }
+  return {
+    type: "doc",
+    children: [{ type: "paragraph", children: [] }]
+  };
+}
+function createFloatingImageDetail(altText, floating) {
+  const parts = [altText ? `Alt text ${altText}.` : "Floating image rendered inline in the editor."];
+  if (floating?.wrap) {
+    parts.push(`Wrap ${floating.wrap}.`);
+  }
+  if (floating?.horizontalPosition?.align || floating?.horizontalPosition?.offset !== void 0) {
+    parts.push(
+      `Horizontal ${floating.horizontalPosition.align ?? floating.horizontalPosition.offset}.`
+    );
+  }
+  if (floating?.verticalPosition?.align || floating?.verticalPosition?.offset !== void 0) {
+    parts.push(
+      `Vertical ${floating.verticalPosition.align ?? floating.verticalPosition.offset}.`
+    );
+  }
+  return parts.join(" ");
+}
+function hasMediaItem(media, mediaId) {
+  return mediaId in media.items;
+}
+
+// src/core/state/text-transaction.ts
+var TextTransactionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "TextTransactionError";
+    this.code = code;
+  }
+};
+function applyTextTransaction(document, selection, intent, options) {
+  const tableScopedResult = tryApplyTableParagraphTransaction(
+    document,
+    selection,
+    intent,
+    options
+  );
+  if (tableScopedResult) {
+    return tableScopedResult;
+  }
+  return applyLinearTextTransaction(document, selection, intent, options);
+}
+function applyLinearTextTransaction(document, selection, intent, options) {
+  const story = parseTextStory(document.content);
+  const normalizedRange = resolveRange(selection, story.size, intent);
+  const insertionUnits = createInsertionUnits(intent, story, normalizedRange.from);
+  ensureEditableRange(story.units.slice(normalizedRange.from, normalizedRange.to));
+  const nextUnits = [
+    ...story.units.slice(0, normalizedRange.from).map(cloneStoryUnit),
+    ...insertionUnits.map(cloneStoryUnit),
+    ...story.units.slice(normalizedRange.to).map(cloneStoryUnit)
+  ];
+  const nextStory = {
+    firstParagraph: cloneParagraphProperties(story.firstParagraph),
+    units: normalizeStoryUnits(nextUnits),
+    size: 0
+  };
+  nextStory.size = nextStory.units.length;
+  const caret = normalizedRange.from + insertionUnits.length;
+  return {
+    document: {
+      ...document,
+      updatedAt: options.timestamp,
+      content: serializeTextStory(nextStory)
+    },
+    selection: createSelectionSnapshot(caret, caret),
+    mapping: {
+      steps: [
+        {
+          from: normalizedRange.from,
+          to: normalizedRange.to,
+          insertSize: insertionUnits.length
+        }
+      ],
+      metadata: {
+        affectsComments: true,
+        affectsRevisions: true,
+        ...containsParagraphBoundaryChange(story, normalizedRange, insertionUnits) ? { invalidatesStructures: true } : {}
+      }
+    },
+    storyText: createPlainText(nextStory)
+  };
+}
+function tryApplyTableParagraphTransaction(document, selection, intent, options) {
+  const scope = resolveTableParagraphScope(document, selection);
+  if (!scope) {
+    return null;
+  }
+  if (scope === "unsupported") {
+    throw new TextTransactionError(
+      "unsupported_content",
+      "Text transactions inside table structures are only supported when the selection stays within one paragraph-backed table cell."
+    );
+  }
+  const localDocument = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph]
+    }
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart
+  );
+  const localResult = applyLinearTextTransaction(localDocument, localSelection, intent, options);
+  const nextParagraphBlocks = localResult.document.content.children;
+  const nextRoot = {
+    ...scope.root,
+    children: scope.root.children.map((child, blockIndex) => {
+      if (blockIndex !== scope.tableBlockIndex) {
+        return child;
+      }
+      const table = child;
+      return {
+        ...table,
+        rows: table.rows.map((row, rowIndex) => {
+          if (rowIndex !== scope.rowIndex) {
+            return row;
+          }
+          return {
+            ...row,
+            cells: row.cells.map((cell, cellIndex) => {
+              if (cellIndex !== scope.cellIndex) {
+                return cell;
+              }
+              return {
+                ...cell,
+                children: [
+                  ...cell.children.slice(0, scope.childIndex),
+                  ...nextParagraphBlocks,
+                  ...cell.children.slice(scope.childIndex + 1)
+                ]
+              };
+            })
+          };
+        })
+      };
+    })
+  };
+  return {
+    document: {
+      ...document,
+      updatedAt: options.timestamp,
+      content: nextRoot
+    },
+    selection: createSelectionSnapshot(
+      localResult.selection.anchor + scope.paragraphStart,
+      localResult.selection.head + scope.paragraphStart
+    ),
+    mapping: {
+      ...localResult.mapping,
+      steps: localResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart
+      }))
+    },
+    storyText: localResult.storyText
+  };
+}
+function resolveTableParagraphScope(document, selection) {
+  const root = document.content;
+  if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
+    return null;
+  }
+  const surface = createEditorSurfaceSnapshot(document, selection);
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+  for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
+    const block = root.children[blockIndex];
+    const surfaceBlock = surface.blocks[blockIndex];
+    if (block?.type !== "table" || surfaceBlock?.kind !== "table") {
+      continue;
+    }
+    const insideTable = selectionFallsWithinSurfaceRange(
+      selectionFrom,
+      selectionTo,
+      surfaceBlock.from,
+      surfaceBlock.to
+    );
+    if (!insideTable) {
+      continue;
+    }
+    for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+      const row = block.rows[rowIndex];
+      const surfaceRow = surfaceBlock.rows[rowIndex];
+      if (!row || !surfaceRow) {
+        continue;
+      }
+      for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+        const cell = row.cells[cellIndex];
+        const surfaceCell = surfaceRow.cells[cellIndex];
+        if (!cell || !surfaceCell) {
+          continue;
+        }
+        for (let childIndex = 0; childIndex < Math.min(cell.children.length, surfaceCell.content.length); childIndex += 1) {
+          const child = cell.children[childIndex];
+          const surfaceChild = surfaceCell.content[childIndex];
+          if (child?.type !== "paragraph" || surfaceChild?.kind !== "paragraph") {
+            continue;
+          }
+          const insideParagraph = selectionFallsWithinSurfaceRange(
+            selectionFrom,
+            selectionTo,
+            surfaceChild.from,
+            surfaceChild.to
+          );
+          if (!insideParagraph) {
+            continue;
+          }
+          return {
+            root,
+            tableBlockIndex: blockIndex,
+            rowIndex,
+            cellIndex,
+            childIndex,
+            paragraph: child,
+            paragraphStart: surfaceChild.from
+          };
+        }
+      }
+    }
+    return "unsupported";
+  }
+  return null;
+}
+function selectionFallsWithinSurfaceRange(selectionFrom, selectionTo, rangeFrom, rangeTo) {
+  if (rangeFrom === rangeTo) {
+    return selectionFrom === rangeFrom && selectionTo === rangeTo;
+  }
+  return selectionFrom >= rangeFrom && selectionTo <= rangeTo && selectionFrom < rangeTo;
+}
+function resolveRange(selection, storySize, intent) {
+  const from = Math.max(0, Math.min(selection.anchor, selection.head));
+  const to = Math.max(0, Math.max(selection.anchor, selection.head));
+  if (from > storySize || to > storySize) {
+    throw new TextTransactionError(
+      "invalid_selection",
+      `Selection ${from}-${to} exceeds story size ${storySize}.`
+    );
+  }
+  if (intent.type === "replace") {
+    if (intent.range) {
+      const explicitFrom = Math.max(0, Math.min(intent.range.from, intent.range.to));
+      const explicitTo = Math.max(0, Math.max(intent.range.from, intent.range.to));
+      if (explicitFrom > storySize || explicitTo > storySize) {
+        throw new TextTransactionError(
+          "invalid_selection",
+          `Explicit range ${explicitFrom}-${explicitTo} exceeds story size ${storySize}.`
+        );
+      }
+      return {
+        from: explicitFrom,
+        to: explicitTo
+      };
+    }
+    return { from, to };
+  }
+  if (from !== to) {
+    return { from, to };
+  }
+  if (intent.type === "delete_backward") {
+    return {
+      from: Math.max(0, from - 1),
+      to: from
+    };
+  }
+  return {
+    from,
+    to: Math.min(storySize, from + 1)
+  };
+}
+function createInsertionUnits(intent, story, position) {
+  if (intent.type !== "replace") {
+    return [];
+  }
+  const inheritedProps = resolveParagraphPropertiesAtPosition(story, position);
+  return intent.insertion.flatMap((entry) => {
+    switch (entry.type) {
+      case "text":
+        return Array.from(entry.text).map((character) => ({
+          kind: "text",
+          value: character
+        }));
+      case "tab":
+        return [{ kind: "tab" }];
+      case "hard_break":
+        return [{ kind: "hard_break" }];
+      case "paragraph_break":
+        return [
+          {
+            kind: "paragraph_break",
+            nextParagraph: cloneParagraphProperties(inheritedProps)
+          }
+        ];
+    }
+  });
+}
+function resolveParagraphPropertiesAtPosition(story, position) {
+  let current = cloneParagraphProperties(story.firstParagraph);
+  for (let index = 0; index < Math.min(position, story.units.length); index += 1) {
+    const unit = story.units[index];
+    if (unit.kind === "paragraph_break") {
+      current = cloneParagraphProperties(unit.nextParagraph);
+    } else if (unit.kind === "opaque_block" && unit.nextParagraph) {
+      current = cloneParagraphProperties(unit.nextParagraph);
+    }
+  }
+  return current;
+}
+function normalizeStoryUnits(units) {
+  if (units.length === 0) {
+    return [];
+  }
+  const normalized = [];
+  for (const unit of units) {
+    if (unit.kind === "paragraph_break" && normalized[normalized.length - 1]?.kind === "paragraph_break") {
+      normalized.push({
+        kind: "paragraph_break",
+        nextParagraph: cloneParagraphProperties(unit.nextParagraph)
+      });
+      continue;
+    }
+    normalized.push(cloneStoryUnit(unit));
+  }
+  return normalized;
+}
+function ensureEditableRange(units) {
+  const protectedUnit = units.find(
+    (unit) => unit.kind === "opaque_inline" || unit.kind === "opaque_block" || unit.kind === "image"
+  );
+  if (!protectedUnit) {
+    return;
+  }
+  throw new TextTransactionError(
+    "unsupported_content",
+    `Text transaction crosses protected ${protectedUnit.kind} content.`
+  );
+}
+function containsParagraphBoundaryChange(story, range, insertionUnits) {
+  if (insertionUnits.some((unit) => unit.kind === "paragraph_break")) {
+    return true;
+  }
+  return story.units.slice(range.from, range.to).some((unit) => unit.kind === "paragraph_break");
+}
+
+// src/core/commands/structural-helpers.ts
+var DEFAULT_TABLE_COLUMN_WIDTH = 2400;
+function createNoopStructuralMutation(document, selection) {
+  return {
+    changed: false,
+    document,
+    selection
+  };
+}
+function resolveParagraphScope(document, selection) {
+  const root = asDocumentRoot(document);
+  if (!root) {
+    return null;
+  }
+  const surface = createEditorSurfaceSnapshot(document, selection);
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+  for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
+    const block = root.children[blockIndex];
+    const surfaceBlock = surface.blocks[blockIndex];
+    if (!surfaceBlock) {
+      continue;
+    }
+    if (block.type === "paragraph" && surfaceBlock.kind === "paragraph" && selectionWithinRange(selectionFrom, selectionTo, surfaceBlock.from, surfaceBlock.to)) {
+      return {
+        kind: "top-level",
+        blockIndex,
+        paragraph: cloneParagraph(block),
+        paragraphStart: surfaceBlock.from
+      };
+    }
+    if (block.type !== "table" || surfaceBlock.kind !== "table") {
+      continue;
+    }
+    for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+      const row = block.rows[rowIndex];
+      const surfaceRow = surfaceBlock.rows[rowIndex];
+      if (!surfaceRow) {
+        continue;
+      }
+      for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+        const cell = row.cells[cellIndex];
+        const surfaceCell = surfaceRow.cells[cellIndex];
+        if (!surfaceCell) {
+          continue;
+        }
+        for (let childIndex = 0; childIndex < cell.children.length; childIndex += 1) {
+          const child = cell.children[childIndex];
+          const surfaceChild = surfaceCell.content[childIndex];
+          if (child?.type === "paragraph" && surfaceChild?.kind === "paragraph" && selectionWithinRange(selectionFrom, selectionTo, surfaceChild.from, surfaceChild.to)) {
+            return {
+              kind: "table-cell",
+              tableBlockIndex: blockIndex,
+              rowIndex,
+              cellIndex,
+              childIndex,
+              paragraph: cloneParagraph(child),
+              paragraphStart: surfaceChild.from
+            };
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function replaceParagraphScope(document, scope, replacementParagraphs) {
+  const root = asDocumentRoot(document);
+  if (!root) {
+    return document;
+  }
+  const nextRoot = scope.kind === "top-level" ? {
+    ...root,
+    children: [
+      ...root.children.slice(0, scope.blockIndex),
+      ...replacementParagraphs,
+      ...root.children.slice(scope.blockIndex + 1)
+    ]
+  } : {
+    ...root,
+    children: root.children.map((child, blockIndex) => {
+      if (blockIndex !== scope.tableBlockIndex || child.type !== "table") {
+        return child;
+      }
+      return {
+        ...child,
+        rows: child.rows.map((row, rowIndex) => {
+          if (rowIndex !== scope.rowIndex) {
+            return row;
+          }
+          return {
+            ...row,
+            cells: row.cells.map((cell, cellIndex) => {
+              if (cellIndex !== scope.cellIndex) {
+                return cell;
+              }
+              return {
+                ...cell,
+                children: [
+                  ...cell.children.slice(0, scope.childIndex),
+                  ...replacementParagraphs,
+                  ...cell.children.slice(scope.childIndex + 1)
+                ]
+              };
+            })
+          };
+        })
+      };
+    })
+  };
+  return {
+    ...document,
+    content: nextRoot
+  };
+}
+function createEmptyParagraph2() {
+  return {
+    type: "paragraph",
+    children: []
+  };
+}
+function createInsertedTableBlock(rows, columns, styleId) {
+  const safeRows = Math.max(1, Math.floor(rows));
+  const safeColumns = Math.max(1, Math.floor(columns));
+  const nextRows = [];
+  for (let rowIndex = 0; rowIndex < safeRows; rowIndex += 1) {
+    const cells = [];
+    for (let columnIndex = 0; columnIndex < safeColumns; columnIndex += 1) {
+      cells.push({
+        type: "table_cell",
+        children: [createEmptyParagraph2()]
+      });
+    }
+    nextRows.push({
+      type: "table_row",
+      cells
+    });
+  }
+  return {
+    type: "table",
+    ...styleId ? { styleId } : {},
+    gridColumns: Array.from({ length: safeColumns }, () => DEFAULT_TABLE_COLUMN_WIDTH),
+    rows: nextRows
+  };
+}
+function resolveInsertedTableStyleId(document) {
+  const styles = document.styles?.tables;
+  if (!styles || typeof styles !== "object") {
+    return void 0;
+  }
+  return "TableGrid" in styles ? "TableGrid" : void 0;
+}
+function findTableCellParagraphSelection(document, tableBlockIndex, rowIndex, cellIndex) {
+  const surface = createEditorSurfaceSnapshot(document, createSelectionSnapshot(0, 0));
+  const tableBlock = surface.blocks[tableBlockIndex];
+  if (!tableBlock || tableBlock.kind !== "table") {
+    return null;
+  }
+  const paragraph = tableBlock.rows[rowIndex]?.cells[cellIndex]?.content.find(
+    (block) => block.kind === "paragraph"
+  );
+  if (!paragraph || paragraph.kind !== "paragraph") {
+    return null;
+  }
+  return createSelectionSnapshot(paragraph.from, paragraph.from);
+}
+function asDocumentRoot(document) {
+  const root = document.content;
+  if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
+    return null;
+  }
+  return root;
+}
+function selectionWithinRange(selectionFrom, selectionTo, rangeFrom, rangeTo) {
+  return selectionFrom >= rangeFrom && selectionTo <= rangeTo;
+}
+function cloneParagraph(paragraph) {
+  return structuredClone(paragraph);
+}
+
+// src/core/commands/text-commands.ts
+function insertText(document, selection, text, context) {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    },
+    context
+  );
+}
+function deleteSelectionOrBackward(document, selection, context) {
+  return applyTextTransaction(
+    document,
+    selection,
+    selection.isCollapsed ? {
+      type: "delete_backward"
+    } : {
+      type: "replace",
+      insertion: []
+    },
+    context
+  );
+}
+function deleteSelectionOrForward(document, selection, context) {
+  return applyTextTransaction(
+    document,
+    selection,
+    selection.isCollapsed ? {
+      type: "delete_forward"
+    } : {
+      type: "replace",
+      insertion: []
+    },
+    context
+  );
+}
+function insertTab(document, selection, context) {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [{ type: "tab" }]
+    },
+    context
+  );
+}
+function insertHardBreak(document, selection, context) {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [{ type: "hard_break" }]
+    },
+    context
+  );
+}
+function splitParagraph(document, selection, context) {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [{ type: "paragraph_break" }]
+    },
+    context
+  );
+}
+function insertPageBreak(document, selection, context) {
+  const scope = resolveParagraphScope(document, selection);
+  if (!scope) {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const localDocument = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph]
+    }
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart
+  );
+  const splitResult = splitParagraph(localDocument, localSelection, context);
+  const splitRoot = splitResult.document.content;
+  if (!splitRoot || splitRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const replacementParagraphs = splitRoot.children.filter((block) => block.type === "paragraph").map(
+    (block, index) => index === 1 ? {
+      ...block,
+      pageBreakBefore: true
+    } : block
+  );
+  if (replacementParagraphs.length < 2) {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const nextDocument = replaceParagraphScope(document, scope, replacementParagraphs);
+  return {
+    changed: true,
+    document: {
+      ...nextDocument,
+      updatedAt: context.timestamp
+    },
+    selection: createSelectionSnapshot(
+      splitResult.selection.anchor + scope.paragraphStart,
+      splitResult.selection.head + scope.paragraphStart
+    ),
+    mapping: {
+      ...splitResult.mapping,
+      steps: splitResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart
+      }))
+    }
+  };
+}
+function insertTable(document, selection, options, context) {
+  const scope = resolveParagraphScope(document, selection);
+  if (!scope || scope.kind !== "top-level") {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const safeRows = Math.max(1, Math.floor(options.rows));
+  const safeColumns = Math.max(1, Math.floor(options.columns));
+  if (!Number.isFinite(safeRows) || !Number.isFinite(safeColumns)) {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const localDocument = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph]
+    }
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart
+  );
+  const splitResult = splitParagraph(localDocument, localSelection, context);
+  const splitRoot = splitResult.document.content;
+  if (!splitRoot || splitRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const replacementParagraphs = splitRoot.children.filter(
+    (block) => block.type === "paragraph"
+  );
+  if (replacementParagraphs.length < 2) {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const nextRoot = document.content;
+  if (!nextRoot || nextRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+  const insertedTable = createInsertedTableBlock(
+    safeRows,
+    safeColumns,
+    resolveInsertedTableStyleId(document)
+  );
+  const nextDocument = {
+    ...document,
+    updatedAt: context.timestamp,
+    content: {
+      ...nextRoot,
+      children: [
+        ...nextRoot.children.slice(0, scope.blockIndex),
+        replacementParagraphs[0],
+        insertedTable,
+        replacementParagraphs[1],
+        ...nextRoot.children.slice(scope.blockIndex + 1)
+      ]
+    }
+  };
+  return {
+    changed: true,
+    document: nextDocument,
+    selection: findTableCellParagraphSelection(
+      nextDocument,
+      scope.blockIndex + 1,
+      0,
+      0
+    ) ?? selection,
+    mapping: {
+      ...splitResult.mapping,
+      steps: splitResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart
+      }))
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteSelectionOrBackward,
+  deleteSelectionOrForward,
+  insertHardBreak,
+  insertPageBreak,
+  insertTab,
+  insertTable,
+  insertText,
+  splitParagraph
+});
+//# sourceMappingURL=text-commands.cjs.map