dsh-doc-assistant 0.1.14 → 0.1.18

package/src/host/office_tool.py

@@ -41,6 +41,8 @@ W_BODY = f'{{{W}}}body'
 W_PPR = f'{{{W}}}pPr'
 W_RPR = f'{{{W}}}rPr'
 W_SECT = f'{{{W}}}sectPr'
+DSH_BREAK_RSID = 'D5A00001'
+DSH_MERGED_RSID = 'D5A00002'
 MC_FALLBACK = f'{{{MC}}}Fallback'
 A_T = f'{{{A}}}t'
 
@@ -53,6 +55,9 @@ AUTHOR = '文档助手'
 
 class ToolError(Exception):
     """Chinese, user-facing, no traceback."""
+    def __init__(self, message, code=None):
+        super().__init__(message)
+        self.code = code
 
 
 def local(tag):
@@ -154,11 +159,17 @@ def repack(src_path, dest_path, updates):
 
 def visible_text(paragraph):
     parts = []
-    for el in paragraph.iter(W_T):
+    for el in paragraph.iter():
         if in_fallback(el) or ancestor_is(el, W_DEL) or ancestor_is(el, qn(W, 'moveFrom')):
             continue
-        if el.text:
+        if el.tag == W_T and el.text:
             parts.append(el.text)
+        elif el.tag == qn(W, 'br'):
+            run = el.getparent()
+            # Existing soft breaks retain the legacy offset space. Only new
+            # plugin insertion runs opt into preserving real line breaks.
+            if run is not None and run.tag == qn(W, 'r') and run.get(qn(W, 'rsidR')) == DSH_BREAK_RSID:
+                parts.append('\n')
     return ''.join(parts)
 
 
@@ -222,7 +233,7 @@ def core_title(zf):
     return (el.text or '').strip() if el is not None else ''
 
 
-def table_rows(tbl, para_of):
+def table_rows(tbl, para_of, layout_styles=None):
     rows = []
     truncated = False
     reason = ''
@@ -245,7 +256,7 @@ def table_rows(tbl, para_of):
                 text = visible_text(paragraph)
                 if text:
                     texts.append(text)
-                    paragraphs.append({'text': text, 'para': para_of[id(paragraph)]})
+                    paragraphs.append({'text': text, 'para': para_of[id(paragraph)], 'wordLayout': word_paragraph_layout(paragraph, layout_styles)})
             cells.append({'text': '\n'.join(texts), 'paragraphs': paragraphs})
         rows.append({'cells': cells})
     return rows, truncated, reason
@@ -259,6 +270,7 @@ def extract_docx(path):
             raise ToolError('这个文件不是有效的 Word 文档（缺少正文）') from error
         root = etree.fromstring(xml)
         styles = heading_styles(zf)
+        layout_styles = word_layout_styles(zf)
         title = core_title(zf)
         paragraphs = all_paragraphs(root)
         para_of = {id(p): index for index, p in enumerate(paragraphs)}
@@ -294,13 +306,14 @@ def extract_docx(path):
                         'type': 'heading' if level else 'para',
                         'text': text,
                         'para': para_of.get(id(child), 0),
+                        'wordLayout': word_paragraph_layout(child, layout_styles),
                     }
                     if level:
                         block['level'] = level
                     if not emit(block):
                         return
                 elif child.tag == W_TBL:
-                    rows, row_cut, row_reason = table_rows(child, para_of)
+                    rows, row_cut, row_reason = table_rows(child, para_of, layout_styles)
                     if row_cut and row_reason:
                         truncated = True
                         reasons.append(row_reason)
@@ -334,6 +347,157 @@ def first_rpr(paragraph):
     return None
 
 
