[matt-edmondson]

Requested by Matt · project thread

Fixes the open non-music bugs in Paths, Color, Quantities, the C++ prelude and Strings. One commit per area.

Paths

• Fixes AbsoluteDirectoryPath.IsRoot is false for /home/.. while Parent returns the path itself, so while (!dir.IsRoot) dir = dir.Parent never ends #479: AbsoluteDirectoryPath.IsRoot is true exactly when Parent returns the path itself, so while (!d.IsRoot) d = d.Parent; from /home/.. stops.
• Fixes DirectoryPath.Parent still treats . and .. as directory names: the parent of /home/user/.. is /home/user, and the parent of .. is "" #478: DirectoryPath.Parent resolves a rooted path (/home/user/.. → /) and normalizes a relative one lexically as RelativeDirectoryPath.Parent does (a/.. → .., .. → ../..). A root still gives the empty path, as documented before.
• Fixes Directory Depth counts separator characters: "/" and "/home" both have depth 1, and "a" (0) and "./a" (1) differ although they name the same directory #466: Depth counts directories, not separator characters. Absolute: segments below the root of the resolved path (/ is 0, /home and /home/ are 1). Relative: levels below the first segment of the normalized path (a and ./a are 0, a/b is 1), so the existing tests keep their values.
• Fixes SemanticDirectoryPath.GetContents() throws for the whole directory when one entry fails path validation #445: GetContents() skips an entry whose path fails validation instead of throwing for the whole listing. Tested on every platform with a directory type that rejects one name, plus a Windows-only test using the real 256-character limit.

#385 is already fixed on main by c00d0cd (segment-wise GetRelativePathBySegments, tested against Path.GetRelativePath for every row in that issue); it can be closed.

Color

• Fixes NamedColors "green" is #00FF00 (CSS "lime"), while gray and purple use CSS values, so names resolve to a different green than CSS #449: NamedColors.Green is CSS's #008000 and a new Lime is #00FF00. Behavior change: Green and TryGet("green") return a darker color than before. A test pins every entry to CSS Color 4.
• Fixes Color contrast ignores alpha: NamedColors.Transparent on white rates 21:1 / AAA, and AdjustForContrast returns a 5%-opaque foreground unchanged #393: new CompositeOver(background) (source-over, in gamma sRGB so ratios agree with axe and DevTools). ContrastRatio, AccessibilityLevelAgainst and AdjustForContrast measure a translucent foreground as it looks over the background; the background's own alpha is ignored. Opaque pairs are unchanged. Transparent on white now rates 1:1 / Fail.
• Fixes Color.AdjustForContrast returns the original failing colour for saturated foregrounds (blue on #777777 stays at 1.92:1 though black reaches 4.69:1) #351: AdjustForContrast gamut-maps each lightness candidate by reducing chroma at the same hue instead of clipping, and falls back to mixing towards black or white. Whenever black or white meets the level, the result does. All five rows from the issue are tests.
• Fixes MixOklab/Gradient/FromOklab return out-of-gamut channels, and later HSL adjustments go wrong: white round-tripped through Oklab then DarkenBy(0.5) gives yellow #FFE500 #355: MixOklab and Gradient return in-gamut colors, and Hsl.FromSrgb/Hsv.FromSrgb clamp their input and treat a spread under 1e-6 as gray. FromOklab(White.ToOklab()).DarkenBy(0.5) is #7F7F7F again. FromOklab/FromOklch stay exact and now document that they can leave the gamut. New Srgb.Clamp().

The color commit is tagged [minor] for the new public members.

Quantities

• Fixes PhysicalConstants: AbsoluteZeroInCelsius returns +273.15, WaterIonProduct returns 14 (pKw), MolarVolumeSTP is in L/mol not SI #386: AbsoluteZeroInCelsius is -273.15, WaterIonProduct is 1e-14 and MolarVolumeSTP is in m³/mol; μ0 and ε0 no longer claim to be exact.
• Fixes PhysicalConstants: SpeedOfLight<long>() and PH<int>.Neutral throw TypeInitializationException, and PlanckConstant<decimal>() quietly returns 0 #392: each physical constant is its own lazily filled field, so a constant the storage type cannot hold throws alone, and one that would lose its precision (a tiny constant in decimal) throws instead of reading as zero.
• Fixes Logarithmic scales throw OverflowException for zero with decimal/integer storage: Gain<decimal>.Silence.ToDecibels() crashes despite docs promising negative infinity #352: logarithmic conversions throw ArgumentOutOfRangeException for a level the storage type cannot hold, and OverflowException going back, as documented.
• Fixes Wavelength/Period/HalfLife reach zero via w - w, w * 0 and Wavelength.From(Length.Zero): the strictly-positive guard only covers From{Unit} #354: Wavelength, Period and HalfLife keep their positive guard through scaling, narrowing and subtraction.
• Fixes Division by zero throws for V1 scalars but returns ±Infinity/NaN for vectors, cross-dimension operators and Normalize() #480: every generated division throws DivideByZeroException for a zero divisor, including vector / scalar, cross-dimension operators and Normalize() of a zero vector.
• Fixes Vector Length()/Magnitude()/Distance() square the components before rooting: Position3D<int>.FromMeter(65536, 0, 0).Length() is 0, and a decimal vector past ~2.8e14 throws #327: vector Length() and Distance() go through StorageMath.Hypot, scaled by the largest component, so int, decimal and float vectors whose squares overflow still have a length.
• Fixes StorageMath.Cbrt / RootN never return for PreciseNumber: Cbrt(27) and RootN(3, 4) run for minutes, with the digit count doubling every Newton step #457: Cbrt/RootN stop for PreciseNumber instead of hanging.
• Fixes Physics operators are unreachable when a semantic overload is the left operand: Distance / Duration, Width * ForceMagnitude, Weight * Length do not compile #456: every semantic overload declares forwarding copies of its base's relationship operators with the base on the left, so distance / duration, width * width, weight * height and windVelocity * duration compile. Results stay base types, and products of two overloads stay unambiguous. The three docs that promised this now describe how it works.

C++ prelude

• Fixes C++ prelude: Quantity converts implicitly in both directions, so double→float silently narrows and float+double quantities fail as ambiguous #451: a Quantity representation converts implicitly only where list-initialisation would (float to double), and narrowing needs an explicit constructor. Quantity<D, float> + Quantity<D, double> now resolves to double instead of being ambiguous. Two compile tests cover both directions.

Strings

• Fixes SemanticString.TryCreate throws and catches an exception to reject a value, and validates every rejected value twice (165× a hand-written check) #443: TryCreate rejects a value by its return value, without throwing, catching or building the error message. Create throws the same ArgumentException as before.
• Fixes SemanticString.Create repeats type reflection on every call (~500 B and ~1.6 µs per value before any validator runs); cache per-type metadata #444: a type's validation attributes are read once per type and reused, so each validator is built once rather than per value, and the WeakString setter is a cached delegate instead of a per-call GetProperty/SetValue. Not benchmarked here; the next benchmark-history point will show it.

Breaking fixes (#482, #481, #391, #310) are left for a 6.0 PR, pending Matt's call.

Testing

The full Semantics.Test suite passes locally on Linux (net10.0): 1821 tests, 0 failed. Semantics.Cpp.Test passes with g++: 45 tests. Generated sources are regenerated and committed. Windows-only tests are written but were not run here.

https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY

---

Generated by Claude Code

[sonarqubecloud]

Quality Gate passed

Issues
10 New issues
0 Accepted issues

Measures
0 Security Hotspots
92.7% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud