feat(core): TimeSpan gains ParseExact, which it had in no spelling (#1943)

TimeSpanStyles sat in modules/globalization with nothing able to consume it --
#1997 group A-3's shape. It moved into Core.Base: #1940's shape C for the third
time, again with not one #include line changed.

The obvious implementation -- reuse InvariantExactDateTimeParser -- would be
wrong in a way that passes most tests. .NET keeps TryParseByFormat apart from
DateTimeParse, and the token table shows why: an UNQUOTED LITERAL IS AN ERROR
here, so "hh:mm" is not a valid TimeSpan format and the colon must be quoted or
escaped, while the date/time scanner matches an unquoted literal instead -- a
shared scanner would silently accept a format .NET rejects. There is also no
sign token at all; each component may appear once; d takes 1..8 digits for one
specifier and exactly N for more, so a uniform rule gets days wrong and passes
every hour/minute/second row; and f requires its digits where F does not.

AssumeNegative is therefore the only route to a negative result, which is what
makes the style load-bearing rather than decorative. The standard formats ignore
it, as .NET does, because c carries its own sign. Bounds are per component, so
"25" against "hh" fails rather than carrying into days.

c/t/T implemented as one format under three names; g and G pinned absent, being
the localized formats -- they need a culture decimal separator this port has no
database for and optional components the custom scanner cannot express.

An illegal style throws where a parse failure returns false, validating before
the result is written.

Nine mutations all caught; two invalid as first written and reformulated: M2's
anchor never matched the file, M9's was rejected by -Werror.

Gate 17,708/38 green. Graph 41/95. Zero downstream sites.

Author: robertvokac

CLAUDE.md

@@ -139,6 +139,44 @@
 > and each is itemised in §2 below. **§4b says where to look next, and the method that found all
 > three of today's tickets.**
 
+## 2026-08-20 — #1943 (TimeSpan half): `TimeSpan` had no `ParseExact` in any spelling
+
+**Gate: 17,708 / 38, 0 failed, 0 skipped** (+8, `Core_Base` 6,118 → 6,126). Graph 41/95, catalogue
+regenerated.
+
+`TimeSpanStyles` existed in `modules/globalization` with **nothing able to consume it** — #1997
+A-3's shape. It moved into `Core.Base`: **#1940's shape C for the third time**, again with **not one
+`#include` line changed**.
+
+**The obvious implementation — reuse the date/time scanner — would be wrong in a way that passes
+most tests.** .NET keeps `TryParseByFormat` apart from `DateTimeParse`, and the token table shows
+why: **an unquoted literal is an ERROR here**, so `"hh:mm"` is *not* a valid `TimeSpan` format and
+the colon must be quoted or escaped — the date/time scanner *matches* an unquoted literal, so a
+shared scanner would silently **accept a format .NET rejects**. There is also **no sign token at
+all**; each component may appear once; **`d`'s digit rule is not the others'** (one specifier means
+1..8 digits, more means exactly that many — a uniform rule gets days wrong and passes every
+hour/minute/second row); and **`f` requires its digits where `F` does not**.
+
+So **`AssumeNegative` is the only route to a negative result** — `ParseExact("-01:30", "hh':'mm")`
+**fails** — which is what makes the style load-bearing rather than decorative. The standard formats
+ignore it, as .NET does. **Bounds are per component**, so `"25"` against `"hh"` fails rather than
+carrying into days.
+
+`c`/`t`/`T` implemented; **`g` and `G` pinned absent** — the *localized* formats, needing a culture
+decimal separator this port has no database for **and** optional components the custom scanner
+cannot express.
+
+Nine mutations, all caught. **Two were invalid as first written and reformulated rather than
+counted**: M2's anchor never matched the file (an absent anchor is a harness state, not a finding),
+M9's was rejected by `-Werror`.
+
+`docs/Migration-TimeSpanParseExact.md`. Downstream zero sites.
+
+**#1943 still has `DateTimeOffset::ParseExact`**, which needs a zone for the *no-offset* case.
+**An offset is not a time zone** — a format carrying an explicit offset would need none at all — so
+adding an offset token to the exact grammar is the route; it is recorded rather than taken because
+the default still needs #1942's answer.
+
 ## 2026-08-20 — #2415: the selective-component gate was red, and building into `/tmp`
 
 **Gate unchanged at 17,700 / 38** — no production code was touched. This repairs a *gate*, and the

NEXT.md

@@ -67,7 +67,7 @@ for maintainers and are not part of the consumer include surface.
 | `Security` | `modules/security` | interface | `Core.Base` | — | — | — | `System/Security/Authentication/AuthenticationException.hpp` |
 | `Security.Cryptography` | `modules/security-cryptography` | static | `Core.Base` | — | — | — | `System/Security/Cryptography/AuthenticationTagMismatchException.hpp` |
 | `Security.Cryptography.Random` | `modules/security-cryptography-random` | static | `Core.Base` | — | — | `bcrypt` on Windows (private) | `System/Security/Cryptography/RNGCryptoServiceProvider.hpp` |
-| `Xml` | `modules/xml` | static | `Core.Base`, `Uri` | `Diagnostics`, `TimeZone` | `Xml.Linq` | vendored tinyxml2 (public) | `System/Xml/ConformanceLevel.hpp` |
+| `Xml` | `modules/xml` | static | `Core.Base`, `Uri` | `Diagnostics`, `TimeZone` | `TimeZone`, `Xml.Linq` | vendored tinyxml2 (public) | `System/Xml/ConformanceLevel.hpp` |
 | `Xml.Linq` | `modules/xml-linq` | static | `Core.Base`, `Xml` | — | — | — | `System/Xml/Linq/Extensions.hpp` |
 
 ## Compatibility components

docs/ComponentCatalog.md

@@ -0,0 +1,99 @@
+<!-- SPDX-License-Identifier: MIT -->
+<!-- Copyright (c) Robert Vokac and contributors -->
+
+# `TimeSpan::ParseExact` — #1943 (TimeSpan half)
+
+**Purely additive, under SA-5.** No existing signature, layout, vtable, `noexcept` specification or
+accepted input changed; nothing needs migrating and no consumer rebuilds.
+
+## The gap
+
+`System::TimeSpan`'s entire parse surface was `Parse(s)` and `TryParse(s, result)` — **there was no
+`ParseExact` in any spelling**, so a caller could not parse a duration against a stated layout.
+`System::Globalization::TimeSpanStyles` existed in `modules/globalization` and **nothing could
+consume it**, exactly the shape #1997 group A-3 found for `UriCreationOptions`.
+
+`TimeSpanStyles.hpp` moved into `Core.Base` — #1940's shape C for the third time (after
+`DateTimeFormatInfo` and `DateTimeStyles`), and again **not one `#include` line changed**, because
+module ownership is by logical path uniqueness. Graph unchanged at **41 / 95**; catalogue
+regenerated.
+
+## Why this is a separate scanner, and why sharing one would be wrong
+
+The obvious implementation reuses `InvariantExactDateTimeParser.hpp`. **It would be wrong in a way
+that passes most tests.** .NET keeps `TimeSpanParse.TryParseByFormat` apart from `DateTimeParse`,
+and the token table shows why:
+
+* **An unquoted literal is an ERROR.** `TryParseByFormat`'s `switch` ends in
+  `default: return result.SetInvalidStringFailure();`, so **`"hh:mm"` is not a valid `TimeSpan`
+  format** — the colon must be `"hh':'mm"` or `"hh\:mm"`. The date/time scanner *matches* an
+  unquoted literal against the input, so a shared scanner would silently **accept a format .NET
+  rejects**.
+* **There is no sign token at all** — no `-`, no `+`.
+* **Each component may appear at most once**, tracked by five `seen*` flags.
+* **`d`'s digit rule is not the others'**: one specifier means **1..8** digits, more than one means
+  **exactly** that many. A scanner written "exactly `tokenLen`" everywhere gets days wrong and
+  passes every hour/minute/second row.
+* **`f` requires its digits where `F` makes them optional** — .NET calls the same reader for both
+  and simply **ignores the result** for `F`.
+
+## `AssumeNegative` is the only route to a negative result
+
+Because the custom grammar has no sign token, `ParseExact("-01:30", "hh':'mm")` **fails** while
+`ParseExact("01:30", "hh':'mm", nullptr, AssumeNegative)` is minus ninety minutes. That is what
+makes `TimeSpanStyles` load-bearing rather than decorative, and it is the property a reader most
+expects to be wrong.
+
+**The standard formats ignore the style**, as .NET does: `c` carries its own sign, so
+`AssumeNegative` must not flip a value that already said what it was. Mutation M6 makes it flip and
+is caught.
+
+## Bounds are per component, not a total range
+
+.NET's own constants (`TimeSpanParse.cs:59-62`): days ≤ 10675199, hours ≤ 23, minutes ≤ 59,
+seconds ≤ 59. So `"25"` against `"hh"` **fails** rather than carrying into days — the reading a
+total-range check would give. Mutation M4 makes it a total range and is caught.
+
+## What is implemented, and what is pinned absent
+
+| Specifier | State |
+|---|---|
+| `c`, `t`, `T` | implemented — one format under three names, delegating to the general `TryParse`, which is that same invariant constant grammar |
+| custom formats | implemented |
+| `g`, `G` | **pinned absent** |
+
+`g` and `G` are .NET's **localized** standard formats and two things stop them: they need a
+culture's decimal separator, which this port has no database for (#2410's boundary), and their
+grammars have **optional components** (`g` is `[-][d':']h':'mm':'ss[.FFFFFFF]`) that the
+custom-format scanner cannot express — each would need its own hand-written arm. A later ticket
+adding them trips the pin.
+
+An empty format and any other single character are **bad format specifiers**, as in .NET.
+
+## A `Try*` method that throws
+
+An illegal `TimeSpanStyles` **raises** where a parse failure returns false — .NET's own shape — and
+**validation runs before the result is written**, so a rejected style leaves the caller's variable
+untouched. That is two claims and each has its own assertion.
+
+## Evidence
+
+Nine mutations, **all caught**. Two were **invalid as first written and reformulated rather than
+counted**: M2's anchor did not match the file (a whitespace mismatch, so the edit never applied —
+an ambiguous or absent anchor is a harness state, not a finding), and M9's first spelling left a
+local unused and was rejected by `-Werror=unused-variable`.
+
+Gate: **17,708 / 38, 0 failed, 0 skipped** (+8; `SharpRuntimeTests_Core_Base` 6,118 → 6,126).
+Module graph **41 / 95**, unchanged; catalogue regenerated. Downstream: **zero sites** in `cna` and
+`mobile-eggbert`.
+
+## What #1943 still has left
+
+`DateTimeOffset::ParseExact`. It needs a zone for the **no-offset** case: .NET's
+`DateTimeStyles.None` gives the result the **local** offset, and `Core.Base` cannot name a zone —
+the same decision #1942 is waiting on. **An offset is not a time zone**, so a format carrying an
+explicit offset would need no zone at all; adding an offset token to the exact grammar is the route,
+and it is recorded here rather than taken, because the no-offset default still needs the answer.
+`XmlConvert::ToDateTimeOffset(s, format)` composes the two today (#1945) in the module that *can*
+name a zone, and a later `DateTimeOffset::ParseExact` should **absorb** that body rather than sit
+beside it.

docs/Migration-TimeSpanParseExact.md

@@ -2,6 +2,8 @@
 // Copyright (c) Robert Vokac and contributors
 // Portions based on .NET runtime API (MIT License, Copyright .NET Foundation and Contributors)
 #pragma once
+#include "System/IFormatProvider.hpp"
+#include "System/Globalization/TimeSpanStyles.hpp"
 #include <atomic>
 #include <chrono>
 #include <cmath>
@@ -449,6 +451,58 @@ namespace System {
         /** Tries to parse a TimeSpan string; returns false without throwing on failure. */
         static bool TryParse(const std::string& s, TimeSpan& result);
 
+        /**
+         * @brief Parses @p input against exactly @p format.
+         *
+         * C++ counterpart of .NET `TimeSpan.ParseExact(string, string, IFormatProvider,
+         * TimeSpanStyles)`, added by #1943.
+         *
+         * @note **THE CUSTOM GRAMMAR HAS NO SIGN TOKEN**, which is not an omission but .NET's
+         *       design: a negative result comes only from `TimeSpanStyles::AssumeNegative`. So
+         *       `ParseExact("-01:30", "hh':'mm")` **fails** -- the `-` matches nothing -- while
+         *       `ParseExact("01:30", "hh':'mm", nullptr, AssumeNegative)` is minus ninety minutes.
+         *
+         * @note **AN UNQUOTED LITERAL IS AN ERROR**, unlike in a `DateTime` exact format:
+         *       `"hh:mm"` is rejected and the colon must be written `"hh':'mm"` or `"hh\:mm"`.
+         *       .NET's `TryParseByFormat` ends its `switch` in `default: SetInvalidStringFailure`,
+         *       so this is the reference's rule rather than this port's strictness.
+         *
+         * @note **`g` AND `G` ARE DELIBERATELY NOT IMPLEMENTED AND ARE PINNED ABSENT.** They are
+         *       .NET's *localized* standard formats, and two things stop them here: they need a
+         *       culture's decimal separator, which this port has no database for (#2410's
+         *       boundary), and their grammars have **optional components** (`g` is
+         *       `[-][d':']h':'mm':'ss[.FFFFFFF]`) that the custom-format scanner cannot express --
+         *       each would need its own hand-written arm. `c`, `t` and `T` are implemented,
+         *       and they are the formats that round-trip `ToString()`.
+         *
+         * @param input The string to parse.
+         * @param format A standard specifier (`c`, `t`, `T`) or a custom format string.
+         * @param provider Reserved for parity; the grammar reads no culture-driven token.
+         * @param styles `AssumeNegative` to make the result negative.
+         * @throws System::FormatException if @p input does not match @p format.
+         * @throws System::ArgumentException if @p styles is not a defined value.
+         */
+        [[nodiscard]] static TimeSpan ParseExact(
+            const std::string& input, const std::string& format,
+            const System::IFormatProvider* provider = nullptr,
+            System::Globalization::TimeSpanStyles styles =
+                System::Globalization::TimeSpanStyles::None);
+
+        /**
+         * @brief Non-throwing counterpart of ParseExact.
+         *
+         * @note **AN ILLEGAL STYLE STILL THROWS**, which is .NET's own shape for a `Try*` method:
+         *       a parse *failure* returns false, but an invalid style is a programming error and
+         *       is raised. Validation runs BEFORE @p result is written.
+         */
+        static bool TryParseExact(const std::string& input, const std::string& format,
+                                  TimeSpan& result);
+
+        /** @brief Non-throwing counterpart of ParseExact, with a provider and styles. */
+        static bool TryParseExact(const std::string& input, const std::string& format,
+                                  const System::IFormatProvider* provider,
+                                  System::Globalization::TimeSpanStyles styles, TimeSpan& result);
+
     public:
         /** Unary minus: returns the negated TimeSpan. */
         TimeSpan operator-() const;