@superdoc/mcp 1.5.0-next.4 → 1.5.0-next.6

package/dist/index.js

@@ -31443,7 +31443,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.18.0-next.4";
+var SDK_VERSION = "2.18.0-next.6";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -164868,6 +164868,39 @@ function stripParagraphPropertyChange(pPrXml) {
   const stripped = pPrXml.slice(0, open.index) + pPrXml.slice(end);
   return /^<([\w.-]+):pPr\b[^>]*>\s*<\/\1:pPr>$/.test(stripped.trim()) ? "" : stripped;
 }
+function replaceDirectParagraphStyleId(pPrXml, newStyleId) {
+  const pPr = readValidatedXmlNodeAt(pPrXml, 0);
+  if (!pPr || pPr.kind !== "element" || xmlLocalName(pPr.qname) !== "pPr" || pPr.selfClosing) {
+    return pPrXml;
+  }
+  let cursor = pPr.openEnd;
+  while (cursor < pPr.closeStart) {
+    const childStart = pPrXml.indexOf("<", cursor);
+    if (childStart < 0 || childStart >= pPr.closeStart)
+      return pPrXml;
+    const child = readValidatedXmlNodeAt(pPrXml, childStart);
+    if (!child || child.end > pPr.closeStart)
+      return pPrXml;
+    if (child.kind === "element" && xmlLocalName(child.qname) === "pStyle") {
+      const openTag = pPrXml.slice(childStart, child.openEnd);
+      let valAttr;
+      for (const attribute of scanRawXmlAttributes(openTag)) {
+        if (attribute.name === "xmlns" || attribute.prefix === "xmlns")
+          continue;
+        if (attribute.localName === "val") {
+          valAttr = attribute;
+          break;
+        }
+      }
+      if (!valAttr)
+        return pPrXml;
+      const rewrittenOpenTag = openTag.slice(0, valAttr.valueStart) + escapeXmlAttribute(newStyleId) + openTag.slice(valAttr.valueEnd);
+      return pPrXml.slice(0, childStart) + rewrittenOpenTag + pPrXml.slice(child.openEnd);
+    }
+    cursor = child.end;
+  }
+  return pPrXml;
+}
 function stripParagraphMarkRevisionMarkers(pPrXml, inheritedNamespaceBindings = {}) {
   if (!pPrXml)
     return pPrXml;
@@ -214889,7 +214922,7 @@ function sliceParagraphContentAt(input) {
   const plan = planCut(map3.pieces, regionStart, input, map3.pieces);
   if (plan.kind === "reject")
     return { ok: false, reason: plan.reason };
-  return assembleHalves(src, regionStart, regionEnd, plan);
+  return { ...assembleHalves(src, regionStart, regionEnd, plan), terminal: input.offset === total };
 }
 function pieceStart(piece, input, rootPieces) {
   const base2 = input.space === "tracked" ? piece.trackedStart : piece.visibleStart;
@@ -215869,6 +215902,566 @@ var init_paragraph_drawing_delete = __esm(() => {
   init_tracked_paragraph_content();
 });
 
+// ../../../v2/editor-core/dist/document/transactions/insertion-formatting-context.js
+function resolveInsertionFormattingContext(state, input) {
+  const inheritance = input.inheritance ?? "anchor";
+  const numberingProperties = input.numberingProperties ?? null;
+  const paragraphXml = input.anchor ? readAnchorParagraphXml(state, input.anchor.entry) : null;
+  if (input.anchor && paragraphXml == null && !input.styleRef) {
+    return { ok: false, reason: "paragraph-target-not-found" };
+  }
+  const style = resolveInsertionStyle(state, paragraphXml, input.anchor, input.styleRef, inheritance, input.fallbackToDocumentDefaultStyle ?? false);
+  if (!style.ok)
+    return style;
+  const direct = inheritance === "anchor" && paragraphXml != null ? resolveDirectInsertionFormatting(paragraphXml, input.anchor.placement, readAnchorNamespaceBindings(state, input.anchor.entry)) : {
+    paragraphPropertiesXml: null,
+    paragraphMarkRunPropertiesXml: null,
+    runPropertiesXml: null,
+    skippedReason: directFormattingSkippedReason(inheritance)
+  };
+  if ("reason" in direct)
+    return direct;
+  const paragraphPropertiesXml = composeParagraphPropertiesXml({
+    styleId: style.styleId,
+    numberingProperties,
+    inheritedParagraphPropertiesXml: direct.paragraphPropertiesXml
+  });
+  return {
+    ok: true,
+    context: {
+      styleId: style.styleId,
+      numberingProperties,
+      paragraphPropertiesXml,
+      runPropertiesXml: direct.runPropertiesXml,
+      provenance: {
+        inheritedParagraphProperties: direct.paragraphPropertiesXml != null,
+        inheritedParagraphMarkProperties: direct.paragraphMarkRunPropertiesXml != null,
+        inheritedRunProperties: direct.runPropertiesXml != null,
+        explicitStyleOverride: Boolean(input.styleRef),
+        explicitNumberingOverride: numberingProperties != null,
+        ...direct.skippedReason ? { skippedReason: direct.skippedReason } : {}
+      }
+    }
+  };
+}
+function directFormattingSkippedReason(inheritance) {
+  if (inheritance === "style")
+    return "direct-inheritance-disabled";
+  if (inheritance === "none")
+    return "inheritance-disabled";
+  return "no-anchor";
+}
+function readAnchorParagraphXml(state, entry) {
+  const bytes = state.packageBytes.get(entry.partUri);
+  if (!bytes)
+    return null;
+  if (entry.byteEnd <= entry.byteStart)
+    return "";
+  return TD51.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
+}
+function readAnchorNamespaceBindings(state, entry) {
+  const mainOverlay = state.mainStorySourceOverlay;
+  if (entry.directBodyChildOrdinal != null && mainOverlay?.partUri === entry.partUri && mainOverlay.storyId === entry.storyId) {
+    return mainOverlay.rootNamespaceBindings;
+  }
+  const bytes = state.packageBytes.get(entry.partUri);
+  return bytes ? namespaceBindingsAtPosition(bytes, entry.byteStart) : {};
+}
+function resolveInsertionStyle(state, anchorParagraphXml, anchor, explicitStyleRef, inheritance, fallbackToDocumentDefaultStyle) {
+  if (explicitStyleRef)
+    return { ok: true, styleId: explicitStyleRef };
+  if (!anchor || inheritance === "none") {
+    return {
+      ok: true,
+      styleId: fallbackToDocumentDefaultStyle ? resolveDefaultParagraphStyleId(state) : null
+    };
+  }
+  if (anchorParagraphXml == null)
+    return { ok: false, reason: "paragraph-target-not-found" };
+  const paragraphStyle = readDirectParagraphStyleId(anchorParagraphXml);
+  if (paragraphStyle.presence === "malformed") {
+    return { ok: false, reason: "paragraph-style-ambiguous" };
+  }
+  const targetStyle = paragraphStyle.styleId;
+  if (anchor.placement === "after" && targetStyle) {
+    const next = lookupNextStyle(state, targetStyle);
+    if (!next.ok)
+      return next;
+    if (next.styleId)
+      return { ok: true, styleId: next.styleId };
+  }
+  if (targetStyle)
+    return { ok: true, styleId: targetStyle };
+  return {
+    ok: true,
+    styleId: fallbackToDocumentDefaultStyle ? resolveDefaultParagraphStyleId(state) : null
+  };
+}
+function resolveDefaultParagraphStyleId(state) {
+  const defaultStyle = resolveDefaultParagraphStyle(state);
+  return defaultStyle.ok ? defaultStyle.styleId ?? "Normal" : "Normal";
+}
+function resolveDefaultParagraphStyle(state) {
+  const inspection = inspectStyleDefinitionsPartUriFromState(state);
+  if (!inspection.valid)
+    return { ok: true, styleId: null };
+  const bytes = inspection.partUri ? ensurePackagePartBytes(state, inspection.partUri) : null;
+  if (!bytes)
+    return { ok: true, styleId: null };
+  const xml = TD51.decode(bytes);
+  const namespaceUri = inspectStyleDefinitionsXmlDialect(xml);
+  if (!namespaceUri)
+    return { ok: true, styleId: null };
+  let depth = 0;
+  const defaults = [];
+  let valid = true;
+  const parsed = walkXmlElements(xml, {
+    onOpenTag({ tag }) {
+      depth += 1;
+      if (depth !== 2 || tag.namespaceUri !== namespaceUri || tag.localName !== "style")
+        return;
+      if (readWordAttribute2(tag, namespaceUri, "type") !== "paragraph" || !["1", "true", "on"].includes(readWordAttribute2(tag, namespaceUri, "default") ?? ""))
+        return;
+      const id = readWordAttribute2(tag, namespaceUri, "styleId");
+      if (!id)
+        valid = false;
+      else
+        defaults.push(id);
+    },
+    onCloseTag() {
+      depth -= 1;
+    }
+  });
+  if (!valid || parsed.errors.length || defaults.length > 1)
+    return { ok: true, styleId: null };
+  return { ok: true, styleId: defaults[0] ?? null };
+}
+function lookupNextStyle(state, styleId) {
+  const inspection = inspectStyleDefinitionsPartUriFromState(state);
+  if (!inspection.valid)
+    return { ok: false, reason: "paragraph-style-ambiguous" };
+  const stylesBytes = inspection.partUri ? ensurePackagePartBytes(state, inspection.partUri) : null;
+  if (!stylesBytes)
+    return { ok: true, styleId: null };
+  const xml = TD51.decode(stylesBytes);
+  const namespaceUri = inspectStyleDefinitionsXmlDialect(xml);
+  if (!namespaceUri)
+    return { ok: false, reason: "paragraph-style-ambiguous" };
+  let depth = 0;
+  let targetStyleDepth = -1;
+  let foundTargetStyle = false;
+  let nextStyleId = null;
+  const parsed = walkXmlElements(xml, {
+    onOpenTag({ tag }) {
+      depth += 1;
+      if (!foundTargetStyle && depth === 2 && tag.namespaceUri === namespaceUri && tag.localName === "style" && readWordAttribute2(tag, namespaceUri, "styleId") === styleId) {
+        foundTargetStyle = true;
+        targetStyleDepth = depth;
+        return;
+      }
+      if (targetStyleDepth >= 0 && depth === targetStyleDepth + 1 && tag.namespaceUri === namespaceUri && tag.localName === "next") {
+        nextStyleId = readWordAttribute2(tag, namespaceUri, "val") ?? null;
+      }
+    },
+    onCloseTag({ tag }) {
+      if (depth === targetStyleDepth && tag.localName === "style")
+        targetStyleDepth = -1;
+      depth -= 1;
+    }
+  });
+  if (parsed.errors.length > 0)
+    return { ok: false, reason: "paragraph-style-ambiguous" };
+  return { ok: true, styleId: nextStyleId };
+}
+function readWordAttribute2(tag, namespaceUri, localName2) {
+  return readXmlAttribute(tag, namespaceUri, localName2)?.value;
+}
+function resolveDirectInsertionFormatting(paragraphXml, placement2, inheritedNamespaceBindings = {}) {
+  const paragraphPropertiesXml = cloneDirectParagraphPropertiesForInsert(paragraphXml);
+  const paragraphMarkRunPropertiesXml = cloneParagraphMarkRunPropertiesForInsert(paragraphXml);
+  const adjacentRunProperties = cloneAdjacentRunPropertiesForInsert(paragraphXml, placement2, paragraphMarkRunPropertiesXml, inheritedNamespaceBindings);
+  if (!adjacentRunProperties.ok)
+    return adjacentRunProperties;
+  const runPropertiesXml = adjacentRunProperties.runPropertiesXml;
+  return {
+    paragraphPropertiesXml,
+    paragraphMarkRunPropertiesXml,
+    runPropertiesXml,
+    ...!paragraphPropertiesXml && !runPropertiesXml ? { skippedReason: "no-direct-formatting" } : {}
+  };
+}
+function cloneAdjacentRunPropertiesCarrierForInsertion(paragraphXml, placement2, inheritedNamespaceBindings = {}) {
+  const paragraphWithoutNestedTextboxes = stripElements(paragraphXml, "txbxContent");
+  const run = adjacentFormattingCarrierRun(paragraphWithoutNestedTextboxes, placement2, inheritedNamespaceBindings);
+  if (!run.ok)
+    return run;
+  if (!run.run)
+    return { ok: true, carrier: null };
+  const carrierRun = run.run;
+  const runPropertiesXml = readRunPropertiesXml(carrierRun.xml);
+  if (!runPropertiesXml)
+    return { ok: true, carrier: null };
+  const namespaceSource = namespaceSourceForRunProperties(paragraphWithoutNestedTextboxes, carrierRun, runPropertiesXml, inheritedNamespaceBindings);
+  if (!namespaceSource)
+    return { ok: true, carrier: null };
+  const { openTag: namespaceSourceOpenTag, hasParagraphRootMarkupCompatibilityAttributes, hasInheritedMarkupCompatibilityAttributes, hasUnresolvedInheritedAttributeNamespaces } = namespaceSource;
+  const hasForeignRevisionLikeRunProperties = runPropertiesContainForeignRevisionLikeElement(runPropertiesXml, namespaceSourceOpenTag);
+  if (hasForeignRevisionLikeRunProperties == null)
+    return { ok: true, carrier: null };
+  if (hasForeignRevisionLikeRunProperties) {
+    return {
+      ok: true,
+      carrier: {
+        runPropertiesXml,
+        namespaceSourceOpenTag,
+        hasForeignRevisionLikeRunProperties,
+        hasNonWordMarkup: runPropertiesContainNonWordMarkup(runPropertiesXml, namespaceSourceOpenTag),
+        hasParagraphRootMarkupCompatibilityAttributes,
+        hasInheritedMarkupCompatibilityAttributes,
+        hasUnresolvedInheritedAttributeNamespaces
+      }
+    };
+  }
+  const normalizedRunProperties = normalizeClonedRunProperties(runPropertiesXml);
+  const normalizedRunPropertiesXml = normalizedRunProperties && carrierRun.insideHyperlink ? stripHyperlinkRunStyle(normalizedRunProperties, namespaceSourceOpenTag) : normalizedRunProperties;
+  return {
+    ok: true,
+    carrier: normalizedRunPropertiesXml ? {
+      runPropertiesXml: normalizedRunPropertiesXml,
+      namespaceSourceOpenTag,
+      hasForeignRevisionLikeRunProperties: false,
+      hasNonWordMarkup: runPropertiesContainNonWordMarkup(normalizedRunPropertiesXml, namespaceSourceOpenTag),
+      hasParagraphRootMarkupCompatibilityAttributes,
+      hasInheritedMarkupCompatibilityAttributes,
+      hasUnresolvedInheritedAttributeNamespaces
+    } : null
+  };
+}
+function cloneDirectParagraphPropertiesForInsert(paraXml) {
+  const inner = paragraphInnerXml(paraXml);
+  if (inner == null)
+    return null;
+  const { pPr } = splitLeadingParagraphPropertyBlock(inner);
+  if (!pPr)
+    return null;
+  let direct = stripParagraphPropertyChange(pPr);
+  if (!direct)
+    return null;
+  for (const localName2 of ["pStyle", "numPr", "sectPr"]) {
+    direct = stripElements(direct, localName2);
+  }
+  direct = replaceParagraphMarkRunProperties(direct);
+  return paragraphPropertiesXmlIsEmpty(direct) ? null : direct;
+}
+function replaceParagraphMarkRunProperties(pPrXml) {
+  const markProperties = extractParagraphMarkRunProperties(pPrXml);
+  if (markProperties == null)
+    return stripElements(pPrXml, "rPr");
+  const span = topLevelMarkRPrSpan(pPrXml);
+  if (!span)
+    return pPrXml;
+  return pPrXml.slice(0, span.start) + markProperties + pPrXml.slice(span.end);
+}
+function topLevelMarkRPrSpan(pPrXml) {
+  const changeOffset = pPrXml.search(/<[\w.-]+:pPrChange\b/);
+  const limit = changeOffset >= 0 ? changeOffset : pPrXml.length;
+  const openOffset = pPrXml.search(/<[\w.-]+:rPr\b/);
+  if (openOffset < 0 || openOffset >= limit)
+    return null;
+  const span = matchLeadingElement(pPrXml.slice(openOffset), "rPr");
+  if (!span)
+    return null;
+  return { start: openOffset, end: openOffset + span.length };
+}
+function cloneAdjacentRunPropertiesForInsert(paraXml, placement2, paragraphMarkRunPropertiesXml, inheritedNamespaceBindings = {}) {
+  const carrierResult = cloneAdjacentRunPropertiesCarrierForInsertion(paraXml, placement2, inheritedNamespaceBindings);
+  if (!carrierResult.ok)
+    return carrierResult;
+  const carrier = carrierResult.carrier;
+  if (!carrier) {
+    return {
+      ok: true,
+      runPropertiesXml: paragraphMarkRunPropertiesXml || null
+    };
+  }
+  if (carrier.hasForeignRevisionLikeRunProperties || carrier.hasInheritedMarkupCompatibilityAttributes && carrier.hasNonWordMarkup !== false || carrier.hasUnresolvedInheritedAttributeNamespaces) {
+    return { ok: false, reason: "unsupported-context" };
+  }
+  if (carrier.hasParagraphRootMarkupCompatibilityAttributes && carrier.hasNonWordMarkup !== false) {
+    return { ok: false, reason: "unsupported-context" };
+  }
+  const runPropertiesXml = namespaceCloseRunPropertiesForRelocation(carrier.runPropertiesXml, carrier.namespaceSourceOpenTag, inheritedNamespaceBindings);
+  if (!runPropertiesXml)
+    return { ok: false, reason: "unsupported-context" };
+  return {
+    ok: true,
+    runPropertiesXml
+  };
+}
+function adjacentFormattingCarrierRun(paragraphXml, placement2, inheritedNamespaceBindings = {}) {
+  const paragraphPrefix = /^<(?:(?<prefix>[\w.-]+):)?p\b/.exec(paragraphXml)?.groups?.prefix ?? "";
+  const additionalNamespaces = xmlFragmentAdditionalNamespaces(paragraphXml, new Map(Object.entries(inheritedNamespaceBindings)), { w: NS_W, [paragraphPrefix]: NS_W });
+  const parsed = collectXmlElementRanges(paragraphXml, { additionalNamespaces });
+  if (parsed.errors.length > 0)
+    return { ok: true, run: undefined };
+  const carrier = adjacentFormattingCarrierPiece(parseParagraphInlineMap(paragraphXml, inheritedNamespaceBindings).pieces, placement2);
+  if (!carrier.ok)
+    return carrier;
+  const carrierPiece = carrier.piece;
+  if (!carrierPiece)
+    return { ok: true, run: undefined };
+  const payloadLocalName = carrierPiece.kind === "text" ? "t" : carrierPiece.control;
+  const run = parsed.ranges.find((range) => range.start === carrierPiece.runCharStart && range.end === carrierPiece.runCharEnd && range.tag.namespaceUri === NS_W && range.tag.localName === "r");
+  const payload = parsed.ranges.find((range) => range.start === carrierPiece.charStart && range.end === carrierPiece.charEnd && range.tag.namespaceUri === NS_W && range.tag.localName === payloadLocalName);
+  if (!run || !payload)
+    return { ok: true, run: undefined };
+  const hyperlinkRanges = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "hyperlink");
+  return {
+    ok: true,
+    run: {
+      start: run.start,
+      end: run.end,
+      xml: paragraphXml.slice(run.start, run.end),
+      insideHyperlink: hyperlinkRanges.some((hyperlink) => hyperlink.start < run.start && run.end <= hyperlink.end)
+    }
+  };
+}
+function adjacentFormattingCarrierPiece(pieces, placement2) {
+  const candidates = placement2 === "before" ? pieces : [...pieces].reverse();
+  for (const piece of candidates) {
+    if (piece.kind === "marker")
+      continue;
+    if (piece.kind === "text") {
+      if (piece.textRole === "visible")
+        return { ok: true, piece };
+      continue;
+    }
+    if (piece.kind === "control") {
+      if (!piece.deleted)
+        return { ok: true, piece };
+      continue;
+    }
+    if (piece.kind === "tracked") {
+      if (piece.removesVisible)
+        continue;
+      const nested = adjacentFormattingCarrierPiece(piece.children, placement2);
+      if (!nested.ok || nested.piece)
+        return nested;
+      if (piece.visibleStart === piece.visibleEnd)
+        continue;
+      return { ok: true, piece: undefined };
+    }
+    if (piece.kind === "container") {
+      if (piece.policy === "fail-closed")
+        return { ok: false, reason: "unsupported-context" };
+      if (piece.policy === "atomic") {
+        if (piece.containerKind === "math")
+          return { ok: true, piece: undefined };
+        continue;
+      }
+      const nested = adjacentFormattingCarrierPiece(piece.children, placement2);
+      if (!nested.ok || nested.piece)
+        return nested;
+      if (piece.visibleStart === piece.visibleEnd)
+        continue;
+      return { ok: true, piece: undefined };
+    }
+    if (piece.kind === "noteReference") {
+      continue;
+    }
+    return { ok: true, piece: undefined };
+  }
+  return { ok: true, piece: undefined };
+}
+function runPropertiesContainForeignRevisionLikeElement(rPrXml, namespaceSourceOpenTag) {
+  const runPropertiesNode = readXmlNodeAt(rPrXml, 0);
+  if (!runPropertiesNode || runPropertiesNode.kind !== "element" || runPropertiesNode.selfClosing || xmlLocalName(runPropertiesNode.qname) !== "rPr" || runPropertiesNode.end !== rPrXml.length) {
+    return null;
+  }
+  const parsedXml = namespaceSourceOpenTag + rPrXml.slice(runPropertiesNode.openEnd, runPropertiesNode.closeStart) + rPrXml.slice(runPropertiesNode.closeStart);
+  const additionalNamespaces = xmlFragmentAdditionalNamespaces(parsedXml, new Map, { w: NS_W });
+  const parsed = collectXmlElementRanges(parsedXml, { additionalNamespaces });
+  if (parsed.errors.length > 0)
+    return null;
+  return parsed.ranges.some((range) => range.tag.localName === "rPrChange" && range.tag.namespaceUri !== NS_W);
+}
+function runPropertiesContainNonWordMarkup(rPrXml, namespaceSourceOpenTag) {
+  const runPropertiesNode = readXmlNodeAt(rPrXml, 0);
+  if (!runPropertiesNode || runPropertiesNode.kind !== "element" || runPropertiesNode.selfClosing || xmlLocalName(runPropertiesNode.qname) !== "rPr" || runPropertiesNode.end !== rPrXml.length) {
+    return null;
+  }
+  const parsedXml = namespaceSourceOpenTag + rPrXml.slice(runPropertiesNode.openEnd, runPropertiesNode.closeStart) + rPrXml.slice(runPropertiesNode.closeStart);
+  const additionalNamespaces = xmlFragmentAdditionalNamespaces(parsedXml, new Map, { w: NS_W });
+  const parsed = collectXmlElementRanges(parsedXml, { additionalNamespaces });
+  if (parsed.errors.length > 0)
+    return null;
+  return parsed.ranges.some((range) => range.tag.namespaceUri !== NS_W || range.tag.attributes.some((attribute) => attribute.prefix !== "xmlns" && attribute.name !== "xmlns" && attribute.namespaceUri !== "" && attribute.namespaceUri !== NS_W && attribute.namespaceUri !== NS_XML));
+}
+function stripHyperlinkRunStyle(rPrXml, namespaceSourceOpenTag) {
+  const runPropertiesNode = readXmlNodeAt(rPrXml, 0);
+  if (!runPropertiesNode || runPropertiesNode.kind !== "element" || runPropertiesNode.selfClosing || xmlLocalName(runPropertiesNode.qname) !== "rPr" || runPropertiesNode.end !== rPrXml.length) {
+    return null;
+  }
+  const parsedXml = namespaceSourceOpenTag + rPrXml.slice(runPropertiesNode.openEnd, runPropertiesNode.closeStart) + rPrXml.slice(runPropertiesNode.closeStart);
+  const additionalNamespaces = xmlFragmentAdditionalNamespaces(parsedXml, new Map, { w: NS_W });
+  const parsed = collectXmlElementRanges(parsedXml, { additionalNamespaces });
+  if (parsed.errors.length > 0)
+    return null;
+  const openTagDelta = namespaceSourceOpenTag.length - runPropertiesNode.openEnd;
+  const styleSpans = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "rStyle" && readXmlAttribute(range.tag, NS_W, "val")?.value === "Hyperlink").map((range) => ({ start: range.start - openTagDelta, end: range.end - openTagDelta })).filter((range) => range.start >= runPropertiesNode.openEnd && range.end <= runPropertiesNode.closeStart).sort((left, right) => right.start - left.start);
+  let stripped = rPrXml;
+  for (const span of styleSpans)
+    stripped = stripped.slice(0, span.start) + stripped.slice(span.end);
+  return runPropertiesXmlIsEmpty(stripped) ? null : stripped;
+}
+function namespaceSourceForRunProperties(paragraphXml, run, runPropertiesXml, inheritedNamespaceBindings) {
+  const runProperties = findFirstElement(run.xml, "rPr");
+  const runPropertiesNode = readXmlNodeAt(runPropertiesXml, 0);
+  if (!runProperties || !runPropertiesNode || runPropertiesNode.kind !== "element" || xmlLocalName(runPropertiesNode.qname) !== "rPr") {
+    return null;
+  }
+  const runPropertiesOpenTag = runPropertiesXml.slice(0, runPropertiesNode.openEnd);
+  const targetStart = run.start + runProperties.start;
+  const inheritedScopes = [];
+  const inheritedCompatibilityScopes = [];
+  const unresolvedInheritedAttributeScopes = [];
+  const compatibilityStack = [];
+  const unresolvedAttributeStack = [];
+  let hasParagraphRootMarkupCompatibilityAttributes = false;
+  const additionalNamespaces = xmlFragmentAdditionalNamespaces(paragraphXml, new Map(Object.entries(inheritedNamespaceBindings)), { w: NS_W });
+  const parsed = walkXmlElements(paragraphXml, {
+    additionalNamespaces,
+    onOpenTag(event) {
+      const parentHasCompatibilityAttributes = compatibilityStack.at(-1) ?? false;
+      const parentHasUnresolvedAttributeNamespaces = unresolvedAttributeStack.at(-1) ?? false;
+      if (event.start === targetStart && event.tag.namespaceUri === NS_W && event.tag.localName === "rPr") {
+        const inherited = { ...event.namespaceBindings };
+        for (const prefix of Object.keys(event.tag.namespaceBindings))
+          delete inherited[prefix];
+        inheritedScopes.push(inherited);
+        inheritedCompatibilityScopes.push(parentHasCompatibilityAttributes);
+        unresolvedInheritedAttributeScopes.push(parentHasUnresolvedAttributeNamespaces);
+      }
+      const isParagraphRoot = event.start === 0 && event.tag.namespaceUri === NS_W && event.tag.localName === "p";
+      if (isParagraphRoot) {
+        hasParagraphRootMarkupCompatibilityAttributes = event.tag.attributes.some((attribute) => attribute.namespaceUri === NS_MC);
+      }
+      const hasLocalCompatibilityAttributes = !isParagraphRoot && event.tag.attributes.some((attribute) => attribute.namespaceUri === NS_MC);
+      compatibilityStack.push(parentHasCompatibilityAttributes || hasLocalCompatibilityAttributes);
+      const hasUnresolvedAttributeNamespaces = event.tag.attributes.some((attribute) => attribute.namespaceUri.startsWith("urn:superdoc:unresolved-namespace-prefix:"));
+      unresolvedAttributeStack.push(parentHasUnresolvedAttributeNamespaces || hasUnresolvedAttributeNamespaces);
+    },
+    onCloseTag() {
+      compatibilityStack.pop();
+      unresolvedAttributeStack.pop();
+    }
+  });
+  const inheritedBindings = inheritedScopes[0];
+  const hasInheritedMarkupCompatibilityAttributes = inheritedCompatibilityScopes[0];
+  const hasUnresolvedInheritedAttributeNamespaces = unresolvedInheritedAttributeScopes[0];
+  if (parsed.errors.length > 0 || !inheritedBindings || hasInheritedMarkupCompatibilityAttributes == null || hasUnresolvedInheritedAttributeNamespaces == null) {
+    return null;
+  }
+  let declarations = "";
+  for (const [prefix, namespaceUri] of Object.entries(inheritedBindings)) {
+    if (prefix === "xml")
+      continue;
+    declarations += prefix.length > 0 ? ` xmlns:${prefix}="${escapeXmlAttribute(namespaceUri)}"` : ` xmlns="${escapeXmlAttribute(namespaceUri)}"`;
+  }
+  return {
+    openTag: declarations.length > 0 ? runPropertiesOpenTag.replace(/>$/, `${declarations}>`) : runPropertiesOpenTag,
+    hasParagraphRootMarkupCompatibilityAttributes,
+    hasInheritedMarkupCompatibilityAttributes,
+    hasUnresolvedInheritedAttributeNamespaces
+  };
+}
+function readRunPropertiesXml(runXml) {
+  const inner = runInnerXml(runXml);
+  if (inner == null)
+    return null;
+  const leading = /^\s*/.exec(inner)?.[0] ?? "";
+  const rPrXml = matchLeadingElement(inner.slice(leading.length), "rPr");
+  return rPrXml || null;
+}
+function cloneParagraphMarkRunPropertiesForInsert(paraXml) {
+  const inner = paragraphInnerXml(paraXml);
+  if (inner == null)
+    return null;
+  const { pPr } = splitLeadingParagraphPropertyBlock(inner);
+  if (!pPr)
+    return null;
+  const markProperties = extractParagraphMarkRunProperties(stripParagraphPropertyChange(pPr));
+  return markProperties && !runPropertiesXmlIsEmpty(markProperties) ? markProperties : null;
+}
+function normalizeClonedRunProperties(rPrXml) {
+  const stripped = stripElements(rPrXml, "rPrChange");
+  return runPropertiesXmlIsEmpty(stripped) ? null : stripped;
+}
+function paragraphInnerXml(paraXml) {
+  const openTag = /^<[\w.-]+:p\b[^>]*>/.exec(paraXml)?.[0];
+  const closeTag = /<\/[\w.-]+:p>\s*$/.exec(paraXml)?.[0];
+  if (!openTag || !closeTag)
+    return null;
+  return paraXml.slice(openTag.length, paraXml.length - closeTag.length);
+}
+function runInnerXml(runXml) {
+  const openTag = /^<[\w.-]+:r\b[^>]*>/.exec(runXml)?.[0];
+  const closeTag = /<\/[\w.-]+:r>\s*$/.exec(runXml)?.[0];
+  if (!openTag || !closeTag)
+    return null;
+  return runXml.slice(openTag.length, runXml.length - closeTag.length);
+}
+function composeParagraphPropertiesXml(input) {
+  const explicit = renderParagraphProperties2(input.styleId, input.numberingProperties);
+  const explicitChildren = paragraphPropertiesChildrenXml(explicit);
+  const inheritedChildren = paragraphPropertiesChildrenXml(input.inheritedParagraphPropertiesXml);
+  const children = `${explicitChildren}${inheritedChildren}`;
+  const namespaceAttrs = paragraphPropertiesNamespaceAttrs(input.inheritedParagraphPropertiesXml);
+  return children.trim().length > 0 ? `<w:pPr${namespaceAttrs}>${children}</w:pPr>` : null;
+}
+function paragraphPropertiesChildrenXml(pPrXml) {
+  if (!pPrXml)
+    return "";
+  const trimmed = pPrXml.trim();
+  const selfClosing = /^<[\w.-]+:pPr\b[^>]*\/>$/.exec(trimmed);
+  if (selfClosing)
+    return "";
+  const open = /^<[\w.-]+:pPr\b[^>]*>/.exec(trimmed)?.[0];
+  const close = /<\/[\w.-]+:pPr>\s*$/.exec(trimmed)?.[0];
+  if (!open || !close)
+    return "";
+  return trimmed.slice(open.length, trimmed.length - close.length);
+}
+function paragraphPropertiesNamespaceAttrs(pPrXml) {
+  if (!pPrXml)
+    return "";
+  const trimmed = pPrXml.trim();
+  const openAttrs = /^<[\w.-]+:pPr\b([^>]*)\/?>/.exec(trimmed)?.[1] ?? "";
+  return openAttrs.match(/\s+xmlns(?::[\w.-]+)?=(?:"[^"]*"|'[^']*')/g)?.join("") ?? "";
+}
+function paragraphPropertiesXmlIsEmpty(pPrXml) {
+  const trimmed = pPrXml.trim();
+  return /^<[\w.-]+:pPr\b[^>]*\/>$/.test(trimmed) || /^<([\w.-]+):pPr\b[^>]*>\s*<\/\1:pPr>$/.test(trimmed);
+}
+function runPropertiesXmlIsEmpty(rPrXml) {
+  const trimmed = rPrXml.trim();
+  return /^<[\w.-]+:rPr\b[^>]*\/>$/.test(trimmed) || /^<([\w.-]+):rPr\b[^>]*>\s*<\/\1:rPr>$/.test(trimmed);
+}
+var TD51;
+var init_insertion_formatting_context = __esm(() => {
+  init_sd_document_state();
+  init_style_definitions_part();
+  init_style_definitions_xml();
+  init_paragraph_inline_model();
+  init_xml_text();
+  init_xml_sax();
+  init_paragraph_contribution();
+  init_direct_paragraph_list_properties();
+  init_paragraph_property_block();
+  init_paragraph_para_id_attrs();
+  TD51 = new TextDecoder;
+});
+
 // ../../../v2/editor-core/dist/document/transactions/field-paragraph-owner.js
 function createPackedFieldParagraphOwnerResolver(input) {
   if (parseXmlForError(input.xml, { namespaceAware: true }) != null) {
@@ -216250,7 +216843,7 @@ function resolveOwnerFromOpeningTag(bytes, entry) {
   }
   if (tagEnd < 0)
     return { resolved: false };
-  const tag = parseRawXmlElementTag(TD51.decode(bytes.subarray(entry.byteStart, tagEnd)));
+  const tag = parseRawXmlElementTag(TD52.decode(bytes.subarray(entry.byteStart, tagEnd)));
   if (!tag || tag.isClose || tag.prefix !== "w" || tag.localName !== "p")
     return { resolved: false };
   const paraIds = [...scanRawXmlAttributes(tag.attrs)].filter((attribute) => attribute.localName === "paraId");
@@ -216280,13 +216873,13 @@ async function parseXmlForErrorCooperatively(xml, checkpoint) {
   }
   return !parseError;
 }
-var TD51, XML_PARSE_CHUNK_CODE_UNITS, MAX_PARAGRAPH_OPEN_TAG_BYTES;
+var TD52, XML_PARSE_CHUNK_CODE_UNITS, MAX_PARAGRAPH_OPEN_TAG_BYTES;
 var init_field_paragraph_owner = __esm(() => {
   init_sd_document_state();
   init_paragraph_index();
   init_xml_text();
   init_xml_sax();
-  TD51 = new TextDecoder;
+  TD52 = new TextDecoder;
   XML_PARSE_CHUNK_CODE_UNITS = 512 * 1024;
   MAX_PARAGRAPH_OPEN_TAG_BYTES = 64 * 1024;
 });
@@ -216382,7 +216975,7 @@ async function screenFieldCandidatesCooperatively(xml, checkpoint) {
   return false;
 }
 function buildFieldCatalog(input) {
-  const xml = input.sharedXml ?? TD52.decode(input.bytes);
+  const xml = input.sharedXml ?? TD53.decode(input.bytes);
   if (!hasFieldCandidates(xml))
     return emptyFieldCatalog(input.storyId, input.partUri, xml.length);
   return buildFieldCatalogFromXml(input, xml, buildSparseFieldUtf8OffsetIndex(xml));
@@ -216873,12 +217466,12 @@ function getOrBuildFieldCatalogForStory(state, storyId) {
     return existing.catalog;
   }
   if (!hasFieldByteCandidates(bytes)) {
-    const catalog2 = emptyFieldCatalog(storyId, partUri, () => TD52.decode(bytes).length);
+    const catalog2 = emptyFieldCatalog(storyId, partUri, () => TD53.decode(bytes).length);
     perStory.set(storyId, { catalog: catalog2, partBytes: bytes });
     return catalog2;
   }
   const shared = peekPartWmlScanFacts(state, partUri);
-  const xml = shared?.bytes === bytes ? shared.xml : DECODED_PART_IN_FLIGHT.get(bytes)?.xml ?? TD52.decode(bytes);
+  const xml = shared?.bytes === bytes ? shared.xml : DECODED_PART_IN_FLIGHT.get(bytes)?.xml ?? TD53.decode(bytes);
   if (!hasFieldCandidates(xml)) {
     const catalog2 = emptyFieldCatalog(storyId, partUri, xml.length);
     perStory.set(storyId, { catalog: catalog2, partBytes: bytes });
@@ -216958,7 +217551,7 @@ async function buildFieldCatalogForStoryCooperatively(input) {
   if (decoded)
     decoded.users += 1;
   else {
-    decoded = { xml: TD52.decode(input.bytes), users: 1 };
+    decoded = { xml: TD53.decode(input.bytes), users: 1 };
     DECODED_PART_IN_FLIGHT.set(input.bytes, decoded);
   }
   let syncWinner = null;
@@ -217092,7 +217685,7 @@ function listFieldCatalogsForState(state) {
   }
   return out;
 }
-var TD52, UTF8_OFFSET_CHECKPOINT_STRIDE = 256, FIELD_CANDIDATE_BYTES, FIELD_CANDIDATE_SEARCHES, STATE_CACHE2, STATE_IN_FLIGHT, DECODED_PART_IN_FLIGHT;
+var TD53, UTF8_OFFSET_CHECKPOINT_STRIDE = 256, FIELD_CANDIDATE_BYTES, FIELD_CANDIDATE_SEARCHES, STATE_CACHE2, STATE_IN_FLIGHT, DECODED_PART_IN_FLIGHT;
 var init_field_catalog = __esm(() => {
   init_sd_document_state();
   init_xml_text();
@@ -217100,7 +217693,7 @@ var init_field_catalog = __esm(() => {
   init_wml_paragraph_spans();
   init_part_wml_scan_cache();
   init_field_paragraph_owner();
-  TD52 = new TextDecoder;
+  TD53 = new TextDecoder;
   FIELD_CANDIDATE_BYTES = [["fldSimple", 3], ["fldChar", 3], ["instrText", 7]];
   FIELD_CANDIDATE_SEARCHES = FIELD_CANDIDATE_BYTES.map(([token, anchorOffset]) => ({
     token: new TextEncoder().encode(token),
@@ -217113,7 +217706,7 @@ var init_field_catalog = __esm(() => {
 
 // ../../../v2/editor-core/dist/document/transactions/range-integrity.js
 function isParagraphRangeMarkerGap(bytes, startByte, endByte) {
-  const xml = TD53.decode(bytes.subarray(startByte, endByte));
+  const xml = TD54.decode(bytes.subarray(startByte, endByte));
   if (xml.trim() === "")
     return true;
   const offsetAt = createMonotonicUtf8OffsetResolver(xml);
@@ -217180,7 +217773,7 @@ function validateParagraphRangeIntegrity(input) {
   const markerWindow = selectedParagraphByteWindow(input.bytes, startEntry, endEntry);
   if (markerWindow) {
     recordSDTxPerf("rangeIntegrityBoundedMarkerBytes", markerWindow.byteLength);
-    if (!PAIRED_RANGE_MARKER_TAG.test(TD53.decode(markerWindow))) {
+    if (!PAIRED_RANGE_MARKER_TAG.test(TD54.decode(markerWindow))) {
       return { ok: true, removedBookmarkNames: [] };
     }
   }
@@ -217292,7 +217885,7 @@ function createVisiblePointResolver(bytes, index) {
       return null;
     let model = models.get(entry.ordinal);
     if (!model) {
-      model = parseParagraphInlineMap(TD53.decode(bytes.subarray(entry.byteStart, entry.byteEnd)));
+      model = parseParagraphInlineMap(TD54.decode(bytes.subarray(entry.byteStart, entry.byteEnd)));
       models.set(entry.ordinal, model);
     }
     return {
@@ -217308,7 +217901,7 @@ function comparePoints(left, right) {
   return left.ordinal - right.ordinal || left.offset - right.offset;
 }
 function collectPairedRangeMarkers(bytes) {
-  const xml = TD53.decode(bytes);
+  const xml = TD54.decode(bytes);
   const byteOffsetAt4 = createMonotonicUtf8OffsetResolver(xml);
   const markers = [];
   const scanned = walkXmlElements(xml, {
@@ -217371,13 +217964,13 @@ function incompleteFieldAt(catalog, byteOffset) {
     complete: false
   };
 }
-var TD53, PAIRED_RANGE_MARKER_FAMILIES, PAIRED_RANGE_MARKER_TAG;
+var TD54, PAIRED_RANGE_MARKER_FAMILIES, PAIRED_RANGE_MARKER_TAG;
 var init_range_integrity = __esm(() => {
   init_paragraph_inline_model();
   init_paragraph_para_id_attrs();
   init_xml_sax();
   init_field_catalog();
-  TD53 = new TextDecoder;
+  TD54 = new TextDecoder;
   PAIRED_RANGE_MARKER_FAMILIES = {
     bookmark: "bookmark",
     perm: "permission",
@@ -217714,566 +218307,6 @@ var init_tracked_block_move = __esm(() => {
   init_moved_picture_identities();
 });
 
-// ../../../v2/editor-core/dist/document/transactions/insertion-formatting-context.js
-function resolveInsertionFormattingContext(state, input) {
-  const inheritance = input.inheritance ?? "anchor";
-  const numberingProperties = input.numberingProperties ?? null;
-  const paragraphXml = input.anchor ? readAnchorParagraphXml(state, input.anchor.entry) : null;
-  if (input.anchor && paragraphXml == null && !input.styleRef) {
-    return { ok: false, reason: "paragraph-target-not-found" };
-  }
-  const style = resolveInsertionStyle(state, paragraphXml, input.anchor, input.styleRef, inheritance, input.fallbackToDocumentDefaultStyle ?? false);
-  if (!style.ok)
-    return style;
-  const direct = inheritance === "anchor" && paragraphXml != null ? resolveDirectInsertionFormatting(paragraphXml, input.anchor.placement, readAnchorNamespaceBindings(state, input.anchor.entry)) : {
-    paragraphPropertiesXml: null,
-    paragraphMarkRunPropertiesXml: null,
-    runPropertiesXml: null,
-    skippedReason: directFormattingSkippedReason(inheritance)
-  };
-  if ("reason" in direct)
-    return direct;
-  const paragraphPropertiesXml = composeParagraphPropertiesXml({
-    styleId: style.styleId,
-    numberingProperties,
-    inheritedParagraphPropertiesXml: direct.paragraphPropertiesXml
-  });
-  return {
-    ok: true,
-    context: {
-      styleId: style.styleId,
-      numberingProperties,
-      paragraphPropertiesXml,
-      runPropertiesXml: direct.runPropertiesXml,
-      provenance: {
-        inheritedParagraphProperties: direct.paragraphPropertiesXml != null,
-        inheritedParagraphMarkProperties: direct.paragraphMarkRunPropertiesXml != null,
-        inheritedRunProperties: direct.runPropertiesXml != null,
-        explicitStyleOverride: Boolean(input.styleRef),
-        explicitNumberingOverride: numberingProperties != null,
-        ...direct.skippedReason ? { skippedReason: direct.skippedReason } : {}
-      }
-    }
-  };
-}
-function directFormattingSkippedReason(inheritance) {
-  if (inheritance === "style")
-    return "direct-inheritance-disabled";
-  if (inheritance === "none")
-    return "inheritance-disabled";
-  return "no-anchor";
-}
-function readAnchorParagraphXml(state, entry) {
-  const bytes = state.packageBytes.get(entry.partUri);
-  if (!bytes)
-    return null;
-  if (entry.byteEnd <= entry.byteStart)
-    return "";
-  return TD54.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
-}
-function readAnchorNamespaceBindings(state, entry) {
-  const mainOverlay = state.mainStorySourceOverlay;
-  if (entry.directBodyChildOrdinal != null && mainOverlay?.partUri === entry.partUri && mainOverlay.storyId === entry.storyId) {
-    return mainOverlay.rootNamespaceBindings;
-  }
-  const bytes = state.packageBytes.get(entry.partUri);
-  return bytes ? namespaceBindingsAtPosition(bytes, entry.byteStart) : {};
-}
-function resolveInsertionStyle(state, anchorParagraphXml, anchor, explicitStyleRef, inheritance, fallbackToDocumentDefaultStyle) {
-  if (explicitStyleRef)
-    return { ok: true, styleId: explicitStyleRef };
-  if (!anchor || inheritance === "none") {
-    return {
-      ok: true,
-      styleId: fallbackToDocumentDefaultStyle ? resolveDefaultParagraphStyleId(state) : null
-    };
-  }
-  if (anchorParagraphXml == null)
-    return { ok: false, reason: "paragraph-target-not-found" };
-  const paragraphStyle = readDirectParagraphStyleId(anchorParagraphXml);
-  if (paragraphStyle.presence === "malformed") {
-    return { ok: false, reason: "paragraph-style-ambiguous" };
-  }
-  const targetStyle = paragraphStyle.styleId;
-  if (anchor.placement === "after" && targetStyle) {
-    const next = lookupNextStyle(state, targetStyle);
-    if (!next.ok)
-      return next;
-    if (next.styleId)
-      return { ok: true, styleId: next.styleId };
-  }
-  if (targetStyle)
-    return { ok: true, styleId: targetStyle };
-  return {
-    ok: true,
-    styleId: fallbackToDocumentDefaultStyle ? resolveDefaultParagraphStyleId(state) : null
-  };
-}
-function resolveDefaultParagraphStyleId(state) {
-  const defaultStyle = resolveDefaultParagraphStyle(state);
-  return defaultStyle.ok ? defaultStyle.styleId ?? "Normal" : "Normal";
-}
-function resolveDefaultParagraphStyle(state) {
-  const inspection = inspectStyleDefinitionsPartUriFromState(state);
-  if (!inspection.valid)
-    return { ok: true, styleId: null };
-  const bytes = inspection.partUri ? ensurePackagePartBytes(state, inspection.partUri) : null;
-  if (!bytes)
-    return { ok: true, styleId: null };
-  const xml = TD54.decode(bytes);
-  const namespaceUri = inspectStyleDefinitionsXmlDialect(xml);
-  if (!namespaceUri)
-    return { ok: true, styleId: null };
-  let depth = 0;
-  const defaults = [];
-  let valid = true;
-  const parsed = walkXmlElements(xml, {
-    onOpenTag({ tag }) {
-      depth += 1;
-      if (depth !== 2 || tag.namespaceUri !== namespaceUri || tag.localName !== "style")
-        return;
-      if (readWordAttribute2(tag, namespaceUri, "type") !== "paragraph" || !["1", "true", "on"].includes(readWordAttribute2(tag, namespaceUri, "default") ?? ""))
-        return;
-      const id = readWordAttribute2(tag, namespaceUri, "styleId");
-      if (!id)
-        valid = false;
-      else
-        defaults.push(id);
-    },
-    onCloseTag() {
-      depth -= 1;
-    }
-  });
-  if (!valid || parsed.errors.length || defaults.length > 1)
-    return { ok: true, styleId: null };
-  return { ok: true, styleId: defaults[0] ?? null };
-}
-function lookupNextStyle(state, styleId) {
-  const inspection = inspectStyleDefinitionsPartUriFromState(state);
-  if (!inspection.valid)
-    return { ok: false, reason: "paragraph-style-ambiguous" };
-  const stylesBytes = inspection.partUri ? ensurePackagePartBytes(state, inspection.partUri) : null;
-  if (!stylesBytes)
-    return { ok: true, styleId: null };
-  const xml = TD54.decode(stylesBytes);
-  const namespaceUri = inspectStyleDefinitionsXmlDialect(xml);
-  if (!namespaceUri)
-    return { ok: false, reason: "paragraph-style-ambiguous" };
-  let depth = 0;
-  let targetStyleDepth = -1;
-  let foundTargetStyle = false;
-  let nextStyleId = null;
-  const parsed = walkXmlElements(xml, {
-    onOpenTag({ tag }) {
-      depth += 1;
-      if (!foundTargetStyle && depth === 2 && tag.namespaceUri === namespaceUri && tag.localName === "style" && readWordAttribute2(tag, namespaceUri, "styleId") === styleId) {
-        foundTargetStyle = true;
-        targetStyleDepth = depth;
-        return;
-      }
-      if (targetStyleDepth >= 0 && depth === targetStyleDepth + 1 && tag.namespaceUri === namespaceUri && tag.localName === "next") {
-        nextStyleId = readWordAttribute2(tag, namespaceUri, "val") ?? null;
-      }
-    },
-    onCloseTag({ tag }) {
-      if (depth === targetStyleDepth && tag.localName === "style")
-        targetStyleDepth = -1;
-      depth -= 1;
-    }
-  });
-  if (parsed.errors.length > 0)
-    return { ok: false, reason: "paragraph-style-ambiguous" };
-  return { ok: true, styleId: nextStyleId };
-}
-function readWordAttribute2(tag, namespaceUri, localName2) {
-  return readXmlAttribute(tag, namespaceUri, localName2)?.value;
-}
-function resolveDirectInsertionFormatting(paragraphXml, placement2, inheritedNamespaceBindings = {}) {
-  const paragraphPropertiesXml = cloneDirectParagraphPropertiesForInsert(paragraphXml);
-  const paragraphMarkRunPropertiesXml = cloneParagraphMarkRunPropertiesForInsert(paragraphXml);
-  const adjacentRunProperties = cloneAdjacentRunPropertiesForInsert(paragraphXml, placement2, paragraphMarkRunPropertiesXml, inheritedNamespaceBindings);
-  if (!adjacentRunProperties.ok)
-    return adjacentRunProperties;
-  const runPropertiesXml = adjacentRunProperties.runPropertiesXml;
-  return {
-    paragraphPropertiesXml,
-    paragraphMarkRunPropertiesXml,
-    runPropertiesXml,
-    ...!paragraphPropertiesXml && !runPropertiesXml ? { skippedReason: "no-direct-formatting" } : {}
-  };
-}
-function cloneAdjacentRunPropertiesCarrierForInsertion(paragraphXml, placement2, inheritedNamespaceBindings = {}) {
-  const paragraphWithoutNestedTextboxes = stripElements(paragraphXml, "txbxContent");
-  const run = adjacentFormattingCarrierRun(paragraphWithoutNestedTextboxes, placement2, inheritedNamespaceBindings);
-  if (!run.ok)
-    return run;
-  if (!run.run)
-    return { ok: true, carrier: null };
-  const carrierRun = run.run;
-  const runPropertiesXml = readRunPropertiesXml(carrierRun.xml);
-  if (!runPropertiesXml)
-    return { ok: true, carrier: null };
-  const namespaceSource = namespaceSourceForRunProperties(paragraphWithoutNestedTextboxes, carrierRun, runPropertiesXml, inheritedNamespaceBindings);
-  if (!namespaceSource)
-    return { ok: true, carrier: null };
-  const { openTag: namespaceSourceOpenTag, hasParagraphRootMarkupCompatibilityAttributes, hasInheritedMarkupCompatibilityAttributes, hasUnresolvedInheritedAttributeNamespaces } = namespaceSource;
-  const hasForeignRevisionLikeRunProperties = runPropertiesContainForeignRevisionLikeElement(runPropertiesXml, namespaceSourceOpenTag);
-  if (hasForeignRevisionLikeRunProperties == null)
-    return { ok: true, carrier: null };
-  if (hasForeignRevisionLikeRunProperties) {
-    return {
-      ok: true,
-      carrier: {
-        runPropertiesXml,
-        namespaceSourceOpenTag,
-        hasForeignRevisionLikeRunProperties,
-        hasNonWordMarkup: runPropertiesContainNonWordMarkup(runPropertiesXml, namespaceSourceOpenTag),
-        hasParagraphRootMarkupCompatibilityAttributes,
-        hasInheritedMarkupCompatibilityAttributes,
-        hasUnresolvedInheritedAttributeNamespaces
-      }
-    };
-  }
-  const normalizedRunProperties = normalizeClonedRunProperties(runPropertiesXml);
-  const normalizedRunPropertiesXml = normalizedRunProperties && carrierRun.insideHyperlink ? stripHyperlinkRunStyle(normalizedRunProperties, namespaceSourceOpenTag) : normalizedRunProperties;
-  return {
-    ok: true,
-    carrier: normalizedRunPropertiesXml ? {
-      runPropertiesXml: normalizedRunPropertiesXml,
-      namespaceSourceOpenTag,
-      hasForeignRevisionLikeRunProperties: false,
-      hasNonWordMarkup: runPropertiesContainNonWordMarkup(normalizedRunPropertiesXml, namespaceSourceOpenTag),
-      hasParagraphRootMarkupCompatibilityAttributes,
-      hasInheritedMarkupCompatibilityAttributes,
-      hasUnresolvedInheritedAttributeNamespaces
-    } : null
-  };
-}
-function cloneDirectParagraphPropertiesForInsert(paraXml) {
-  const inner = paragraphInnerXml(paraXml);
-  if (inner == null)
-    return null;
-  const { pPr } = splitLeadingParagraphPropertyBlock(inner);
-  if (!pPr)
-    return null;
-  let direct = stripParagraphPropertyChange(pPr);
-  if (!direct)
-    return null;
-  for (const localName2 of ["pStyle", "numPr", "sectPr"]) {
-    direct = stripElements(direct, localName2);
-  }
-  direct = replaceParagraphMarkRunProperties(direct);
-  return paragraphPropertiesXmlIsEmpty(direct) ? null : direct;
-}
-function replaceParagraphMarkRunProperties(pPrXml) {
-  const markProperties = extractParagraphMarkRunProperties(pPrXml);
-  if (markProperties == null)
-    return stripElements(pPrXml, "rPr");
-  const span = topLevelMarkRPrSpan(pPrXml);
-  if (!span)
-    return pPrXml;
-  return pPrXml.slice(0, span.start) + markProperties + pPrXml.slice(span.end);
-}
-function topLevelMarkRPrSpan(pPrXml) {
-  const changeOffset = pPrXml.search(/<[\w.-]+:pPrChange\b/);
-  const limit = changeOffset >= 0 ? changeOffset : pPrXml.length;
-  const openOffset = pPrXml.search(/<[\w.-]+:rPr\b/);
-  if (openOffset < 0 || openOffset >= limit)
-    return null;
-  const span = matchLeadingElement(pPrXml.slice(openOffset), "rPr");
-  if (!span)
-    return null;
-  return { start: openOffset, end: openOffset + span.length };
-}
-function cloneAdjacentRunPropertiesForInsert(paraXml, placement2, paragraphMarkRunPropertiesXml, inheritedNamespaceBindings = {}) {
-  const carrierResult = cloneAdjacentRunPropertiesCarrierForInsertion(paraXml, placement2, inheritedNamespaceBindings);
-  if (!carrierResult.ok)
-    return carrierResult;
-  const carrier = carrierResult.carrier;
-  if (!carrier) {
-    return {
-      ok: true,
-      runPropertiesXml: paragraphMarkRunPropertiesXml || null
-    };
-  }
-  if (carrier.hasForeignRevisionLikeRunProperties || carrier.hasInheritedMarkupCompatibilityAttributes && carrier.hasNonWordMarkup !== false || carrier.hasUnresolvedInheritedAttributeNamespaces) {
-    return { ok: false, reason: "unsupported-context" };
-  }
-  if (carrier.hasParagraphRootMarkupCompatibilityAttributes && carrier.hasNonWordMarkup !== false) {
-    return { ok: false, reason: "unsupported-context" };
-  }
-  const runPropertiesXml = namespaceCloseRunPropertiesForRelocation(carrier.runPropertiesXml, carrier.namespaceSourceOpenTag, inheritedNamespaceBindings);
-  if (!runPropertiesXml)
-    return { ok: false, reason: "unsupported-context" };
-  return {
-    ok: true,
-    runPropertiesXml
-  };
-}
-function adjacentFormattingCarrierRun(paragraphXml, placement2, inheritedNamespaceBindings = {}) {
-  const paragraphPrefix = /^<(?:(?<prefix>[\w.-]+):)?p\b/.exec(paragraphXml)?.groups?.prefix ?? "";
-  const additionalNamespaces = xmlFragmentAdditionalNamespaces(paragraphXml, new Map(Object.entries(inheritedNamespaceBindings)), { w: NS_W, [paragraphPrefix]: NS_W });
-  const parsed = collectXmlElementRanges(paragraphXml, { additionalNamespaces });
-  if (parsed.errors.length > 0)
-    return { ok: true, run: undefined };
-  const carrier = adjacentFormattingCarrierPiece(parseParagraphInlineMap(paragraphXml, inheritedNamespaceBindings).pieces, placement2);
-  if (!carrier.ok)
-    return carrier;
-  const carrierPiece = carrier.piece;
-  if (!carrierPiece)
-    return { ok: true, run: undefined };
-  const payloadLocalName = carrierPiece.kind === "text" ? "t" : carrierPiece.control;
-  const run = parsed.ranges.find((range) => range.start === carrierPiece.runCharStart && range.end === carrierPiece.runCharEnd && range.tag.namespaceUri === NS_W && range.tag.localName === "r");
-  const payload = parsed.ranges.find((range) => range.start === carrierPiece.charStart && range.end === carrierPiece.charEnd && range.tag.namespaceUri === NS_W && range.tag.localName === payloadLocalName);
-  if (!run || !payload)
-    return { ok: true, run: undefined };
-  const hyperlinkRanges = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "hyperlink");
-  return {
-    ok: true,
-    run: {
-      start: run.start,
-      end: run.end,
-      xml: paragraphXml.slice(run.start, run.end),
-      insideHyperlink: hyperlinkRanges.some((hyperlink) => hyperlink.start < run.start && run.end <= hyperlink.end)
-    }
-  };
-}
-function adjacentFormattingCarrierPiece(pieces, placement2) {
-  const candidates = placement2 === "before" ? pieces : [...pieces].reverse();
-  for (const piece of candidates) {
-    if (piece.kind === "marker")
-      continue;
-    if (piece.kind === "text") {
-      if (piece.textRole === "visible")
-        return { ok: true, piece };
-      continue;
-    }
-    if (piece.kind === "control") {
-      if (!piece.deleted)
-        return { ok: true, piece };
-      continue;
-    }
-    if (piece.kind === "tracked") {
-      if (piece.removesVisible)
-        continue;
-      const nested = adjacentFormattingCarrierPiece(piece.children, placement2);
-      if (!nested.ok || nested.piece)
-        return nested;
-      if (piece.visibleStart === piece.visibleEnd)
-        continue;
-      return { ok: true, piece: undefined };
-    }
-    if (piece.kind === "container") {
-      if (piece.policy === "fail-closed")
-        return { ok: false, reason: "unsupported-context" };
-      if (piece.policy === "atomic") {
-        if (piece.containerKind === "math")
-          return { ok: true, piece: undefined };
-        continue;
-      }
-      const nested = adjacentFormattingCarrierPiece(piece.children, placement2);
-      if (!nested.ok || nested.piece)
-        return nested;
-      if (piece.visibleStart === piece.visibleEnd)
-        continue;
-      return { ok: true, piece: undefined };
-    }
-    if (piece.kind === "noteReference") {
-      continue;
-    }
-    return { ok: true, piece: undefined };
-  }
-  return { ok: true, piece: undefined };
-}
-function runPropertiesContainForeignRevisionLikeElement(rPrXml, namespaceSourceOpenTag) {
-  const runPropertiesNode = readXmlNodeAt(rPrXml, 0);
-  if (!runPropertiesNode || runPropertiesNode.kind !== "element" || runPropertiesNode.selfClosing || xmlLocalName(runPropertiesNode.qname) !== "rPr" || runPropertiesNode.end !== rPrXml.length) {
-    return null;
-  }
-  const parsedXml = namespaceSourceOpenTag + rPrXml.slice(runPropertiesNode.openEnd, runPropertiesNode.closeStart) + rPrXml.slice(runPropertiesNode.closeStart);
-  const additionalNamespaces = xmlFragmentAdditionalNamespaces(parsedXml, new Map, { w: NS_W });
-  const parsed = collectXmlElementRanges(parsedXml, { additionalNamespaces });
-  if (parsed.errors.length > 0)
-    return null;
-  return parsed.ranges.some((range) => range.tag.localName === "rPrChange" && range.tag.namespaceUri !== NS_W);
-}
-function runPropertiesContainNonWordMarkup(rPrXml, namespaceSourceOpenTag) {
-  const runPropertiesNode = readXmlNodeAt(rPrXml, 0);
-  if (!runPropertiesNode || runPropertiesNode.kind !== "element" || runPropertiesNode.selfClosing || xmlLocalName(runPropertiesNode.qname) !== "rPr" || runPropertiesNode.end !== rPrXml.length) {
-    return null;
-  }
-  const parsedXml = namespaceSourceOpenTag + rPrXml.slice(runPropertiesNode.openEnd, runPropertiesNode.closeStart) + rPrXml.slice(runPropertiesNode.closeStart);
-  const additionalNamespaces = xmlFragmentAdditionalNamespaces(parsedXml, new Map, { w: NS_W });
-  const parsed = collectXmlElementRanges(parsedXml, { additionalNamespaces });
-  if (parsed.errors.length > 0)
-    return null;
-  return parsed.ranges.some((range) => range.tag.namespaceUri !== NS_W || range.tag.attributes.some((attribute) => attribute.prefix !== "xmlns" && attribute.name !== "xmlns" && attribute.namespaceUri !== "" && attribute.namespaceUri !== NS_W && attribute.namespaceUri !== NS_XML));
-}
-function stripHyperlinkRunStyle(rPrXml, namespaceSourceOpenTag) {
-  const runPropertiesNode = readXmlNodeAt(rPrXml, 0);
-  if (!runPropertiesNode || runPropertiesNode.kind !== "element" || runPropertiesNode.selfClosing || xmlLocalName(runPropertiesNode.qname) !== "rPr" || runPropertiesNode.end !== rPrXml.length) {
-    return null;
-  }
-  const parsedXml = namespaceSourceOpenTag + rPrXml.slice(runPropertiesNode.openEnd, runPropertiesNode.closeStart) + rPrXml.slice(runPropertiesNode.closeStart);
-  const additionalNamespaces = xmlFragmentAdditionalNamespaces(parsedXml, new Map, { w: NS_W });
-  const parsed = collectXmlElementRanges(parsedXml, { additionalNamespaces });
-  if (parsed.errors.length > 0)
-    return null;
-  const openTagDelta = namespaceSourceOpenTag.length - runPropertiesNode.openEnd;
-  const styleSpans = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "rStyle" && readXmlAttribute(range.tag, NS_W, "val")?.value === "Hyperlink").map((range) => ({ start: range.start - openTagDelta, end: range.end - openTagDelta })).filter((range) => range.start >= runPropertiesNode.openEnd && range.end <= runPropertiesNode.closeStart).sort((left, right) => right.start - left.start);
-  let stripped = rPrXml;
-  for (const span of styleSpans)
-    stripped = stripped.slice(0, span.start) + stripped.slice(span.end);
-  return runPropertiesXmlIsEmpty(stripped) ? null : stripped;
-}
-function namespaceSourceForRunProperties(paragraphXml, run, runPropertiesXml, inheritedNamespaceBindings) {
-  const runProperties = findFirstElement(run.xml, "rPr");
-  const runPropertiesNode = readXmlNodeAt(runPropertiesXml, 0);
-  if (!runProperties || !runPropertiesNode || runPropertiesNode.kind !== "element" || xmlLocalName(runPropertiesNode.qname) !== "rPr") {
-    return null;
-  }
-  const runPropertiesOpenTag = runPropertiesXml.slice(0, runPropertiesNode.openEnd);
-  const targetStart = run.start + runProperties.start;
-  const inheritedScopes = [];
-  const inheritedCompatibilityScopes = [];
-  const unresolvedInheritedAttributeScopes = [];
-  const compatibilityStack = [];
-  const unresolvedAttributeStack = [];
-  let hasParagraphRootMarkupCompatibilityAttributes = false;
-  const additionalNamespaces = xmlFragmentAdditionalNamespaces(paragraphXml, new Map(Object.entries(inheritedNamespaceBindings)), { w: NS_W });
-  const parsed = walkXmlElements(paragraphXml, {
-    additionalNamespaces,
-    onOpenTag(event) {
-      const parentHasCompatibilityAttributes = compatibilityStack.at(-1) ?? false;
-      const parentHasUnresolvedAttributeNamespaces = unresolvedAttributeStack.at(-1) ?? false;
-      if (event.start === targetStart && event.tag.namespaceUri === NS_W && event.tag.localName === "rPr") {
-        const inherited = { ...event.namespaceBindings };
-        for (const prefix of Object.keys(event.tag.namespaceBindings))
-          delete inherited[prefix];
-        inheritedScopes.push(inherited);
-        inheritedCompatibilityScopes.push(parentHasCompatibilityAttributes);
-        unresolvedInheritedAttributeScopes.push(parentHasUnresolvedAttributeNamespaces);
-      }
-      const isParagraphRoot = event.start === 0 && event.tag.namespaceUri === NS_W && event.tag.localName === "p";
-      if (isParagraphRoot) {
-        hasParagraphRootMarkupCompatibilityAttributes = event.tag.attributes.some((attribute) => attribute.namespaceUri === NS_MC);
-      }
-      const hasLocalCompatibilityAttributes = !isParagraphRoot && event.tag.attributes.some((attribute) => attribute.namespaceUri === NS_MC);
-      compatibilityStack.push(parentHasCompatibilityAttributes || hasLocalCompatibilityAttributes);
-      const hasUnresolvedAttributeNamespaces = event.tag.attributes.some((attribute) => attribute.namespaceUri.startsWith("urn:superdoc:unresolved-namespace-prefix:"));
-      unresolvedAttributeStack.push(parentHasUnresolvedAttributeNamespaces || hasUnresolvedAttributeNamespaces);
-    },
-    onCloseTag() {
-      compatibilityStack.pop();
-      unresolvedAttributeStack.pop();
-    }
-  });
-  const inheritedBindings = inheritedScopes[0];
-  const hasInheritedMarkupCompatibilityAttributes = inheritedCompatibilityScopes[0];
-  const hasUnresolvedInheritedAttributeNamespaces = unresolvedInheritedAttributeScopes[0];
-  if (parsed.errors.length > 0 || !inheritedBindings || hasInheritedMarkupCompatibilityAttributes == null || hasUnresolvedInheritedAttributeNamespaces == null) {
-    return null;
-  }
-  let declarations = "";
-  for (const [prefix, namespaceUri] of Object.entries(inheritedBindings)) {
-    if (prefix === "xml")
-      continue;
-    declarations += prefix.length > 0 ? ` xmlns:${prefix}="${escapeXmlAttribute(namespaceUri)}"` : ` xmlns="${escapeXmlAttribute(namespaceUri)}"`;
-  }
-  return {
-    openTag: declarations.length > 0 ? runPropertiesOpenTag.replace(/>$/, `${declarations}>`) : runPropertiesOpenTag,
-    hasParagraphRootMarkupCompatibilityAttributes,
-    hasInheritedMarkupCompatibilityAttributes,
-    hasUnresolvedInheritedAttributeNamespaces
-  };
-}
-function readRunPropertiesXml(runXml) {
-  const inner = runInnerXml(runXml);
-  if (inner == null)
-    return null;
-  const leading = /^\s*/.exec(inner)?.[0] ?? "";
-  const rPrXml = matchLeadingElement(inner.slice(leading.length), "rPr");
-  return rPrXml || null;
-}
-function cloneParagraphMarkRunPropertiesForInsert(paraXml) {
-  const inner = paragraphInnerXml(paraXml);
-  if (inner == null)
-    return null;
-  const { pPr } = splitLeadingParagraphPropertyBlock(inner);
-  if (!pPr)
-    return null;
-  const markProperties = extractParagraphMarkRunProperties(stripParagraphPropertyChange(pPr));
-  return markProperties && !runPropertiesXmlIsEmpty(markProperties) ? markProperties : null;
-}
-function normalizeClonedRunProperties(rPrXml) {
-  const stripped = stripElements(rPrXml, "rPrChange");
-  return runPropertiesXmlIsEmpty(stripped) ? null : stripped;
-}
-function paragraphInnerXml(paraXml) {
-  const openTag = /^<[\w.-]+:p\b[^>]*>/.exec(paraXml)?.[0];
-  const closeTag = /<\/[\w.-]+:p>\s*$/.exec(paraXml)?.[0];
-  if (!openTag || !closeTag)
-    return null;
-  return paraXml.slice(openTag.length, paraXml.length - closeTag.length);
-}
-function runInnerXml(runXml) {
-  const openTag = /^<[\w.-]+:r\b[^>]*>/.exec(runXml)?.[0];
-  const closeTag = /<\/[\w.-]+:r>\s*$/.exec(runXml)?.[0];
-  if (!openTag || !closeTag)
-    return null;
-  return runXml.slice(openTag.length, runXml.length - closeTag.length);
-}
-function composeParagraphPropertiesXml(input) {
-  const explicit = renderParagraphProperties2(input.styleId, input.numberingProperties);
-  const explicitChildren = paragraphPropertiesChildrenXml(explicit);
-  const inheritedChildren = paragraphPropertiesChildrenXml(input.inheritedParagraphPropertiesXml);
-  const children = `${explicitChildren}${inheritedChildren}`;
-  const namespaceAttrs = paragraphPropertiesNamespaceAttrs(input.inheritedParagraphPropertiesXml);
-  return children.trim().length > 0 ? `<w:pPr${namespaceAttrs}>${children}</w:pPr>` : null;
-}
-function paragraphPropertiesChildrenXml(pPrXml) {
-  if (!pPrXml)
-    return "";
-  const trimmed = pPrXml.trim();
-  const selfClosing = /^<[\w.-]+:pPr\b[^>]*\/>$/.exec(trimmed);
-  if (selfClosing)
-    return "";
-  const open = /^<[\w.-]+:pPr\b[^>]*>/.exec(trimmed)?.[0];
-  const close = /<\/[\w.-]+:pPr>\s*$/.exec(trimmed)?.[0];
-  if (!open || !close)
-    return "";
-  return trimmed.slice(open.length, trimmed.length - close.length);
-}
-function paragraphPropertiesNamespaceAttrs(pPrXml) {
-  if (!pPrXml)
-    return "";
-  const trimmed = pPrXml.trim();
-  const openAttrs = /^<[\w.-]+:pPr\b([^>]*)\/?>/.exec(trimmed)?.[1] ?? "";
-  return openAttrs.match(/\s+xmlns(?::[\w.-]+)?=(?:"[^"]*"|'[^']*')/g)?.join("") ?? "";
-}
-function paragraphPropertiesXmlIsEmpty(pPrXml) {
-  const trimmed = pPrXml.trim();
-  return /^<[\w.-]+:pPr\b[^>]*\/>$/.test(trimmed) || /^<([\w.-]+):pPr\b[^>]*>\s*<\/\1:pPr>$/.test(trimmed);
-}
-function runPropertiesXmlIsEmpty(rPrXml) {
-  const trimmed = rPrXml.trim();
-  return /^<[\w.-]+:rPr\b[^>]*\/>$/.test(trimmed) || /^<([\w.-]+):rPr\b[^>]*>\s*<\/\1:rPr>$/.test(trimmed);
-}
-var TD54;
-var init_insertion_formatting_context = __esm(() => {
-  init_sd_document_state();
-  init_style_definitions_part();
-  init_style_definitions_xml();
-  init_paragraph_inline_model();
-  init_xml_text();
-  init_xml_sax();
-  init_paragraph_contribution();
-  init_direct_paragraph_list_properties();
-  init_paragraph_property_block();
-  init_paragraph_para_id_attrs();
-  TD54 = new TextDecoder;
-});
-
 // ../../../v2/editor-core/dist/document/transactions/compile-paragraph-ops.js
 function prepareParagraphInsert(state, op) {
   const site = resolveParagraphInsertSite(state, op);
@@ -219541,7 +219574,17 @@ function prepareParagraphSplit(input) {
   });
   if (!tailProperties.ok)
     return tailProperties;
-  const tailXml = tailWithId + tailProperties.paragraphPropertiesXml + slice.tail + closeTag;
+  let tailPropertiesXml = tailProperties.paragraphPropertiesXml;
+  if (slice.terminal && input.resolveTailStyleId) {
+    const sourceStyle = readDirectParagraphStyleId(paragraphXml);
+    if (sourceStyle.presence === "present") {
+      const tailStyleId = input.resolveTailStyleId(sourceStyle.styleId);
+      if (tailStyleId) {
+        tailPropertiesXml = replaceDirectParagraphStyleId(tailPropertiesXml, tailStyleId);
+      }
+    }
+  }
+  const tailXml = tailWithId + tailPropertiesXml + slice.tail + closeTag;
   const headMarkProperties = /<(?:[\w.-]+:)?(?:ins|del|moveFrom|moveTo)\b/.test(pPrXml) ? stripParagraphMarkRevisionMarkers(pPrXml, namespaceBindingsAtPosition(input.partBytes, input.paragraphByteStart, openTag)) : pPrXml;
   const headProperties = stripParagraphPropertyChange(headMarkProperties);
   const headXml = openTag + headProperties + slice.head + closeTag;
@@ -219633,6 +219676,17 @@ function runParagraphSplitCommit(input) {
   const tailParaId = provisionalParaId;
   const splitAllocatedWIds = [];
   const metadataClones = [];
+  const nextStyleCache = new Map;
+  const resolveTailStyleId = (currentStyleId) => {
+    let cached2 = nextStyleCache.get(currentStyleId);
+    if (cached2 === undefined) {
+      cached2 = lookupNextStyle(input.state, currentStyleId);
+      nextStyleCache.set(currentStyleId, cached2);
+    }
+    if (!cached2.ok)
+      return null;
+    return cached2.styleId && cached2.styleId !== currentStyleId ? cached2.styleId : null;
+  };
   const primarySplit = prepareParagraphSplit({
     paragraphXml: paraXml,
     partBytes: bytes,
@@ -219646,7 +219700,8 @@ function runParagraphSplitCommit(input) {
       const wId = allocateRevisionWId(input.state);
       splitAllocatedWIds.push(wId);
       return wId;
-    }
+    },
+    resolveTailStyleId
   });
   if (!primarySplit.ok)
     return rejected8(input.txId, primarySplit.reason);
@@ -219685,7 +219740,8 @@ function runParagraphSplitCommit(input) {
             return 0;
           }
           return wId;
-        }
+        },
+        resolveTailStyleId
       });
       if (!split.ok)
         return split;
@@ -221250,6 +221306,8 @@ var init_compile_paragraph_ops = __esm(() => {
   init_part_payload();
   init_paragraph_contribution();
   init_paragraph_property_block();
+  init_direct_paragraph_list_properties();
+  init_insertion_formatting_context();
   init_paragraph_para_id_attrs();
   init_paragraph_index();
   init_commit_prepared_mutation();
@@ -278610,6 +278668,17 @@ function storyMatches(a, b) {
   const bn = canonicalStory(b);
   return an === bn;
 }
+function pickStoryLocator(target, override) {
+  if (override)
+    return override;
+  if (target.story)
+    return target.story;
+  if (target.start.kind === "text" && target.start.story)
+    return target.start.story;
+  if (target.end.kind === "text" && target.end.story)
+    return target.end.story;
+  return;
+}
 function selectionTargetStoriesMatch(target, overrideStory) {
   const suppliedStories = [
     overrideStory,
@@ -279084,6 +279153,9 @@ function resolveBodySelectionTarget(context, target) {
   const index = getSDDocumentSessionInternalParagraphIndex(context.session);
   if (!index)
     return { error: "PRECONDITION_FAILED", message: "paragraph index is not available." };
+  return resolveStorySelectionTarget(context, target, index);
+}
+function resolveStorySelectionTarget(context, target, index) {
   return resolveSelectionTargetToRange({
     target,
     index,
@@ -279093,6 +279165,24 @@ function resolveBodySelectionTarget(context, target) {
     buildOffsetMap: buildSDDocumentSessionInternalParagraphOffsetMap
   });
 }
+function listStoryPartSources(context) {
+  const body = context.resolveFullStoryLocator({ kind: "story", storyType: "body" });
+  if ("error" in body)
+    throw operationError("TARGET_NOT_FOUND", "body story is not available.");
+  const sources = [{ partUri: body.partUri, storyId: body.storyId }];
+  const seen = new Set([body.partUri]);
+  for (const rel of listSDDocumentSessionInternalHeaderFooterRels(context.session)) {
+    if (seen.has(rel.partUri))
+      continue;
+    const story = { kind: "story", storyType: "headerFooterPart", refId: rel.refId };
+    const resolved = context.resolveFullStoryLocator(story);
+    if ("error" in resolved)
+      continue;
+    seen.add(rel.partUri);
+    sources.push({ partUri: rel.partUri, storyId: resolved.storyId, story });
+  }
+  return sources;
+}
 function contentTypeForPart2(partUri) {
   if (partUri.endsWith(".rels"))
     return "application/vnd.openxmlformats-package.relationships+xml";
@@ -285967,8 +286057,10 @@ function toCssFontFamily(fontName, options = {}) {
   if (trimmed.includes(";")) {
     trimmed = splitOutsideQuotes(trimmed, ";").join(", ");
   }
-  const { fallback, wordFamily } = options;
-  const fallbackValue = fallback ?? (wordFamily ? mapWordFamilyFallback(wordFamily) : undefined) ?? inferGenericFallbackFromFontName(trimmed);
+  const { fallback, wordFamily, pitch } = options;
+  const family = typeof wordFamily === "string" ? wordFamily.trim().toLowerCase() : "";
+  const fixedPitch = typeof pitch === "string" && pitch.trim().toLowerCase() === "fixed";
+  const fallbackValue = fallback ?? (fixedPitch ? "monospace" : undefined) ?? (family !== "auto" && Object.hasOwn(FONT_FAMILY_FALLBACKS, family) ? mapWordFamilyFallback(family) : undefined) ?? inferGenericFallbackFromFontName(trimmed);
   const fallbackParts = normalizeParts(fallbackValue);
   if (fallbackParts.length === 0) {
     return trimmed;
@@ -285984,7 +286076,12 @@ var FONT_FAMILY_FALLBACKS, DEFAULT_GENERIC_FALLBACK = "sans-serif", INHERITED_FO
   if (!fontName || typeof fontName !== "string")
     return "";
   return fontName.trim().replace(/^["']|["']$/g, "").toLowerCase();
-}, inferGenericFallbackFromFontName = (fontName) => SERIF_LIKE_FONTS.has(normalizeFontNameForLookup(fontName)) ? "serif" : DEFAULT_GENERIC_FALLBACK, normalizeParts = (value) => (value || "").split(",").map((part) => part.trim()).filter(Boolean), splitOutsideQuotes = (str, delimiter) => {
+}, MONOSPACE_FONTS, inferGenericFallbackFromFontName = (fontName) => {
+  const name = normalizeFontNameForLookup(fontName);
+  if (MONOSPACE_FONTS.has(name))
+    return "monospace";
+  return SERIF_LIKE_FONTS.has(name) ? "serif" : DEFAULT_GENERIC_FALLBACK;
+}, normalizeParts = (value) => (value || "").split(",").map((part) => part.trim()).filter(Boolean), splitOutsideQuotes = (str, delimiter) => {
   if (!str.includes('"') && !str.includes("'")) {
     return str.split(delimiter).map((p) => p.trim()).filter(Boolean);
   }
@@ -286041,6 +286138,17 @@ var init_font_utils = __esm(() => {
     "bodoni mt",
     "constantia"
   ]);
+  MONOSPACE_FONTS = new Set([
+    "courier",
+    "courier new",
+    "consolas",
+    "menlo",
+    "monaco",
+    "lucida console",
+    "liberation mono",
+    "dejavu sans mono",
+    "source code pro"
+  ]);
 });
 
 // ../../../v2/node_modules/.pnpm/@superdoc+style-engine@file+..+public+packages+layout-engine+style-engine/node_modules/@superdoc/style-engine/src/normalize/run-attrs.ts
@@ -286064,7 +286172,9 @@ function normalizeRunAttrsFromOoxml(props, context = {}) {
   if (props.smallCaps != null)
     out.smallCaps = props.smallCaps === true;
   const fontFamily = resolveFontFamily(props, context.themeFontScheme);
-  const cssFontFamily = toCssFontFamily(fontFamily);
+  const fontKey = fontFamily?.trim().replace(/^["']|["']$/g, "");
+  const metadata2 = fontKey ? context.fontTable?.[fontKey] ?? context.fontTable?.[fontKey.toLowerCase()] : undefined;
+  const cssFontFamily = toCssFontFamily(fontFamily, { wordFamily: metadata2?.family, pitch: metadata2?.pitch });
   if (cssFontFamily)
     out.fontFamily = cssFontFamily;
   const fontSize = resolveFontSize(props.fontSize);
@@ -328302,7 +328412,112 @@ var init_tracked_structural_wrapper = __esm(() => {
   init_common();
 });
 
+// ../../../v2/document-api-v2-adapter/dist/address/story-surface.js
+function resolveStorySurface(session, bodyStoryId, locator) {
+  const resolved = resolveSessionStoryLocator(session, bodyStoryId, locator);
+  if ("error" in resolved) {
+    return { ok: false, failure: classifyStoryLocatorFailure(resolved.error) };
+  }
+  return { ok: true, descriptor: toStorySurfaceDescriptor(resolved) };
+}
+function toStorySurfaceDescriptor(resolved) {
+  const descriptor = {
+    storyId: resolved.storyId,
+    partUri: resolved.partUri,
+    storyKind: resolved.storyKind,
+    relationshipOwnerPartUri: resolved.relationshipOwnerPartUri,
+    sourceAvailability: resolved.materialization ? "materialize-on-write" : "available"
+  };
+  if (resolved.storyByteRange)
+    descriptor.storyByteRange = resolved.storyByteRange;
+  if (resolved.refId)
+    descriptor.refId = resolved.refId;
+  if (resolved.noteId)
+    descriptor.noteId = resolved.noteId;
+  if (resolved.textboxId)
+    descriptor.textboxId = resolved.textboxId;
+  if (resolved.materialization)
+    descriptor.materialization = resolved.materialization;
+  if (resolved.slot)
+    descriptor.slot = resolved.slot;
+  if (resolved.resolvedFromSectionId)
+    descriptor.resolvedFromSectionId = resolved.resolvedFromSectionId;
+  return descriptor;
+}
+function classifyStoryLocatorFailure(error48) {
+  return {
+    category: storyLocatorFailureCategory(error48),
+    reason: error48,
+    message: storyLocatorFailureMessage(error48)
+  };
+}
+function receiptFailureForStoryLocatorError(error48) {
+  const failure4 = classifyStoryLocatorFailure(error48);
+  return {
+    code: failure4.category,
+    message: failure4.message
+  };
+}
+function storyLocatorFailureCategory(error48) {
+  switch (error48) {
+    case "not-found":
+    case "unknown-section":
+    case "no-sections":
+      return "TARGET_NOT_FOUND";
+    case "unsupported-story":
+    case "inherited-edit-rejected":
+    case "cross-story-write-rejected":
+      return "CAPABILITY_UNAVAILABLE";
+    case "no-source-for-edit":
+      return "PRECONDITION_FAILED";
+    default: {
+      const _exhaustive = error48;
+      return _exhaustive;
+    }
+  }
+}
+function storyLocatorFailureMessage(error48) {
+  switch (error48) {
+    case "not-found":
+      return "the requested story target was not found";
+    case "unknown-section":
+      return "the requested section is not part of this document";
+    case "no-sections":
+      return "the document has no resolvable sections for this story";
+    case "unsupported-story":
+      return "this story family is not supported for the requested operation";
+    case "inherited-edit-rejected":
+      return "the header/footer slot is inherited and cannot be edited under the requested write policy";
+    case "cross-story-write-rejected":
+      return "the requested write would cross story boundaries";
+    case "no-source-for-edit":
+      return "the requested story has no source bytes available for this edit";
+    default:
+      return "the requested story could not be resolved";
+  }
+}
+function rangeWithinStorySurface(descriptor, range) {
+  const window2 = descriptor.storyByteRange;
+  if (!window2)
+    return null;
+  if (range.start >= window2[0] && range.end <= window2[1] && range.start <= range.end) {
+    return null;
+  }
+  return {
+    category: "INVALID_CONTEXT",
+    reason: null,
+    message: `byte range [${range.start}, ${range.end}] falls outside the resolved story window ` + `[${window2[0]}, ${window2[1]}] for story ${descriptor.storyId}`
+  };
+}
+var init_story_surface = __esm(() => {
+  init_story_locator();
+});
+
 // ../../../v2/document-api-v2-adapter/dist/permission-ranges/adapter.js
+function isSupportedStoryKind(storyKind) {
+  return storyKind === "main" || storyKind === "header" || storyKind === "footer";
+}
+
 class V2PermissionRangesAdapter {
   constructor(context) {
     this.context = context;
@@ -328318,10 +328533,7 @@ class V2PermissionRangesAdapter {
     });
   }
   get(input) {
-    const range = listPermissionRanges(this.context).find((entry) => entry.id === input.id);
-    if (!range)
-      throw operationError("TARGET_NOT_FOUND", `permission range ${input.id} not found.`);
-    return stripInternal2(range);
+    return stripInternal2(this.findByIdOrThrow(input.id));
   }
   create(input, options) {
     const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
@@ -328329,11 +328541,12 @@ class V2PermissionRangesAdapter {
       return mutationGuard;
     const wholeControl = resolveWholeControlPermissionTarget(this.context, input.target);
     if (wholeControl) {
-      const xml2 = this.readDocumentXml();
-      const id2 = input.id ?? allocateRangeId(listPermissionRanges(this.context));
-      if (listPermissionRanges(this.context).some((range) => range.id === id2)) {
-        throw operationError("INVALID_INPUT", "permission range id already exists.");
+      const xml2 = this.readPartXmlOrThrow(DOCUMENT_PART_URI5);
+      const rawIds2 = listPermissionRangeRawIds(this.context);
+      if (input.id !== undefined && rawIds2.has(input.id)) {
+        throw operationError("DUPLICATE_ID", `permission range id "${input.id}" already exists.`);
       }
+      const id2 = input.id ?? allocateRangeId(rawIds2);
       const rangeXml = buildPermStart(id2, input.principal) + xml2.slice(wholeControl.start, wholeControl.end) + buildPermEnd(id2);
       const nextXml2 = replaceRange2(xml2, wholeControl.start, wholeControl.end, rangeXml);
       if (dryRunRequested(input, options)) {
@@ -328345,14 +328558,38 @@ class V2PermissionRangesAdapter {
         return { success: false, failure: { code: committed2.code, message: committed2.message } };
       return { success: true, range: this.get({ id: id2 }) };
     }
-    const resolved = resolveBodySelectionTarget(this.context, input.target);
+    const storyLocator = pickStoryLocator(input.target, undefined);
+    if (storyLocator && storyLocator.storyType !== "headerFooterPart" && storyLocator.storyType !== "body") {
+      throw operationError("CAPABILITY_UNAVAILABLE", "permissionRanges.create only supports body and headerFooterPart story targets.");
+    }
+    const resolvedStory = this.context.resolveFullStoryLocator(storyLocator);
+    if ("error" in resolvedStory) {
+      const failure4 = classifyStoryLocatorFailure(resolvedStory.error);
+      throw operationError(failure4.category, failure4.message);
+    }
+    if (!isSupportedStoryKind(resolvedStory.storyKind) || resolvedStory.materialization) {
+      throw operationError("CAPABILITY_UNAVAILABLE", "permissionRanges.create only supports body and explicit header/footer story targets.");
+    }
+    if (resolvedStory.storyKind !== "main" && this.context.isCollaborativeSession()) {
+      throw operationError("CAPABILITY_UNAVAILABLE", COLLABORATIVE_SECONDARY_STORY_MESSAGE);
+    }
+    const index2 = resolvedStory.storyKind === "main" ? getSDDocumentSessionInternalParagraphIndex(this.context.session) : getSDDocumentSessionInternalStoryParagraphIndex(this.context.session, resolvedStory.storyId);
+    if (!index2)
+      throw operationError("PRECONDITION_FAILED", "paragraph index is not available.");
+    const resolved = resolveStorySelectionTarget(this.context, input.target, index2);
     if ("error" in resolved)
       throw operationError(resolved.error, resolved.message);
     if (resolved.startBlockId !== resolved.endBlockId) {
       throw operationError("INVALID_TARGET", "permissionRanges.create requires a same-paragraph text selection.");
     }
-    const xml = this.readDocumentXml();
-    const id = input.id ?? allocateRangeId(listPermissionRanges(this.context));
+    const rawIds = listPermissionRangeRawIds(this.context);
+    if (input.id !== undefined && rawIds.has(input.id)) {
+      throw operationError("DUPLICATE_ID", `permission range id "${input.id}" already exists.`);
+    }
+    const id = input.id ?? allocateRangeId(rawIds);
+    const targetPartUri = resolvedStory.partUri;
+    const story = resolvedStory.storyKind === "main" ? undefined : { kind: "story", storyType: "headerFooterPart", refId: resolvedStory.refId };
+    const xml = this.readPartXmlOrThrow(targetPartUri);
     const para = findParagraphById2(xml, resolved.startBlockId);
     if (!para)
       throw operationError("TARGET_NOT_FOUND", `paragraph ${resolved.startBlockId} not found.`);
@@ -328364,13 +328601,14 @@ class V2PermissionRangesAdapter {
           principal: input.principal,
           kind: "inline",
           start: { blockId: resolved.startBlockId, offset: resolved.startOffset },
-          end: { blockId: resolved.endBlockId, offset: resolved.endOffset }
+          end: { blockId: resolved.endBlockId, offset: resolved.endOffset },
+          ...story ? { story } : {}
         }
       };
     }
     const wrapped = wrapTextRangeWithPermissionMarkers(para.xml, resolved.startOffset, resolved.endOffset, id, input.principal);
     const nextXml = replaceRange2(xml, para.start, para.end, wrapped);
-    const committed = commitWholePartUpdates(this.context, "permission-range-create", { [DOCUMENT_PART_URI5]: encodeXml(nextXml) }, { expectedRevision: expectedRevisionFrom(input, options) });
+    const committed = commitWholePartUpdates(this.context, "permission-range-create", { [targetPartUri]: encodeXml(nextXml) }, { expectedRevision: expectedRevisionFrom(input, options), storyIds: [resolvedStory.storyId] });
     if (!committed.ok)
       return { success: false, failure: { code: committed.code, message: committed.message } };
     return { success: true, range: this.get({ id }) };
@@ -328379,15 +328617,14 @@ class V2PermissionRangesAdapter {
     const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
     if (mutationGuard)
       return mutationGuard;
-    const range = listPermissionRanges(this.context).find((entry) => entry.id === input.id);
-    if (!range)
-      throw operationError("TARGET_NOT_FOUND", `permission range ${input.id} not found.`);
+    const range = this.findByIdOrThrow(input.id);
+    this.guardCollaborativeSecondaryStory(range);
     if (dryRunRequested(input, options))
       return { success: true, id: input.id };
-    let xml = this.readDocumentXml();
+    let xml = this.readPartXmlOrThrow(range.partUri);
     xml = removeMarkerAt(xml, range.endTagStart, range.endTagEnd);
     xml = removeMarkerAt(xml, range.startTagStart, range.startTagEnd);
-    const committed = commitWholePartUpdates(this.context, "permission-range-remove", { [DOCUMENT_PART_URI5]: encodeXml(xml) }, { expectedRevision: expectedRevisionFrom(input, options) });
+    const committed = commitWholePartUpdates(this.context, "permission-range-remove", { [range.partUri]: encodeXml(xml) }, { expectedRevision: expectedRevisionFrom(input, options), storyIds: [range.storyId] });
     if (!committed.ok)
       return { success: false, failure: { code: committed.code, message: committed.message } };
     return { success: true, id: input.id };
@@ -328396,37 +328633,80 @@ class V2PermissionRangesAdapter {
     const mutationGuard = guardDirectOnlyMutation(this.context, input, options);
     if (mutationGuard)
       return mutationGuard;
-    const range = listPermissionRanges(this.context).find((entry) => entry.id === input.id);
-    if (!range)
-      throw operationError("TARGET_NOT_FOUND", `permission range ${input.id} not found.`);
+    const range = this.findByIdOrThrow(input.id);
+    this.guardCollaborativeSecondaryStory(range);
     if (dryRunRequested(input, options))
       return { success: true, range: stripInternal2(range) };
-    const xml = this.readDocumentXml();
+    const xml = this.readPartXmlOrThrow(range.partUri);
     const marker = xml.slice(range.startTagStart, range.startTagEnd);
     const nextMarker = buildPermStart(input.id, input.principal);
     const nextXml = xml.replace(marker, nextMarker);
-    const committed = commitWholePartUpdates(this.context, "permission-range-update", { [DOCUMENT_PART_URI5]: encodeXml(nextXml) }, { expectedRevision: expectedRevisionFrom(input, options) });
+    const committed = commitWholePartUpdates(this.context, "permission-range-update", { [range.partUri]: encodeXml(nextXml) }, { expectedRevision: expectedRevisionFrom(input, options), storyIds: [range.storyId] });
     if (!committed.ok)
       return { success: false, failure: { code: committed.code, message: committed.message } };
     return { success: true, range: this.get({ id: input.id }) };
   }
-  readDocumentXml() {
-    const xml = readPartXml(this.context, DOCUMENT_PART_URI5);
+  findByIdOrThrow(id) {
+    const matches = listPermissionRanges(this.context).filter((entry) => entry.id === id);
+    if (matches.length === 0)
+      throw operationError("TARGET_NOT_FOUND", `permission range ${id} not found.`);
+    if (matches.length > 1) {
+      throw operationError("AMBIGUOUS_MATCH", `permission range id "${id}" exists in more than one part.`);
+    }
+    const [match] = matches;
+    if (match.malformed) {
+      throw operationError("AMBIGUOUS_MATCH", `permission range id "${id}" has duplicated markers within its part and cannot be resolved unambiguously.`);
+    }
+    return match;
+  }
+  readPartXmlOrThrow(partUri) {
+    const xml = readPartXml(this.context, partUri);
     if (!xml)
-      throw operationError("PRECONDITION_FAILED", "document.xml bytes are unavailable.");
+      throw operationError("PRECONDITION_FAILED", `${partUri} bytes are unavailable.`);
     return xml;
   }
+  guardCollaborativeSecondaryStory(range) {
+    if (range.story && this.context.isCollaborativeSession()) {
+      throw operationError("CAPABILITY_UNAVAILABLE", COLLABORATIVE_SECONDARY_STORY_MESSAGE);
+    }
+  }
 }
 function listPermissionRanges(context) {
-  const xml = readPartXml(context, DOCUMENT_PART_URI5);
-  if (!xml)
-    return [];
+  const out = [];
+  for (const source of listStoryPartSources(context)) {
+    const xml = readPartXml(context, source.partUri);
+    if (!xml)
+      continue;
+    out.push(...parsePermissionRangesFromXml(xml, source));
+  }
+  return out.sort((a, b) => a.partUri === b.partUri ? a.startTagStart - b.startTagStart : a.partUri.localeCompare(b.partUri));
+}
+function listPermissionRangeRawIds(context) {
+  const ids = new Set;
+  const markerRe = /<w:perm(?:Start|End)\b[^>]*\/>/g;
+  for (const source of listStoryPartSources(context)) {
+    const xml = readPartXml(context, source.partUri);
+    if (!xml)
+      continue;
+    for (let match = markerRe.exec(xml);match; match = markerRe.exec(xml)) {
+      const id = attrValue(match[0], "id");
+      if (id)
+        ids.add(id);
+    }
+  }
+  return ids;
+}
+function parsePermissionRangesFromXml(xml, source) {
   const starts = new Map;
+  const duplicateStartIds = new Set;
   const startRe = /<w:permStart\b[^>]*\/>/g;
   for (let match = startRe.exec(xml);match; match = startRe.exec(xml)) {
     const id = attrValue(match[0], "id");
-    if (id)
-      starts.set(id, { start: match.index, end: startRe.lastIndex, tag: match[0] });
+    if (!id)
+      continue;
+    if (starts.has(id))
+      duplicateStartIds.add(id);
+    starts.set(id, { start: match.index, end: startRe.lastIndex, tag: match[0] });
   }
   const out = [];
   const endRe = /<w:permEnd\b[^>]*\/>/g;
@@ -328438,21 +328718,23 @@ function listPermissionRanges(context) {
     if (!start)
       continue;
     const positions = positionsForMarkerEnvelope(xml, start.start, match.index);
-    const startPos = positions.start;
-    const endPos = positions.end;
     out.push({
       id,
       principal: principalFromPermStart(start.tag),
-      kind: startPos.blockId === endPos.blockId ? "inline" : "block",
-      start: startPos,
-      end: endPos,
+      kind: positions.start.blockId === positions.end.blockId ? "inline" : "block",
+      start: positions.start,
+      end: positions.end,
+      partUri: source.partUri,
+      storyId: source.storyId,
+      malformed: duplicateStartIds.has(id),
+      ...source.story ? { story: source.story } : {},
       startTagStart: start.start,
       startTagEnd: start.end,
       endTagStart: match.index,
       endTagEnd: endRe.lastIndex
     });
   }
-  return out.sort((a, b) => a.startTagStart - b.startTagStart);
+  return out;
 }
 function findContentControlXmlRange(xml, id) {
   const parsed = collectXmlElementRanges(xml);
@@ -328500,7 +328782,8 @@ function stripInternal2(range) {
     principal: range.principal,
     kind: range.kind,
     start: range.start,
-    end: range.end
+    end: range.end,
+    ...range.story ? { story: range.story } : {}
   };
 }
 function principalFromPermStart(tag) {
@@ -328520,9 +328803,9 @@ function buildPermEnd(id) {
 }
 function wrapTextRangeWithPermissionMarkers(paragraphXml, start, end, id, principal) {
   return replaceTextRangeInParagraph(paragraphXml, start, end, (selected) => [
-    `<w:r>${buildPermStart(id, principal)}</w:r>`,
+    buildPermStart(id, principal),
     `<w:r><w:t>${xmlEscapeText(selected)}</w:t></w:r>`,
-    `<w:r>${buildPermEnd(id)}</w:r>`
+    buildPermEnd(id)
   ].join(""));
 }
 function positionForXmlIndex(documentXml, index2) {
@@ -328578,10 +328861,13 @@ function replaceTextRangeInParagraph(paragraphXml, start, end, replacement) {
 }
 function removeMarkerAt(xml, start, end) {
   const runStart = findEnclosingRunStart(xml, start);
-  const runEnd = xml.indexOf("</w:r>", end);
-  if (runStart >= 0 && runEnd >= end) {
-    const runXml = xml.slice(runStart, runEnd + "</w:r>".length);
-    if (/^<w:r\b[^>]*>\s*<w:perm(?:Start|End)\b[^>]*\/>\s*<\/w:r>$/.test(runXml)) {
+  if (runStart >= 0) {
+    const { runOpenTag, runProperties } = readRunOpenTagAndProperties(xml, runStart);
+    const runContentStart = runStart + runOpenTag.length + runProperties.length;
+    const runEnd = xml.indexOf("</w:r>", end);
+    const beforeMarker = xml.slice(runContentStart, start);
+    const afterMarker = runEnd >= end ? xml.slice(end, runEnd) : null;
+    if (afterMarker !== null && /^\s*$/.test(beforeMarker) && /^\s*$/.test(afterMarker)) {
       return replaceRange2(xml, runStart, runEnd + "</w:r>".length, "");
     }
   }
@@ -328597,14 +328883,19 @@ function extractText2(xml) {
     out += decodeXmlEntities(match[1]);
   return out;
 }
-function allocateRangeId(existing) {
-  const max2 = existing.reduce((acc, range) => Math.max(acc, Number(range.id) || 0), 1000);
+function allocateRangeId(existingIds) {
+  let max2 = 1000;
+  for (const id of existingIds)
+    max2 = Math.max(max2, Number(id) || 0);
   return String(max2 + 1 + Math.floor(Math.random() * 1000));
 }
+var COLLABORATIVE_SECONDARY_STORY_MESSAGE = "permission ranges in header/footer stories are not supported in collaborative sessions.";
 var init_adapter6 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
   init_visible_text();
+  init_selection_target();
+  init_story_surface();
   init_shared();
   init_xml();
 });
@@ -328793,9 +329084,9 @@ var init_adapter7 = __esm(() => {
 function documentProtectionAllowsXmlRange(context, partUri, start, end) {
   if (!new V2ProtectionAdapter(context).get().editingRestriction.runtimeEnforced)
     return true;
-  if (partUri !== DOCUMENT_PART_URI5 || start < 0 || end < start)
+  if (start < 0 || end < start)
     return false;
-  return listPermissionRanges(context).some((range) => range.principal.kind === "everyone" && range.startTagEnd <= start && end <= range.endTagStart);
+  return listPermissionRanges(context).some((range) => range.partUri === partUri && !range.malformed && range.principal.kind === "everyone" && range.startTagEnd <= start && end <= range.endTagStart);
 }
 function requireDocumentProtectionXmlRange(context, partUri, start, end) {
   if (!documentProtectionAllowsXmlRange(context, partUri, start, end)) {
@@ -328820,7 +329111,6 @@ var DOCUMENT_PROTECTION_MESSAGE = "document protection permits edits only within
 var init_mutation_guard = __esm(() => {
   init_shared();
   init_adapter6();
-  init_xml();
   init_adapter7();
 });
 
@@ -329557,107 +329847,6 @@ var init_v2_search_ref = __esm(() => {
   init_textbox_story();
 });
 
-// ../../../v2/document-api-v2-adapter/dist/address/story-surface.js
-function resolveStorySurface(session, bodyStoryId, locator) {
-  const resolved = resolveSessionStoryLocator(session, bodyStoryId, locator);
-  if ("error" in resolved) {
-    return { ok: false, failure: classifyStoryLocatorFailure(resolved.error) };
-  }
-  return { ok: true, descriptor: toStorySurfaceDescriptor(resolved) };
-}
-function toStorySurfaceDescriptor(resolved) {
-  const descriptor = {
-    storyId: resolved.storyId,
-    partUri: resolved.partUri,
-    storyKind: resolved.storyKind,
-    relationshipOwnerPartUri: resolved.relationshipOwnerPartUri,
-    sourceAvailability: resolved.materialization ? "materialize-on-write" : "available"
-  };
-  if (resolved.storyByteRange)
-    descriptor.storyByteRange = resolved.storyByteRange;
-  if (resolved.refId)
-    descriptor.refId = resolved.refId;
-  if (resolved.noteId)
-    descriptor.noteId = resolved.noteId;
-  if (resolved.textboxId)
-    descriptor.textboxId = resolved.textboxId;
-  if (resolved.materialization)
-    descriptor.materialization = resolved.materialization;
-  if (resolved.slot)
-    descriptor.slot = resolved.slot;
-  if (resolved.resolvedFromSectionId)
-    descriptor.resolvedFromSectionId = resolved.resolvedFromSectionId;
-  return descriptor;
-}
-function classifyStoryLocatorFailure(error48) {
-  return {
-    category: storyLocatorFailureCategory(error48),
-    reason: error48,
-    message: storyLocatorFailureMessage(error48)
-  };
-}
-function receiptFailureForStoryLocatorError(error48) {
-  const failure5 = classifyStoryLocatorFailure(error48);
-  return {
-    code: failure5.category,
-    message: failure5.message
-  };
-}
-function storyLocatorFailureCategory(error48) {
-  switch (error48) {
-    case "not-found":
-    case "unknown-section":
-    case "no-sections":
-      return "TARGET_NOT_FOUND";
-    case "unsupported-story":
-    case "inherited-edit-rejected":
-    case "cross-story-write-rejected":
-      return "CAPABILITY_UNAVAILABLE";
-    case "no-source-for-edit":
-      return "PRECONDITION_FAILED";
-    default: {
-      const _exhaustive = error48;
-      return _exhaustive;
-    }
-  }
-}
-function storyLocatorFailureMessage(error48) {
-  switch (error48) {
-    case "not-found":
-      return "the requested story target was not found";
-    case "unknown-section":
-      return "the requested section is not part of this document";
-    case "no-sections":
-      return "the document has no resolvable sections for this story";
-    case "unsupported-story":
-      return "this story family is not supported for the requested operation";
-    case "inherited-edit-rejected":
-      return "the header/footer slot is inherited and cannot be edited under the requested write policy";
-    case "cross-story-write-rejected":
-      return "the requested write would cross story boundaries";
-    case "no-source-for-edit":
-      return "the requested story has no source bytes available for this edit";
-    default:
-      return "the requested story could not be resolved";
-  }
-}
-function rangeWithinStorySurface(descriptor, range) {
-  const window2 = descriptor.storyByteRange;
-  if (!window2)
-    return null;
-  if (range.start >= window2[0] && range.end <= window2[1] && range.start <= range.end) {
-    return null;
-  }
-  return {
-    category: "INVALID_CONTEXT",
-    reason: null,
-    message: `byte range [${range.start}, ${range.end}] falls outside the resolved story window ` + `[${window2[0]}, ${window2[1]}] for story ${descriptor.storyId}`
-  };
-}
-var init_story_surface = __esm(() => {
-  init_story_locator();
-});
-
 // ../../../v2/document-api-v2-adapter/dist/address/raw-block-ref.js
 function resolveRawBlockRefTarget(context, ref5, scope) {
   if (scope) {
@@ -331245,14 +331434,14 @@ var init_effective_inline_uniformity = __esm(() => {
 });
 
 // ../../../v2/document-api-v2-adapter/dist/selection-mutation/adapter.js
-function selectionIsAllowedByDocumentProtection(context, target, index2) {
+function selectionIsAllowedByDocumentProtection(context, target, index2, storyId) {
   const protection = new V2ProtectionAdapter(context).get().editingRestriction;
   if (!protection.runtimeEnforced)
     return true;
   const { start, end } = target;
   if (start.kind !== "text" || end.kind !== "text")
     return false;
-  return listPermissionRanges(context).some((range) => range.principal.kind === "everyone" && textPointIsWithinPermissionRange(start, range, index2) && textPointIsWithinPermissionRange(end, range, index2));
+  return listPermissionRanges(context).some((range) => range.storyId === storyId && !range.malformed && range.principal.kind === "everyone" && textPointIsWithinPermissionRange(start, range, index2) && textPointIsWithinPermissionRange(end, range, index2));
 }
 function textPointIsWithinPermissionRange(point3, range, index2) {
   const pointEntry = index2.byParaId(point3.blockId);
@@ -331276,7 +331465,7 @@ function resolvedTextRangeIsAllowedByDocumentProtection(context, range) {
     kind: "selection",
     start: { kind: "text", blockId: range.startBlockId, offset: range.startOffset },
     end: { kind: "text", blockId: range.endBlockId, offset: range.endOffset }
-  }, index2);
+  }, index2, range.storyId);
 }
 
 class V2SelectionMutationAdapter {
@@ -331568,7 +331757,7 @@ class V2SelectionMutationAdapter {
       return failureWithoutResolution("PRECONDITION_FAILED", "paragraph index is not available.");
     }
     const storyResolveMs = nowMs6() - storyResolveStartedAt;
-    if (!selectionIsAllowedByDocumentProtection(this.context, target, index2)) {
+    if (!selectionIsAllowedByDocumentProtection(this.context, target, index2, story.storyId)) {
       return failureWithoutResolution("PERMISSION_DENIED", PERMISSION_DENIED_DOC_PROTECTION);
     }
     if ((options?.changeMode ?? "direct") === "tracked" && story.storyKind === "main") {
@@ -332298,7 +332487,7 @@ class V2SelectionMutationAdapter {
       resolved: outcome.resolved
     });
     const index2 = isMainStoryId(outcome.resolved.storyId) ? getSDDocumentSessionInternalParagraphIndex(this.context.session) : getSDDocumentSessionInternalStoryParagraphIndex(this.context.session, outcome.resolved.storyId);
-    if (index2 && !selectionIsAllowedByDocumentProtection(this.context, outcome.selectionTarget, index2)) {
+    if (index2 && !selectionIsAllowedByDocumentProtection(this.context, outcome.selectionTarget, index2, outcome.resolved.storyId)) {
       return {
         success: false,
         failure: {
@@ -332333,7 +332522,7 @@ class V2SelectionMutationAdapter {
     if (!index2) {
       return failureWithoutResolution("PRECONDITION_FAILED", "paragraph index is not available.");
     }
-    if (!selectionIsAllowedByDocumentProtection(this.context, destination, index2)) {
+    if (!selectionIsAllowedByDocumentProtection(this.context, destination, index2, story.storyId)) {
       return failureWithoutResolution("PERMISSION_DENIED", PERMISSION_DENIED_DOC_PROTECTION);
     }
     const offsetSpace = selectionOffsetSpace(options);
@@ -332478,7 +332667,7 @@ class V2SelectionMutationAdapter {
     if (!index2) {
       return failureWithoutResolution("PRECONDITION_FAILED", "paragraph index is not available.");
     }
-    if (!selectionIsAllowedByDocumentProtection(this.context, target, index2)) {
+    if (!selectionIsAllowedByDocumentProtection(this.context, target, index2, story.storyId)) {
       return failureWithoutResolution("PERMISSION_DENIED", PERMISSION_DENIED_DOC_PROTECTION);
     }
     const offsetSpace = selectionOffsetSpace(options);
@@ -332905,7 +333094,7 @@ class V2SelectionMutationAdapter {
     if (!index2 || index2.entries.length === 0) {
       return failureWithoutResolution("PRECONDITION_FAILED", "paragraph index is not available.");
     }
-    if (!selectionIsAllowedByDocumentProtection(this.context, target, index2)) {
+    if (!selectionIsAllowedByDocumentProtection(this.context, target, index2, story.storyId)) {
       return failureWithoutResolution("PERMISSION_DENIED", "document protection permits edits only within an everyone permission range.");
     }
     const startEntry = index2.byParaId(target.start.blockId);
@@ -333252,17 +333441,6 @@ function buildInsertedTextEffect(input) {
     insertedText: [{ kind: "insertedText", target, selectionTarget, text: input.text }]
   };
 }
-function pickStoryLocator(target, override) {
-  if (override)
-    return override;
-  if (target.story)
-    return target.story;
-  if (target.start.kind === "text" && target.start.story)
-    return target.start.story;
-  if (target.end.kind === "text" && target.end.story)
-    return target.end.story;
-  return;
-}
 function selectionOffsetSpace(options) {
   const offsetSpace = options?.offsetSpace;
   return offsetSpace === "selection" || offsetSpace === "kernel" ? offsetSpace : undefined;
@@ -422668,6 +422846,15 @@ function nextSeededBlockId(shardId, paragraphIndex, reason) {
   return `sd-${shardToken}-${reason}-${ordinal}`;
 }
 function seedStoryShard(input) {
+  const target = input.doc;
+  const doc2 = "rootDoc" in target ? target.rootDoc : ("doc" in target) ? target.doc : target;
+  let result;
+  doc2.transact(() => {
+    result = seedStoryShardInTransaction(input);
+  }, "story-shard:seed");
+  return result;
+}
+function seedStoryShardInTransaction(input) {
   const { shardId, storyId, storyKind, sourcePartUri, paragraphs } = input;
   const editable = input.editable ?? STORY_EDITABLE.get(storyKind) ?? false;
   const scope = resolveStoryShardScope(input.doc);
@@ -448986,6 +449173,12 @@ async function openV2CollaborativeDocumentSession(options) {
         contentUnitIds: Array.from(canonical.contentUnitIds)
       });
       if (!finalized.committed) {
+        if (finalized.classification === ROOM_CLASSIFICATION.v2Committed && options.runtime.validateLateJoin({
+          compatibility: { supports: COLLAB_V2_ROOM_SCHEMA_VERSION },
+          readiness: READINESS_CLASS.bodyEditable
+        }).ok) {
+          throw new CollabV2DiagnosticError(COLLAB_V2_DIAGNOSTICS.COLLAB_V2_ROOM_ALREADY_EXISTS, "another creator committed this v2 collaboration room during open; reopen with join", { rootId: options.runtime.rootId });
+        }
         if (finalized.diagnostics.some((diagnostic2) => diagnostic2.code === COLLAB_V2_DIAGNOSTICS.COLLAB_V2_BOOTSTRAP_CLAIM_LOST)) {
           throw new CollabV2DiagnosticError(COLLAB_V2_DIAGNOSTICS.COLLAB_V2_ROOM_INITIALIZING, "another creator is initializing this v2 collaboration room", { rootId: options.runtime.rootId });
         }