@@ -2476,6 +2476,10 @@ R3. Rationale: initials abbreviate the person's name words; titles,
     word of its own. A part holding nothing else is a part where it
     is joining nothing, and there it initials like any other name
     word, agreeing with the base.
+    The first letter is the one the word's composed spelling begins
+    with, written in the form the writer used: a letter written as a
+    base letter followed by its combining accent initials whole, and
+    so does a syllable written as its separate parts.
     The question is asked of the WHOLE PART, never of a word count. A
     part of two words where one is the connective is still a part
     where it joins — the base of "Jon Dough and" is "Dough and" and
@@ -2500,6 +2504,8 @@ R3. Rationale: initials abbreviate the person's name words; titles,
       "Nguyen, Van Le"            →  initials="V. L. N."
       "Hassan, Mohamad Ahmad Ali"  middle_as_family  →  initials="M. A. A. H."
       "Sean O'Connor"             →  initials="S. O."  · boundary
+      "émile zola"                →  initials="e\u0301. z."
+      "マイケル ジャクソン"            →  initials="マ. シ\u3099."
     A family that is ALL particles therefore contributes its words
     rather than nothing: they are the base (R2), so they initial.
       "Juan van der"              →  initials="J. v. d."
 
@@ -52,6 +52,8 @@ Release Log
 
     - **Fix case repair breaking a name typed with decomposed accents at each accent.** ``HumanName(unicodedata.normalize("NFD", "josé garcía")).capitalize()`` gives ``José García``, where every release from 1.4.0 through 2.3.0 gave ``José GarcíA``: decomposed text (NFD, which macOS file names and some databases hand back) writes ``í`` as ``i`` followed by a combining accent, and the letters after the accent were repaired as a separate word. A decomposed name now repairs the way its composed spelling does, Mac/Mc names and case-repair masks included, and the output keeps the form it was typed in. See the ``R4`` entry of ``docs/design/decisions.md`` (closes #542)
 
+    - **Fix initials dropping the accent from a name typed with decomposed accents.** ``parse(unicodedata.normalize("NFD", "émile zola")).initials()`` gives ``é. z.``, where every release gave ``e. z.``: the initial was a word's first code point, which in decomposed text is the letter without its accent. Decomposed katakana lost its voicing mark the same way and now keeps it: ``マイケル ジャクソン`` typed decomposed initials ``マ. ジ.``, where every release gave ``マ. シ.``. ``HumanName.initials()`` moves alike, a decomposed name's initials stay decomposed, and a composed name's initials do not change. See the ``R3`` entry of ``docs/design/decisions.md`` (closes #585)
+
     - **Change the parse pipeline to copy its state without dataclasses.replace.** Every stage returns a copy of its frozen state, and several also copy tokens one at a time; ``dataclasses.replace`` goes through ``fields()`` and ``__init__`` on every one of those copies. The stages now copy fields directly through a small helper that is limited to the pipeline's own three dataclasses and checks them at import. One parse of the benchmark's reference name makes 36 fewer calls on py3.11 and 3.12 and 54 fewer from 3.13 (on 3.11, ``parse`` 406 to 370 and ``HumanName`` 443 to 407), and the call-count baselines move with them. Recomputable with ``uv run python tools/perf/call_count.py --against e0f1a2f``; the counts for every interpreter are in the ``parse-cost`` entry of ``docs/design/decisions.md``. No user-visible behavior changes (#546)
 
     - **Fix a long given part after a family comma costing quadratic time.** Since 2.3.0, parsing ``"Doe, Jane " + "Smith " * n`` took time growing with the square of the part's length: going from 1,600 to 6,400 words cost 8.4x the time, where 2.2.0 and the comma-less form cost 4x. A run of trailing titles in the same place (``Doe, Jane Smith Prof. Prof. ...``) cost 10x. Both cost 4x again (Python 3.11, measured 2026-09-28). No field moves (closes #553)
 
@@ -643,7 +643,7 @@ def _process_initial(self, name_part: str,
             # #461: the conjunction filter reaches EVERY group; only
             # the particle filter is exempted for the given group.
             if not conjunction and (firstname or not self._is_particle(word)):
-                initials.append(word[0])
+                initials.append(_render._first_letter(word))
         if len(initials) > 0:
             return self.initials_separator.join(initials)
         # Return '' (never empty_attribute_default, which may be None)
@@ -711,7 +711,7 @@ def all_particle_guard(got: list[str], words: list[str]) -> list[str]:
             # both surfaces for names whose roles agree. _split_last
             # already applies the same guard to the base, which is why
             # last_base was never empty here.
-            return [w[0] for w in words]
+            return [_render._first_letter(w) for w in words]
 
         def group_initials(groups: list[tuple[Token, ...]],
                            firstname: bool = False) -> list[str]:
 
@@ -177,6 +177,39 @@ def render(name: ParsedName, spec: str) -> str:
 # rules.md#R3: "initials take the first letter of each given, middle,
 # and base family word; titles, suffixes, particles and nicknames
 # contribute nothing"
+def _first_letter(text: str) -> str:
+    """The initial of `text`: its first character as its composed (NFC)
+    spelling reads it, written in the form `text` was written (#585).
+    That is the shortest start of `text` that composes to the composed
+    text's first character -- 'e' + U+0301 for a decomposed 'é', and
+    the two or three jamo of a decomposed hangul syllable, which are
+    letters rather than marks -- or, where a mark composing with
+    nothing stands inside that start, the character decomposed (even
+    where the writer composed part of it). A text whose first code
+    point holds a whole character gives text[0], as it always did --
+    a composed text, and one opening with a character Unicode excludes
+    from composition -- so a mark that composes with nothing (a
+    Bengali vowel sign) stays out of the initial in either form. Raises IndexError on an empty `text`, as
+    text[0] does."""
+    if text.isascii():
+        return text[0]
+    first = unicodedata.normalize("NFC", text)[0]
+    end = 1
+    while not unicodedata.normalize("NFC", text[:end]).startswith(first):
+        end += 1
+    # end == 1: one code point already holds the first letter, kept
+    # as written even where NFC would split it (U+0958, excluded from
+    # composition, is 'क' + a nukta composed; it keeps its nukta here)
+    if end == 1 or unicodedata.normalize("NFC", text[:end]) == first:
+        return text[:end]
+    # A mark that composes with nothing stands, in canonical order,
+    # between the letter and a mark that does ('o' + U+0331 + U+0301,
+    # where the composed spelling is 'ó' + U+0331), so no start of the
+    # text composes to `first` alone: write `first` decomposed, the
+    # form the writer used for it.
+    return unicodedata.normalize("NFD", first)
+
+
 def initials(name: ParsedName, spec: str, delimiter: str, separator: str) -> str:
     """First letter of each contributing token per group, v1 semantics:
     delimiter follows each initial, separator sits between initials
@@ -227,7 +260,7 @@ def initials(name: ParsedName, spec: str, delimiter: str, separator: str) -> str
         tokens = (tuple(t for t in tokens if FOLDED_TAG in t.tags)
                   + tuple(t for t in tokens if FOLDED_TAG not in t.tags))
         values[key] = separator.join(
-            t.text[0] + delimiter for t in tokens)
+            _first_letter(t.text) + delimiter for t in tokens)
     return _format_spec(spec, values, "initials", _INITIALS_KEYS)
 
 
 
@@ -3635,8 +3635,11 @@ def _claim(rule: dict) -> _Claim:
         # '田中 太郎 旧姓 佐藤 MA' -- the tolerated row this change
         # added, so radar corpus. Growth into new corpus again; no
         # role joined the list.
+        # 2026-10-02, #585: 138 -> 139, one new corpus name and not a
+        # wider rule: the decomposed katakana R3 row 'マイケル ジャクソン'
+        # (NFD) lies in its script span, and fix(#585) explains it.
         "fix(#271/#272/#298) native-script CJK: family-first order, hangul segmentation, the kana license and the dots":
-            _Claim(138, ('family', 'given', 'middle'), "397de8444acc", None),
+            _Claim(139, ('family', 'given', 'middle'), "0feb71190b77", None),
         # 2026-09-19, #533: 33 -> 68. The count grew with the CORPUS
         # rather than with the rule -- this change added 35
         # maiden-clause names as rules.md example lines and
@@ -4601,6 +4604,8 @@ def _claim(rule: dict) -> _Claim:
         # 'SMITH, VD MA', 'smith, de ma'.
         "fix(#573) a never-given particle opening the given part takes the member behind it":
             _Claim(3, ('family', 'suffix'), "54ce0dda7114", ('DEFAULT',)),
+        "fix(#585) a decomposed initial keeps its whole first letter":
+            _Claim(2, ('_initials',), "c4f045134f0f", None),
     },
     "expected_since_2.0.0.toml": {
         # The ph removal (#459/#521): one literal name, the cases.py
@@ -4777,8 +4782,11 @@ def _claim(rule: dict) -> _Claim:
         # as the 1.4 twin.
         # 2026-09-19, #533: 137 -> 138, the same one new tolerated
         # corpus name as the 1.4.0 copy, '田中 太郎 旧姓 佐藤 MA'.
+        # 2026-10-02, #585: 138 -> 139, one new corpus name and not a
+        # wider rule: the decomposed katakana R3 row 'マイケル ジャクソン'
+        # (NFD) lies in its script span, and fix(#585) explains it.
         "fix(#271/#272/#298) native-script CJK: family-first order, hangul segmentation, the kana license and the dots":
-            _Claim(138, ('_ambiguities', 'family', 'given', 'middle'), "397de8444acc", None),
+            _Claim(139, ('_ambiguities', 'family', 'given', 'middle'), "0feb71190b77", None),
         # 37 -> 35 with the same 2026-09-05 narrowing as the 1.4 twin,
         # whose entry carries the reason. Here the one name that
         # changed hands, '김민준 박사님', goes to the spaced rule
@@ -5353,6 +5361,8 @@ def _claim(rule: dict) -> _Claim:
         # 'SMITH, VD MA', 'smith, de ma'.
         "fix(#573) a never-given particle opening the given part takes the member behind it":
             _Claim(3, ('_ambiguities',), "54ce0dda7114", ('DEFAULT',)),
+        "fix(#585) a decomposed initial keeps its whole first letter":
+            _Claim(2, ('_initials',), "c4f045134f0f", None),
     },
     # The 2.3 cycle's first rule, and a facade-only render fix: every
     # role is identical, so `_initials` alone. Reach and digest as in
@@ -5827,6 +5837,8 @@ def _claim(rule: dict) -> _Claim:
         # 'SMITH, VD MA', 'smith, de ma'.
         "fix(#573) a never-given particle opening the given part takes the member behind it":
             _Claim(3, ('_ambiguities',), "54ce0dda7114", ('DEFAULT',)),
+        "fix(#585) a decomposed initial keeps its whole first letter":
+            _Claim(2, ('_initials',), "c4f045134f0f", None),
     },
     "expected_since_2.1.0.toml": {
         # The ph removal (#459/#521): one literal name, the cases.py
@@ -6546,6 +6558,8 @@ def _claim(rule: dict) -> _Claim:
         # 'SMITH, VD MA', 'smith, de ma'.
         "fix(#573) a never-given particle opening the given part takes the member behind it":
             _Claim(3, ('_ambiguities',), "54ce0dda7114", ('DEFAULT',)),
+        "fix(#585) a decomposed initial keeps its whole first letter":
+            _Claim(2, ('_initials',), "c4f045134f0f", None),
     },
     "expected_since_2.3.0.toml": {
         # The ph removal (#459/#521): one literal name, the cases.py
@@ -6865,6 +6879,8 @@ def _claim(rule: dict) -> _Claim:
         # 'SMITH, VD MA', 'smith, de ma'.
         "fix(#573) a never-given particle opening the given part takes the member behind it":
             _Claim(3, ('_ambiguities',), "54ce0dda7114", ('DEFAULT',)),
+        "fix(#585) a decomposed initial keeps its whole first letter":
+            _Claim(2, ('_initials',), "c4f045134f0f", None),
     },
 }
 
 
@@ -3106,12 +3106,12 @@ def test_the_case_only_walk_can_fail(
     assert any("'Ph.D.' -> 'PhD'" in line for line in failures), failures
 
 
-# --- #542: a decomposed name repairs as its composed twin does -------
+# --- #542/#585: a decomposed name renders as its composed twin does -
 # The same texts as the walk above, those that decompose at all, each
-# parsed and repaired in both forms and compared once the decomposed
-# output is composed again. A text whose two forms PARSE differently
-# is set aside rather than compared: repair follows the parse, so the
-# comparison would report the parse, and the one class that does so is
+# parsed in both forms, repaired and initialled, and compared once the
+# decomposed output is composed again. A text whose two forms PARSE
+# differently is set aside rather than compared: both views follow the
+# parse, so the comparison would report the parse, and the one class that does so is
 # unspaced hangul, which segmentation matches as written by decision
 # (docs/usage.rst, "Decomposed text"). The test below pins that filter.
 
@@ -3120,7 +3120,7 @@ def _hangul(text: str) -> bool:
                for c in unicodedata.normalize("NFC", text))
 
 
-def _nfd_repair_findings() -> tuple[list[str], list[str], int]:
+def _nfd_twin_findings() -> tuple[list[str], list[str], int]:
     """(disagreements, texts set aside, texts compared)."""
     def nfc(text: str) -> str:
         return unicodedata.normalize("NFC", text)
@@ -3139,6 +3139,14 @@ def nfc(text: str) -> str:
             set_aside.append(text)
             continue
         compared += 1
+        human, twin = HumanName(decomposed), HumanName(nfc(text))
+        for surface, decomposed_initials, composed_initials in (
+                ("core", name.initials(), composed.initials()),
+                ("facade", human.initials(), twin.initials())):
+            if nfc(decomposed_initials) != composed_initials:
+                out.append(f"[initials, {surface}] {text!r}: "
+                           f"{nfc(decomposed_initials)!r} != "
+                           f"{composed_initials!r}")
         for force in (False, True):
             got = [nfc(t.text) for t in
                    parser.capitalized(name, force=force).tokens]
@@ -3147,7 +3155,6 @@ def nfc(text: str) -> str:
             if got != want:
                 out.append(f"[core, force={force}] {text!r}: "
                            f"{got!r} != {want!r}")
-        human, twin = HumanName(decomposed), HumanName(nfc(text))
         for force in (False, True):
             human.capitalize(force=force)
             twin.capitalize(force=force)
@@ -3159,25 +3166,31 @@ def nfc(text: str) -> str:
     return out, set_aside, compared
 
 
-def test_a_decomposed_name_repairs_as_its_composed_twin() -> None:
-    """rules.md#R4 read as an invariant over encodings: a letter written
-    as a base letter and its combining accent repairs as the letter
-    written whole does (#542). Core and facade, plain and forced. The output is compared composed
-    because repair keeps the form it was given, which the case-only
-    walk above holds separately.
-
-    Recorded negative control, measured 2026-10-02 with 97af1f02's
-    _render.py, before a word ran on through its marks, over this
-    change's corpus (its own two R4 rows included): 144 disagreements
-    over the 137 texts compared, 47 more set aside, every one hangul
-    ('JOSÉ GARCÍA' repairing to 'José GarcíA'). The live control is the test below."""
-    failures, set_aside, compared = _nfd_repair_findings()
+def test_a_decomposed_name_renders_as_its_composed_twin() -> None:
+    """rules.md#R3 and #R4 read as an invariant over encodings: a
+    letter written as a base letter and its combining accent initials
+    (#585) and repairs (#542) as the letter written whole does. Core
+    and facade; repair plain and forced. The output is compared
+    composed because both views keep the form they were given.
+
+    Recorded negative controls, measured 2026-10-02. Repair, with
+    97af1f02's _render.py, before a word ran on through its marks, over
+    #542's corpus (its own two R4 rows included): 144 disagreements over
+    the 137 texts compared, 47 more set aside, every one hangul
+    ('JOSÉ GARCÍA' repairing to 'José GarcíA'). Initials, with
+    _first_letter taking text[0] again, over #585's corpus (its own two
+    R3 rows included, so 139 texts compared where #542's had 137): 44
+    disagreements, 22 texts each failing on both surfaces, katakana as
+    well as Latin ('マイケル ジャクソン' initialling 'マ. シ.', the
+    dakuten of 'ジ' decomposing to a combining mark). The live
+    controls are the two tests below."""
+    failures, set_aside, compared = _nfd_twin_findings()
     assert compared, "no decomposable text was compared"
     assert all(_hangul(text) for text in set_aside), (
         "a non-hangul text parses differently decomposed: "
         f"{[t for t in set_aside if not _hangul(t)]}")
     assert not failures, (
-        f"{len(failures)} decomposed repair(s) disagree:\n"
+        f"{len(failures)} decomposed rendering(s) disagree:\n"
         + "\n".join(failures[:10]))
 
 
@@ -3188,10 +3201,23 @@ def test_the_decomposed_walk_can_fail(
     import nameparser._render as render_module
     monkeypatch.setattr(render_module, "_past_marks",
                         lambda text, end: end)
-    failures, _, _ = _nfd_repair_findings()
+    failures, _, _ = _nfd_twin_findings()
     assert any("'José', 'GarcíA'" in line for line in failures), failures
 
 
+def test_the_decomposed_initials_walk_can_fail(
+        monkeypatch: pytest.MonkeyPatch) -> None:
+    """Taking a token's first code point again -- #585's defect -- has
+    to be seen by the walk above, on both surfaces."""
+    import nameparser._render as render_module
+    monkeypatch.setattr(render_module, "_first_letter",
+                        lambda text: text[0])
+    failures, _, _ = _nfd_twin_findings()
+    for surface in ("core", "facade"):
+        assert any(line.startswith(f"[initials, {surface}]")
+                   for line in failures), failures
+
+
 def test_a_delimiter_core_reads_as_if_it_were_not_written() -> None:
     """#538: under a core-bearing policy, a maiden clause reads exactly
     as the same text written without the core. The core is structure