+def word_layout_styles(zf):
+    try:
+        root = etree.fromstring(zf.read('word/styles.xml'))
+    except KeyError:
+        return {}
+    return {style.get(qn(W, 'styleId')): style for style in root.findall(qn(W, 'style'))}
+
+
+def effective_paragraph_property(paragraph, name, styles=None):
+    ppr = paragraph.find(W_PPR)
+    node = ppr.find(qn(W, name)) if ppr is not None else None
+    if node is not None:
+        return node
+    sid = ppr.find(qn(W, 'pStyle')) if ppr is not None else None
+    style_id = sid.get(qn(W, 'val')) if sid is not None else None
+    if style_id is None:
+        style_id = next((sid for sid, style in (styles or {}).items()
+                         if style.get(qn(W, 'type')) == 'paragraph' and style.get(qn(W, 'default')) in ('1', 'true', 'on')), None)
+    seen = set()
+    while style_id and style_id not in seen:
+        seen.add(style_id)
+        style = (styles or {}).get(style_id)
+        if style is None:
+            break
+        properties = style.find(W_PPR)
+        node = properties.find(qn(W, name)) if properties is not None else None
+        if node is not None:
+            return node
+        base = style.find(qn(W, 'basedOn'))
+        style_id = base.get(qn(W, 'val')) if base is not None else None
+    return None
+
+
+def effective_run_property(paragraph, run, name, styles=None):
+    rpr = run.find(W_RPR)
+    direct = rpr.find(qn(W, name)) if rpr is not None else None
+    if direct is not None:
+        return direct
+    run_style = rpr.find(qn(W, 'rStyle')) if rpr is not None else None
+    ppr = paragraph.find(W_PPR)
+    pstyle = ppr.find(qn(W, 'pStyle')) if ppr is not None else None
+    default = next((sid for sid, style in (styles or {}).items()
+                    if style.get(qn(W, 'type')) == 'paragraph' and style.get(qn(W, 'default')) in ('1', 'true', 'on')), None)
+    for initial in (run_style.get(qn(W, 'val')) if run_style is not None else None,
+                    pstyle.get(qn(W, 'val')) if pstyle is not None else default):
+        sid, seen = initial, set()
+        while sid and sid not in seen:
+            seen.add(sid)
+            style = (styles or {}).get(sid)
+            if style is None:
+                break
+            properties = style.find(W_RPR)
+            node = properties.find(qn(W, name)) if properties is not None else None
+            if node is not None:
+                return node
+            base = style.find(qn(W, 'basedOn'))
+            sid = base.get(qn(W, 'val')) if base is not None else None
+    return None
+
+
+def word_paragraph_layout(paragraph, styles=None):
+    """Describe layout constraints; the writer independently rechecks XML."""
+    ppr = paragraph.find(W_PPR)
+    frame = effective_paragraph_property(paragraph, 'framePr', styles)
+    spacing = effective_paragraph_property(paragraph, 'spacing', styles)
+    names = {local(node.tag) for node in paragraph.iter() if isinstance(node.tag, str)}
+    text_box = 'txbxContent' in names or ancestor_is(paragraph, qn(W, 'txbxContent'))
+    objects = sorted(names.intersection({'drawing', 'pict', 'object', 'fldChar', 'fldSimple', 'hyperlink', 'footnoteReference', 'endnoteReference'}))
+    floating = []
+    wp = 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing'
+    for anchor in paragraph.iter(qn(wp, 'anchor')):
+        floating.append({'kind': 'drawing', 'foreground': anchor.get('behindDoc') not in ('1', 'true', 'on')})
+    for shape in paragraph.iter('{urn:schemas-microsoft-com:vml}shape'):
+        props = dict((item.split(':', 1)[0].strip().lower(), item.split(':', 1)[1].strip())
+                     for item in (shape.get('style') or '').split(';') if ':' in item)
+        if props.get('position') == 'absolute':
+            floating.append({'kind': 'vml', 'foreground': not props.get('z-index', '').startswith('-')})
+    row = paragraph.getparent()
+    while row is not None and row.tag != qn(W, 'tr'):
+        row = row.getparent()
+    row_pr = row.find(qn(W, 'trPr')) if row is not None else None
+    height = row_pr.find(qn(W, 'trHeight')) if row_pr is not None else None
+    table = paragraph.getparent()
+    while table is not None and table.tag != W_TBL:
+        table = table.getparent()
+    table_pr = table.find(qn(W, 'tblPr')) if table is not None else None
+    floating_table = table_pr.find(qn(W, 'tblpPr')) if table_pr is not None else None
+    page_width, margin_left = 12240, 1440
+    owner = paragraph
+    while owner.getparent() is not None and owner.getparent().tag != W_BODY:
+        owner = owner.getparent()
+    body = owner.getparent()
+    if body is not None and body.tag == W_BODY:
+        following = list(body)[list(body).index(owner):]
+        section = next((child if child.tag == W_SECT else child.find('./' + W_PPR + '/' + W_SECT)
+                        for child in following if child.tag == W_SECT or child.find('./' + W_PPR + '/' + W_SECT) is not None), None)
+        if section is not None:
+            size, margins = section.find(qn(W, 'pgSz')), section.find(qn(W, 'pgMar'))
+            if size is not None:
+                page_width = int(size.get(qn(W, 'w')) or page_width)
+            if margins is not None:
+                margin_left = int(margins.get(qn(W, 'left')) or 0)
+    return {'version': 1, 'mode': 'fixed' if frame is not None or text_box or floating_table is not None else 'flow',
+            **({'frame': {local(k): v for k, v in frame.attrib.items()}} if frame is not None else {}),
+            **({'pageWidthTwips': page_width, 'marginLeftTwips': margin_left} if frame is not None else {}),
+            **({'lineRule': spacing.get(qn(W, 'lineRule')), 'lineTwips': spacing.get(qn(W, 'line'))} if spacing is not None else {}),
+            **({'rowHeight': {local(k): v for k, v in height.attrib.items()}} if height is not None else {}),
+            **({'textBox': True} if text_box else {}), **({'objects': objects} if objects else {}),
+            **({'floatingObjects': floating} if floating else {}),
+            **({'floatingTable': {local(k): value for k, value in floating_table.attrib.items()}} if floating_table is not None else {}),
+            **({'sectionBreak': True} if ppr is not None and ppr.find(W_SECT) is not None else {})}
+
+
+def protect_word_layout(paragraphs, locations, styles=None):
+    """Permit flow to grow, preserving widths; never flatten opaque objects."""
+    for location in locations:
+        for para, *_ in location['segments']:
+            paragraph = paragraphs[para]
+            layout = word_paragraph_layout(paragraph, styles)
+            if layout.get('textBox') or layout.get('objects'):
+                raise ToolError('这段文字与图片、文本框、链接或复杂域位于同一段，无法安全写回。修订尚未写入。请点击文档标题右侧的 Office 图标，手动打开文档调整排版。',
+                                'WORD_LAYOUT_UNSUPPORTED')
+            ppr = paragraph.find(W_PPR)
+            if ppr is not None and ppr.find(W_SECT) is not None and location['compound']:
+                raise ToolError('选区跨越分节或分栏边界，无法合并写回；请在同一正文区域内选择')
+            # Fixed frames are left exactly as they are. The host renders both
+            # temporary versions and checks them before publication.
+            if layout['mode'] != 'flow':
+                continue
+            inherited = effective_paragraph_property(paragraph, 'spacing', styles)
+            if inherited is not None and inherited.get(qn(W, 'lineRule')) == 'exact':
+                if ppr is None:
+                    ppr = etree.Element(W_PPR)
+                    paragraph.insert(0, ppr)
+                spacing = ppr.find(qn(W, 'spacing'))
+                if spacing is None:
+                    spacing = deepcopy(inherited)
+                    ppr.append(spacing)
+                spacing.set(qn(W, 'lineRule'), 'atLeast')
+            row = paragraph.getparent()
+            while row is not None and row.tag != qn(W, 'tr'):
+                row = row.getparent()
+            row_pr = row.find(qn(W, 'trPr')) if row is not None else None
+            if row_pr is not None:
+                for height in row_pr.findall(qn(W, 'trHeight')):
+                    if height.get(qn(W, 'hRule')) == 'exact':
+                        height.set(qn(W, 'hRule'), 'atLeast')
+                for lock in row_pr.findall(qn(W, 'cantSplit')):
+                    row_pr.remove(lock)
+
+
 def add_text_run(parent, tag_text, text, rpr, kind, rev_id):
     """Append plain / ins / del content. Empty text appends nothing."""
     if text == '':
@@ -353,8 +517,14 @@ def add_text_run(parent, tag_text, text, rpr, kind, rev_id):
     run = etree.SubElement(host, qn(W, 'r'))
     if rpr is not None:
         run.append(deepcopy(rpr))
-    node = etree.SubElement(run, qn(W, tag_text))
-    set_space(node, text)
+    if '\n' in text:
+        run.set(qn(W, 'rsidR'), DSH_BREAK_RSID)
+    for index, piece in enumerate(text.split('\n')):
+        if index:
+            etree.SubElement(run, qn(W, 'br'))
+        if piece:
+            node = etree.SubElement(run, qn(W, tag_text))
+            set_space(node, piece)
 
 
 def utf16_position(text, offset):
@@ -388,16 +558,22 @@ def rewrite_paragraph(paragraph, original, revised, rev_id, anchor):
         if text.find(original, at + 1) >= 0:
             raise ToolError('原文在同一段里出现了多次，无法确定要改哪一处')
         end = at + len(original)
-    before, after = text[:at], text[end:]
+    before = styled_text_slice(paragraph, 0, at)
+    after = styled_text_slice(paragraph, end, len(text))
+    selected = styled_text_slice(paragraph, at, end)
+    inserted = revised_body_runs(selected, revised)
     ppr = paragraph.find(W_PPR)
