v0.1.0

Out of beta. Nothing in the API changed to earn that: the surface has been stable since
0.1.0-beta.1 and moves to PublicAPI.Shipped.txt unchanged. What changed is that the questions
the beta was holding open have answers.

0.1.0-beta.1 said beta because the API "may still move". It has not, through two betas. The
Windows performance gap was the other open question and it is measured now, in ADR-0006 and
ADR-0007, rather than explained by a guess this file used to print as fact.

This is still 0.x. Under SemVer that means a minor bump may break the API, so the promise here
is that the surface is considered done, not that it is frozen.

Added

• win-arm64. Native binaries for it ship in the package, the conformance suite runs on a
  windows-11-arm runner, and the reproducibility check and the checksum manifest cover it. The
  binary cross compiles from the x64 runner, so native/verify-windows.ps1 now reads the PE
  machine field and fails unless it matches the RID: an x64 binary shipped under win-arm64
  would pass every other gate and then fail on exactly the machines the RID exists for.
  /CETCOMPAT is not passed there, because CET is x86 and x64 only and the linker takes the flag
  and emits nothing. ADR-0008.

• Benchmark W4 gained ReuseHandleAndReadHostname, which re-parses into one AdaUrl through
  TrySetHref instead of allocating a URL object per URL. It is the only lever the binding has
  over the native allocation and it is worth the most on Windows.

• native/bench/alloc-probe.cpp and a dispatch only workflow that runs it on Windows and Linux.
  It replaces global operator new to count and size what ada_parse allocates, then times
  ada_can_parse, ada_parse with ada_free, a replay of just the recorded allocations, and
  ada_set_href on a kept handle, reporting each against the allocation free control because the
  two runners are different machines.

Changed

• README says why Windows is slower instead of listing hypotheses, and documents handle reuse
  with the case where it does not help. The Windows gap is the heap: ada_parse allocates twice
  per URL and replaying those two allocations alone costs 87 ns on Windows against 22 ns on
  Linux, which is 76% of everything the Windows parse spends beyond validating. Reproduced in two
  runs, decided in ADR-0007, measured in #20.
• The claim that the native allocation is "an upstream limit rather than something this package
  can route around" was half wrong and is corrected. ada_set_href re-parses into an existing
  handle, so a loop can avoid one of the two allocations. Worth 27% on Windows and 8% on Linux
  on a plain URL, and nothing at all on a hard one.

Removed

• The clang-cl toolset option in native/build-windows.ps1, native/cmake/clang-cl-tweaks.cmake,
  the toolset probe workflow, and the two clang-cl variants in the performance experiment. It
  existed to answer #19, whether a different code generator closes the Windows gap. ADR-0007
  answered that from the other direction: the gap is the heap, and both compilers link against
  the same one. The path also carried a build flag that never worked, /p:UseLldLink=false,
  which is worse to leave in than to remove.

Fixed

• The ADR-0001 gate stopped reading generated code. It greps src and tests for #if and runs
  after the build, so it was walking obj too. xunit.v3 4.0.1 added an
  #if XUNIT_GENERATED_DISABLE_WARNINGS guard to its generated test entry point and failed a gate
  about source on a dependency bump that touched none.

Install

dotnet add package Ada.Url --version 0.1.0

Verification

• Attached: the package, its symbols, and a CycloneDX SBOM listing the native library.
• The seven native binaries are built from the pinned Ada tag in CI and their SHA-256
  checksums are matched against native/CHECKSUMS.txt before the package is pushed.
• Published with NuGet trusted publishing, so no long lived API key exists for this repository.

Full changelog