docxdriver 0.4.0__tar.gz → 0.4.2__tar.gz

{docxdriver-0.4.0 → docxdriver-0.4.2}/Cargo.lock

@@ -416,7 +416,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-cli"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "clap",
  "docxdriver-core",
@@ -427,10 +427,11 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-core"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "hex",
  "latex2mathml",
+ "quick-xml",
  "regex-lite",
  "schemars 0.8.22",
  "serde",
@@ -444,7 +445,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-mcp"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "axum",
  "cap-std",
@@ -462,14 +463,14 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-monty-repl"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "docxdriver-core",
 ]
 
 [[package]]
 name = "docxdriver-python"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "docxdriver-core",
  "pyo3",
@@ -479,7 +480,7 @@ dependencies = [
 
 [[package]]
 name = "docxdriver-wasm"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "docxdriver-core",
  "js-sys",
@@ -1188,6 +1189,15 @@ dependencies = [
  "syn 2.0.118",
 ]
 
+[[package]]
+name = "quick-xml"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.46"

{docxdriver-0.4.0 → docxdriver-0.4.2}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/docxdriver-python"]
 
 [workspace.package]
-version = "0.4.0"
+version = "0.4.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/jhnoel/docxdriver"

{docxdriver-0.4.0 → docxdriver-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docxdriver
-Version: 0.4.0
+Version: 0.4.2
 Summary: Python SDK for the native Rust DOCX engine
 License-Expression: MIT
 Requires-Python: >=3.10

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/Cargo.toml

@@ -8,9 +8,9 @@ repository.workspace = true
 readme = "README.md"
 keywords = ["docx", "ooxml", "word", "document", "track-changes"]
 categories = ["text-processing", "parser-implementations"]
-# Library sources and the runtime template only; tests, examples and the
-# schema generator stay in the repository.
-include = ["/src/**/*.rs", "!/src/bin/**", "/assets/blank.docx", "/README.md", "/LICENSE"]
+# Library sources, the runtime template and the generated schema model
+# only; tests, examples and the schema generator stay in the repository.
+include = ["/src/**/*.rs", "!/src/bin/**", "/src/integrity/wml-model.json", "/assets/blank.docx", "/README.md", "/LICENSE"]
 
 [dependencies]
 xmloxide = { version = "0.4.3", default-features = false }
@@ -24,5 +24,6 @@ sha2 = "0.10"
 hex = "0.4"
 toml = "0.8"
 schemars = "0.8"
+quick-xml = "0.42.0"
 
 [dev-dependencies]

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/api.rs

@@ -1957,7 +1957,22 @@ fn fold_typed(
         crate::outcome::Outcome::ok("plan applied", serde_json::json!({})),
         &ctx,
     );
-    (report, out.bytes, None)
+    if out.status != crate::outcome::Status::Ok {
+        return (
+            report.clone(),
+            None,
+            Some((diag("package_write", out.summary, None), report)),
+        );
+    }
+    // Review and commit apply the same gate to the same bytes, so a plan
+    // that reviews clean commits clean.
+    if let Some(bytes) = &out.bytes {
+        if let Err(failure) = crate::integrity::gate(input, bytes) {
+            let diagnostic = diag("integrity_regression", failure.summary(), None);
+            return (report.clone(), None, Some((diagnostic, report)));
+        }
+    }
+    (report, if commit { out.bytes } else { None }, None)
 }
 /// When a selector matched nothing but matches the same paragraph as it was
 /// before the plan, name the earlier operations that changed that text:

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/comments.rs

@@ -28,7 +28,6 @@ const EXTENDED_PART: &str = "word/commentsExtended.xml";
 const IDS_PART: &str = "word/commentsIds.xml";
 const EXTENSIBLE_PART: &str = "word/commentsExtensible.xml";
 const CONTENT_TYPES_PART: &str = "[Content_Types].xml";
-const DOCUMENT_RELS_PART: &str = "word/_rels/document.xml.rels";
 
 const W15_NS: &str = "http://schemas.microsoft.com/office/word/2012/wordml";
 const W14_NS: &str = "http://schemas.microsoft.com/office/word/2010/wordml";
@@ -104,15 +103,18 @@ fn register_part(
         }
     }
 
