@@ -653,9 +653,13 @@ in the `.docx` (Word has no grouping concept and strips unknown markup), so
 groups are **inferred** at parse time instead
 (`Revision.group_source == "inferred"`): contiguous revisions in the same
 paragraph sharing identical `w:author` + `w:date` reconstruct as one group.
-That heuristic almost always matches the original logical edits — one caveat:
-`w:date` has second precision, so two edits to the *same paragraph* within the
-same second merge into one inferred group. When Word already resolved part of
+That heuristic matches this library's own edits exactly: each changeset (one
+edit call, or one whole `batch_edit`/`batch_rewrite` call) stamps a
+collision-bumped whole-second date, so two changesets by the same author never
+share a second; all ops of one batch call share one date (one changeset) and
+same-paragraph batch ops merge by design. Foreign revisions with identical
+`w:author` + `w:date` still merge (`w:date` has second precision). When Word
+already resolved part of
 a former edit, the remainder reconstructs as a smaller (rump) group, and
 `accept_group()`/`reject_group()` handle it fine. Revisions missing an author
 or date, sitting outside any paragraph (e.g. table-row markers), or sharing a
 
@@ -346,10 +346,13 @@ class Revision:
       groups created by edits through this open Document, ``"inferred"``
       for groups reconstructed at parse time by the heuristic (contiguous
       same-paragraph revisions sharing identical ``w:author`` + ``w:date``
-      are one group). Inferred groups usually match the original logical
-      edits, but two edits to the same paragraph within the same second
-      merge into one group (``w:date`` has second precision). None iff
-      ``group_id`` is None.
+      are one group). Our own writes stamp collision-bumped dates (two
+      changesets by one author never share a second), so inferred groups
+      match the original changesets; same-paragraph ops of one
+      ``batch_edit``/``batch_rewrite`` call share their date and merge by
+      design. Foreign revisions with identical author + date can still
+      over-merge (``w:date`` has second precision). None iff ``group_id``
+      is None.
     """
 
     id: int
@@ -584,9 +587,12 @@ def _reconstruct_groups(self) -> None:
 
         Known, accepted imprecisions:
 
-        - Two logical edits to the same paragraph within the same second
-          (w:date has second precision) merge into one group — accepted
-          over-merge, pinned by test.
+        - Same-paragraph over-merge is confined to one batch call for our
+          own writes: each changeset stamps a collision-bumped date (never
+          reused across an author's changesets), so only ops of a single
+          batch_edit/batch_rewrite call — which share their date by
+          design — merge. Foreign producers stamping identical author +
+          date (w:date has second precision) can still over-merge.
         - A revision inside a nested paragraph (e.g. a text box's
           w:txbxContent) interrupts the outer paragraph's run in document
           order — conservative over-split.
@@ -856,7 +862,9 @@ def batch_edit(self, operations: list[EditOperation]) -> list[int]:
 
         Validates all paragraph hashes before applying any edits.
         Applies edits in reverse paragraph order so earlier paragraphs'
-        hashes remain valid throughout.
+        hashes remain valid throughout. The whole call is one changeset:
+        every op's revisions share one ``w:date``, while each op still
+        records its own revision group in-session.
 
         Args:
             operations: List of EditOperation objects (each must have paragraph set)
@@ -901,15 +909,18 @@ def batch_edit(self, operations: list[EditOperation]) -> list[int]:
 
         try:
             results = [0] * len(operations)
-            for original_idx, _ref, op in parsed:
-                try:
-                    # Each op is its own logical edit: one group per op, so
-                    # callers can accept one op and reject another.
-                    with self._grouped():
-                        change_id = self._apply_single_edit(op)
-                except (ValueError, DocxEditError) as e:
-                    raise BatchOperationError(original_idx, str(e), original=e) from e
-                results[original_idx] = change_id
+            # One batch call = one changeset: every op's revisions share one
+            # w:date (the per-op _grouped() freezes join this outer scope).
+            with self.editor.frozen_timestamp():
+                for original_idx, _ref, op in parsed:
+                    try:
+                        # Each op is its own logical edit: one group per op, so
+                        # callers can accept one op and reject another.
+                        with self._grouped():
+                            change_id = self._apply_single_edit(op)
+                    except (ValueError, DocxEditError) as e:
+                        raise BatchOperationError(original_idx, str(e), original=e) from e
+                    results[original_idx] = change_id
             return results
         except Exception:
             # Restore via the line-tracking parser so parse_position is preserved.
@@ -1053,6 +1064,9 @@ def _validate_single(self, op: EditOperation) -> str | None:
     def batch_rewrite(self, rewrites: list[tuple[str, str]]) -> list[int | None]:
         """Rewrite multiple paragraphs with upfront hash validation.
 
+        The whole call is one changeset: all rewrites share one ``w:date``,
+        while each rewrite still records its own revision group in-session.
+
         Returns:
             One revision group id per rewrite, in input order (None for
             rewrites that created no revisions) — each rewrite gets its own
@@ -1099,13 +1113,18 @@ def batch_rewrite(self, rewrites: list[tuple[str, str]]) -> list[int | None]:
         registry_snapshot = self._registry_snapshot()
 
         try:
