athena-python-docx 0.41.0__tar.gz → 0.42.0__tar.gz

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/AGENTS.md

@@ -1080,6 +1080,20 @@ architecture or a DOCX Studio constraint:
   name the document lacks raises `KeyError` unless docx-studio holds Word's
   definition of it (`BUILTIN_CHARACTER_STYLE_NAMES` in
   `docx/styles/_table.py`: `"Strong"`, `"Intense Emphasis"`, `"Book Title"`…).
+  A character style the uploaded file's runs name without defining it (a
+  generator's links naming `Hyperlink`) reads as the default character
+  style, as python-docx reads it, and the export leaves it undefined, so an
+  unedited download is the file (owner decision, 2026-10-26, #46935 A2).
+  The editor and the server's PDFs still draw those runs in Word's built-in
+  style, blue and underlined. docx-studio records the import's list, and a
+  format that gives a run one of those styles (`run.style = "Hyperlink"`):
+  from then on the export defines it, as Word adds a style's definition when
+  it is applied, and `Info`'s `undefinedRunStyleIds` no longer lists it, so
+  every session reads its runs as the built-in; the SDK asks `Info` again
+  after such a write. An edit in the editor that copies such a run (a paste,
+  the format painter) leaves the style undefined. A room imported before
+  the record (no `undefinedRunStyleIds`) reads them as the built-in and its
+  export adds the definition, as before.
   `Document.add_table(style=)` and `Paragraph.add_run(style=)` resolve the
   style before creating anything, so a rejected style leaves the document
   untouched; python-docx raises after adding the table or run to its
@@ -1258,6 +1272,30 @@ architecture or a DOCX Studio constraint:
   changes; the owner may overrule it. Recorded in
   `tests/parity/intentional_deviations.json` (`live_deviations`).
 
+- **The inner link of a nested link reads with its text.** A `w:hyperlink`
+  inside another (the duplicate wrapper Word writes around a pasted link,
+  each with a relationship of its own; 3 of 6,826 customer uploads) reads
+  its inner link's runs in `Hyperlink.runs` / `text`, `Paragraph.text` and
+  `iter_inner_content()`, as Word shows them; upstream reads only a link's
+  own `w:r` children, so the inner text is invisible to it and
+  `p.text = p.text.replace(...)` would delete it unseen. The same choice as
+  inline wrappers and tracked changes. Owner decision, 2026-10-26 (#46935,
+  A1). Recorded in `tests/parity/intentional_deviations.json`
+  (`live_deviations`) with the synthetic fixture `hyperlinks-nested`.
+
+- **An emoji written as `w16se:symEx` reads as its run's text.** Word 2016
+  writes an emoji as the run's `mc:AlternateContent`: an `mc:Choice
+  Requires="w16se"` holding `w16se:symEx` (its font and character), and an
+  `mc:Fallback` holding a `w:t` of the emoji (1 of 6,826 customer uploads).
+  `Run.text`, `iter_inner_content()` and the paragraph's text hold the emoji,
+  as Word shows it; upstream reads only a run's own `w:t` children and reads
+  `""`, so a script rewriting the paragraph would delete the emoji unseen.
+  An edited paragraph's export writes the emoji in a plain `w:t`, without
+  the `w16se:symEx` choice, so upstream then reads it there too. Owner
+  decision, 2026-10-26 (#46935, A5). Recorded in
+  `tests/parity/intentional_deviations.json` (`live_deviations`) with the
+  synthetic fixture `symbols-emoji-alternate-content`.
+
 - **Two things a source writes that the model holds otherwise read as the
   model holds them** (2026-10-22 SDK live parity run over 398 customer
   documents). Each is recorded in
@@ -1434,6 +1472,22 @@ architecture or a DOCX Studio constraint:
   exported file. Against a docx-studio that predates `fieldRun` reads, a
   field reads as no runs and no text, as before (`tests/test_field_runs.py`).
 
+- **A header or footer run holding text beside a whole field reads as more
+  runs.** A generator writes a page number as one `w:r` holding `Page ` and a
+  `PAGE` field's begin, code, separate and end characters (1 of 6,826
+  customer uploads). Upstream reads one run, `Page `. The import cuts that
+  `w:r` into a run of the text and the field's own run (and a run of any text
+  after the field; `RunParseOptions.cutRunsAtFields`), so the paragraph's
+  text reads as upstream's and the editor and the server's PDFs draw it;
+  before, the field took the whole run and the text was lost, from the reads
+  and from an edited footer's export. `paragraph.runs` holds the extra runs,
+  and an edited paragraph's export writes them as runs of their own: a
+  cosmetic run split. A body run of that shape is still read the old way, as
+  its room stores what its import read. Owner decision, 2026-10-26 (#46935,
+  A4). Recorded in `tests/parity/intentional_deviations.json`
+  (`live_deviations`) with the synthetic fixture
+  `footers-text-and-field-one-run`.
+
 - **A run that holds a page number block refuses a tracked whole-run format
   and two text writes.** A page number block (`w:pgNum`) reads as a run with
   no text, and a run that holds text and blocks (or two blocks) reads as

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: athena-python-docx
-Version: 0.41.0
+Version: 0.42.0
 Summary: Drop-in replacement for python-docx that connects to Athena's DOCX Studio collaborative document stack
 Project-URL: Homepage, https://athenaintelligence.ai
 Author-email: Athena Intelligence <engineering@athenaintelligence.ai>

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/docx/__init__.py

@@ -6,7 +6,7 @@ See CLAUDE.md for the API parity contract.
 
 from __future__ import annotations
 
-__version__ = "0.41.0"
+__version__ = "0.42.0"
 
 from docx.api import Document
 from docx._buffer import discard_all, flush_all

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/docx/styles/_table.py

@@ -159,6 +159,15 @@ _latent: "weakref.WeakKeyDictionary[Any, dict[str, Any] | None]" = weakref.WeakK
 #: Each session's paragraph style ids its document's source names without
 #: defining them, as ``Info`` reports them (``undefinedStyleIds``).
 _undefined: "weakref.WeakKeyDictionary[Any, frozenset[str]]" = weakref.WeakKeyDictionary()
+#: Each session's character style ids the runs of its uploaded file name
+#: without the file defining them and no write has given a run, as ``Info``
+#: reports them (``undefinedRunStyleIds``; none from a room imported before the
+#: record): the export leaves them undefined.
+_undefined_runs: "weakref.WeakKeyDictionary[Any, frozenset[str]]" = weakref.WeakKeyDictionary()
+#: Sessions whose script gave a run one of ``_undefined_runs``: docx-studio
+#: records the write (the export defines the style from then on), so the next
+#: read of such a style asks ``Info`` again, after the write.
+_runs_restyled: "weakref.WeakSet[Any]" = weakref.WeakSet()
 
 
 def _records(info: object) -> tuple[StyleRecord, ...] | None:
@@ -229,6 +238,12 @@ def style_table(session: Any) -> tuple[StyleRecord, ...] | None:
         if isinstance(undefined_ids, list)
         else frozenset()
     )
+    undefined_run_ids: object = info.get("undefinedRunStyleIds") if isinstance(info, dict) else None
+    _undefined_runs[session] = (
+        frozenset(i for i in undefined_run_ids if isinstance(i, str))
+        if isinstance(undefined_run_ids, list)
+        else frozenset()
+    )
     _stale.discard(session)
     # A server that showed it writes styles still does once deletes leave its
     # table without the entries that told: the signal holds for the session.
@@ -577,11 +592,15 @@ def style_of(
     default style, else None.
 
     A Word built-in the document does not define reads back as that built-in,
-    as ``style_id_for`` lets it be set. A document without styles reads its
-    defaults as Word's, as python-docx's default ``styles.xml`` gives them.
-    Without a style table: the stored style as given, else Word's default.
-    The style reads the definition it was found as (its record), as
-    python-docx's wraps that ``w:style``.
+    as ``style_id_for`` lets it be set; not a character style the runs of the
+    uploaded file already named without defining it and no write has given a
+    run (``Info``'s ``undefinedRunStyleIds``), which python-docx reads as the
+    default character style and the export leaves undefined. A document
+    without styles reads its defaults as Word's,
+    as python-docx's default ``styles.xml`` gives them. Without a style table:
+    the stored style as given, else Word's default. The style reads the
+    definition it was found as (its record), as python-docx's wraps that
+    ``w:style``.
     """
     from docx.styles.style import _style_of_record
 
@@ -592,7 +611,12 @@ def style_of(
         name, style_id = builtin or (BabelFish.internal2ui(stored_style_id), stored_style_id)
         return _new_style(session, name, style_id, style_type)
     record = first_of_id(table or (), stored_style_id) if stored_style_id else None
-    if record is None and builtin is not None and _defined_builtin(style_type, builtin[1]):
+    if (
+        record is None
+        and builtin is not None
+        and _defined_builtin(style_type, builtin[1])
+        and not _file_left_undefined(session, stored_style_id, style_type)
+    ):
         return _new_style(session, *builtin, style_type)
     if record is None or record.type != style_type:
         record = default_style(table, style_type) if table else None
@@ -601,6 +625,39 @@ def style_of(
     return _style_of_record(record, session)
 
 
+def _file_left_undefined(session: Any, style_id: str | None, style_type: WD_STYLE_TYPE) -> bool:
+    """Whether ``style_id`` is a character style the uploaded file's runs name
+    without the file defining it and no write has given a run, as ``Info``
+    reports them (``undefinedRunStyleIds``): python-docx reads such a run's
+    style as the default character style, and the export leaves the style
+    undefined. After the script gave a run one of them, ``Info`` is read again
+    first (it sends the write before it), so the answer is docx-studio's
+    record, as every later session reads it."""
+    if style_type != WD_STYLE_TYPE.CHARACTER or not style_id:
+        return False
+    try:
+        if session in _runs_restyled:
+            _runs_restyled.discard(session)
+            forget_style_table(session)
+            style_table(session)
+        return style_id in _undefined_runs.get(session, frozenset())
+    except TypeError:
+        return False
+
+
+def _note_applied_run_style(session: Any, style_id: str | None, style_type: WD_STYLE_TYPE) -> None:
+    """Note that the script gives a run ``style_id``, one the uploaded file's
+    runs name undefined: docx-studio records the write if it applies, so the
+    next read of such a style asks ``Info`` again."""
+    if style_type != WD_STYLE_TYPE.CHARACTER or not style_id:
+        return
+    try:
+        if style_id in _undefined_runs.get(session, frozenset()):
+            _runs_restyled.add(session)
+    except TypeError:
+        pass
+
+
 def style_id_for(
     session: Any,
     style_or_name: object,
@@ -643,7 +700,10 @@ def style_id_for(
             f"{owner} requires str, {kind} (with ``.style_id``/``.name``), or None; "
             f"got {type(style_or_name).__name__} {style_or_name!r}",
         )
-    return None if style_id == _document_default_style_id(session, style_type) else style_id
+    if style_id == _document_default_style_id(session, style_type):
+        return None
+    _note_applied_run_style(session, style_id, style_type)
+    return style_id
 
 
 def _style_id_of_name(session: Any, requested: str, style_type: WD_STYLE_TYPE) -> str:

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "athena-python-docx"
-version = "0.41.0"
+version = "0.42.0"
 description = "Drop-in replacement for python-docx that connects to Athena's DOCX Studio collaborative document stack"
 readme = "README.md"
 license = "MIT"

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/tests/fidelity/fake_session.py

@@ -140,6 +140,9 @@ class FakeDocState:
         # The paragraph style ids the document's source names without defining
         # them, as ``Info`` reports them beside the style table (``undefinedStyleIds``).
         self.undefined_style_ids: list[str] | None = None
+        # The character style ids the uploaded file's runs name without defining
+        # them, as ``Info`` reports them beside the style table (``undefinedRunStyleIds``).
+        self.undefined_run_style_ids: list[str] | None = None
         # What an older server's ``Info`` lists instead: the paragraph styles in use.
         self.paragraph_styles_in_use: list[dict] = []
         # ``docProps/core.xml`` as ``Info`` reports it (``includeCoreProperties``):
@@ -254,6 +257,8 @@ class FakeDocState:
                     info["latentStyles"] = self.latent_styles
                 if "styleTable" in info and self.undefined_style_ids is not None:
                     info["undefinedStyleIds"] = list(self.undefined_style_ids)
+                if "styleTable" in info and self.undefined_run_style_ids is not None:
+                    info["undefinedRunStyleIds"] = list(self.undefined_run_style_ids)
                 if (params or {}).get("includeCoreProperties") and self.core_properties is not None:
                     info["coreProperties"] = dict(self.core_properties)
                     if self.core_properties_default:

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/tests/live/fixture_scripts.py

@@ -417,6 +417,16 @@ FIXTURE_SCRIPTS: list[FixtureScript] = [
             "caption.runs[4].italic = True\n"
         ),
     ),
+    FixtureScript(
+        # A run added to a footer paragraph whose one run holds "Page " and a
+        # whole PAGE field: python-docx appends a w:r after it; the SDK adds
+        # its run after the field, and the export writes the edited paragraph
+        # with the text, the field and the new run each a run of its own (the
+        # recorded run split, #46935 item A4), keeping "Page ".
+        name="fixture-footers-text-and-field-one-run-writes",
+        fixture="footers-text-and-field-one-run",
+        script=('doc.sections[0].footer.paragraphs[0].add_run(" (draft)")\n'),
+    ),
     FixtureScript(
         # Run writes in a header whose style turns bold on and a footer whose
         # fields are each written whole in one run, read back one `w:r` at a
@@ -711,6 +721,37 @@ FIXTURE_SCRIPTS: list[FixtureScript] = [
             'last.header.paragraphs[0].add_run(" (revised)")\n'
         ),
     ),
+    FixtureScript(
+        # Runs added to the paragraphs that anchor a VML and a DrawingML text
+        # box whose text is not wrapped, and a paragraph added after them:
+        # python-docx writes the runs after the boxes' runs and keeps the
+        # boxes as they are, as does the SDK.
+        name="fixture-textboxes-no-wrap-writes",
+        fixture="textboxes-no-wrap",
+        script=(
+            'doc.paragraphs[0].add_run(" (anchor kept)").bold = True\n'
+            'doc.paragraphs[2].add_run(" (second anchor kept)")\n'
+            'doc.add_paragraph("A paragraph added after the boxes.")\n'
+        ),
+    ),
+    FixtureScript(
+        # Writes to the header row of a table that names a style and has no
+        # w:tblLook, which Word reads by its default look: the cells' text,
+        # a run added and one made italic, a paragraph added to a header cell
+        # and a row added. python-docx writes none of the style's bold as the
+        # runs' own and no look, nor does the SDK.
+        name="fixture-tables-default-look-writes",
+        fixture="tables-default-look",
+        script=(
+            "table = doc.tables[0]\n"
+            'table.cell(0, 1).text = "Summary"\n'
+            'table.cell(0, 0).paragraphs[0].add_run(" (code)")\n'
+            "table.cell(0, 2).paragraphs[0].runs[0].italic = True\n"
+            'table.cell(0, 2).add_paragraph("Region")\n'
+            "row = table.add_row()\n"
+            'row.cells[0].text = "Delta"\n'
+        ),
+    ),
     FixtureScript(
         # Writes to a footer part written with a header's root element and to
         # a header part written with a footer's: python-docx edits the part's

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/tests/parity/intentional_deviations.json

@@ -202,6 +202,46 @@
       "match": "fixture-inline-tags::reads::tables.cell_paragraph_content",
       "reason": "As fixture-inline-tags::reads::runs.*: runs inside an inline wrapper (w:smartTag, w:customXml) read as the paragraph's (owner question 47)."
     },
+    {
+      "match": "fixture-hyperlinks-nested::reads::paragraphs.text",
+      "reason": "The inner link of a link nested in another (<w:hyperlink><w:hyperlink>, the duplicate wrapper Word writes around a pasted link) reads with its text, as Word shows it: the link's runs, the paragraph's text and inner content, and the section's blocks hold the inner link's run, where python-docx reads only a link's own runs (w:hyperlink/w:r) and a paragraph's direct w:r and w:hyperlink children, so Hyperlink.text and Paragraph.text leave the inner text out. Owner decision, 2026-10-26 (#46935, item A1): 3 of 6,826 customer uploads hold one, and with python-docx's reads a script that rewrites such a paragraph's text (p.text = p.text.replace(...)) deletes the inner link's text unseen. The same choice as owner question 47 (inline wrappers) and tracked changes (Word's final view)."
+    },
+    {
+      "match": "fixture-hyperlinks-nested::reads::paragraphs.inner_content",
+      "reason": "As fixture-hyperlinks-nested::reads::paragraphs.text: the inner link of a nested link reads with its text, as Word shows it (owner decision, 2026-10-26, #46935 item A1)."
+    },
+    {
+      "match": "fixture-hyperlinks-nested::reads::hyperlinks",
+      "reason": "As fixture-hyperlinks-nested::reads::paragraphs.text: the inner link of a nested link reads with its text, as Word shows it (owner decision, 2026-10-26, #46935 item A1)."
+    },
+    {
+      "match": "fixture-hyperlinks-nested::reads::hyperlinks.runs",
+      "reason": "As fixture-hyperlinks-nested::reads::paragraphs.text: the inner link of a nested link reads with its text, as Word shows it (owner decision, 2026-10-26, #46935 item A1)."
+    },
+    {
+      "match": "fixture-hyperlinks-nested::reads::sections.inner_content",
+      "reason": "As fixture-hyperlinks-nested::reads::paragraphs.text: the inner link of a nested link reads with its text, as Word shows it (owner decision, 2026-10-26, #46935 item A1)."
+    },
+    {
+      "match": "fixture-symbols-emoji-alternate-content::reads::runs.text",
+      "reason": "An emoji Word 2016 writes as mc:AlternateContent in its run (an mc:Choice Requires=\"w16se\" holding w16se:symEx, an mc:Fallback holding a w:t of the emoji) reads as the run's text, as Word shows it: the run's text and inner content, the paragraph's text and inner content and the section's blocks hold the emoji, where python-docx reads a run's text from its own w:t children only and reads \"\" for it. Owner decision, 2026-10-26 (#46935, item A5): 1 of 6,826 customer uploads holds one, and with python-docx's read a script that rewrites the paragraph's text deletes the emoji unseen."
+    },
+    {
+      "match": "fixture-symbols-emoji-alternate-content::reads::runs.inner_content",
+      "reason": "As fixture-symbols-emoji-alternate-content::reads::runs.text: an emoji written as w16se:symEx in mc:AlternateContent reads as the run's text, as Word shows it (owner decision, 2026-10-26, #46935 item A5)."
+    },
+    {
+      "match": "fixture-symbols-emoji-alternate-content::reads::paragraphs.text",
+      "reason": "As fixture-symbols-emoji-alternate-content::reads::runs.text: an emoji written as w16se:symEx in mc:AlternateContent reads as the run's text, as Word shows it (owner decision, 2026-10-26, #46935 item A5)."
+    },
+    {
+      "match": "fixture-symbols-emoji-alternate-content::reads::paragraphs.inner_content",
+      "reason": "As fixture-symbols-emoji-alternate-content::reads::runs.text: an emoji written as w16se:symEx in mc:AlternateContent reads as the run's text, as Word shows it (owner decision, 2026-10-26, #46935 item A5)."
+    },
+    {
+      "match": "fixture-symbols-emoji-alternate-content::reads::sections.inner_content",
+      "reason": "As fixture-symbols-emoji-alternate-content::reads::runs.text: an emoji written as w16se:symEx in mc:AlternateContent reads as the run's text, as Word shows it (owner decision, 2026-10-26, #46935 item A5)."
+    },
     {
       "match": "fixture-bidi-wrappers::reads::runs.*",
       "reason": "Runs inside an inline wrapper (w:dir, w:bdo) read as the paragraph's runs, so the runs, their fonts and inner content, the links' runs, the paragraph's text and inner content, and the cells holding them read with the wrapped runs, where python-docx reads only a w:p's direct w:r and w:hyperlink children and cannot see their text. Decided on 2026-10-21 under the Word fidelity goal (owner question 47) and flagged to the owner, who may overrule it: 62 of 6,803 customer uploads hold text inside smart tags (842 tags), and with python-docx's reads a script that rewrites such a paragraph (p.text = p.text.replace(...)) deletes that text, which python-docx's setter clears unseen. The same choice as the recorded decision for tracked changes, which the SDK reads as Word's final view."
@@ -277,6 +317,14 @@
     {
       "match": "fixture-comments-annotation-ref-unstyled::reads::comments.runs.style",
       "reason": "A comment's annotation reference run (w:annotationRef) that names no character style (1 of 398 customer documents, 13 of 6,826 uploads) reads in Word's CommentReference style, in which the export writes every comment's annotation run when it writes the comments part, as Word does for a comment it inserts; python-docx reads the source run's style, the default character style. The model holds no annotation mark (the parser keeps the run as an empty run nothing tells from another), so reading the source run's own formatting would need the stored comment to mark it. Confirmed by the owner, 2026-10-23."
+    },
+    {
+      "match": "fixture-footers-text-and-field-one-run*::reads::sections.footer.paragraph_reads",
+      "reason": "A footer run that holds text beside a whole field (\"Page \" and a PAGE field's begin, code, separate and end characters in one w:r, as a generator writes a page number) reads as more runs than python-docx's one: the import cuts the w:r into a run of the text and the field's own run (and a run of any text after the field), so the paragraph's text reads as python-docx's and Word's, and the editor and the server's PDFs draw it, where the field took the whole run and its text was lost. A cosmetic run split, recorded by owner decision, 2026-10-26 (#46935, item A4): 1 of 6,826 customer uploads holds one."
+    },
+    {
+      "match": "fixture-footers-text-and-field-one-run-writes::export::sections.footer.paragraph_reads",
+      "reason": "As fixture-footers-text-and-field-one-run::reads::sections.footer.paragraph_reads: a footer paragraph whose run holds \"Page \" and a whole PAGE field, edited by the script, is written back with the text and the field each a run of its own, so python-docx reads the export's paragraph as more runs, with the same text (owner decision, 2026-10-26, #46935 item A4)."
     }
   ],
 

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/tests/test_run_table_style_objects.py

@@ -139,6 +139,64 @@ class TestRunStyleReads:
 
         assert run.style is None
 
+    def test_a_built_in_the_uploaded_file_named_undefined_reads_as_the_default(self) -> None:
+        # A generator's links name Hyperlink, which its styles.xml lacks:
+        # python-docx's get_by_id finds no such style and gives the default.
+        doc = _document()
+        doc._session.state().undefined_run_style_ids = ["Hyperlink"]
+        p = doc.add_paragraph()
+        p.add_run("link")
+        doc._session.state()._find_block(p._node_id).inlines[0]["run"]["rStyle"] = "Hyperlink"
+
+        assert _style(doc.paragraphs[0].runs[0].style) == (
+            "Default Paragraph Font",
+            "DefaultParagraphFont",
+            WD_STYLE_TYPE.CHARACTER,
+        )
+
+    def test_a_built_in_a_room_imported_before_named_undefined_reads_as_the_built_in(self) -> None:
+        # No ``undefinedRunStyleIds``: the room's export defines the style, as before.
+        doc = _document()
+        p = doc.add_paragraph()
+        p.add_run("link")
+        doc._session.state()._find_block(p._node_id).inlines[0]["run"]["rStyle"] = "Hyperlink"
+
+        assert _style(doc.paragraphs[0].runs[0].style) == ("Hyperlink", "Hyperlink", WD_STYLE_TYPE.CHARACTER)
+
+    def test_a_built_in_the_file_named_undefined_reads_as_docx_studio_records_a_write_of_it(self) -> None:
+        # docx-studio records a format that gives a run the style (the export
+        # defines it from then on) and reports it no more: the next read asks
+        # Info again, after the write, as a later session would.
+        doc = _document()
+        state = doc._session.state()
+        state.undefined_run_style_ids = ["Hyperlink"]
+        p = doc.add_paragraph()
+        p.add_run("link")
+        state._find_block(p._node_id).inlines[0]["run"]["rStyle"] = "Hyperlink"
+        assert doc.paragraphs[0].runs[0].style.style_id == "DefaultParagraphFont"
+
+        added = p.add_run(" more")
+        added.style = "Hyperlink"
+        state.undefined_run_style_ids = []
+
+        assert _sent_run_styles(doc) == ["Hyperlink"]
+        assert _style(added.style) == ("Hyperlink", "Hyperlink", WD_STYLE_TYPE.CHARACTER)
+        assert doc.paragraphs[0].runs[0].style.style_id == "Hyperlink"
+
+    def test_a_write_docx_studio_did_not_record_leaves_the_default_read(self) -> None:
+        # A format docx-studio refused or skipped records nothing: Info still
+        # reports the style, and its runs still read as the default.
+        doc = _document()
+        state = doc._session.state()
+        state.undefined_run_style_ids = ["Hyperlink"]
+        p = doc.add_paragraph()
+        p.add_run("link")
+        state._find_block(p._node_id).inlines[0]["run"]["rStyle"] = "Hyperlink"
+
+        p.add_run(" more").style = "Hyperlink"
+
+        assert doc.paragraphs[0].runs[0].style.style_id == "DefaultParagraphFont"
+
     def test_the_style_has_a_font(self) -> None:
         from docx.text.run import Font
 

{athena_python_docx-0.41.0 → athena_python_docx-0.42.0}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "athena-python-docx"
-version = "0.41.0"
+version = "0.42.0"
 source = { editable = "." }
 dependencies = [
     { name = "athena-references" },