-    // word/_rels/document.xml.rels relationship
-    let mut rels = parse_part(package, DOCUMENT_RELS_PART, "")?;
+    // The main document part's relationship.
+    let rels_part = super::document_rels_part(package);
+    let mut rels = parse_part(package, &rels_part, "")?;
     let root = rels
         .doc
         .root_element()
         .ok_or_else(|| Outcome::error("malformed document.xml.rels"))?;
     let target = part.strip_prefix("word/").unwrap_or(part);
     let exists = rels.doc.children(root).any(|child| {
-        rels.is_local(child, "Relationship") && rels.doc.attribute(child, "Target") == Some(target)
+        rels.is_local(child, "Relationship")
+            && rels.doc.attribute(child, "Target") == Some(target)
+            && rels.doc.attribute(child, "Type") == Some(rel_type)
     });
     if !exists {
         let mut max_rid = 0u64;
@@ -132,7 +134,7 @@ fn register_part(
         rels.doc.set_attribute(node, "Type", rel_type);
         rels.doc.set_attribute(node, "Target", target);
         rels.doc.append_child(root, node);
-        package.set(DOCUMENT_RELS_PART, rels.serialize());
+        package.set(&rels_part, rels.serialize());
     }
     Ok(())
 }
@@ -279,14 +281,35 @@ fn next_para_id(records: &[CommentRecord], extra_occupied: &HashSet<u64>) -> u64
     }
 }
 
-fn document_para_ids(xml: &DocxXml) -> HashSet<u64> {
-    xml.all_paragraphs()
+/// Paragraph ids in use: the in-memory document's (it may carry repaired or
+/// new ids not yet written) and every `paraId` attribute in any XML part —
+/// other comment paragraphs, headers, footers and notes. A paragraph id
+/// names one paragraph across the whole document.
+fn occupied_para_ids(package: &Package, xml: &DocxXml) -> HashSet<u64> {
+    static PARA_ID: std::sync::OnceLock<regex_lite::Regex> = std::sync::OnceLock::new();
+    let pattern = PARA_ID.get_or_init(|| {
+        regex_lite::Regex::new(r#"paraId(?:Parent)?\s*=\s*["']([0-9A-Fa-f]{8})["']"#).unwrap()
+    });
+    let mut occupied: HashSet<u64> = xml
+        .all_paragraphs()
         .into_iter()
         .filter_map(|node| {
             xml.para_id(node)
                 .and_then(|value| u64::from_str_radix(value, 16).ok())
         })
-        .collect()
+        .collect();
+    for (name, bytes) in package.parts() {
+        if !name.to_ascii_lowercase().ends_with(".xml") {
+            continue;
+        }
+        let text = String::from_utf8_lossy(bytes);
+        occupied.extend(
+            pattern
+                .captures_iter(&text)
+                .filter_map(|c| u64::from_str_radix(&c[1], 16).ok()),
+        );
+    }
+    occupied
 }
 
 /// Deterministic 8-hex durable id (FNV-1a over identifying fields), clamped
@@ -447,7 +470,7 @@ pub(crate) fn anchor_comment_at(
     let comments = parse_part(package, COMMENTS_PART, EMPTY_COMMENTS)?;
     let records = comment_records(&comments);
     let id = next_comment_id(&records);
-    let para_id = format!("{:08X}", next_para_id(&records, &document_para_ids(xml)));
+    let para_id = format!("{:08X}", next_para_id(&records, &occupied_para_ids(package, xml)));
 
     insert_anchor_markers(xml, paragraph, start, end, id)?;
     append_comment_record(package, id, &para_id, None, author, date, text)?;
@@ -736,7 +759,7 @@ pub fn reply_comment_typed(
     let parent_para_id = parent.para_id.clone();
     let parent_id = parent.id.clone();
     let id = next_comment_id(&records);
-    let para_id = format!("{:08X}", next_para_id(&records, &document_para_ids(xml)));
+    let para_id = format!("{:08X}", next_para_id(&records, &occupied_para_ids(package, xml)));
     append_comment_record(
         package,
         id,

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/equations.rs

@@ -101,6 +101,7 @@ pub(super) fn replace(
         xml.doc.insert_before(target, holder);
         xml.doc.detach(target);
         xml.doc.append_child(deletion, target);
+        crate::segments::mark_deleted_leaves(xml, target, true);
         let ins_id = xml.next_revision_id();
         xml.doc.set_attribute(holder, "w:id", &ins_id.to_string());
         xml.doc.set_attribute(holder, "w:author", author);
@@ -110,7 +111,7 @@ pub(super) fn replace(
             xml.doc.detach(child);
             xml.doc.insert_before(target, child);
         }
-        xml.doc.remove_node(target);
+        crate::segments::remove_content(xml, target);
         xml.doc.remove_node(holder);
     }
     Ok((
@@ -156,8 +157,9 @@ pub(super) fn delete(
         xml.doc.insert_before(target, deletion);
         xml.doc.detach(target);
         xml.doc.append_child(deletion, target);
+        crate::segments::mark_deleted_leaves(xml, target, true);
     } else {
-        xml.doc.remove_node(target);
+        crate::segments::remove_content(xml, target);
     }
     Ok((
         format!("deleted equation {} in paragraph {at}", index + 1),

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/headers.rs

@@ -13,7 +13,6 @@ use crate::package::Package;
 use super::layout::ensure_sect_pr;
 
 const CONTENT_TYPES_PART: &str = "[Content_Types].xml";
-const DOCUMENT_RELS_PART: &str = "word/_rels/document.xml.rels";
 const SETTINGS_CT: &str =
     "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml";
 const SETTINGS_REL: &str =
@@ -73,13 +72,18 @@ fn ensure_document_rel(
         "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
         "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"/>",
     );
-    let mut rels = parse_part(package, DOCUMENT_RELS_PART, default)?;
+    let rels_part = super::document_rels_part(package);
+    let mut rels = parse_part(package, &rels_part, default)?;
     let root = rels
         .doc
         .root_element()
         .ok_or_else(|| Outcome::error("malformed document.xml.rels"))?;
+    // Reuse only a relationship of the same type: a header id that names a
+    // footer relationship makes Word refuse the document.
     if let Some(existing) = rels.doc.children(root).find(|&child| {
-        rels.is_local(child, "Relationship") && rels.doc.attribute(child, "Target") == Some(target)
+        rels.is_local(child, "Relationship")
+            && rels.doc.attribute(child, "Target") == Some(target)
+            && rels.doc.attribute(child, "Type") == Some(rel_type)
     }) {
         return Ok(rels
             .doc
@@ -104,7 +108,7 @@ fn ensure_document_rel(
     rels.doc.set_attribute(node, "Type", rel_type);
     rels.doc.set_attribute(node, "Target", target);
     rels.doc.append_child(root, node);
-    package.set(DOCUMENT_RELS_PART, rels.serialize());
+    package.set(&rels_part, rels.serialize());
     Ok(id)
 }
 

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/layout.rs

@@ -188,10 +188,13 @@ fn ensure_property_child(
         .iter()
         .position(|name| *name == local)
         .map_or(&[][..], |index| &sequence[index + 1..]);
-    let successor = xml
-        .doc
-        .children(parent)
-        .find(|&child| successors.iter().any(|name| xml.is_w(child, name)));
+    // Office extension elements (w14 text effects and the like) close the
+    // base sequence, before only the trailing revision record.
+    let trailing = sequence.last() == Some(&local);
+    let successor = xml.doc.children(parent).find(|&child| {
+        successors.iter().any(|name| xml.is_w(child, name))
+            || (!trailing && xml.doc.is_element(child) && is_extension(xml, child))
+    });
     if let Some(next) = successor {
         xml.doc.insert_before(next, node);
     } else {
@@ -200,6 +203,13 @@ fn ensure_property_child(
     node
 }
 
+/// An element outside WordprocessingML: an Office extension, or the markup
+/// compatibility wrapper that carries one.
+fn is_extension(xml: &DocxXml, node: NodeId) -> bool {
+    let ns = xml.doc.node_namespace(node);
+    ns.is_some() && ns != Some(crate::document::W_NS)
+}
+
 pub(crate) fn set_child_val(xml: &mut DocxXml, parent: NodeId, local: &str, val: &str) {
     let node = if matches!(local, "pStyle" | "jc") {
         ensure_ppr_child(xml, parent, local)

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/mod.rs

@@ -27,6 +27,8 @@ pub struct ExecCtx {
     pub now: String,
 }
 
+const STRICT_W_NS: &str = "http://purl.oclc.org/ooxml/wordprocessingml/main";
+
 /// The parsed working set the operation fold runs over: one unzip + one
 /// document.xml parse per typed plan, however many operations follow.
 pub(crate) struct WorkState {
@@ -62,6 +64,14 @@ impl WorkState {
                 .map_err(|error| Outcome::error(error.to_string()))?;
             DocxXml::parse(bytes).map_err(Outcome::error)?
         };
+        // ISO Strict markup lives in other namespaces: the engine would read
+        // it as empty and write Transitional markup into it.
+        if xml.doc.root_element().and_then(|root| xml.doc.node_namespace(root)) == Some(STRICT_W_NS) {
+            return Err(Outcome::error(
+                "this document is saved as Strict Open XML, which docxdriver does not support; \
+                 save it as a standard Word Document (.docx) and try again",
+            ));
+        }
         let table_positions = table_positions(&xml);
         let table_handles = table_positions.iter().map(|(node, address)| (address.clone(), *node)).collect();
         Ok(WorkState {
@@ -93,6 +103,16 @@ pub(crate) fn table_positions(xml: &DocxXml) -> HashMap<xmloxide::tree::NodeId,
     map
 }
 
+/// The relationships part of the main document part (`word/_rels/document.xml.rels`
+/// for the conventional name; a renamed main part has its own).
+pub(crate) fn document_rels_part(package: &crate::package::Package) -> String {
+    let main = package.document_part_name();
+    match main.rsplit_once('/') {
+        Some((dir, file)) => format!("{dir}/_rels/{file}.rels"),
+        None => format!("_rels/{main}.rels"),
+    }
+}
+
 /// sha256 of the exact input package bytes.
 pub(crate) fn package_sha256(bytes: &[u8]) -> [u8; 32] {
     use sha2::{Digest, Sha256};
@@ -100,14 +120,16 @@ pub(crate) fn package_sha256(bytes: &[u8]) -> [u8; 32] {
 }
 
 /// Attach the serialized package to a successful outcome when something
-/// actually mutated (and dryRun doesn't withhold it). The one zip write.
+/// actually mutated. The one zip write. A dry run builds the bytes too, so
+/// review runs the same integrity gate as commit; callers withhold them.
 ///
 /// Every engine write persists paragraph identity first: existing valid
 /// `w14:paraId` values are untouched, while missing/invalid/duplicate and
 /// engine-created paragraphs receive the same deterministic values inspection
 /// showed — one atomic write of repairs plus content operations.
 pub(crate) fn emit(mut state: WorkState, outcome: Outcome, ctx: &ExecCtx) -> Outcome {
-    if outcome.status != crate::outcome::Status::Ok || !state.mutated || ctx.dry_run {
+    let _ = ctx;
+    if outcome.status != crate::outcome::Status::Ok || !state.mutated {
         return outcome;
     }
     state.flush_lists();

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/readonly.rs

@@ -219,7 +219,10 @@ pub fn create(command: &Value, ctx: &ExecCtx) -> Outcome {
         return Outcome::ok(summary, result);
     }
     match package.to_bytes() {
-        Ok(bytes) => Outcome::ok_bytes(summary, result, bytes),
+        Ok(bytes) => match crate::integrity::gate_created(&bytes) {
+            Ok(()) => Outcome::ok_bytes(summary, result, bytes),
+            Err(failure) => Outcome::error(failure.summary()),
+        },
         Err(error) => Outcome::error(error.to_string()),
     }
 }

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/revisions.rs

@@ -8,7 +8,7 @@ use xmloxide::tree::NodeId;
 use crate::document::DocxXml;
 use crate::outcome::Outcome;
 use crate::package::Package;
-use crate::segments::{all_text, build_segments, rename_for};
+use crate::segments::{all_text, build_segments, mark_deleted_leaves, remove_content};
 
 use super::readonly::plural;
 
@@ -357,16 +357,25 @@ fn resolve_entry(xml: &mut DocxXml, entry: &RevisionEntry, accept: bool) -> Resu
                 }
                 sibling
             };
+            // The joined paragraph ends at the next paragraph's mark, so that
+            // mark's pPr and identity win, as in Word: this paragraph's
+            // content moves to the front of the next one and this one goes.
+            //   <p A>Mine.¶(ins)</p><p B, list>item one¶</p>
+            //   -> <p B, list>Mine.item one¶</p>
             if let Some(next) = next {
-                let children: Vec<NodeId> = xml.doc.children(next).collect();
+                let anchor = xml.doc.children(next).find(|&c| !xml.is_w(c, "pPr"));
+                let children: Vec<NodeId> = xml.doc.children(entry.paragraph).collect();
                 for child in children {
                     if xml.is_w(child, "pPr") {
                         continue;
                     }
                     xml.doc.detach(child);
-                    xml.doc.append_child(entry.paragraph, child);
+                    match anchor {
+                        Some(anchor) => xml.doc.insert_before(anchor, child),
+                        None => xml.doc.append_child(next, child),
+                    }
                 }
-                xml.doc.remove_node(next);
+                xml.doc.remove_node(entry.paragraph);
             }
         }
         return Ok(());
@@ -381,24 +390,15 @@ fn resolve_entry(xml: &mut DocxXml, entry: &RevisionEntry, accept: bool) -> Resu
                 xml.doc.detach(child);
                 xml.doc.insert_before(entry.node, child);
                 if !accept {
-                    // Rejected delete: its w:delText leaves become live w:t again.
-                    let leaves: Vec<NodeId> = xml
-                        .doc
-                        .descendants(child)
-                        .filter(|&n| xml.is_w(n, "delText"))
-                        .collect();
-                    for leaf in leaves {
-                        let name = rename_for(xml, leaf, false);
-                        xml.doc.rename_element(leaf, name);
-                    }
+                    // Rejected delete: its w:delText leaves become live w:t
+                    // again, and w:delInstrText field codes w:instrText.
+                    mark_deleted_leaves(xml, child, false);
                 }
             }
             xml.doc.remove_node(entry.node);
         }
         // Rejected insert / accepted delete: the content goes.
-        (true, false) | (false, true) => {
-            xml.doc.remove_node(entry.node);
-        }
+        (true, false) | (false, true) => remove_content(xml, entry.node),
     }
     Ok(())
 }
@@ -519,6 +519,27 @@ fn accept_reject_all_in_xml(xml: &mut DocxXml, accept: bool) -> Result<usize, Ou
         resolve_entry(xml, &entry, accept)?;
         count += 1;
     }
+    // Tracked cell insertions and deletions: the marker sits in the cell's
+    // tcPr, and the cell goes on a rejected insert or an accepted delete.
+    let mut shortened: Vec<NodeId> = Vec::new();
+    loop {
+        let marker = scope(xml).and_then(|root| {
+            xml.doc.descendants(root).find(|&n| {
+                (xml.is_w(n, "cellIns") || xml.is_w(n, "cellDel"))
+                    && xml.doc.parent(n).is_some_and(|p| xml.is_w(p, "tcPr"))
+            })
+        });
+        let Some(marker) = marker else { break };
+        count += 1;
+        let cell = xml.doc.parent(marker).and_then(|p| xml.doc.parent(p));
+        if accept != xml.is_w(marker, "cellDel") {
+            xml.doc.remove_node(marker);
+            continue;
+        }
+        if let Some(row) = cell.and_then(|cell| remove_cell(xml, cell)) {
+            shortened.push(row);
+        }
+    }
     // One record at a time, re-scanning between resolutions: rejecting a
     // record swaps subtrees around, which can relocate or remove records
     // collected earlier (e.g. an rPrChange nested in a pPrChange snapshot).
@@ -534,12 +555,119 @@ fn accept_reject_all_in_xml(xml: &mut DocxXml, accept: bool) -> Result<usize, Ou
         resolve_property_change(xml, node, accept);
         count += 1;
     }
+    // Rows that lost a cell are padded with gridAfter against the settled
+    // grid, the way Word writes a short row.
+    for row in shortened {
+        pad_short_row(xml, row);
+    }
     if let Some(root) = scope(xml) {
         strip_move_range_markers_in(xml, root, None);
     }
     Ok(count)
 }
 
+/// The cells of `row`, through any content-control wrappers, but not those
+/// of tables nested in its cells.
+fn row_cells(xml: &DocxXml, row: NodeId) -> Vec<NodeId> {
+    xml.doc
+        .descendants(row)
+        .filter(|&n| {
+            xml.is_w(n, "tc")
+                && xml.doc.ancestors(n).skip(1).find(|&a| xml.is_w(a, "tr")) == Some(row)
+        })
+        .collect()
+}
+
+/// Remove a table cell. A row left without cells goes too, and a table
+/// left without rows becomes an empty paragraph. Returns the row when it
+/// remains, now short of its grid.
+fn remove_cell(xml: &mut DocxXml, cell: NodeId) -> Option<NodeId> {
+    let row = xml.doc.ancestors(cell).skip(1).find(|&a| xml.is_w(a, "tr"))?;
+    // A content control holding only this cell goes with it.
+    let mut target = cell;
+    while let Some(parent) = xml.doc.parent(target) {
+        let wrapper = xml.is_w(parent, "sdtContent")
+            && xml.doc.children(parent).filter(|&c| xml.doc.is_element(c)).count() == 1;
+        if !wrapper {
+            break;
+        }
+        target = xml.doc.parent(parent).unwrap_or(parent);
+    }
+    xml.doc.remove_node(target);
+    if !row_cells(xml, row).is_empty() {
+        return Some(row);
+    }
+    let table = xml.doc.ancestors(row).skip(1).find(|&a| xml.is_w(a, "tbl"));
+    xml.doc.remove_node(row);
+    if let Some(table) = table {
+        let rows = xml
+            .doc
+            .descendants(table)
+            .any(|n| xml.is_w(n, "tr") && xml.doc.ancestors(n).skip(1).find(|&a| xml.is_w(a, "tbl")) == Some(table));
+        if !rows {
+            let paragraph = xml.doc.create_element("w:p");
+            xml.doc.insert_before(table, paragraph);
+            xml.doc.remove_node(table);
+        }
+    }
+    None
+}
+
+/// Raise a row's gridAfter so its cells and padding cover the table grid.
+fn pad_short_row(xml: &mut DocxXml, row: NodeId) {
+    let attached = xml.doc.root_element().is_some_and(|root| xml.doc.ancestors(row).any(|a| a == root));
+    let Some(table) = xml.doc.ancestors(row).skip(1).find(|&a| xml.is_w(a, "tbl")) else {
+        return;
+    };
+    if !attached {
+        return;
+    }
+    let columns = xml
+        .child_w(table, "tblGrid")
+        .map(|grid| xml.doc.children(grid).filter(|&c| xml.is_w(c, "gridCol")).count())
+        .unwrap_or(0) as i64;
+    let value = |xml: &DocxXml, parent: Option<NodeId>, name: &str, default: i64| {
+        parent
+            .and_then(|p| xml.child_w(p, name))
+            .and_then(|n| xml.attr(n, "val"))
+            .and_then(|v| v.trim().parse::<i64>().ok())
+            .unwrap_or(default)
+    };
+    let trpr = xml.child_w(row, "trPr");
+    let after = value(xml, trpr, "gridAfter", 0);
+    let mut position = value(xml, trpr, "gridBefore", 0) + after;
+    for cell in row_cells(xml, row) {
+        position += value(xml, xml.child_w(cell, "tcPr"), "gridSpan", 1);
+    }
+    if columns == 0 || position >= columns {
+        return;
+    }
+    let trpr = match trpr {
+        Some(trpr) => trpr,
+        None => {
+            let trpr = xml.doc.create_element("w:trPr");
+            match xml.child_w(row, "tblPrEx") {
+                Some(ex) => xml.doc.insert_after(ex, trpr),
+                None => match xml.doc.first_child(row) {
+                    Some(first) => xml.doc.insert_before(first, trpr),
+                    None => xml.doc.append_child(row, trpr),
+                },
+            }
+            trpr
+        }
+    };
+    if let Some(old) = xml.child_w(trpr, "gridAfter") {
+        xml.doc.remove_node(old);
+    }
+    let grid_after = xml.doc.create_element("w:gridAfter");
+    xml.doc.set_attribute(grid_after, "w:val", &(after + columns - position).to_string());
+    // CT_TrPrBase is an unordered choice; the revision records close CT_TrPr.
+    match xml.doc.first_child(trpr) {
+        Some(first) => xml.doc.insert_before(first, grid_after),
+        None => xml.doc.append_child(trpr, grid_after),
+    }
+}
+
 /*    split_boundary(xml, paragraph, offset);
     let segments = build_segments(xml, paragraph);
 

{docxdriver-0.4.0 → docxdriver-0.4.2}/crates/docxdriver-core/src/commands/tables.rs

@@ -363,13 +363,23 @@ pub fn validate_row(at: &str, f: &RowFormat) -> Result<(), String> {
     }
     Ok(())
 }
+/// The properties element of a table, row or cell. It precedes all content —
+/// including cells wrapped in w:sdt or w:customXml, which `ensure` would not
+/// recognize — and follows only w:tblPrEx in a row.
 fn bag(x: &mut DocxXml, n: NodeId, tag: &str) -> NodeId {
-    let seq = match tag {
-        "tblPr" => &["tblPr", "tblGrid", "tr"][..],
-        "trPr" => &["tblPrEx", "trPr", "tc"][..],
-        _ => &["tcPr", "p", "tbl"][..],
-    };
-    ensure(x, n, tag, seq)
+    if let Some(existing) = x.child_w(n, tag) {
+        return existing;
+    }
+    let props = x.doc.create_element(&format!("w:{tag}"));
+    let next = x
+        .doc
+        .children(n)
+        .find(|&c| x.doc.is_element(c) && !(tag == "trPr" && x.is_w(c, "tblPrEx")));
+    match next {
+        Some(next) => x.doc.insert_before(next, props),
+        None => x.doc.append_child(n, props),
+    }
+    props
 }
 fn snapshot(
     x: &mut DocxXml,