-    rpr = first_rpr(paragraph)
     for child in list(paragraph):
         if child is not ppr:
             paragraph.remove(child)
-    add_text_run(paragraph, 't', before, rpr, 'plain', rev_id)
-    add_text_run(paragraph, 'delText', original, rpr, 'del', rev_id)
-    add_text_run(paragraph, 't', revised, rpr, 'ins', rev_id + 1)
-    add_text_run(paragraph, 't', after, rpr, 'plain', rev_id)
+    for content, style in before:
+        add_text_run(paragraph, 't', content, style, 'plain', rev_id)
+    for content, style in selected:
+        add_text_run(paragraph, 'delText', content, style, 'del', rev_id)
+    for content, style in inserted:
+        add_text_run(paragraph, 't', content, style, 'ins', rev_id + 1)
+    for content, style in after:
+        add_text_run(paragraph, 't', content, style, 'plain', rev_id)
 
 
 def locate_paragraph(paragraphs, revision):
@@ -435,6 +611,240 @@ def enable_track_revisions(zf):
     return None
 
 
+def word_source_positions(root):
+    """The same block/cell joins as DocIR, with actual physical paragraph ids."""
+    paragraphs = all_paragraphs(root)
+    para_of = {id(p): index for index, p in enumerate(paragraphs)}
+    blocks = []
+
+    def walk(parent):
+        for child in parent:
+            if child.tag == MC_FALLBACK or in_fallback(child):
+                continue
+            if child.tag == W_P:
+                text = visible_text(child)
+                if text:
+                    blocks.append((text, [(para_of[id(child)], 0, len(text))]))
+            elif child.tag == W_TBL:
+                rows, positions, cursor = [], [], 0
+                for row_index, tr in enumerate(child.findall(qn(W, 'tr'))):
+                    if row_index:
+                        cursor += 1
+                    cells = []
+                    for cell_index, tc in enumerate(tr.findall(qn(W, 'tc'))):
+                        if cell_index:
+                            cursor += 3
+                        texts = []
+                        for p in tc.iter(W_P):
+                            if in_fallback(p):
+                                continue
+                            text = visible_text(p)
+                            if not text:
+                                continue
+                            if texts:
+                                cursor += 1
+                            positions.append((para_of[id(p)], cursor, cursor + len(text)))
+                            texts.append(text)
+                            cursor += len(text)
+                        cells.append('\n'.join(texts))
+                    rows.append(cells)
+                text = '\n'.join(' | '.join(cells) for cells in rows) if any(any(cells) for cells in rows) else ''
+                blocks.append((text, positions))
+            elif child.tag != W_SECT:
+                walk(child)
+
+    body = root.find(W_BODY)
+    if body is None:
+        raise ToolError('Word 文档缺少正文')
+    walk(body)
+    source, positions, cursor = [], {}, 0
+    for text, spans in blocks:
+        for para, start, end in spans:
+            positions[para] = (cursor + start, cursor + end)
+        source.append(text)
+        cursor += len(text) + 1
+    return '\n'.join(source), positions
+
+
+def word_revision_location(paragraphs, revision, source, positions):
+    """Preflight all source slices before any paragraph is rewritten."""
+    anchor = revision.get('anchor') or {}
+    segments = anchor.get('segments')
+    if not isinstance(segments, list):
+        paragraph = locate_paragraph(paragraphs, revision)
+        para = paragraphs.index(paragraph)
+        text = visible_text(paragraph)
+        original = str(revision.get('original') or '')
+        start, end = paragraph_span(text, anchor, original) if 'paraStart' in anchor else (text.index(original), text.index(original) + len(original))
+        if para not in positions:
+            raise ToolError('选区无法定位到 Word 正文')
+        return {'revision': revision, 'segments': [(para, start, end, original)],
+                'start': positions[para][0] + start, 'end': positions[para][0] + end, 'compound': False}
+    if not segments or len(segments) > 256:
+        raise ToolError('Word 复合选区段落数量不正确')
+    spans, originals, previous = [], [], -1
+    for segment in segments:
+        para = segment.get('para')
+        if type(para) is not int or not 0 <= para < len(paragraphs) or para not in positions:
+            raise ToolError('复合选区的段落位置已经变化')
+        text = visible_text(paragraphs[para])
+        start = utf16_position(text, segment.get('paraStart'))
+        end = utf16_position(text, segment.get('paraEnd'))
+        if start is None or end is None or end <= start:
+            raise ToolError('复合选区的字符位置不正确')
+        original = text[start:end]
+        if 'original' in segment and segment['original'] != original:
+            raise ToolError('复合选区原文已经变化，请重新选择')
+        first, last = positions[para][0] + start, positions[para][0] + end
+        if first < previous or (previous >= 0 and source[previous:first].strip()):
+            raise ToolError('复合选区重叠或包含未选中的正文')
+        if utf16_position(source, segment.get('srcStart')) != first or utf16_position(source, segment.get('srcEnd')) != last:
+            raise ToolError('复合选区与文档原文位置不一致')
+        spans.append((para, start, end, original))
+        originals.append(original)
+        previous = last
+    if '\n'.join(originals) != str(revision.get('original') or ''):
+        raise ToolError('复合选区没有包含全部原文，请重新选择')
+    parent = paragraphs[spans[0][0]].getparent()
+    if any(paragraphs[para].getparent() != parent for para, *_ in spans):
+        raise ToolError('选区跨越表格单元格或不同正文区域')
+    children = list(parent)
+    first_child = children.index(paragraphs[spans[0][0]])
+    last_child = children.index(paragraphs[spans[-1][0]])
+    selected = {para for para, *_ in spans}
+    for child in children[first_child:last_child + 1]:
+        if child.tag != W_P:
+            raise ToolError('选区跨越表格或非正文结构，无法合并写回')
+        if paragraphs.index(child) not in selected and visible_text(child).strip():
+            raise ToolError('选区中间有未选中的段落，无法合并写回')
+        if any(node.tag in {qn(W, name) for name in ('drawing', 'pict', 'object', 'fldChar', 'fldSimple', 'hyperlink')}
+               for node in child.iter()):
+            raise ToolError('选区所在段落包含图片、链接或复杂域，暂不支持跨段合并写回')
+    first, last = positions[spans[0][0]][0] + spans[0][1], positions[spans[-1][0]][0] + spans[-1][2]
+    if ('srcStart' in anchor and utf16_position(source, anchor['srcStart']) != first) or ('srcEnd' in anchor and utf16_position(source, anchor['srcEnd']) != last):
+        raise ToolError('复合选区完整边界不一致')
+    return {'revision': revision, 'segments': spans, 'start': first, 'end': last, 'compound': True}
+
+
+def styled_text_slice(paragraph, start, end):
+    """Retain each untouched prefix/suffix run's formatting during a merge."""
+    chunks, at = [], 0
+    for node in paragraph.iter():
+        if in_fallback(node) or ancestor_is(node, W_DEL) or ancestor_is(node, qn(W, 'moveFrom')):
+            continue
+        run = node.getparent()
+        text = node.text or '' if node.tag == W_T else ''
+        if node.tag == qn(W, 'br') and run is not None and run.get(qn(W, 'rsidR')) == DSH_BREAK_RSID:
+            text = '\n'
+        if not text:
+            continue
+        lo, hi = max(start, at), min(end, at + len(text))
+        if hi > lo:
+            while run is not None and run.tag != qn(W, 'r'):
+                run = run.getparent()
+            rpr = run.find(W_RPR) if run is not None else None
+            chunks.append((text[lo - at:hi - at], deepcopy(rpr) if rpr is not None else None))
+        at += len(text)
+    return chunks
+
+
+def body_run_style(chunks):
+    """Choose the predominant selected text style, excluding list markers."""
+    def key(node):
+        if node is None:
+            return None
+        return (node.tag, tuple(sorted(node.attrib.items())), (node.text or '').strip(),
+                tuple(sorted((key(child) for child in node), key=repr)))
+
+    weights, styles = {}, {}
+    for text, style in chunks:
+        weight = sum(not char.isspace() for char in text)
+        if not weight:
+            continue
+        identity = key(style)
+        weights[identity] = weights.get(identity, 0) + weight
+        styles.setdefault(identity, style)
+    if not weights:
+        return chunks[0][1] if chunks else None
+    return styles[max(weights, key=weights.get)]
+
+
+def revised_body_runs(chunks, revised):
+    """Preserve a common prefix's runs, then style the whole new body once."""
+    original = ''.join(text for text, _ in chunks)
+    common = 0
+    while common < min(len(original), len(revised)) and original[common] == revised[common]:
+        common += 1
+    style = body_run_style(chunks)
+    result, remaining = [], common
+    for text, old_style in chunks:
+        if not remaining:
+            break
+        piece = text[:remaining]
+        result.append((piece, old_style))
+        remaining -= len(piece)
+    if common < len(revised):
+        result.append((revised[common:], style))
+    return result
+
+
+def rewrite_word_compound(paragraphs, location, rev_id):
+    revision, spans = location['revision'], location['segments']
+    revised = str(revision.get('revised') or '')
+    marker_pattern = r'^[\s⚫•●▪◦‣⁃∙○◉◎■□◆◇◼◾⬤*\-]+$'
+    protected, count = [], 0
+    while count < len(spans) - 1:
+        para, start, end, original = spans[count]
+        text = visible_text(paragraphs[para])
+        if start != 0 or end != len(text) or not re.fullmatch(marker_pattern, text) or not text.strip():
+            break
+        protected.append(text)
+        count += 1
+    if protected:
+        prefix = '\n'.join(protected) + '\n'
+        if not revised.startswith(prefix):
+            raise ToolError('复合修订不能改动选区开头的列表标记')
+        revised = revised[len(prefix):]
+        spans = spans[count:]
+    first_para, start, _, _ = spans[0]
+    last_para, _, end, _ = spans[-1]
+    first, last = paragraphs[first_para], paragraphs[last_para]
+    parent, children = first.getparent(), list(first.getparent())
+    selected_paragraphs = children[children.index(first):children.index(last) + 1]
+    before = styled_text_slice(first, 0, start)
+    last_text = visible_text(last)
+    after = styled_text_slice(last, end, len(last_text))
+    rpr = first_rpr(first)
+    selected_styles = []
+    for index, (para, lo, hi, _) in enumerate(spans):
+        if index:
+            selected_styles.append(('\n', selected_styles[-1][1] if selected_styles else None))
+        selected_styles.extend(styled_text_slice(paragraphs[para], lo, hi))
+    inserted = revised_body_runs(selected_styles, revised)
+    old_texts = [visible_text(p) for p in selected_paragraphs]
+    old_styles = [first_rpr(p) for p in selected_paragraphs]
+    for index, paragraph in enumerate(selected_paragraphs):
+        ppr = paragraph.find(W_PPR)
+        for child in list(paragraph):
+            if child is not ppr:
+                paragraph.remove(child)
+        old = old_texts[index]
+        if index == 0:
+            for text, style in before:
+                add_text_run(paragraph, 't', text, style, 'plain', rev_id)
+            deleted = old[start:end] if first is last else old[start:]
+            add_text_run(paragraph, 'delText', deleted, rpr, 'del', rev_id)
+            for text, style in inserted:
+                add_text_run(paragraph, 't', text, style, 'ins', rev_id + 1)
+            for text, style in after:
+                # Moving the original suffix is tracked, so rejecting changes
+                # in Office restores it to its original paragraph as well.
+                add_text_run(paragraph, 't', text, style, 'plain' if first is last else 'ins', rev_id + 1)
+        else:
+            add_text_run(paragraph, 'delText', old, old_styles[index], 'del', rev_id)
+            paragraph.set(qn(W, 'rsidDel'), DSH_MERGED_RSID)
+
+
 def write_docx(path, output, revisions):
     with read_zip(path) as zf:
         try:
@@ -444,21 +854,25 @@ def write_docx(path, output, revisions):
         root = etree.fromstring(document)
         settings = enable_track_revisions(zf)
         paragraphs = all_paragraphs(root)
-        # 从后往前写，同一段里多个精确选区的原始偏移才不会移动。
-        ordered = sorted(revisions, key=lambda revision: (
-            revision.get('anchor', {}).get('srcStart', -1)
-        ), reverse=True)
-        for index, revision in enumerate(ordered):
-            # Re-scan: a previous rewrite changes text but not paragraph count.
-            paragraphs = all_paragraphs(root)
-            paragraph = locate_paragraph(paragraphs, revision)
-            rewrite_paragraph(
-                paragraph,
-                str(revision.get('original') or ''),
-                str(revision.get('revised') or ''),
-                1000 + index * 2,
-                revision.get('anchor') or {},
-            )
+        source, positions = word_source_positions(root)
+        locations = [word_revision_location(paragraphs, revision, source, positions) for revision in revisions]
+        ascending = sorted(locations, key=lambda item: item['start'])
+        if any(b['start'] < a['end'] for a, b in zip(ascending, ascending[1:])):
+            raise ToolError('修订选区重叠，只能接受同一选区的一份结果')
+        protect_word_layout(paragraphs, locations, word_layout_styles(zf))
+        expected = source
+        # From back to front: offsets of every earlier revision remain valid.
+        for index, location in enumerate(reversed(ascending)):
+            revision = location['revision']
+            expected = expected[:location['start']] + str(revision.get('revised') or '') + expected[location['end']:]
+            if location['compound']:
+                rewrite_word_compound(paragraphs, location, 1000 + index * 2)
+            else:
+                paragraph = locate_paragraph(paragraphs, revision)
+                rewrite_paragraph(paragraph, str(revision.get('original') or ''), str(revision.get('revised') or ''),
+                                  1000 + index * 2, revision.get('anchor') or {})
+        if any(location['compound'] for location in locations) and word_source_positions(root)[0] != expected:
+            raise ToolError('写回后的完整正文与修订不一致，文档未被修改')
         updates = {
             'word/document.xml': etree.tostring(
                 root, xml_declaration=True, encoding='UTF-8', standalone=True,
@@ -1117,6 +1531,14 @@ def preview_docx(req):
                         at += 1
                     parent.remove(node)
                     changed = True
+            # Only these plugin-merged empty paragraphs are omitted from the
+            # disposable preview. Original blank paragraphs remain untouched,
+            # and the source keeps every physical paragraph id for undo/bulk.
+            for paragraph in list(root.iter(W_P)):
+                parent = paragraph.getparent()
+                if parent is not None and paragraph.get(qn(W, 'rsidDel')) == DSH_MERGED_RSID and not visible_text(paragraph):
+                    parent.remove(paragraph)
+                    changed = True
             if changed:
                 updates[name] = etree.tostring(root, xml_declaration=True, encoding='UTF-8', standalone=True)
     repack(path, output, updates)
@@ -1166,7 +1588,7 @@ def main():
         else:
             result = {'ok': False, 'error': '未知的文档操作'}
     except ToolError as error:
-        result = {'ok': False, 'error': str(error)}
+        result = {'ok': False, 'error': str(error), **({'code': error.code} if error.code else {})}
     except Exception as error:
         line = str(error).strip().splitlines()
         detail = line[0][:160] if line else '未知错误'