-            # Apply rewrites in reverse paragraph order
+            # Apply rewrites in reverse paragraph order. One batch call = one
+            # changeset: all rewrites share one w:date (each rewrite still
+            # gets its own group; duplicate paragraphs are rejected above, so
+            # reconstruction keeps one group per paragraph despite the
+            # shared date).
             group_ids: list[int | None] = [None] * len(rewrites)
-            for original_idx, ref, new_text in parsed:
-                try:
-                    group_ids[original_idx] = self.rewrite_paragraph(f"P{ref.index}#{ref.hash}", new_text)
-                except (ValueError, DocxEditError) as e:
-                    raise BatchOperationError(original_idx, str(e), original=e) from e
+            with self.editor.frozen_timestamp():
+                for original_idx, ref, new_text in parsed:
+                    try:
+                        group_ids[original_idx] = self.rewrite_paragraph(f"P{ref.index}#{ref.hash}", new_text)
+                    except (ValueError, DocxEditError) as e:
+                        raise BatchOperationError(original_idx, str(e), original=e) from e
             return group_ids
         except Exception:
             # Restore via the line-tracking parser so parse_position is preserved.
 
@@ -12,7 +12,7 @@
 from collections.abc import Callable, Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Literal
 from xml.dom.minidom import Element
@@ -1239,6 +1239,9 @@ def __init__(
         self._max_change_id = -1
         self._tracked_change_collector: list[Element] | None = None
         self._frozen_timestamp: str | None = None
+        # Last stamped (author, second) — the one collision counter behind
+        # _next_changeset_timestamp.
+        self._last_changeset_stamp: tuple[str, datetime] | None = None
 
     def _get_next_change_id(self) -> int:
         """Get the next available change ID by checking all tracked change elements."""
@@ -1276,6 +1279,25 @@ def collect_tracked_changes(self) -> Iterator[list[Element]]:
         finally:
             self._tracked_change_collector = None
 
+    def _next_changeset_timestamp(self) -> str:
+        """Whole-second UTC stamp for one changeset, collision-bumped.
+
+        True wall clock, except when this editor's previous changeset by the
+        same author already occupies this (or a later) second — then previous
+        second + 1, keeping (author, second) unique per changeset so
+        parse-time group reconstruction never merges two changesets. The
+        same rule keeps stamps monotonic per author across a clock
+        regression (e.g. an NTP step back): dates never go backwards,
+        pinned at previous + 1 until the clock catches up.
+        """
+        now = datetime.now(timezone.utc).replace(microsecond=0)
+        if self._last_changeset_stamp is not None:
+            last_author, last_second = self._last_changeset_stamp
+            if last_author == self.author and now <= last_second:
+                now = last_second + timedelta(seconds=1)
+        self._last_changeset_stamp = (self.author, now)
+        return now.strftime("%Y-%m-%dT%H:%M:%SZ")
+
     @contextmanager
     def frozen_timestamp(self) -> Iterator[None]:
         """Stamp every element injected in this context with ONE ``w:date``.
@@ -1285,12 +1307,19 @@ def frozen_timestamp(self) -> Iterator[None]:
         several times — crossing a second boundary mid-operation would spread
         the operation's revisions across two ``w:date`` values, and parse-time
         group reconstruction (which keys on identical dates) would then reopen
-        one edit as several groups. Does not nest — same single-slot design as
-        ``collect_tracked_changes``.
+        one edit as several groups.
+
+        One changeset = one outermost ``frozen_timestamp()`` scope, stamped
+        via ``_next_changeset_timestamp`` (collision-bumped so two changesets
+        never share a second). Reentrant by reuse: a nested entry joins the
+        enclosing changeset — ``batch_edit``/``batch_rewrite`` open the scope
+        once for the whole call and the per-op ``_grouped()`` freezes join
+        it. Only the outermost entry allocates a stamp and clears it on exit.
         """
         if self._frozen_timestamp is not None:
-            raise RuntimeError("frozen_timestamp() does not nest")
-        self._frozen_timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+            yield
+            return
+        self._frozen_timestamp = self._next_changeset_timestamp()
         try:
             yield
         finally:
 
@@ -502,10 +502,12 @@ doc.reject_group(result.group_id)   # undo the whole rewrite, or:
 # group (r.group_source == "inferred"; session edits are "recorded"). So
 # accept_group/reject_group work after reopen too — but always take the
 # group_id from THIS session's list_revisions()/EditResult; a stale id
-# from a previous session may resolve to a different group. Caveat:
-# w:date has second precision, so two edits to the same paragraph in the
-# same second merge into one inferred group. save() keeps groups alive
-# (the Document stays open).
+# from a previous session may resolve to a different group. Own edits
+# stamp collision-bumped whole-second dates (two changesets by one author
+# never share a second); all ops of one batch_edit/batch_rewrite call
+# share one date (one changeset). Foreign revisions with identical
+# author + date still merge. save() keeps groups alive (the Document
+# stays open).
 # Revision ids, unlike group ids, ARE stable: they are the w:id attributes
 # stored in the document XML and survive save()/close()/reopen — resolving
 # by revision id in a later session is always safe.