@@ -129,15 +129,15 @@ for start in range(1, count + 1, page_size):
 
 #### `get_paragraph_location(ref)`
 
-Report whether a paragraph lives in the document body or inside a table cell, whether it is a list item, and its heading context (style, outline level, and the chain of headings above it).
+Report whether a paragraph lives in the document body or inside a table cell, whether it is a list item, its heading context (style, outline level, and the chain of headings above it), and its section index.
 
 **Parameters:**
 
 - `ref` (str): Paragraph reference from `list_paragraphs()`, such as `P2#f3c1`
 
 **Returns:** `ParagraphLocation`. `location.in_table` is `False` for body paragraphs; `True` when the paragraph is inside a `<w:tc>` cell, in which case `location.table` carries the 1-based table index, row, `w:gridSpan`-aware logical column, and nesting depth. `location.list` is a `ListItem(num_id, ilvl)` for paragraphs carrying a direct `w:pPr/w:numPr`, `None` otherwise — raw values only: numbering inherited via a paragraph style is not resolved, and rendered display numbers (e.g. "7.2(a)") are not computed.
 
-`location.style` is the raw `w:pStyle` style id (e.g. `"Heading1"`), `None` when the paragraph carries no explicit style — no name resolution against `word/styles.xml`. `location.outline_level` is the 0-based outline level (`0` == Heading 1, so a document heading level is `outline_level + 1`): a direct `w:outlineLvl` on the paragraph wins, and the spec's `w:val="9"` marker means body text (`None`); otherwise the level defined by the paragraph's style applies, with `w:basedOn` inheritance chains resolved. `location.heading_path` is the chain of nearest preceding headings that contains the paragraph, outermost first (e.g. `("Chapter one", "Termination")`), built from each heading's current visible text; a heading's own path lists only its ancestors, never itself. Headings inside table cells participate in document order.
+`location.style` is the raw `w:pStyle` style id (e.g. `"Heading1"`), `None` when the paragraph carries no explicit style — no name resolution against `word/styles.xml`. `location.outline_level` is the 0-based outline level (`0` == Heading 1, so a document heading level is `outline_level + 1`): a direct `w:outlineLvl` on the paragraph wins, and the spec's `w:val="9"` marker means body text (`None`); otherwise the level defined by the paragraph's style applies, with `w:basedOn` inheritance chains resolved. `location.heading_path` is the chain of nearest preceding headings that contains the paragraph, outermost first (e.g. `("Chapter one", "Termination")`), built from each heading's current visible text; a heading's own path lists only its ancestors, never itself. Headings inside table cells participate in document order. `location.section` is the paragraph's 1-based section index: a paragraph carrying a direct `w:pPr/w:sectPr` closes a section and belongs to the section it closes, the next paragraph starts the following one, and the body-level `w:sectPr` defines the final section — single-section documents report `1` everywhere.
 
 **Example:**
 
@@ -151,13 +151,14 @@ if loc.list:
 if loc.outline_level is not None:
     print(f"heading level {loc.outline_level + 1}: style={loc.style}")
 print(" > ".join(loc.heading_path))  # e.g. "Chapter one > Termination"
+print(f"section {loc.section}")
 ```
 
 #### `list_paragraph_locations()`
 
-Batch counterpart to `get_paragraph_location()`: pair every paragraph with its structural location in one pass, precomputing table indices, style outline levels, and heading paths once instead of rescanning the document per ref.
+Batch counterpart to `get_paragraph_location()`: pair every paragraph with its structural location in one pass, precomputing table indexes, style outline levels, heading paths, and section indexes once instead of rescanning the document per ref.
 
-**Returns:** List of `(ref, ParagraphLocation)` tuples in document order, where `ref` is the same `P{index}#{hash}` token emitted by `list_paragraphs()`. Each location carries the same table, list, style, outline-level, and heading-path info as `get_paragraph_location()`.
+**Returns:** List of `(ref, ParagraphLocation)` tuples in document order, where `ref` is the same `P{index}#{hash}` token emitted by `list_paragraphs()`. Each location carries the same table, list, style, outline-level, heading-path, and section info as `get_paragraph_location()`.
 
 **Example:**
 
 
@@ -25,6 +25,7 @@
     _build_table_index,
     _compute_heading_paths,
     _compute_paragraph_location,
+    _compute_section_indexes,
     build_text_map,
     compute_paragraph_hash,
 )
@@ -436,8 +437,14 @@ def get_paragraph_location(self, ref: str) -> ParagraphLocation:
         excludes itself. Headings inside table cells participate in
         document order.
 
-        Heading context is derived from whole-document scans on every
-        call; to locate many paragraphs, prefer
+        ``location.section`` is the paragraph's 1-based section index. A
+        paragraph carrying a direct ``w:pPr/w:sectPr`` closes a section
+        and belongs to the section it closes; the next paragraph starts
+        the following one. The body-level ``w:sectPr`` defines the final
+        section. Single-section documents report ``1`` everywhere.
+
+        Heading and section context is derived from whole-document scans
+        on every call; to locate many paragraphs, prefer
         :meth:`list_paragraph_locations`, which precomputes it once.
 
         Args:
@@ -451,7 +458,8 @@ def get_paragraph_location(self, ref: str) -> ParagraphLocation:
             ``location.list`` is a :class:`ListItem` for list paragraphs,
             ``None`` otherwise. ``location.style``,
             ``location.outline_level`` and ``location.heading_path`` carry
-            the paragraph's heading context as described above.
+            the paragraph's heading context, and ``location.section`` its
+            1-based section index, as described above.
 
         Raises:
             ValueError: If ``ref`` has an invalid format.
@@ -470,6 +478,7 @@ def get_paragraph_location(self, ref: str) -> ParagraphLocation:
             if loc.outline_level is not None:
                 print(f"heading level {loc.outline_level + 1}")
             print(f"under {' > '.join(loc.heading_path) or '(no heading)'}")
+            print(f"section {loc.section}")
         """
         self._ensure_open()
         parsed = ParagraphRef.parse(ref)
@@ -486,17 +495,19 @@ def get_paragraph_location(self, ref: str) -> ParagraphLocation:
             raise HashMismatchError(parsed.index, parsed.hash, actual_hash, preview)
         style_outlines = self._style_outline_map()
         heading_path = _compute_heading_paths(paragraphs[: parsed.index], style_outlines)[-1]
-        return _compute_paragraph_location(p, style_outlines=style_outlines, heading_path=heading_path)
+        section = _compute_section_indexes(paragraphs[: parsed.index])[-1]
+        return _compute_paragraph_location(p, style_outlines=style_outlines, heading_path=heading_path, section=section)
 
     def list_paragraph_locations(self) -> list[tuple[str, ParagraphLocation]]:
         """List every paragraph paired with its structural location.
 
         Batch counterpart to :meth:`get_paragraph_location`: precomputes
-        table indices, style outline levels, and heading paths once instead
-        of re-scanning the document per ref. Each entry is ``(ref,
-        location)`` where ``ref`` is the same ``"P{i}#{hash}"`` token
-        emitted by :meth:`list_paragraphs` (the part before ``|``) and
-        accepted by :meth:`get_paragraph_location` and the editing methods.
+        table indexes, style outline levels, heading paths, and section
+        indexes once instead of re-scanning the document per ref. Each
+        entry is ``(ref, location)`` where ``ref`` is the same
+        ``"P{i}#{hash}"`` token emitted by :meth:`list_paragraphs` (the
+        part before ``|``) and accepted by :meth:`get_paragraph_location`
+        and the editing methods.
 
         Returns:
             List of ``(ref, ParagraphLocation)`` tuples in document order.
@@ -505,9 +516,10 @@ def list_paragraph_locations(self) -> list[tuple[str, ParagraphLocation]]:
             ``location.list`` is a :class:`ListItem` for paragraphs with a
             direct ``w:pPr/w:numPr``, ``None`` otherwise (raw values; no
             style-inherited numbering, no rendered display numbers).
-            ``location.style``, ``location.outline_level`` and
-            ``location.heading_path`` carry the paragraph's heading context
-            with the same semantics as :meth:`get_paragraph_location`.
+            ``location.style``, ``location.outline_level``,
+            ``location.heading_path`` and ``location.section`` carry the
+            paragraph's heading and section context with the same
+            semantics as :meth:`get_paragraph_location`.
 
         Example:
             for ref, loc in doc.list_paragraph_locations():
@@ -517,19 +529,23 @@ def list_paragraph_locations(self) -> list[tuple[str, ParagraphLocation]]:
                 if loc.list:
                     print(f"{ref}: list numId={loc.list.num_id} level={loc.list.ilvl}")
                 print(f"{ref}: under {' > '.join(loc.heading_path) or '(no heading)'}")
+                print(f"{ref}: section {loc.section}")
         """
         self._ensure_open()
         dom = self._document_editor.dom
         table_index = _build_table_index(dom)
         style_outlines = self._style_outline_map()
         paragraphs = dom.getElementsByTagName("w:p")
         heading_paths = _compute_heading_paths(paragraphs, style_outlines)
+        section_indexes = _compute_section_indexes(paragraphs)
         result = []
-        for i, (p, path) in enumerate(zip(paragraphs, heading_paths, strict=True), start=1):
+        for i, (p, path, section) in enumerate(zip(paragraphs, heading_paths, section_indexes, strict=True), start=1):
             ref = f"P{i}#{compute_paragraph_hash(p)}"
             result.append((
                 ref,
-                _compute_paragraph_location(p, table_index, style_outlines=style_outlines, heading_path=path),
+                _compute_paragraph_location(
+                    p, table_index, style_outlines=style_outlines, heading_path=path, section=section
+                ),
             ))
         return result
 
 
@@ -179,9 +179,9 @@ class ListItem:
 class ParagraphLocation:
     """Structural location of a paragraph within the document body.
 
-    Reports table membership, list membership, and heading context. The
-    shape is intentionally extensible: future releases may add other
-    container kinds (header, footer, footnote), section index, etc., as
+    Reports table membership, list membership, heading context, and
+    section index. The shape is intentionally extensible: future releases
+    may add other container kinds (header, footer, footnote), etc., as
     plain optional field additions.
 
     ``list`` is the paragraph's raw numbering reference (see
@@ -201,13 +201,21 @@ class ParagraphLocation:
     contains this paragraph, outermost first (e.g. ``("Chapter one",
     "Termination")``), using each heading's current visible text. A
     heading's own path lists only its ancestors, never itself.
+
+    ``section`` is the paragraph's 1-based section index. A paragraph
+    whose ``w:pPr`` carries a direct ``w:sectPr`` closes a section — the
+    carrying paragraph belongs to the section it closes, and the next
+    paragraph starts the following one. The body-level ``w:sectPr``
+    defines the final section. Every paragraph belongs to exactly one
+    section; single-section documents report ``1`` everywhere.
     """
 
     table: TableCell | None
     list: ListItem | None = None
     style: str | None = None
     outline_level: int | None = None
     heading_path: tuple[str, ...] = ()
+    section: int = 1
 
     @property
     def in_table(self) -> bool:
@@ -491,11 +499,31 @@ def _compute_heading_paths(paragraphs, style_outlines: dict[str, int]) -> list[t
     return paths
 
 
+def _compute_section_indexes(paragraphs) -> list[int]:
+    """1-based section index for each of ``paragraphs`` (document order).
+
+    A direct ``<w:pPr>/<w:sectPr>`` closes the current section — the
+    carrying paragraph still belongs to it; the next paragraph starts the
+    following section. The body-level ``<w:sectPr>`` (final section) needs
+    no handling: the running counter already names it. Direct-child walk
+    only, so ``<w:pPrChange>`` decoys are ignored.
+    """
+    indexes = []
+    section = 1
+    for p in paragraphs:
+        indexes.append(section)
+        ppr = _direct_child(p, "w:pPr")
+        if ppr is not None and _direct_child(ppr, "w:sectPr") is not None:
+            section += 1
+    return indexes
+
+
 def _compute_paragraph_location(
     paragraph,
     table_index: dict | None = None,
     style_outlines: dict[str, int] | None = None,
     heading_path: tuple[str, ...] = (),
+    section: int = 1,
 ) -> ParagraphLocation:
     """Compute the structural location of a ``<w:p>`` element.
 
@@ -512,23 +540,34 @@ def _compute_paragraph_location(
     ``style_outlines`` is an optional precomputed ``{style_id:
     outline_level}`` map (see :func:`_build_style_outline_map`) used to
     resolve style-defined outline levels; ``None`` behaves like ``{}``.
-    ``heading_path`` is threaded through verbatim — computing it needs
-    whole-document context (see :func:`_compute_heading_paths`).
+    ``heading_path`` and ``section`` are threaded through verbatim —
+    computing them needs whole-document context (see
+    :func:`_compute_heading_paths` and :func:`_compute_section_indexes`).
     """
     list_item = _extract_list_item(paragraph)
     style = _extract_style(paragraph)
     outline_level = _extract_outline_level(paragraph, style, style_outlines or {})
     tc = _innermost_ancestor(paragraph, "w:tc")
     if tc is None:
         return ParagraphLocation(
-            table=None, list=list_item, style=style, outline_level=outline_level, heading_path=heading_path
+            table=None,
+            list=list_item,
+            style=style,
+            outline_level=outline_level,
+            heading_path=heading_path,
+            section=section,
         )
     tr = _innermost_ancestor(tc, "w:tr")
     tbl = _innermost_ancestor(tr, "w:tbl") if tr is not None else None
     if tr is None or tbl is None:
         # Malformed table structure — tolerate by treating as body content.
         return ParagraphLocation(
-            table=None, list=list_item, style=style, outline_level=outline_level, heading_path=heading_path
+            table=None,
+            list=list_item,
+            style=style,
+            outline_level=outline_level,
+            heading_path=heading_path,
+            section=section,
         )
     if table_index is not None and tbl in table_index:
         index = table_index[tbl]
@@ -545,6 +584,7 @@ def _compute_paragraph_location(
         style=style,
         outline_level=outline_level,
         heading_path=heading_path,
+        section=section,
     )
 
 
 
@@ -226,7 +226,8 @@ match = doc.find_text("30 days")
 # Get all visible text (inserted text included, deleted text excluded)
 visible = doc.get_visible_text()
 
-# Structural location: table cell, list item (raw numId/ilvl), and heading context
+# Structural location: table cell, list item (raw numId/ilvl), heading context,
+# and section index
 loc = doc.get_paragraph_location("P3#b2c4")
 if loc.table:
     print(f"table {loc.table.index} r{loc.table.row} c{loc.table.col}")
@@ -235,6 +236,7 @@ if loc.list:
 if loc.outline_level is not None:  # 0-based; 0 == Heading 1
     print(f"heading level {loc.outline_level + 1}: style={loc.style}")
 print(" > ".join(loc.heading_path))  # e.g. "Chapter one > Termination"
+print(loc.section)  # 1-based section index; sectPr-carrying paragraph closes its section
 
 # All edit methods return the new paragraph ref as a plain string.
 # Use it for follow-up edits on the same paragraph: